mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-17 13:01:05 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - Every master push runs a canary, and only one canary at a time may run the release workflow > - After #21554 and #21555 a canary held that lock for 35.5 min, and 13-16 min of it was waiting for npm to show the new packages > - The wait was required: the next canary computed `canary.N` from npm's version list, so starting before npm showed the previous canary would reuse its number > - This pull request numbers a canary by its commit's position on master and moves the registry confirmation, the git tag, the Docker dispatch and the onboarding smoke to a separate `canary-finalize.yml` run > - The benefit is that the release lock is held for about 20-25 min per canary instead of 35, with the same checks before a canary is tagged ## Linked Issues or Issue Description **What existing behavior does this improve?** Canary throughput. In run 43715037497 (2026-11-15) `publish_canary` took 23.7 min, and 13.3 min of that was "Waiting for registry visibility" (13:08:50 to 13:22:11). The next canary could not start until that run ended. **Current behavior** `release.sh canary` sets `N` to (highest published `-canary.N` for today) + 1, then publishes, waits for npm to show every package, checks dist-tags, installs `paperclipai@canary`, and creates `canary/v<version>`. `publish_canary` pushes the tag, dispatches `docker.yml`, and `smoke_canary_onboarding` runs in the same run. **Proposed behavior** `N` = `git rev-list --count HEAD` (full history required), or the registry number + 1 when that is higher (a rerun of the same commit). `release.sh canary --defer-registry-confirmation` ends after npm accepts every publish. `publish_canary` dispatches `canary-finalize.yml`, which does the confirmation, tag, Docker dispatch and smoke outside the release lock. Nightly, beta and stable numbering and flow are unchanged. Refs #21554, #21555 ## What Changed - `scripts/release-lib.sh`: `next_canary_version_from_source`. A publishing canary refuses a shallow checkout; a dry run (the PR Canary Dry Run job) falls back to the registry number. - `scripts/release.sh`: canary uses the new number; new canary-only `--defer-registry-confirmation` flag skips the registry wait, the dist-tag check and the local tag, and writes the version to `PAPERCLIP_RELEASE_VERSION_FILE`. - `scripts/confirm-canary-publication.sh` (new): waits for registry visibility, checks provenance, checks dist-tags with `--allow-newer-canary`, installs `paperclipai@<version>`, then creates and pushes `canary/v<version>`. A tag already on the same commit is accepted, so reruns are safe. - `scripts/verify-canary-provenance.mjs` (new): every package's npm SLSA provenance must name `.github/workflows/release.yml` on `refs/heads/master` in `paperclipai/paperclip` at the source commit. A dispatch with invented inputs cannot tag anything. - `scripts/verify-release-registry-state.mjs`: `--allow-newer-canary` accepts a `canary` dist-tag that a newer canary already moved; older, foreign or missing tags still fail. - `.github/workflows/canary-finalize.yml` (new, `workflow_dispatch`, master only): `confirm_canary` (contents: write, actions: write) and `smoke_canary_onboarding` (downloads the publisher's lockfile artifact by run id). Inputs reach shell steps only through a validating step. - `.github/workflows/release.yml`: `publish_canary` hands off to `canary-finalize.yml` and drops to `contents: read`; its tag push, Docker dispatch and smoke job move to `canary-finalize.yml`. - Tests and `doc/RELEASING.md`. ## Verification - `node --test .github/scripts/tests/*.test.mjs scripts/release-lib.test.mjs scripts/verify-release-registry-state.test.mjs scripts/verify-canary-provenance.test.mjs`: 846 pass. `scripts/__tests__/release-verify-workflow.test.mjs`: 73 pass. - New tests: numbering by master position, rerun moves past a published number, shallow refusal and dry-run fallback; newer/older/foreign dist-tags; provenance from another commit, workflow, branch, repository or package is rejected; finalize wiring, permissions and input handling. - Real npm data: `verify-canary-provenance.mjs 2026.1116.0-canary.7 b4fa1c7f... paperclipai @paperclipai/shared @paperclipai/server` passes; the same version with another commit fails. - `confirm-canary-publication.sh 2026.1116.0-canary.7 b4fa1c7f...` from a checkout of that commit ran all steps against npm in 61 s and ended with "canary/v2026.1116.0-canary.7 already points at b4fa1c7f...", pushing nothing. - `release.sh canary --dry-run --defer-registry-confirmation` and `release.sh nightly --defer-registry-confirmation` both stop with "only applies to a published canary". - `actionlint` reports no new findings compared with master. - Not verified before merge: a full publish through `canary-finalize.yml`. It can run only from master. The first canary after merge is the check. ## Risks - Canary numbers jump from `canary.7` to about `canary.8144` (master has 8,143 commits). This is valid semver and still higher than every earlier canary; users install through the `canary` dist-tag. - The `canary/v` tag, Docker image and smoke now finish after the release run ends. Nightly selects only tagged canaries, as before. If finalize fails, that canary is on npm without a tag, so nightly skips it, as it skips any canary whose old in-run verification failed. - A canary can now publish while the previous one is still being confirmed. Publishing itself is still serialized, so the `canary` dist-tag only moves forward. ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, in Claude Code with tool use and code execution. ## 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 - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [ ] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
528 lines
20 KiB
Bash
Executable File
528 lines
20 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
|
|
# shellcheck source=./release-lib.sh
|
|
. "$REPO_ROOT/scripts/release-lib.sh"
|
|
CLI_DIR="$REPO_ROOT/cli"
|
|
|
|
channel=""
|
|
release_date=""
|
|
dry_run=false
|
|
skip_verify=false
|
|
print_version_only=false
|
|
from_candidate=false
|
|
defer_registry_confirmation=false
|
|
notes_file_override=
|
|
tag_name=""
|
|
|
|
cleanup_on_exit=false
|
|
|
|
usage() {
|
|
cat <<'EOF'
|
|
Usage:
|
|
./scripts/release.sh <canary|nightly|beta|stable> [--date YYYY-MM-DD] [--dry-run] [--skip-verify] [--print-version] [--notes-file PATH] [--defer-registry-confirmation]
|
|
|
|
Examples:
|
|
./scripts/release.sh canary
|
|
./scripts/release.sh canary --date 2026-03-17 --dry-run
|
|
./scripts/release.sh nightly --dry-run
|
|
./scripts/release.sh beta --dry-run
|
|
./scripts/release.sh beta --from-candidate --dry-run
|
|
./scripts/release.sh stable
|
|
./scripts/release.sh stable --date 2026-03-17 --dry-run
|
|
./scripts/release.sh stable --date 2026-03-18 --print-version
|
|
|
|
Notes:
|
|
- Stable versions use YYYY.MDD.P, where M is the UTC month, DD is the
|
|
zero-padded UTC day, and P is the same-day stable patch slot.
|
|
- Canary releases publish YYYY.MDD.P-canary.N under the npm dist-tag
|
|
"canary" and create the git tag canary/vYYYY.MDD.P-canary.N. N is
|
|
100 x the source commit's position on master (git rev-list --count HEAD)
|
|
plus the run attempt minus 1 (GITHUB_RUN_ATTEMPT, default 1). Each commit
|
|
owns its own range, so neither a rerun nor an overlapping canary can take
|
|
another commit's number, and no registry lookup is involved.
|
|
- --defer-registry-confirmation (published canary only) stops after npm
|
|
accepts every publish. It skips the registry-visibility wait, the
|
|
dist-tag check and the git tag; scripts/confirm-canary-publication.sh
|
|
does those later, outside the release lock.
|
|
- Nightly releases republish a commit that already shipped a canary (HEAD
|
|
must carry a canary/v* tag) as YYYY.MDD.P-nightly.N under the npm
|
|
dist-tag "nightly", with the git tag nightly/vYYYY.MDD.P-nightly.N.
|
|
The version dates the nightly cut, not the source canary.
|
|
- Beta releases republish a commit that already shipped a nightly (HEAD
|
|
must carry a nightly/v* tag) as YYYY.MDD.P-beta.N under the npm
|
|
dist-tag "beta", with the git tag beta/vYYYY.MDD.P-beta.N.
|
|
- --from-candidate (beta only) waives the nightly-tag requirement for
|
|
cherry-picked candidate-branch builds; callers are responsible for
|
|
validating the candidate branch before using it.
|
|
- Stable releases publish YYYY.MDD.P under the npm dist-tag "latest" and
|
|
create the git tag vYYYY.MDD.P.
|
|
- Non-dry-run stable release notes must already exist at releases/vYYYY.MDD.P.md,
|
|
or be supplied explicitly with --notes-file (stable only). The override
|
|
exists so promotions can read notes maintained on master instead of
|
|
requiring them inside the promoted source commit's tree.
|
|
- The script rewrites versions temporarily and restores the working tree on
|
|
exit. Tags always point at the original source commit, not a generated
|
|
release commit.
|
|
EOF
|
|
}
|
|
|
|
restore_publish_artifacts() {
|
|
if [ -f "$CLI_DIR/package.dev.json" ]; then
|
|
mv "$CLI_DIR/package.dev.json" "$CLI_DIR/package.json"
|
|
fi
|
|
|
|
rm -f "$CLI_DIR/README.md"
|
|
rm -rf "$REPO_ROOT/server/ui-dist"
|
|
|
|
for pkg_dir in server packages/adapters/claude-local packages/adapters/codex-local; do
|
|
rm -rf "$REPO_ROOT/$pkg_dir/skills"
|
|
done
|
|
}
|
|
|
|
cleanup_release_state() {
|
|
restore_publish_artifacts
|
|
|
|
tracked_changes="$(git -C "$REPO_ROOT" diff --name-only; git -C "$REPO_ROOT" diff --cached --name-only)"
|
|
if [ -n "$tracked_changes" ]; then
|
|
printf '%s\n' "$tracked_changes" | sort -u | while IFS= read -r path; do
|
|
[ -z "$path" ] && continue
|
|
git -C "$REPO_ROOT" checkout -q HEAD -- "$path" || true
|
|
done
|
|
fi
|
|
|
|
untracked_changes="$(git -C "$REPO_ROOT" ls-files --others --exclude-standard)"
|
|
if [ -n "$untracked_changes" ]; then
|
|
printf '%s\n' "$untracked_changes" | while IFS= read -r path; do
|
|
[ -z "$path" ] && continue
|
|
if [ -d "$REPO_ROOT/$path" ]; then
|
|
rm -rf "$REPO_ROOT/$path"
|
|
else
|
|
rm -f "$REPO_ROOT/$path"
|
|
fi
|
|
done
|
|
fi
|
|
}
|
|
|
|
set_cleanup_trap() {
|
|
cleanup_on_exit=true
|
|
trap cleanup_release_state EXIT
|
|
}
|
|
|
|
while [ $# -gt 0 ]; do
|
|
case "$1" in
|
|
canary|nightly|beta|stable)
|
|
if [ -n "$channel" ]; then
|
|
release_fail "only one release channel may be provided."
|
|
fi
|
|
channel="$1"
|
|
;;
|
|
--date)
|
|
shift
|
|
[ $# -gt 0 ] || release_fail "--date requires YYYY-MM-DD."
|
|
release_date="$1"
|
|
;;
|
|
--dry-run) dry_run=true ;;
|
|
--skip-verify) skip_verify=true ;;
|
|
--print-version) print_version_only=true ;;
|
|
--from-candidate) from_candidate=true ;;
|
|
--defer-registry-confirmation) defer_registry_confirmation=true ;;
|
|
--notes-file)
|
|
shift
|
|
[ $# -gt 0 ] || release_fail "--notes-file requires a path."
|
|
notes_file_override="$1"
|
|
;;
|
|
-h|--help)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
release_fail "unexpected argument: $1"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ -n "$channel" ] || {
|
|
usage
|
|
exit 1
|
|
}
|
|
|
|
if [ "$from_candidate" = true ] && [ "$channel" != "beta" ]; then
|
|
release_fail "--from-candidate only applies to the beta channel."
|
|
fi
|
|
|
|
if [ -n "$notes_file_override" ] && [ "$channel" != "stable" ]; then
|
|
release_fail "--notes-file only applies to the stable channel."
|
|
fi
|
|
|
|
if [ "$defer_registry_confirmation" = true ] && { [ "$channel" != "canary" ] || [ "$dry_run" = true ]; }; then
|
|
release_fail "--defer-registry-confirmation only applies to a published canary."
|
|
fi
|
|
|
|
PUBLISH_REMOTE="$(resolve_release_remote)"
|
|
fetch_release_remote "$PUBLISH_REMOTE"
|
|
|
|
CURRENT_BRANCH="$(git_current_branch)"
|
|
CURRENT_SHA="$(git -C "$REPO_ROOT" rev-parse HEAD)"
|
|
LAST_STABLE_TAG="$(get_last_stable_tag)"
|
|
CURRENT_STABLE_VERSION="$(get_current_stable_version)"
|
|
RELEASE_DATE="${release_date:-$(utc_date_iso)}"
|
|
|
|
PUBLIC_PACKAGE_INFO="$(list_public_package_info)"
|
|
PUBLIC_PACKAGE_NAMES=()
|
|
while IFS= read -r package_name; do
|
|
[ -n "$package_name" ] || continue
|
|
PUBLIC_PACKAGE_NAMES+=("$package_name")
|
|
done < <(printf '%s\n' "$PUBLIC_PACKAGE_INFO" | cut -f2)
|
|
|
|
[ -n "$PUBLIC_PACKAGE_INFO" ] || release_fail "no public packages were found in the workspace."
|
|
|
|
# Pre-fetch published versions for every public package in parallel so the
|
|
# version helpers below do not each issue one serial `npm view` call per
|
|
# package (see scripts/release-registry-versions.mjs).
|
|
RELEASE_PACKAGE_VERSIONS_FILE="$(mktemp)"
|
|
export RELEASE_PACKAGE_VERSIONS_FILE
|
|
node "$REPO_ROOT/scripts/release-registry-versions.mjs" fetch "${PUBLIC_PACKAGE_NAMES[@]}" > "$RELEASE_PACKAGE_VERSIONS_FILE"
|
|
|
|
TARGET_STABLE_VERSION="$(next_stable_version "$RELEASE_DATE" "${PUBLIC_PACKAGE_NAMES[@]}")"
|
|
TARGET_PUBLISH_VERSION="$TARGET_STABLE_VERSION"
|
|
DIST_TAG="latest"
|
|
|
|
if [ "$channel" = "canary" ]; then
|
|
require_on_master_branch
|
|
TARGET_PUBLISH_VERSION="$(next_canary_version_from_source "$REPO_ROOT" "$dry_run" "$TARGET_STABLE_VERSION" "${GITHUB_RUN_ATTEMPT:-1}" "${PUBLIC_PACKAGE_NAMES[@]}")"
|
|
DIST_TAG="canary"
|
|
tag_name="$(prerelease_tag_name canary "$TARGET_PUBLISH_VERSION")"
|
|
elif [ "$channel" = "nightly" ]; then
|
|
# Nightly promotes an already-shipped canary commit, so it runs from a
|
|
# detached checkout of that commit rather than the master branch tip.
|
|
require_channel_tag_at_head canary
|
|
require_channel_tag_absent_at_head nightly
|
|
TARGET_PUBLISH_VERSION="$(next_prerelease_version nightly "$TARGET_STABLE_VERSION" "${PUBLIC_PACKAGE_NAMES[@]}")"
|
|
DIST_TAG="nightly"
|
|
tag_name="$(prerelease_tag_name nightly "$TARGET_PUBLISH_VERSION")"
|
|
elif [ "$channel" = "beta" ]; then
|
|
if [ "$from_candidate" = true ]; then
|
|
# Candidate builds carry targeted cherry-picks that never shipped as a
|
|
# nightly, so the nightly-tag requirement does not apply; the workflow
|
|
# validates the candidate branch identity before invoking this path.
|
|
:
|
|
else
|
|
# Beta promotes an already-shipped nightly commit.
|
|
require_channel_tag_at_head nightly
|
|
fi
|
|
require_channel_tag_absent_at_head beta
|
|
TARGET_PUBLISH_VERSION="$(next_prerelease_version beta "$TARGET_STABLE_VERSION" "${PUBLIC_PACKAGE_NAMES[@]}")"
|
|
DIST_TAG="beta"
|
|
tag_name="$(prerelease_tag_name beta "$TARGET_PUBLISH_VERSION")"
|
|
else
|
|
tag_name="$(stable_tag_name "$TARGET_STABLE_VERSION")"
|
|
fi
|
|
|
|
rm -f "$RELEASE_PACKAGE_VERSIONS_FILE"
|
|
unset RELEASE_PACKAGE_VERSIONS_FILE
|
|
|
|
if [ "$print_version_only" = true ]; then
|
|
printf '%s\n' "$TARGET_PUBLISH_VERSION"
|
|
exit 0
|
|
fi
|
|
|
|
NOTES_FILE="$(release_notes_file "$TARGET_STABLE_VERSION")"
|
|
if [ -n "$notes_file_override" ]; then
|
|
NOTES_FILE="$notes_file_override"
|
|
fi
|
|
|
|
require_clean_worktree
|
|
require_npm_publish_auth "$dry_run"
|
|
|
|
if [ "$channel" = "beta" ] || [ "$channel" = "stable" ]; then
|
|
require_runner_lockfile_current
|
|
fi
|
|
|
|
if [ "$channel" = "stable" ] && [ "$dry_run" = false ] && [ ! -f "$NOTES_FILE" ]; then
|
|
release_fail "stable release notes file is required at $NOTES_FILE before publishing stable."
|
|
fi
|
|
|
|
if [ "$channel" = "canary" ] && [ -f "$NOTES_FILE" ]; then
|
|
release_info " ✓ Stable release notes already exist at $NOTES_FILE"
|
|
fi
|
|
|
|
if git_local_tag_exists "$tag_name" || git_remote_tag_exists "$tag_name" "$PUBLISH_REMOTE"; then
|
|
release_fail "git tag $tag_name already exists locally or on $PUBLISH_REMOTE."
|
|
fi
|
|
|
|
# Fresh (non-cached) existence check, batched in parallel. Prints the
|
|
# offending package@version pairs itself before failing.
|
|
node "$REPO_ROOT/scripts/release-registry-versions.mjs" assert-absent "$TARGET_PUBLISH_VERSION" "${PUBLIC_PACKAGE_NAMES[@]}" \
|
|
|| release_fail "npm version ${TARGET_PUBLISH_VERSION} already exists for one or more packages."
|
|
|
|
release_info ""
|
|
release_info "==> Release plan"
|
|
release_info " Remote: $PUBLISH_REMOTE"
|
|
release_info " Channel: $channel"
|
|
release_info " Current branch: ${CURRENT_BRANCH:-<detached>}"
|
|
release_info " Source commit: $CURRENT_SHA"
|
|
release_info " Last stable tag: ${LAST_STABLE_TAG:-<none>}"
|
|
release_info " Current stable version: $CURRENT_STABLE_VERSION"
|
|
release_info " Release date (UTC): $RELEASE_DATE"
|
|
release_info " Target stable version: $TARGET_STABLE_VERSION"
|
|
case "$channel" in
|
|
canary) release_info " Canary version: $TARGET_PUBLISH_VERSION" ;;
|
|
nightly) release_info " Nightly version: $TARGET_PUBLISH_VERSION" ;;
|
|
beta) release_info " Beta version: $TARGET_PUBLISH_VERSION" ;;
|
|
*) release_info " Stable version: $TARGET_PUBLISH_VERSION" ;;
|
|
esac
|
|
release_info " Dist-tag: $DIST_TAG"
|
|
release_info " Git tag: $tag_name"
|
|
if [ "$channel" = "stable" ]; then
|
|
release_info " Release notes: $NOTES_FILE"
|
|
fi
|
|
|
|
set_cleanup_trap
|
|
|
|
# The release flow already prepares ui/dist before packaging. Reuse that output
|
|
# so server prepack does not rebuild the UI a second time during preview/publish.
|
|
export PAPERCLIP_RELEASE_REUSE_UI_DIST=1
|
|
|
|
if [ "$skip_verify" = false ]; then
|
|
release_info ""
|
|
release_info "==> Step 1/7: Verification gate..."
|
|
cd "$REPO_ROOT"
|
|
pnpm -r typecheck
|
|
pnpm test:run
|
|
pnpm build
|
|
else
|
|
release_info ""
|
|
release_info "==> Step 1/7: Verification gate skipped (--skip-verify)"
|
|
fi
|
|
|
|
release_info ""
|
|
release_info "==> Step 2/7: Building workspace artifacts..."
|
|
cd "$REPO_ROOT"
|
|
pnpm build
|
|
if [ -n "${PAPERCLIP_RELEASE_RUNNER_ARTIFACTS_DIR:-}" ]; then
|
|
pack_args=()
|
|
if [ -n "${PAPERCLIP_RELEASE_PROVIDER_PACK_ARTIFACTS_DIR:-}" ]; then
|
|
pack_args=("$PAPERCLIP_RELEASE_PROVIDER_PACK_ARTIFACTS_DIR")
|
|
fi
|
|
node "$REPO_ROOT/packages/paperclip-runner/scripts/stage-release-runner-binaries.mjs" \
|
|
assemble-daemons "$PAPERCLIP_RELEASE_RUNNER_ARTIFACTS_DIR" "$(git rev-parse HEAD)" "${pack_args[@]}"
|
|
cp -R "$REPO_ROOT/packages/paperclip-runner/dist/bin/." "$REPO_ROOT/server/dist/vendor/paperclip-runner/bin/"
|
|
if [ -d "$REPO_ROOT/packages/paperclip-runner/dist/remote-provider-packs" ]; then
|
|
cp -R "$REPO_ROOT/packages/paperclip-runner/dist/remote-provider-packs" "$REPO_ROOT/server/dist/vendor/paperclip-runner/"
|
|
fi
|
|
elif [ "$dry_run" = false ]; then
|
|
release_fail "Public releases require the four hosted runner daemon artifacts; use the supported Release workflow."
|
|
fi
|
|
node "$REPO_ROOT/scripts/build-standalone-public-packages.mjs"
|
|
bash "$REPO_ROOT/scripts/prepare-server-ui-dist.sh"
|
|
for pkg_dir in server packages/adapters/claude-local packages/adapters/codex-local; do
|
|
rm -rf "$REPO_ROOT/$pkg_dir/skills"
|
|
cp -r "$REPO_ROOT/skills" "$REPO_ROOT/$pkg_dir/skills"
|
|
done
|
|
release_info " ✓ Workspace build complete"
|
|
|
|
release_info ""
|
|
release_info "==> Step 3/7: Rewriting workspace versions..."
|
|
set_public_package_version "$TARGET_PUBLISH_VERSION"
|
|
release_info " ✓ Versioned workspace to $TARGET_PUBLISH_VERSION"
|
|
|
|
release_info ""
|
|
release_info "==> Step 4/7: Building publishable CLI bundle..."
|
|
"$REPO_ROOT/scripts/build-npm.sh" --skip-checks --skip-typecheck
|
|
release_info " ✓ CLI bundle ready"
|
|
|
|
VERSIONED_PACKAGE_INFO="$(list_public_package_info)"
|
|
VERSION_IN_CLI_PACKAGE="$(node -e "console.log(require('$CLI_DIR/package.json').version)")"
|
|
if [ "$VERSION_IN_CLI_PACKAGE" != "$TARGET_PUBLISH_VERSION" ]; then
|
|
release_fail "versioning drift detected. Expected $TARGET_PUBLISH_VERSION but found $VERSION_IN_CLI_PACKAGE."
|
|
fi
|
|
|
|
VERIFY_ATTEMPTS="${NPM_PUBLISH_VERIFY_ATTEMPTS:-12}"
|
|
VERIFY_DELAY_SECONDS="${NPM_PUBLISH_VERIFY_DELAY_SECONDS:-5}"
|
|
|
|
release_info ""
|
|
if [ "$dry_run" = true ]; then
|
|
release_info "==> Step 5/7: Previewing publish payloads (--dry-run)..."
|
|
# Previews are independent per package (each works in its own temp dir and
|
|
# never touches npm), so run them concurrently in batches. Serial previews
|
|
# took ~78s of every PR Canary Dry Run job (run 35036001734, 2026-09-15).
|
|
# The real publish path below stays strictly serial.
|
|
preview_logs_dir="$(mktemp -d "${TMPDIR:-/tmp}/paperclip-release-previews.XXXXXX")"
|
|
preview_batch_size=8
|
|
preview_pids=()
|
|
preview_dirs=()
|
|
preview_logs=()
|
|
preview_failed=false
|
|
|
|
wait_for_preview_batch() {
|
|
# Guard the expansion: "${preview_pids[@]}" on an empty array trips
|
|
# `set -u` under bash < 4.4 (the macOS system bash).
|
|
if [ "${#preview_pids[@]}" -eq 0 ]; then
|
|
return 0
|
|
fi
|
|
for pid in "${preview_pids[@]}"; do
|
|
if ! wait "$pid"; then
|
|
preview_failed=true
|
|
fi
|
|
done
|
|
preview_pids=()
|
|
}
|
|
|
|
while IFS=$'\t' read -r pkg_dir _pkg_name _pkg_version; do
|
|
[ -z "$pkg_dir" ] && continue
|
|
preview_log="$preview_logs_dir/$(printf '%03d' "${#preview_logs[@]}")-${pkg_dir//\//_}.log"
|
|
preview_dirs+=("$pkg_dir")
|
|
preview_logs+=("$preview_log")
|
|
(
|
|
set -euo pipefail
|
|
cd "$REPO_ROOT/$pkg_dir"
|
|
publish_tool="$(package_publish_tool)"
|
|
if [ "$publish_tool" = "npm" ]; then
|
|
publish_dir="$(mktemp -d "${TMPDIR:-/tmp}/paperclip-release-package.XXXXXX")"
|
|
node "$REPO_ROOT/scripts/prepare-bundled-package.mjs" "$REPO_ROOT/$pkg_dir" "$publish_dir"
|
|
cd "$publish_dir"
|
|
run_bundled_npm_pack pack --pack-destination "$publish_dir" 2>&1 | tail -3
|
|
rm -rf "$publish_dir"
|
|
else
|
|
pnpm publish --dry-run --no-git-checks --tag "$DIST_TAG" 2>&1 | tail -3
|
|
fi
|
|
) > "$preview_log" 2>&1 &
|
|
preview_pids+=($!)
|
|
if [ "$(( ${#preview_pids[@]} % preview_batch_size ))" -eq 0 ]; then
|
|
wait_for_preview_batch
|
|
fi
|
|
done <<< "$VERSIONED_PACKAGE_INFO"
|
|
wait_for_preview_batch
|
|
|
|
preview_index=0
|
|
for pkg_dir in "${preview_dirs[@]}"; do
|
|
release_info " --- $pkg_dir ---"
|
|
cat "${preview_logs[$preview_index]}"
|
|
preview_index=$((preview_index + 1))
|
|
done
|
|
rm -rf "$preview_logs_dir"
|
|
if [ "$preview_failed" = true ]; then
|
|
release_fail "one or more publish payload previews failed; see the package output above"
|
|
fi
|
|
release_info " [dry-run] Would create git tag $tag_name on $CURRENT_SHA"
|
|
else
|
|
release_info "==> Step 5/7: Publishing packages to npm..."
|
|
while IFS=$'\t' read -r pkg_dir pkg_name pkg_version; do
|
|
[ -z "$pkg_dir" ] && continue
|
|
release_info " Publishing $pkg_name@$pkg_version"
|
|
cd "$REPO_ROOT/$pkg_dir"
|
|
publish_tool="$(package_publish_tool)"
|
|
if [ "$publish_tool" = "npm" ]; then
|
|
publish_dir="$(mktemp -d "${TMPDIR:-/tmp}/paperclip-release-package.XXXXXX")"
|
|
node "$REPO_ROOT/scripts/prepare-bundled-package.mjs" "$REPO_ROOT/$pkg_dir" "$publish_dir"
|
|
cd "$publish_dir"
|
|
fi
|
|
if ! publish_package_to_npm \
|
|
"$DIST_TAG" \
|
|
"$pkg_name" \
|
|
"$pkg_version" \
|
|
"$publish_tool"; then
|
|
if [ "$publish_tool" = "npm" ]; then
|
|
rm -rf "$publish_dir"
|
|
fi
|
|
release_fail "stopping release: npm did not accept the publish of ${pkg_name}@${pkg_version}"
|
|
fi
|
|
if [ "$publish_tool" = "npm" ]; then
|
|
rm -rf "$publish_dir"
|
|
fi
|
|
release_info " ✓ npm accepted the publish"
|
|
done <<< "$VERSIONED_PACKAGE_INFO"
|
|
release_info " ✓ npm accepted every package publish under dist-tag $DIST_TAG"
|
|
if [ "$defer_registry_confirmation" = false ]; then
|
|
release_info " Waiting for registry visibility of all packages concurrently..."
|
|
if ! wait_for_npm_package_versions \
|
|
"$VERIFY_ATTEMPTS" \
|
|
"$VERIFY_DELAY_SECONDS" \
|
|
"$VERSIONED_PACKAGE_INFO"; then
|
|
release_fail "stopping release: npm did not expose every published version under dist-tag $DIST_TAG"
|
|
fi
|
|
release_info " ✓ Published the full package set under dist-tag $DIST_TAG"
|
|
fi
|
|
fi
|
|
|
|
release_info ""
|
|
if [ "$dry_run" = true ]; then
|
|
release_info "==> Step 6/7: Skipping npm verification in dry-run mode..."
|
|
elif [ "$defer_registry_confirmation" = true ]; then
|
|
release_info "==> Step 6/7: Registry confirmation deferred to scripts/confirm-canary-publication.sh"
|
|
else
|
|
release_info "==> Step 6/7: Confirming npm package availability and dist-tag integrity..."
|
|
REGISTRY_STATE_VERIFY_ATTEMPTS="${NPM_REGISTRY_STATE_VERIFY_ATTEMPTS:-12}"
|
|
REGISTRY_STATE_VERIFY_DELAY_SECONDS="${NPM_REGISTRY_STATE_VERIFY_DELAY_SECONDS:-5}"
|
|
release_info " ✓ Every version was registry-visible before tagging began"
|
|
|
|
verify_args=(
|
|
--channel "$channel"
|
|
--dist-tag "$DIST_TAG"
|
|
--target-version "$TARGET_PUBLISH_VERSION"
|
|
)
|
|
while IFS=$'\t' read -r _pkg_dir pkg_name _pkg_version; do
|
|
[ -z "$pkg_name" ] && continue
|
|
verify_args+=(--package "$pkg_name")
|
|
done <<< "$VERSIONED_PACKAGE_INFO"
|
|
|
|
release_info " Waiting for npm dist-tags and package metadata to converge..."
|
|
if wait_for_release_registry_state \
|
|
"$REGISTRY_STATE_VERIFY_ATTEMPTS" \
|
|
"$REGISTRY_STATE_VERIFY_DELAY_SECONDS" \
|
|
"${verify_args[@]}"; then
|
|
:
|
|
else
|
|
verify_status=$?
|
|
if [ "$verify_status" -eq 2 ]; then
|
|
release_fail "publish completed, but registry verification failed immediately for ${TARGET_PUBLISH_VERSION}; dist-tag state is wrong or requires operator intervention"
|
|
fi
|
|
|
|
release_fail "publish completed, but npm dist-tags or registry metadata never converged for ${TARGET_PUBLISH_VERSION}"
|
|
fi
|
|
|
|
release_info " Installing paperclipai@$DIST_TAG into a clean prefix..."
|
|
if ! verify_npm_installable "paperclipai@$DIST_TAG" "$TARGET_PUBLISH_VERSION"; then
|
|
release_fail "paperclipai@$DIST_TAG did not install cleanly at expected version ${TARGET_PUBLISH_VERSION}"
|
|
fi
|
|
release_info " ✓ Clean-prefix install resolved ${TARGET_PUBLISH_VERSION}"
|
|
fi
|
|
|
|
release_info ""
|
|
if [ "$dry_run" = true ]; then
|
|
release_info "==> Step 7/7: Dry run complete..."
|
|
elif [ "$defer_registry_confirmation" = true ]; then
|
|
release_info "==> Step 7/7: Tag deferred until npm confirms ${TARGET_PUBLISH_VERSION}"
|
|
if [ -n "${PAPERCLIP_RELEASE_VERSION_FILE:-}" ]; then
|
|
printf '%s\n' "$TARGET_PUBLISH_VERSION" > "$PAPERCLIP_RELEASE_VERSION_FILE"
|
|
fi
|
|
else
|
|
release_info "==> Step 7/7: Creating git tag..."
|
|
git -C "$REPO_ROOT" tag "$tag_name" "$CURRENT_SHA"
|
|
release_info " ✓ Created tag $tag_name on $CURRENT_SHA"
|
|
fi
|
|
|
|
release_info ""
|
|
if [ "$dry_run" = true ]; then
|
|
release_info "Dry run complete for $channel ${TARGET_PUBLISH_VERSION}."
|
|
elif [ "$defer_registry_confirmation" = true ]; then
|
|
release_info "Published $channel ${TARGET_PUBLISH_VERSION}; npm confirmation and the git tag follow in canary-finalize."
|
|
else
|
|
case "$channel" in
|
|
canary|nightly|beta)
|
|
release_info "Published $channel ${TARGET_PUBLISH_VERSION}."
|
|
release_info "Install with: npx paperclipai@$channel onboard"
|
|
release_info "Next step: git push ${PUBLISH_REMOTE} refs/tags/${tag_name}"
|
|
;;
|
|
*)
|
|
release_info "Published stable ${TARGET_PUBLISH_VERSION}."
|
|
release_info "Next steps:"
|
|
release_info " git push ${PUBLISH_REMOTE} refs/tags/${tag_name}"
|
|
release_info " ./scripts/create-github-release.sh $TARGET_STABLE_VERSION"
|
|
;;
|
|
esac
|
|
fi
|