Files
hyperframes/.github/workflows/publish.yml
T
James RussoandClaude Opus 5.5 81d73d2278 fix(aws-lambda): chrome-headless-shell 158 in the arm64 video image, sparticuz 153 in the x86 ZIP (#8155)
* fix(aws-lambda): run chrome-headless-shell 158 in the arm64 video image

The arm64 video image now installs Chrome for Testing's linux-arm64 chrome-headless-shell
158.0.8127.36, pinned by sha256 and fetched with curl -f, as the whole shell folder. The Lambda
Node 22 base has none of the shared libraries the shell links and no fonts, so the image installs
them from the base's repository at the same pinned release. The image sets
HYPERFRAMES_LAMBDA_CHROME_SOURCE and HYPERFRAMES_LAMBDA_CHROME_PATH itself, and the nested video
function no longer passes ChromeSource, which would override them. stage-arm64-image.ts stops
fetching the sparticuz arm64 pack and drops the ZIP's x86 sparticuz Chrome instead.

The x86 handler ZIP stays on @sparticuz/chromium, bumped from 148.0.0 to 153.0.0. It builds at
258,502,222 bytes unzipped, under Lambda's 262,144,000-byte limit and the 248 MiB in-house gate.

Two fixes for --source=chrome-headless-shell:
- build-zip.ts staged only the executable, which exits at launch without its ICU data and .pak
  files. It now stages the whole shell folder at chrome-headless-shell-linux64/.
- Nothing set HYPERFRAMES_LAMBDA_CHROME_PATH, which src/chromium.ts requires for that source.
  The SAM template and the CDK stack now set it to the bundled shell when ChromeSource asks for it.

Drops the unused @types/aws-lambda devDependency, which the dead-code audit reports whenever this
package's manifest changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci(publish): build the Lambda arm64 video image on an ARM runner

The video stage now installs Chrome's system libraries with microdnf, so it runs code for arm64.
The pack job built that image on ubuntu-latest with no emulation, which it could do only while the
stage copied files. A new lambda-video-image job builds it natively on ubuntu-24.04-arm, from the
handler zip whose sha256 the zip job reported, and reports the OCI tarball's sha256. Pack downloads
that tarball, checks the sha256 against the job's, and pins it as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(aws-lambda): fit the comment ratchet and the package size budget

chromium.ts loses the two doc lines on BUNDLED_SHELL_DIR and BUNDLED_SHELL_PATH; the names and the
SAM template's comment already say what they are.

@hyperframes/aws-lambda's unpacked budget goes from 290,508 to 298,000 bytes. The package unpacks to
295,324 bytes, up from the shared chrome-headless-shell staging module the ZIP and image scripts now
import and from the README and docs that describe the two Chrome sources.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 09:07:46 +00:00

968 lines
47 KiB
YAML

name: Publish to npm
permissions: {}
# Explicit bash enables pipefail, including digest-generation pipelines.
defaults:
run:
shell: bash
on:
push:
# A stable release publishes from the push that merges its reviewed release PR into main.
branches: [main]
tags:
# Stable tags are created only by the publish job. Direct tag pushes are reserved for
# prerelease channels.
- "v*-*"
env:
# Every package a release publishes, in publish order. The CLI is packed from
# @hyperframes/cli and published as the unscoped "hyperframes" package.
NPM_PACKAGES: >-
@hyperframes/share @hyperframes/parsers @hyperframes/lint @hyperframes/studio-server
@hyperframes/core @hyperframes/inspector @hyperframes/sdk @hyperframes/engine
@hyperframes/player @hyperframes/producer @hyperframes/shader-transitions
@hyperframes/studio @hyperframes/aws-lambda @hyperframes/gcp-cloud-run hyperframes
jobs:
release-source:
name: Check the release commit
runs-on: ubuntu-latest
timeout-minutes: 5
permissions:
contents: read
pull-requests: read
outputs:
sha: ${{ steps.source.outputs.sha }}
version: ${{ steps.source.outputs.version }}
source: ${{ steps.source.outputs.source }}
ref: ${{ steps.source.outputs.ref }}
steps:
# A prerelease tag can name any commit; every job after this builds what it names. Alphas are cut from main,
# next or alpha (release-channels.mdx), so the tagged commit must already be on one of them.
- name: Check the tagged commit is on main, next or alpha
if: github.ref_type == 'tag'
env:
GH_TOKEN: ${{ github.token }}
REPO: ${{ github.repository }}
TAGGED: ${{ github.sha }}
run: |
for branch in main next alpha; do
# A branch that does not exist answers 404; that branch holds nothing.
status="$(gh api "repos/$REPO/compare/$branch...$TAGGED" --jq .status 2>/dev/null)" || continue
case "$status" in identical | behind) exit 0 ;; esac
done
echo "::error::the tagged commit $TAGGED is not an ancestor of main, next or alpha, so it does not publish"
exit 1
# Every later job reads the release from these outputs. A push to main that merges no release PR leaves them
# empty, so nothing after this job runs.
- name: Find the release this push publishes
id: source
env:
GH_TOKEN: ${{ github.token }}
REPO: ${{ github.repository }}
SHA: ${{ github.sha }}
REF_TYPE: ${{ github.ref_type }}
REF_NAME: ${{ github.ref_name }}
HEAD_MESSAGE: ${{ github.event.head_commit.message }}
BEFORE: ${{ github.event.before }}
run: |
if [ "$REF_TYPE" = "tag" ]; then
{
echo "sha=$SHA"
echo "version=${REF_NAME#v}"
echo "source=tag"
echo "ref=$REF_NAME"
} >> "$GITHUB_OUTPUT"
exit 0
fi
# The merge queue can land several PRs in one push, and this runs once, for the last: every commit the push
# brought is read, and a release publishes its own merge commit, never a later one.
if [[ "$BEFORE" =~ ^0*$ ]]; then
jq -n --arg sha "$SHA" --arg message "$HEAD_MESSAGE" \
'{total_commits: 1, commits: [{sha: $sha, commit: {message: $message}}]}' > "$RUNNER_TEMP/push.json"
else
gh api "repos/$REPO/compare/$BEFORE...$SHA" > "$RUNNER_TEMP/push.json"
fi
[ "$(jq '.commits | length' "$RUNNER_TEMP/push.json")" = "$(jq .total_commits "$RUNNER_TEMP/push.json")" ] ||
{ echo "::error::the push to $SHA has more commits than GitHub lists, so a release in it could be missed"; exit 1; }
heads=""
while IFS=$'\t' read -r -u 3 commit subject; do
gh api "repos/$REPO/commits/$commit/pulls" > "$RUNNER_TEMP/pulls.json"
found="$(jq -r --arg sha "$commit" --arg repo "$REPO" '.[]
| select(.merged_at != null and .base.ref == "main" and .merge_commit_sha == $sha)
| select(.head.repo.full_name == $repo)
| select(.head.ref | test("^release/v[0-9]+[.][0-9]+[.][0-9]+$"))
| [.head.ref, .number, .head.sha, .user.login, .user.type, $sha] | @tsv' "$RUNNER_TEMP/pulls.json")"
# A release commit GitHub has not linked to its PR yet must fail, where a rerun recovers it, not skip.
if [ -z "$found" ] && [[ "$subject" =~ ^chore:\ release\ v[0-9] ]]; then
echo "::error::$commit reads as a release commit but merges no release PR from this repo; rerun once GitHub lists it"
exit 1
fi
heads+="${found:+$found$'\n'}"
done 3< <(jq -r '.commits[] | [.sha, (.commit.message | split("\n")[0])] | @tsv' "$RUNNER_TEMP/push.json")
heads="${heads%$'\n'}"
if [ -z "$heads" ]; then
echo "the push to $SHA merges no release PR; nothing to publish"
exit 0
fi
if [ "$(wc -l <<<"$heads")" -ne 1 ]; then
echo "::error::$SHA is the merge of more than one release PR: $(cut -f1 <<<"$heads" | tr '\n' ' ')"
exit 1
fi
IFS=$'\t' read -r ref number head author author_type release <<<"$heads"
# Branch protection can be bypassed, so a maintainer who did not open, write or push the release must approve
# its final commit, and no maintainer's or app's change request may stand. Anyone can review a public repo:
# a person's review counts only with write access. Each reviewer's latest verdict counts.
gh api "repos/$REPO/pulls/$number" > "$RUNNER_TEMP/pull.json"
gh api --paginate "repos/$REPO/pulls/$number/reviews" > "$RUNNER_TEMP/reviews.json"
gh api --paginate "repos/$REPO/pulls/$number/commits" > "$RUNNER_TEMP/commits.json"
gh api --paginate "repos/$REPO/issues/$number/events" > "$RUNNER_TEMP/events.json"
# Commit names can be anyone's, so every account that pushed the branch is a writer too.
gh api --paginate "repos/$REPO/activity?ref=refs/heads/$ref&per_page=100" > "$RUNNER_TEMP/activity.json"
listed="$(jq -s 'add | length' "$RUNNER_TEMP/commits.json")"
[ "$listed" = "$(jq .commits "$RUNNER_TEMP/pull.json")" ] ||
{ echo "::error::#$number has more commits than GitHub lists ($listed), so who wrote it is unknown"; exit 1; }
jq -s -r 'add | .[] | select(.activity_type != "branch_deletion") | [.actor.login, .actor.type] | @tsv' \
"$RUNNER_TEMP/activity.json" > "$RUNNER_TEMP/pushers.tsv"
[ -s "$RUNNER_TEMP/pushers.tsv" ] ||
{ echo "::error::no push to $ref is recorded, so who pushed it is unknown"; exit 1; }
! grep -q $'^\t' "$RUNNER_TEMP/pushers.tsv" ||
{ echo "::error::a push to $ref is recorded with no account, so who pushed it is unknown"; exit 1; }
{
echo "$author"
cut -f1 "$RUNNER_TEMP/pushers.tsv"
jq -s -r 'add | .[] | .author.login?, .committer.login? | values' "$RUNNER_TEMP/commits.json"
jq -s -r 'add | .[] | select(.event == "head_ref_force_pushed") | .actor.login? | values' \
"$RUNNER_TEMP/events.json"
} > "$RUNNER_TEMP/writers.txt"
# A second person with write access opened or pushed it; none of them can be the approver.
second=""
for login in $({ [ "$author_type" != User ] || echo "$author"; awk -F'\t' '$2 == "User" { print $1 }' \
"$RUNNER_TEMP/pushers.tsv"; } | sort -u); do
permission="$(gh api "repos/$REPO/collaborators/$login/permission" --jq .permission)" ||
{ echo "::error::could not read $login's permission on $REPO, so the release does not publish"; exit 1; }
case "$permission" in admin | write) second="$login" && break ;; esac
done
[ -n "$second" ] ||
{ echo "::error::no person with write access opened or pushed $ref besides its approver"; exit 1; }
: > "$RUNNER_TEMP/maintainers.txt"
for login in $(jq -s -r 'add
| map(select(.user.type == "User" and (.state == "APPROVED" or .state == "CHANGES_REQUESTED")))
| map(.user.login) | unique[]' \
"$RUNNER_TEMP/reviews.json"); do
permission="$(gh api "repos/$REPO/collaborators/$login/permission" --jq .permission)" ||
{ echo "::error::could not read $login's permission on $REPO, so the release does not publish"; exit 1; }
case "$permission" in admin | write) echo "$login" >> "$RUNNER_TEMP/maintainers.txt" ;; esac
done
# An approval counts only after the PR's last base change, so it reviewed the diff into main.
based="$(jq -s -r 'add | map(select(.event == "base_ref_changed") | .created_at) | max // ""' \
"$RUNNER_TEMP/events.json")"
reviewed="$(jq -s -r --arg head "$head" --arg based "$based" \
--rawfile maintainers "$RUNNER_TEMP/maintainers.txt" --rawfile writers "$RUNNER_TEMP/writers.txt" 'add
| ($maintainers | split("\n")) as $maintainers | ($writers | split("\n")) as $writers
| map(select(.state == "APPROVED" or .state == "CHANGES_REQUESTED"))
| map(select(.user.type != "User" or (.user.login | IN($maintainers[]))))
| group_by(.user.login) | map(max_by(.submitted_at))
| any(.state == "APPROVED" and .commit_id == $head and .user.type == "User" and .submitted_at > $based
and (.user.login | IN($writers[]) | not))
and all(.state != "CHANGES_REQUESTED")' \
"$RUNNER_TEMP/reviews.json")"
if [ "$reviewed" != "true" ]; then
echo "::error::$ref (#$number): no maintainer who did not write or push it approved its final commit," \
"or a change request stands"
exit 1
fi
{
echo "sha=$release"
echo "version=${ref#release/v}"
echo "source=release-pr"
echo "ref=$ref"
} >> "$GITHUB_OUTPUT"
lambda-arm64-ffmpeg:
name: Lambda arm64 ffmpeg
needs: [release-source]
runs-on: ubuntu-24.04-arm
# A cache miss compiles ffmpeg natively, 15-20 minutes.
timeout-minutes: 60
permissions:
contents: read
env:
EXPECTED_RELEASE_SHA: ${{ needs.release-source.outputs.sha }}
if: needs.release-source.outputs.sha != ''
steps:
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
with:
ref: ${{ env.EXPECTED_RELEASE_SHA }}
# lambda-arm64-image.yml saves this key on main; a release run's own saves reach only its re-runs.
- id: cache
uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
with:
path: out/
key: hf-media-linux-aarch64-${{ hashFiles('packages/aws-lambda/image/**') }}
- if: steps.cache.outputs.cache-hit != 'true'
run: >-
docker buildx build --progress=plain --platform linux/arm64 --target artifact
--output type=local,dest=out packages/aws-lambda/image
# The reviewed digest of the build; a tarball from the cache or this run that differs fails here.
- name: Check the tarball against its committed digest
working-directory: out
run: sha256sum hf-media-linux-aarch64.tar.gz && sha256sum --strict -c ../packages/aws-lambda/hf-media-linux-aarch64.sha256
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: hf-media-linux-aarch64
overwrite: true
path: out/hf-media-linux-aarch64.tar.gz
if-no-files-found: error
lambda-handler-zip:
name: Lambda handler zip
needs: [release-source]
runs-on: ubuntu-latest
timeout-minutes: 30
# Runs apart from the publish job: read-only token, no secrets, no stored git credentials.
permissions:
contents: read
env:
EXPECTED_RELEASE_SHA: ${{ needs.release-source.outputs.sha }}
if: needs.release-source.outputs.sha != ''
outputs:
sha256: ${{ steps.zip.outputs.sha256 }}
steps:
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
with:
ref: ${{ env.EXPECTED_RELEASE_SHA }}
persist-credentials: false
- name: Verify immutable release checkout
run: |
ACTUAL_SHA="$(git rev-parse HEAD)"
EXPECTED_COMMIT_SHA="$(git rev-parse "${EXPECTED_RELEASE_SHA}^{commit}")"
if [ "$ACTUAL_SHA" != "$EXPECTED_COMMIT_SHA" ]; then
echo "::error::Expected release commit $EXPECTED_COMMIT_SHA, checked out $ACTUAL_SHA"
exit 1
fi
# The release installs the bun it downloads, never one restored from the shared cache.
- uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
with:
no-cache: true
- uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
with:
node-version: 24
- run: bun install --frozen-lockfile
- run: bun run build
- name: Build Lambda handler zip
id: zip
run: |
bun run --cwd packages/aws-lambda build:zip
echo "sha256=$(sha256sum packages/aws-lambda/dist/handler.zip | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: hyperframes-lambda-handler-zip
overwrite: true
path: packages/aws-lambda/dist/handler.zip
if-no-files-found: error
# The video stage installs Chrome's system libraries with microdnf, so it builds on ARM, not under emulation.
lambda-video-image:
name: Lambda video image
needs: [release-source, lambda-arm64-ffmpeg, lambda-handler-zip]
runs-on: ubuntu-24.04-arm
timeout-minutes: 30
permissions:
contents: read
env:
EXPECTED_RELEASE_SHA: ${{ needs.release-source.outputs.sha }}
if: needs.release-source.outputs.sha != ''
outputs:
sha256: ${{ steps.image.outputs.sha256 }}
steps:
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
with:
ref: ${{ env.EXPECTED_RELEASE_SHA }}
persist-credentials: false
- name: Verify immutable release checkout
run: |
ACTUAL_SHA="$(git rev-parse HEAD)"
EXPECTED_COMMIT_SHA="$(git rev-parse "${EXPECTED_RELEASE_SHA}^{commit}")"
if [ "$ACTUAL_SHA" != "$EXPECTED_COMMIT_SHA" ]; then
echo "::error::Expected release commit $EXPECTED_COMMIT_SHA, checked out $ACTUAL_SHA"
exit 1
fi
- uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
with:
no-cache: true
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
name: hyperframes-lambda-handler-zip
path: dist/lambda-handler-build
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
name: hf-media-linux-aarch64
path: dist/hf-media
- name: Build Lambda video image
id: image
env:
EXPECTED_ZIP_SHA256: ${{ needs.lambda-handler-zip.outputs.sha256 }}
run: |
ACTUAL_ZIP_SHA256="$(sha256sum dist/lambda-handler-build/handler.zip | cut -d' ' -f1)"
if [ -z "$EXPECTED_ZIP_SHA256" ] || [ "$ACTUAL_ZIP_SHA256" != "$EXPECTED_ZIP_SHA256" ]; then
echo "::error::Lambda handler zip sha256 $ACTUAL_ZIP_SHA256 does not match the build job's $EXPECTED_ZIP_SHA256"
exit 1
fi
bun packages/aws-lambda/scripts/stage-arm64-image.ts --zip=dist/lambda-handler-build/handler.zip \
--ffmpeg=dist/hf-media/hf-media-linux-aarch64.tar.gz --out=dist/arm64-image
# OCI export needs a docker-container builder; no attestations, so index.json lists one image.
docker buildx create --use
docker buildx build --progress=plain --platform linux/arm64 --target video \
--provenance=false --sbom=false --build-context task=dist/arm64-image/task \
--output type=oci,dest=dist/hyperframes-lambda-video-arm64.oci.tar packages/aws-lambda/image
echo "sha256=$(sha256sum dist/hyperframes-lambda-video-arm64.oci.tar | cut -d' ' -f1)" >> "$GITHUB_OUTPUT"
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: hyperframes-lambda-video-arm64
overwrite: true
path: dist/hyperframes-lambda-video-arm64.oci.tar
if-no-files-found: error
pack:
name: Build and pack
outputs:
bundle_id: ${{ steps.previous_bundle.outputs.artifact || steps.bundle.outputs.artifact-id }}
needs: [release-source, lambda-handler-zip, lambda-video-image]
runs-on: ubuntu-latest
timeout-minutes: 30
# Every build and lifecycle script of the release commit runs here, with a
# read-only token and no secrets. The publish job gets only what this job packs.
permissions:
contents: read
actions: read
env:
EXPECTED_RELEASE_SHA: ${{ needs.release-source.outputs.sha }}
if: needs.release-source.outputs.sha != ''
steps:
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
with:
fetch-depth: 0
# Pin every release to an immutable ref: main may advance before this job starts, so check out
# the exact commit release-source found.
ref: ${{ env.EXPECTED_RELEASE_SHA }}
persist-credentials: false
- name: Verify immutable release checkout
run: |
ACTUAL_SHA="$(git rev-parse HEAD)"
EXPECTED_COMMIT_SHA="$(git rev-parse "${EXPECTED_RELEASE_SHA}^{commit}")"
if [ "$ACTUAL_SHA" != "$EXPECTED_COMMIT_SHA" ]; then
echo "::error::Expected release commit $EXPECTED_COMMIT_SHA, checked out $ACTUAL_SHA"
exit 1
fi
- name: Find previous release bundle
id: previous_bundle
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REPO: ${{ github.repository }}
RUN_ID: ${{ github.run_id }}
run: |
gh api --paginate "repos/$REPO/actions/runs/$RUN_ID/artifacts?per_page=100" > "$RUNNER_TEMP/previous_bundle-pages.json"
FOUND="$(jq -sre '[.[].artifacts[] | select(.name == "release-bundle")] | if length == 0 then "" elif length == 1 and .[0].expired == false then .[0].id | tostring else error("Missing valid unique release-bundle") end' "$RUNNER_TEMP/previous_bundle-pages.json")"
echo "artifact=${FOUND}" >> "$GITHUB_OUTPUT"
- name: Restore previous release bundle
if: steps.previous_bundle.outputs.artifact != ''
uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
artifact-ids: ${{ steps.previous_bundle.outputs.artifact }}
path: release-bundle
merge-multiple: true
- name: Resolve version
if: steps.previous_bundle.outputs.artifact == ''
id: version
env:
VERSION: ${{ needs.release-source.outputs.version }}
run: |
echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
# Detect pre-release tag (e.g. 0.1.16-alpha.1 → alpha, 0.1.16-beta.2 → beta)
if [[ "$VERSION" =~ -([a-zA-Z]+) ]]; then
DIST_TAG="${BASH_REMATCH[1]}"
echo "prerelease=true" >> "$GITHUB_OUTPUT"
else
DIST_TAG="latest"
echo "prerelease=false" >> "$GITHUB_OUTPUT"
fi
echo "dist_tag=${DIST_TAG}" >> "$GITHUB_OUTPUT"
echo "Resolved version=${VERSION} dist_tag=${DIST_TAG}"
- name: Validate release channel
if: steps.previous_bundle.outputs.artifact == ''
env:
VERSION: ${{ steps.version.outputs.version }}
DIST_TAG: ${{ steps.version.outputs.dist_tag }}
SOURCE: ${{ needs.release-source.outputs.source }}
RELEASE_REF: ${{ needs.release-source.outputs.ref }}
run: node scripts/validate-release-channel.mjs
# The release installs the bun it downloads, never one restored from the shared cache.
- uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
if: steps.previous_bundle.outputs.artifact == ''
with:
no-cache: true
- uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
if: steps.previous_bundle.outputs.artifact == ''
with:
node-version: 24
- run: corepack enable
if: steps.previous_bundle.outputs.artifact == ''
- run: corepack prepare pnpm@10.17.1 --activate
if: steps.previous_bundle.outputs.artifact == ''
- run: bun install --frozen-lockfile
if: steps.previous_bundle.outputs.artifact == ''
- run: bun run build
if: steps.previous_bundle.outputs.artifact == ''
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
if: steps.previous_bundle.outputs.artifact == ''
with:
name: hyperframes-lambda-handler-zip
path: dist/lambda-handler-build
# Before packing, so @hyperframes/aws-lambda pins this exact zip.
- name: Pin Lambda handler zip
if: steps.previous_bundle.outputs.artifact == ''
id: lambda_zip
env:
EXPECTED_SHA256: ${{ needs.lambda-handler-zip.outputs.sha256 }}
run: |
ACTUAL_SHA256="$(sha256sum dist/lambda-handler-build/handler.zip | cut -d' ' -f1)"
if [ -z "$EXPECTED_SHA256" ] || [ "$ACTUAL_SHA256" != "$EXPECTED_SHA256" ]; then
echo "::error::Lambda handler zip sha256 $ACTUAL_SHA256 does not match the build job's $EXPECTED_SHA256"
exit 1
fi
mv dist/lambda-handler-build/handler.zip dist/hyperframes-lambda-handler.zip
rm -rf dist/lambda-handler-build
bun packages/aws-lambda/scripts/pin-handler-zip.ts
# lambda-video-image built it on ARM from the same zip sha pinned above.
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
if: steps.previous_bundle.outputs.artifact == ''
with:
name: hyperframes-lambda-video-arm64
path: dist
- name: Pin Lambda video image
if: steps.previous_bundle.outputs.artifact == ''
id: lambda_video_image
env:
EXPECTED_SHA256: ${{ needs.lambda-video-image.outputs.sha256 }}
run: |
ACTUAL_SHA256="$(sha256sum dist/hyperframes-lambda-video-arm64.oci.tar | cut -d' ' -f1)"
if [ -z "$EXPECTED_SHA256" ] || [ "$ACTUAL_SHA256" != "$EXPECTED_SHA256" ]; then
echo "::error::Lambda video image sha256 $ACTUAL_SHA256 does not match the build job's $EXPECTED_SHA256"
exit 1
fi
bun packages/aws-lambda/scripts/pin-handler-zip.ts --video-image
- run: bun run verify:packed-manifests
if: steps.previous_bundle.outputs.artifact == ''
# pnpm pack writes the same tarball pnpm publish uploads: publishConfig
# applied and workspace: ranges replaced with versions.
- name: Pack packages
if: steps.previous_bundle.outputs.artifact == ''
run: |
OUT="$PWD/release-bundle/npm"
mkdir -p "$OUT"
for name in $NPM_PACKAGES; do
[ "$name" = "hyperframes" ] && continue
pnpm --filter "$name" pack --pack-destination "$OUT"
done
# pnpm --filter cannot match the rewritten name, so npm packs the CLI.
node -e "
const fs = require('fs');
const p = 'packages/cli/package.json';
const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
pkg.name = 'hyperframes';
fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n');
"
(cd packages/cli && npm pack --pack-destination "$OUT")
- name: Build portable agent plugin
if: steps.previous_bundle.outputs.artifact == ''
run: node scripts/package-agent-plugin.mjs
# Keep the original bytes for all retries, including partially uploaded pairs.
- name: Collect release bundle
if: steps.previous_bundle.outputs.artifact == ''
env:
VERSION: ${{ steps.version.outputs.version }}
run: |
mkdir -p release-bundle/assets release-bundle/plugin
mv dist/hyperframes-lambda-handler.zip dist/hyperframes-lambda-handler.sha256 release-bundle/assets/
mv dist/hyperframes-lambda-video-arm64.oci.tar dist/hyperframes-lambda-video-arm64.sha256 release-bundle/assets/
mv dist/hyperframes-agent-plugin.zip dist/hyperframes-agent-plugin.sha256 dist/hyperframes-agent-plugin.json release-bundle/plugin/
if [ -f "releases/v${VERSION}.md" ]; then
cp "releases/v${VERSION}.md" release-bundle/notes.md
fi
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
id: bundle
if: steps.previous_bundle.outputs.artifact == ''
with:
name: release-bundle
path: release-bundle/
if-no-files-found: error
compression-level: 1
overwrite: false
retention-days: 7
publish:
name: Publish
needs: [release-source, pack]
runs-on: ubuntu-latest
timeout-minutes: 30
# Per release, not per ref: on main a later push would cancel a release run still waiting to start.
concurrency:
group: publish-${{ needs.release-source.outputs.version }}
cancel-in-progress: false
# npm's trusted publishers name this environment, so every trigger uses it. A required reviewer
# approves each run, on top of the reviewed release PR; only repository admins may push v*-* tags.
environment: npm-publish
# This job holds the release credentials, so it runs no code from the
# release commit: no install, no build, no repo scripts. It checks the
# pack job's tarballs and uploads them.
permissions:
contents: write
actions: read
id-token: write
env:
EXPECTED_RELEASE_SHA: ${{ needs.release-source.outputs.sha }}
# Stable releases come only from the merge of a reviewed release PR. Tag pushes are
# prerelease-only because the trigger pattern requires a hyphenated version.
if: needs.release-source.outputs.sha != ''
steps:
# Only git reads this checkout, for the release tag.
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
with:
fetch-depth: 0
ref: ${{ env.EXPECTED_RELEASE_SHA }}
# Keep the write token out of .git/config. Only "Create release tag"
# pushes, and it authenticates its own git calls.
persist-credentials: false
- name: Verify immutable release checkout
run: |
ACTUAL_SHA="$(git rev-parse HEAD)"
EXPECTED_COMMIT_SHA="$(git rev-parse "${EXPECTED_RELEASE_SHA}^{commit}")"
if [ "$ACTUAL_SHA" != "$EXPECTED_COMMIT_SHA" ]; then
echo "::error::Expected release commit $EXPECTED_COMMIT_SHA, checked out $ACTUAL_SHA"
exit 1
fi
# Read from release-source, which runs no release-commit code: the pack job did, so its outputs are not
# trusted here.
- name: Resolve version
id: version
env:
VERSION: ${{ needs.release-source.outputs.version }}
run: |
echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
# Detect pre-release tag (e.g. 0.1.16-alpha.1 → alpha, 0.1.16-beta.2 → beta)
if [[ "$VERSION" =~ -([a-zA-Z]+) ]]; then
DIST_TAG="${BASH_REMATCH[1]}"
echo "prerelease=true" >> "$GITHUB_OUTPUT"
else
DIST_TAG="latest"
echo "prerelease=false" >> "$GITHUB_OUTPUT"
fi
echo "dist_tag=${DIST_TAG}" >> "$GITHUB_OUTPUT"
echo "Resolved version=${VERSION} dist_tag=${DIST_TAG}"
# The event rules of scripts/validate-release-channel.mjs, inline so they
# hold even when the release commit changes that script.
- name: Check release channel
env:
SOURCE: ${{ needs.release-source.outputs.source }}
VERSION: ${{ steps.version.outputs.version }}
PRERELEASE: ${{ steps.version.outputs.prerelease }}
DIST_TAG: ${{ steps.version.outputs.dist_tag }}
run: |
if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z][0-9A-Za-z-]*(\.[0-9A-Za-z-]+)*)?$ ]]; then
echo "::error::Invalid release version \"$VERSION\". Expected x.y.z or x.y.z-channel.N."
exit 1
fi
if [ "$SOURCE" != "tag" ] && [ "$SOURCE" != "release-pr" ]; then
echo "::error::Unknown release source \"$SOURCE\"."
exit 1
fi
if [ "$SOURCE" = "tag" ] && [ "$PRERELEASE" != "true" ]; then
echo "::error::Tag pushes publish prereleases only; v$VERSION is a stable version."
exit 1
fi
if [ "$SOURCE" = "release-pr" ] && [ "$PRERELEASE" != "false" ]; then
echo "::error::Merged release PRs publish stable releases only; v$VERSION is a prerelease."
exit 1
fi
if [ "$PRERELEASE" = "true" ] && [ "$DIST_TAG" = "latest" ]; then
echo "::error::v$VERSION is a prerelease and cannot publish to the latest dist-tag."
exit 1
fi
# An allow-list, matched exactly, so no letter case or new suffix of a pushed tag names another dist-tag.
if [ "$PRERELEASE" = "true" ]; then
case "$DIST_TAG" in
alpha | beta | rc | next | canary | hdr | native | desktop) ;;
*)
echo "::error::v$VERSION names the dist-tag \"$DIST_TAG\". Prereleases publish only to alpha, beta, rc, next, canary, hdr, native or desktop."
exit 1
;;
esac
fi
- uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
with:
node-version: 24
registry-url: "https://registry.npmjs.org"
- uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
artifact-ids: ${{ needs.pack.outputs.bundle_id }}
merge-multiple: true
path: ${{ runner.temp }}/release-bundle
- name: Check packed tarballs
env:
VERSION: ${{ steps.version.outputs.version }}
run: |
FOUND="$RUNNER_TEMP/packed.tsv"
ORDER="$RUNNER_TEMP/publish-order.tsv"
: > "$FOUND"
: > "$ORDER"
for tarball in "$RUNNER_TEMP"/release-bundle/npm/*; do
file="$(basename "$tarball")"
if ! [[ "$file" =~ ^[A-Za-z0-9._-]+\.tgz$ ]]; then
echo "::error::Unexpected file in the packed tarballs: $file"
exit 1
fi
# npm unpacks every entry one level down, so anything but plain files under package/ could hand npm a
# different package.json than the one checked here.
entries="$(tar -tzf "$tarball")"
types="$(tar -tvzf "$tarball" | cut -c1 | sort -u)"
if grep -q -v '^package/' <<<"$entries" \
|| grep -q -E '(^|/)\.\.?(/|$)|//|\\' <<<"$entries" \
|| [ "$(grep -cx 'package/package.json' <<<"$entries")" -ne 1 ] \
|| grep -q -v -E '^[-d]$' <<<"$types"; then
echo "::error::$file must hold one package/package.json and only plain files under package/"
exit 1
fi
manifest="$(tar -xzOf "$tarball" package/package.json)"
# Publishing applies publishConfig, so it may only carry what our packages set.
if ! jq -e '(.publishConfig // {}) | type == "object"
and (keys - ["access", "registry", "exports", "main", "types"] | length == 0)
and ((.access // "public") == "public")
and ((.registry // "https://registry.npmjs.org/") == "https://registry.npmjs.org/")' \
<<<"$manifest" >/dev/null; then
echo "::error::$file has a publishConfig this release does not allow"
exit 1
fi
name="$(jq -r '.name' <<<"$manifest")"
version="$(jq -r '.version' <<<"$manifest")"
if ! [[ "$name" =~ ^(@[a-z0-9-]+/)?[a-z0-9._-]+$ ]]; then
echo "::error::$file has an invalid package name"
exit 1
fi
if [ "$version" != "$VERSION" ]; then
echo "::error::$file packs $name@$version, but this release is $VERSION"
exit 1
fi
printf '%s\t%s\n' "$name" "$tarball" >> "$FOUND"
done
DUPLICATES="$(cut -f1 "$FOUND" | sort | uniq -d)"
if [ -n "$DUPLICATES" ]; then
echo "::error::Packed more than once: $DUPLICATES"
exit 1
fi
for name in $NPM_PACKAGES; do
line="$(awk -F'\t' -v name="$name" '$1 == name' "$FOUND")"
if [ -z "$line" ]; then
echo "::error::No packed tarball for $name"
exit 1
fi
printf '%s\n' "$line" >> "$ORDER"
done
if [ "$(wc -l < "$FOUND")" -ne "$(wc -l < "$ORDER")" ]; then
EXTRA="$(cut -f1 "$FOUND" | grep -vxF -f <(cut -f1 "$ORDER") | tr '\n' ' ')"
echo "::error::Packed tarballs for packages this workflow does not publish: $EXTRA"
exit 1
fi
cat "$ORDER"
# npm publish reads each tarball with its own node-tar; a header GNU tar reads another way can give it
# a different package.json than the one checked above. This asks that npm, without uploading, what it publishes.
- name: Check what npm will publish
working-directory: ${{ runner.temp }}
env:
VERSION: ${{ steps.version.outputs.version }}
DIST_TAG: ${{ steps.version.outputs.dist_tag }}
run: |
while IFS=$'\t' read -r name tarball; do
if ! view="$(npm publish "$tarball" --dry-run --json --ignore-scripts --access public --tag "$DIST_TAG" \
--registry https://registry.npmjs.org/ 2>/dev/null)"; then
echo "::error::npm cannot read $(basename "$tarball")"
exit 1
fi
# npm 10 prints one object, npm 11 keys it by package name.
read_as="$(jq -r 'if has("name") then . else (to_entries | if length == 1 then .[0].value else error("more than one package") end) end
| "\(.name)@\(.version)\t\([.files[].path | select(. != "")] | sort | join("\n"))"' <<<"$view")" || {
echo "::error::npm reads $(basename "$tarball") as more than one package"
exit 1
}
npm_id="${read_as%%$'\t'*}"
npm_files="${read_as#*$'\t'}"
tar_files="$(tar -tzf "$tarball" | grep -v '/$' | sed 's#^package/##' | LC_ALL=C sort)"
if [ "$npm_id" != "$name@$VERSION" ]; then
echo "::error::npm would publish $(basename "$tarball") as $npm_id, not $name@$VERSION"
exit 1
fi
if [ "$npm_files" != "$(LC_ALL=C sort <<<"$npm_files")" ] || [ "$npm_files" != "$tar_files" ]; then
echo "::error::npm and tar read different files in $(basename "$tarball")"
exit 1
fi
done < publish-order.tsv
- name: Create release tag
if: needs.release-source.outputs.source == 'release-pr'
env:
VERSION: ${{ steps.version.outputs.version }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
: "${GITHUB_TOKEN:?}"
BASIC_AUTH="$(printf 'x-access-token:%s' "$GITHUB_TOKEN" | base64 -w0)"
echo "::add-mask::$BASIC_AUTH"
export GIT_CONFIG_COUNT=1
export GIT_CONFIG_KEY_0="http.https://github.com/.extraheader"
export GIT_CONFIG_VALUE_0="AUTHORIZATION: basic $BASIC_AUTH"
TAG="v$VERSION"
EXPECTED_TAG_SHA="$(git rev-parse HEAD)"
verify_remote_tag() {
git fetch --force --no-tags origin "+refs/tags/$TAG:refs/tags/$TAG"
ACTUAL_TAG_SHA="$(git rev-parse "refs/tags/$TAG^{commit}")"
if [ "$ACTUAL_TAG_SHA" != "$EXPECTED_TAG_SHA" ]; then
echo "::error::Release tag $TAG points to $ACTUAL_TAG_SHA, expected $EXPECTED_TAG_SHA"
exit 1
fi
echo "Release tag $TAG already exists at the expected commit — skipping"
}
if [ -n "$(git ls-remote --refs origin "refs/tags/$TAG")" ]; then
verify_remote_tag
else
git tag --no-sign "$TAG" "$EXPECTED_TAG_SHA"
if ! git push origin "refs/tags/$TAG"; then
# A concurrent retry may have created the tag after ls-remote.
git tag -d "$TAG"
verify_remote_tag
fi
fi
- name: Check published Lambda pins
env:
VERSION: ${{ steps.version.outputs.version }}
run: |
META="$RUNNER_TEMP/aws-lambda-version.json"
PUBLISHED="$RUNNER_TEMP/aws-lambda-published.tgz"
STATUS="$(curl -sS -o "$META" -w '%{http_code}' "https://registry.npmjs.org/@hyperframes%2faws-lambda/${VERSION}")"
if [ "$STATUS" = "404" ]; then
exit 0
fi
if [ "$STATUS" != "200" ]; then
echo "::error::The npm registry answered $STATUS for @hyperframes/aws-lambda@${VERSION}"
exit 1
fi
curl -fsSL -o "$PUBLISHED" "$(jq -r '.dist.tarball' "$META")"
INTEGRITY="sha512-$(openssl dgst -sha512 -binary "$PUBLISHED" | base64 -w0)"
if [ "$INTEGRITY" != "$(jq -r '.dist.integrity' "$META")" ]; then
echo "::error::The @hyperframes/aws-lambda@${VERSION} tarball does not match its npm integrity"
exit 1
fi
check_pin() {
local asset="$1" manifest="$2" pinned built
pinned="$(tar -xzOf "$PUBLISHED" "package/prebuilt/$manifest" | jq -r '.sha256')"
built="$(sha256sum "$RUNNER_TEMP/release-bundle/assets/$asset" | cut -d' ' -f1)"
if [ "$pinned" != "$built" ]; then
echo "::error::@hyperframes/aws-lambda@${VERSION} on npm pins $asset at $pinned, but this run's original bundle has $built"
exit 1
fi
}
check_pin hyperframes-lambda-handler.zip handler-zip.json
check_pin hyperframes-lambda-video-arm64.oci.tar video-image.json
- name: Find previous release receipt
id: previous_receipt
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REPO: ${{ github.repository }}
RUN_ID: ${{ github.run_id }}
run: |
gh api --paginate "repos/$REPO/actions/runs/$RUN_ID/artifacts?per_page=100" > "$RUNNER_TEMP/previous_receipt-pages.json"
FOUND="$(jq -sre '[.[].artifacts[] | select(.name == "lambda-release-receipt")] | if length == 0 then "" elif length == 1 and .[0].expired == false then .[0].id | tostring else error("Missing valid unique lambda-release-receipt") end' "$RUNNER_TEMP/previous_receipt-pages.json")"
echo "artifact=${FOUND}" >> "$GITHUB_OUTPUT"
- name: Restore previous release receipt
if: steps.previous_receipt.outputs.artifact != ''
uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
with:
artifact-ids: ${{ steps.previous_receipt.outputs.artifact }}
path: ${{ runner.temp }}/release-receipt
merge-multiple: true
# This receipt is stored in this run's immutable Actions artifact, never on the mutable release.
- name: Create GitHub Release
id: release
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
VERSION: ${{ steps.version.outputs.version }}
PRERELEASE: ${{ steps.version.outputs.prerelease }}
REPO: ${{ github.repository }}
RUN_ID: ${{ github.run_id }}
run: |
RECEIPT="$RUNNER_TEMP/release-receipt/receipt.json"
ASSETS="$RUNNER_TEMP/release-bundle/assets"
mkdir -p "$RUNNER_TEMP/release-receipt"
DIGESTS="$RUNNER_TEMP/lambda-digests.json"
for name in hyperframes-lambda-handler.zip hyperframes-lambda-handler.sha256 hyperframes-lambda-video-arm64.oci.tar hyperframes-lambda-video-arm64.sha256; do
digest="$(sha256sum "$ASSETS/$name" | cut -d' ' -f1)"
jq -n --arg name "$name" --arg digest "$digest" '{key: $name, value: $digest}'
done | jq -s 'from_entries' > "$DIGESTS"
if [ -f "$RECEIPT" ]; then
jq -e --arg repo "$REPO" --arg run "$RUN_ID" --arg tag "v$VERSION" --arg sha "$EXPECTED_RELEASE_SHA" --slurpfile assets "$DIGESTS" '
.repo == $repo and .run == $run and .tag == $tag and .sha == $sha and
(.release_id | type == "number" and . > 0 and floor == .) and .assets == $assets[0]
' "$RECEIPT" > /dev/null
RELEASE_ID="$(jq -r .release_id "$RECEIPT")"
gh api "repos/$REPO/releases/tags/v$VERSION" > "$RUNNER_TEMP/release.json"
jq -e --argjson id "$RELEASE_ID" '.id == $id' "$RUNNER_TEMP/release.json" > /dev/null
else
# Create-only: an existing release or a concurrent creator fails, never becomes ours.
NOTES_FILE="$RUNNER_TEMP/release-bundle/notes.md"
if [ ! -f "$NOTES_FILE" ]; then
gh api --method POST "repos/$REPO/releases/generate-notes" -f tag_name="v$VERSION" --jq .body > "$RUNNER_TEMP/generated-notes.md"
NOTES_FILE="$RUNNER_TEMP/generated-notes.md"
fi
jq -n --arg tag "v$VERSION" --arg sha "$EXPECTED_RELEASE_SHA" --argjson prerelease "$PRERELEASE" --rawfile body "$NOTES_FILE" \
'{tag_name:$tag, target_commitish:$sha, name:$tag, prerelease:$prerelease, body:$body}' > "$RUNNER_TEMP/create-release.json"
gh api --method POST "repos/$REPO/releases" --input "$RUNNER_TEMP/create-release.json" > "$RUNNER_TEMP/release.json"
RELEASE_ID="$(jq -er '.id | select(type == "number" and . > 0 and floor == .)' "$RUNNER_TEMP/release.json")"
jq -n --arg repo "$REPO" --arg run "$RUN_ID" --arg tag "v$VERSION" --arg sha "$EXPECTED_RELEASE_SHA" --argjson id "$RELEASE_ID" --slurpfile assets "$DIGESTS" \
'{repo:$repo,run:$run,tag:$tag,sha:$sha,release_id:$id,assets:$assets[0]}' > "$RECEIPT"
fi
echo "id=$RELEASE_ID" >> "$GITHUB_OUTPUT"
- name: Save release receipt
if: steps.previous_receipt.outputs.artifact == ''
uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
with:
name: lambda-release-receipt
path: ${{ runner.temp }}/release-receipt/receipt.json
if-no-files-found: error
overwrite: false
retention-days: 7
- name: Attach Lambda assets to release
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REPO: ${{ github.repository }}
VERSION: ${{ steps.version.outputs.version }}
RELEASE_ID: ${{ steps.release.outputs.id }}
run: |
ASSETS="$RUNNER_TEMP/release-bundle/assets"
for name in hyperframes-lambda-handler.zip hyperframes-lambda-handler.sha256 hyperframes-lambda-video-arm64.oci.tar hyperframes-lambda-video-arm64.sha256; do
digest="$(sha256sum "$ASSETS/$name" | cut -d' ' -f1)"
gh api --paginate "repos/$REPO/releases/$RELEASE_ID/assets?per_page=100" > "$RUNNER_TEMP/assets-pages.json"
existing="$(jq -sc --arg name "$name" '[.[][] | select(.name == $name)]' "$RUNNER_TEMP/assets-pages.json")"
if [ "$(jq length <<< "$existing")" != 0 ]; then
jq -e --arg digest "sha256:$digest" 'length == 1 and .[0].state == "uploaded" and .[0].digest == $digest' <<< "$existing" > /dev/null
else
# Upload by the recorded ID; a replacement release at the tag cannot receive these bytes.
gh api --method POST "https://uploads.github.com/repos/$REPO/releases/$RELEASE_ID/assets?name=$name" \
-H 'Content-Type: application/octet-stream' --input "$ASSETS/$name" > "$RUNNER_TEMP/uploaded-asset.json"
jq -e --arg digest "sha256:$digest" '.state == "uploaded" and .digest == $digest' "$RUNNER_TEMP/uploaded-asset.json" > /dev/null
fi
done
- name: Verify Lambda release before npm publication
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
REPO: ${{ github.repository }}
VERSION: ${{ steps.version.outputs.version }}
RELEASE_ID: ${{ steps.release.outputs.id }}
run: |
gh api "repos/$REPO/releases/tags/v$VERSION" > "$RUNNER_TEMP/release.json"
jq -e --argjson id "$RELEASE_ID" '.id == $id' "$RUNNER_TEMP/release.json" > /dev/null
gh api --paginate "repos/$REPO/releases/$RELEASE_ID/assets?per_page=100" > "$RUNNER_TEMP/assets-pages.json"
jq -se --slurpfile receipt "$RUNNER_TEMP/release-receipt/receipt.json" '
[.[][]] as $assets | $receipt[0].assets | to_entries | all(.[];
. as $expected | [$assets[] | select(.name == $expected.key)] |
length == 1 and .[0].state == "uploaded" and .[0].digest == ("sha256:" + $expected.value))
' "$RUNNER_TEMP/assets-pages.json" > /dev/null
# Runs outside the checkout so no project .npmrc applies, and with
# --ignore-scripts so no lifecycle script runs next to the npm credentials.
- name: Publish packages
working-directory: ${{ runner.temp }}
env:
# Empty, not setup-node's placeholder: npm authenticates with the job's OIDC token only.
NODE_AUTH_TOKEN: ""
VERSION: ${{ steps.version.outputs.version }}
DIST_TAG: ${{ steps.version.outputs.dist_tag }}
run: |
FAILED=0
publish_tarball() {
local name="$1"
local tarball="$2"
local integrity published
integrity="sha512-$(openssl dgst -sha512 -binary "$tarball" | base64 -w0)"
if published="$(npm view "${name}@${VERSION}" dist.integrity 2>/dev/null)" && [ -n "$published" ]; then
if [ "$published" = "$integrity" ]; then
echo "⏭️ ${name}@${VERSION} already published with these contents — skipping"
else
echo "::error::${name}@${VERSION} is already on npm, and this run did not publish it. Find out who did before releasing this version."
FAILED=1
fi
return 0
fi
echo "📦 Publishing ${name}@${VERSION}..."
if npm publish "$tarball" --access public --tag "$DIST_TAG" --registry https://registry.npmjs.org/ --ignore-scripts; then
echo "✅ ${name}@${VERSION} published"
else
echo "❌ ${name}@${VERSION} failed to publish"
FAILED=1
fi
}
while IFS=$'\t' read -r name tarball; do
publish_tarball "$name" "$tarball"
done < publish-order.tsv
if [ "$FAILED" -ne 0 ]; then
echo "::error::One or more packages failed to publish"
exit 1
fi
- name: Attach portable plugin to release
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
VERSION: ${{ steps.version.outputs.version }}
REPO: ${{ github.repository }}
working-directory: ${{ runner.temp }}/release-bundle/plugin
run: gh release upload "v${VERSION}" hyperframes-agent-plugin.zip hyperframes-agent-plugin.sha256 hyperframes-agent-plugin.json --repo "$REPO" --clobber