Files
PaperClipAI/.github/workflows/refresh-lockfile.yml
T
Nicky LeachandPaperclip 3c32b8d4dc fix(ci): waive lockfile bake time for pinned harnesses (#22349)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work.
> - Paperclip Runner ships pinned harnesses that run those agents.
> - Some new models require a new harness release before they can run.
> - The lockfile bot waits three days before it can merge new dependency
versions automatically.
> - That wait held the Claude and Codex refresh in #22231.
> - This PR waives the wait for a fixed set of harness packages so model
updates can ship as soon as npm confirms the releases.

## Linked Issues or Issue Description

Refs #22231, #22278, #14942, #15572, and #18238.

**What happened?**

The refresh in #22231 held 16 new Claude Agent SDK and Codex versions
even though the new model support needed those harness updates.

**Expected behavior**

Verified npm releases of named harness packages can pass the gate
immediately. The gate applies the normal minimum age to other packages.

**Steps to reproduce**

Compare the parent and head of #22231 across the three lockfiles managed
by the bot. Run the gate with the publish times in its hold comment and
a clock within three days of the releases.

## What Changed

- Exempt 28 exact package names from the minimum age. These cover the
Claude Agent SDK, Codex CLI, their provider-specific ACP bridges,
OpenCode, and the Copilot binaries pinned by Runner.
- Take package identities from the Runner manifest and active provider
profiles, then check the managed lockfiles for platform binaries. Codex
platform aliases use the same registry name with a platform suffix on
each version. Pi and Kimi use separate npm locks. Gemini, Grok, the
local Cursor CLI, and Antigravity use separate install paths. The Cursor
Cloud SDK gets model availability from the service.
- Keep the npm publish-time and resolution checks for every entry.
Update the bot report and setup documentation.

## Verification

- Replayed the exact #22231 lockfile diff using the bot's recorded
publish times and a fixed clock. The previous gate held all 16 versions.
The new gate verified all 16 and held zero.
- Ran the workflow CLI against the same three lockfile pairs and the
live npm registry. It wrote `eligible=true` and reported 16 passing
versions.
- Reconciled the 28 exact names with the Runner manifest, provider
profiles, all three bot-managed pnpm lockfiles, and the npm manifests
for Claude Agent SDK 0.3.328, Codex 0.170.0, and OpenCode 1.18.34.
- Ran `node --test '.github/scripts/tests/*.test.mjs'` locally. All 810
tests passed. The new cases cover mixed refreshes, similar names,
registry errors, missing publish times, and non-registry resolutions.
- Ran `git diff --check`.
- GitHub Actions passed the required typecheck, build, test, and e2e
checks on `9c8bccac51`. The Canary runner shut down on the first
attempt, and browser shard 7 had a test-company cleanup error. Both
passed on the failed-jobs retry. [CI attempt
2](https://github.com/paperclipai/paperclip/actions/runs/44610325309/attempts/2)
- Standard Greptile scored the same revision 5/5.
[Review](https://github.com/paperclipai/paperclip/pull/22349#issuecomment-7021573041)

## Risks

An npm release of an allowlisted harness can reach master during its
first three days through the existing automatic merge path. A
compromised release can use that same path. Every added version still
needs an npm publish time and a registry resolution. Review new platform
package names before adding them to the allowlist. Superagent requests
security review for this policy change. [Scanner
finding](https://github.com/paperclipai/paperclip/pull/22349#discussion_r4634801827)

## Model Used

OpenAI GPT-6 in Codex, with shell and code execution. The exact model
snapshot and context window were not reported.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [x] All Paperclip CI gates are green
- [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

Co-authored-by: Paperclip <noreply@paperclip.ing>
2026-11-19 14:17:32 -08:00

321 lines
14 KiB
YAML

name: Refresh Lockfile
on:
push:
branches:
- master
schedule:
# Retry refreshes held by the release-age gate once their versions are old enough.
- cron: "23 6 * * *"
workflow_dispatch:
concurrency:
group: refresh-lockfile-master
cancel-in-progress: false
jobs:
refresh:
runs-on: ubuntu-latest
timeout-minutes: 10
# Holds the lockfile bot key. Restrict this environment to master so no
# other branch or workflow can mint a token that bypasses master rules.
environment: lockfile-refresh
permissions:
actions: read
contents: write
pull-requests: write
env:
# Every lockfile this workflow owns: the root one, then the sandbox
# providers' own lockfiles. Keep it equal to LOCKFILES in
# .github/scripts/lockfile-trust.mjs, which blocks contributor edits to
# the same files. A test checks that the two lists match.
LOCKFILES: pnpm-lock.yaml scripts/typecheck-sandbox-providers/pnpm-lock.yaml packages/plugins/sandbox-providers/daytona/pnpm-lock.yaml
steps:
- name: Checkout repository
uses: actions/checkout@v7
- name: Setup pnpm
uses: pnpm/action-setup@v6
with:
version: 9.15.4
run_install: false
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: 24
# Resolution-only installs do not populate the package store. Do not
# claim the shared cache key with an empty archive before full installs.
package-manager-cache: false
# Start from the lockfiles the previous run held, so resolution keeps those
# versions while their manifests are unchanged and they can age past the
# gate. Read them from that run's artifact, not the PR branch: anyone with
# write access can push to chore/refresh-lockfile.
- name: Reuse versions from a held refresh
env:
GH_TOKEN: ${{ github.token }}
run: |
run_id="$(
gh run list --workflow refresh-lockfile.yml --branch master --status success --limit 20 \
--json databaseId,event \
--jq '[.[] | select(.event == "push" or .event == "schedule" or .event == "workflow_dispatch")][0].databaseId // empty'
)"
held="$RUNNER_TEMP/held-lock"
if [ -z "$run_id" ] || ! gh run download "$run_id" --name held-pnpm-lock --dir "$held" 2>/dev/null; then
echo "The previous refresh held nothing. Resolving from master."
exit 0
fi
# An artifact saved before the provider lockfiles has no
# source-locks.sha256. Resolve from master instead.
if [ ! -f "$held/source-locks.sha256" ]; then
echo "Run $run_id held its refresh in an older format. Resolving from master."
exit 0
fi
# Reuse the held locks only while master still has every lock they
# were resolved from. A lock change on master, such as a maintainer's
# correction, supersedes them.
if ! sha256sum --check --status "$held/source-locks.sha256"; then
echo "A lockfile on master changed after run $run_id held its refresh. Resolving from master."
exit 0
fi
for lock in $LOCKFILES; do
cp "$held/$lock" "$lock"
done
echo "Resolving from the lockfiles held by run $run_id."
- name: Refresh pnpm lockfile
run: pnpm install --resolution-only --ignore-scripts --no-frozen-lockfile
# Sandbox providers stay out of the root workspace. The shared typecheck
# workspace has its own pnpm-workspace.yaml, and Daytona installs alone.
- name: Refresh sandbox provider lockfiles
run: |
pnpm --dir scripts/typecheck-sandbox-providers install --resolution-only --ignore-scripts --no-frozen-lockfile
pnpm --dir packages/plugins/sandbox-providers/daytona install --ignore-workspace --resolution-only --ignore-scripts --no-frozen-lockfile
# A verified Dependabot lockfile merged to master is trusted lock content.
# Report its hash so the proof refresh can admit it.
- name: Identify a verified Dependabot lockfile on master
id: trusted_lock
env:
GH_TOKEN: ${{ github.token }}
run: node .github/scripts/lockfile-trust.mjs merged
- name: Refresh reviewed eval report dependency proof
env:
TRUSTED_LOCK_SHA256: ${{ steps.trusted_lock.outputs.trusted_lock_sha256 }}
run: |
if [ -n "$TRUSTED_LOCK_SHA256" ]; then
node tests/runner-e2e/prepare-report-lock.mjs --refresh --trusted-lock-sha256 "$TRUSTED_LOCK_SHA256"
else
node tests/runner-e2e/prepare-report-lock.mjs --refresh
fi
- name: Fail on unexpected file changes
run: |
changed="$(git status --porcelain)"
if [ -z "$changed" ]; then
echo "Lockfile is already up to date."
exit 0
fi
unexpected="$(printf '%s\n' "$changed" | awk -v allowed="$LOCKFILES tests/runner-e2e/report-lock.json tests/runner-e2e/report-lock.patch" '
BEGIN { n = split(allowed, files, " "); for (i = 1; i <= n; i++) ok[files[i]] = 1 }
!($2 in ok) { print }')"
if [ -n "$unexpected" ]; then
echo "Unexpected files changed during lockfile refresh:"
echo "$changed"
exit 1
fi
- name: Create or update pull request
id: upsert-pr
env:
GH_TOKEN: ${{ github.token }}
REPO_OWNER: ${{ github.repository_owner }}
run: |
# A verified Dependabot lockfile that already resolves changes only
# the reporting-lock proof. Commit that proof too.
if git diff --quiet -- $LOCKFILES tests/runner-e2e/report-lock.json tests/runner-e2e/report-lock.patch; then
echo "Lockfiles and reporting-lock proof unchanged, nothing to do."
echo "pr_url=" >> "$GITHUB_OUTPUT"
echo "head_sha=" >> "$GITHUB_OUTPUT"
exit 0
fi
BRANCH="chore/refresh-lockfile"
git config user.name "lockfile-bot"
git config user.email "lockfile-bot@users.noreply.github.com"
git checkout -B "$BRANCH"
git add $LOCKFILES tests/runner-e2e/report-lock.json tests/runner-e2e/report-lock.patch
git commit -m "chore(lockfile): refresh pnpm lockfiles"
# The SDK public source proof pins the committed lock blob and the
# report-lock output hash. This PR merges without CI, so resync those
# pins from the commit above and check them before pushing (#20615).
node tests/runner-e2e/source-sdk-public-inputs.mjs "$(git rev-parse HEAD)" --write
git add tests/runner-e2e/source-sdk-public-inputs.json
git commit --amend --no-edit
node tests/runner-e2e/source-sdk-public-inputs.mjs "$(git rev-parse HEAD)" --check
git push --force origin "$BRANCH"
# Only reuse an open PR from this repository owner, not a fork with the same branch name.
pr_url="$(
gh pr list --state open --head "$BRANCH" --json url,headRepositoryOwner \
--jq ".[] | select(.headRepositoryOwner.login == \"$REPO_OWNER\") | .url" |
head -n 1
)"
if [ -z "$pr_url" ]; then
pr_body_file="$RUNNER_TEMP/lockfile-pr-body.md"
cat > "$pr_body_file" <<'PR_BODY'
## Thinking Path
> - Paperclip uses a dependency lock for reproducible builds.
> - Dependency changes on master need matching lock entries.
> - Paid eval reports also pin a reviewed offline correction.
> - Reports must install before paid model work starts.
> - This automated PR keeps the lock and report proof together.
## Linked Issues or Issue Description
**What happened?**
Dependency manifests on master changed after the last committed lock refresh.
**Expected behavior**
Frozen installs must match those manifests. Eval reports must retain matching offline lock proof.
**Steps to reproduce**
Run a frozen install before and after this lock refresh.
## What Changed
- Refresh the dependency lock from the manifests on master.
- Refresh the sandbox provider lockfiles from their manifests on master.
- Include the matching offline report correction and hashes.
- Resync the SDK public source proof's lock pins from the refreshed lock.
## Verification
- Pinned pnpm resolution completed with lifecycle scripts disabled.
- The report proof refresh accepted the reviewed committed baseline.
- The workflow rejected changes outside the lock and report proof files.
## Risks
The lockfile bot merges this PR without CI or review when it verifies every added version on npm and all versions outside the harness allowlist are at least 3 days old. Otherwise the PR waits for a maintainer, and the daily refresh tries again. The bot merges only the exact commit this workflow generated from manifests already reviewed on master. Unknown report lock baselines remain blocked. This update changes no permissions or paid enable gates.
## Model Used
None — generated by pnpm and the deterministic report-lock updater.
## Checklist
- [x] Thinking path and problem description included
- [x] Generated lock and matching report proof included
- [x] Release-age gate decides between bot merge and maintainer review
PR_BODY
pr_url="$(gh pr create \
--head "$BRANCH" \
--title "chore(lockfile): refresh pnpm lockfiles" \
--body-file "$pr_body_file")"
echo "Created new PR: $pr_url"
else
echo "PR already exists: $pr_url"
fi
echo "pr_url=$pr_url" >> "$GITHUB_OUTPUT"
echo "head_sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
# Resolution picks the newest matching version for any added or widened
# dependency. The gate verifies every added version on npm and enforces
# the age requirement outside the harness allowlist.
- name: Check release age of added package versions
id: release-age
if: steps.upsert-pr.outputs.pr_url != ''
run: |
# Keep each base lockfile at its repository path. "Stage held
# lockfile" hashes them from there.
base="$RUNNER_TEMP/base-locks"
pairs=()
for lock in $LOCKFILES; do
mkdir -p "$base/$(dirname "$lock")"
# A lockfile that master does not have yet has no base, so all of its entries count as added.
git show "$GITHUB_SHA:$lock" > "$base/$lock" 2>/dev/null || : > "$base/$lock"
pairs+=(--base "$base/$lock" --head "$lock")
done
node .github/scripts/check-lockfile-release-age.mjs \
"${pairs[@]}" \
--min-age-days 3 \
--report "$RUNNER_TEMP/release-age-report.md"
cat "$RUNNER_TEMP/release-age-report.md" >> "$GITHUB_STEP_SUMMARY"
- name: Hold lockfile PR for review
if: steps.release-age.outputs.eligible == 'false'
env:
GH_TOKEN: ${{ github.token }}
PR_URL: ${{ steps.upsert-pr.outputs.pr_url }}
run: |
# Keep one report comment per PR instead of adding one on every run.
pr_number="${PR_URL##*/}"
comment_id="$(
gh api --paginate "repos/$GITHUB_REPOSITORY/issues/$pr_number/comments" \
--jq '.[] | select(.user.login == "github-actions[bot]" and (.body | startswith("<!-- lockfile-release-age -->"))) | .id' |
head -n 1
)"
if [ -n "$comment_id" ]; then
gh api --method PATCH "repos/$GITHUB_REPOSITORY/issues/comments/$comment_id" \
-F "body=@$RUNNER_TEMP/release-age-report.md" > /dev/null
else
gh pr comment "$PR_URL" --body-file "$RUNNER_TEMP/release-age-report.md"
fi
echo "::notice title=Lockfile PR held::Added package versions are too new to merge without review. See $PR_URL"
- name: Stage held lockfile
if: steps.release-age.outputs.eligible == 'false'
run: |
held="$RUNNER_TEMP/held-upload"
for lock in $LOCKFILES; do
mkdir -p "$held/$(dirname "$lock")"
cp "$lock" "$held/$lock"
done
# Hash the master lockfiles this refresh started from, by repository
# path, so the next run can check them with sha256sum --check.
(cd "$RUNNER_TEMP/base-locks" && sha256sum $LOCKFILES) > "$held/source-locks.sha256"
- name: Save held lockfile for the next refresh
if: steps.release-age.outputs.eligible == 'false'
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
with:
name: held-pnpm-lock
path: ${{ runner.temp }}/held-upload/
if-no-files-found: error
retention-days: 7
# Mint the bypass token only after resolution has finished, so no earlier
# step can read it. The lockfile bot is a master ruleset bypass actor in
# pull_request mode: it can merge PRs past checks and review, but cannot
# push to master directly. See doc/RELEASE-AUTOMATION-SETUP.md.
- name: Create lockfile bot token
id: bot-token
if: steps.release-age.outputs.eligible == 'true'
uses: actions/create-github-app-token@64ab729a6294000f5aa4a4bc0b73d1f32bc45510 # v3.3.0
with:
client-id: ${{ vars.LOCKFILE_BOT_CLIENT_ID }}
private-key: ${{ secrets.LOCKFILE_BOT_PRIVATE_KEY }}
permission-contents: write
permission-pull-requests: write
- name: Merge lockfile PR
if: steps.release-age.outputs.eligible == 'true'
env:
GH_TOKEN: ${{ steps.bot-token.outputs.token }}
PR_URL: ${{ steps.upsert-pr.outputs.pr_url }}
HEAD_SHA: ${{ steps.upsert-pr.outputs.head_sha }}
run: |
# Merge only the commit this job pushed. Anything else pushed to the
# branch since then makes GitHub refuse the merge.
gh pr merge "$PR_URL" --squash --admin --delete-branch --match-head-commit "$HEAD_SHA"