Skip to content

YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context

fix(release): require enterprise handoff and share Windows dependency install (#7055)

Ezra Ellette75d435f9335b
diff --git a/.github/actions/install-windows-frontend-dependencies/action.yml b/.github/actions/install-windows-frontend-dependencies/action.yml
new file mode 100644
index 000000000..2eb6b8d80
--- /dev/null
+++ b/.github/actions/install-windows-frontend-dependencies/action.yml
@@ -0,0 +1,39 @@
+# screenpipe — AI that knows everything you've seen, said, or heard
+# https://screenpipe.com
+
+name: Install Windows frontend dependencies
+description: Install the pinned app dependencies without requiring Windows symlink privileges.
+
+runs:
+ using: composite
+ steps:
+ - name: Stage the local Workflows package and install dependencies
+ shell: pwsh
+ working-directory: ${{ github.workspace }}/apps/screenpipe-app-tauri
+ # Bun uses per-file symlinks for ../ dependencies even with copyfile.
+ # Stage the exact release source inside the app, preserving its lockfile.
+ run: |
+ $ErrorActionPreference = 'Stop'
+ $source = (Resolve-Path '../../packages/workflows-ui').Path
+ $destination = Join-Path (Get-Location) 'node_modules/@screenpipe/workflows-ui'
+ if (Test-Path -LiteralPath $destination) {
+ $item = Get-Item -LiteralPath $destination -Force
+ if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) {
+ cmd /c rmdir "$destination"
+ if ($LASTEXITCODE -ne 0) { throw 'failed to remove stale local package link' }
+ } else {
+ Remove-Item -LiteralPath $destination -Recurse -Force
+ }
+ }
+ $staged = Join-Path (Get-Location) '.release-workflows-ui'
+ New-Item -ItemType Directory -Force -Path $staged | Out-Null
+ Copy-Item -LiteralPath "$source/package.json" -Destination $staged -Force
+ Copy-Item -LiteralPath "$source/src" -Destination $staged -Recurse -Force
+ foreach ($file in @('package.json', 'bun.lock')) {
+ $path = Join-Path (Get-Location) $file
+ $text = [IO.File]::ReadAllText($path)
+ if (-not $text.Contains('file:../../packages/workflows-ui')) { throw "local dependency missing from $file" }
+ [IO.File]::WriteAllText($path, $text.Replace('file:../../packages/workflows-ui', 'file:./.release-workflows-ui'))
+ }
+ bun install --frozen-lockfile --backend=copyfile
+ if ($LASTEXITCODE -ne 0) { throw 'frontend dependency installation failed' }
diff --git a/.github/scripts/enterprise-release.cjs b/.github/scripts/enterprise-release.cjs
new file mode 100644
index 000000000..ff0050a0f
--- /dev/null
+++ b/.github/scripts/enterprise-release.cjs
@@ -0,0 +1,48 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+
+async function status({ github, context, sha, dryRun, state, description }) {
+ if (!/^[0-9a-f]{40}$/i.test(sha)) throw new Error("Expected a full release SHA");
+ const { owner, repo } = context.repo;
+ await github.rest.repos.createCommitStatus({
+ owner, repo, sha, state, description,
+ context: dryRun ? "Enterprise artifacts (dry run)" : "Enterprise artifacts",
+ target_url: `${context.serverUrl || "https://github.com"}/${owner}/${repo}/actions/runs/${context.runId}`,
+ });
+}
+
+async function dispatchEnterprise({ github, context, sha, version, forceGithubRunners, dryRun }) {
+ const common = { github, context, sha, dryRun };
+ await status({ ...common, state: "pending", description: "Consumer ready; waiting for enterprise artifacts" });
+ try {
+ await github.rest.actions.createWorkflowDispatch({
+ ...context.repo,
+ workflow_id: "release-enterprise.yml",
+ ref: context.ref.replace(/^refs\/(heads|tags)\//, ""),
+ inputs: {
+ commit_hash: sha,
+ version,
+ force_github_runners: String(forceGithubRunners),
+ dry_run: String(dryRun),
+ },
+ });
+ } catch (error) {
+ await status({ ...common, state: "failure", description: "Enterprise build could not be started" });
+ throw error;
+ }
+}
+
+async function reportEnterprise({ github, context, sha, dryRun, results }) {
+ const jobs = Object.entries(results);
+ const complete = jobs.length > 0 && jobs.every(([, job]) => job.result === "success");
+ await status({
+ github, context, sha, dryRun,
+ state: complete ? "success" : "failure",
+ description: complete ? "All enterprise platforms succeeded" : "Enterprise artifacts incomplete; see build results",
+ });
+ if (!complete) {
+ throw new Error(`Enterprise artifacts incomplete: ${jobs.map(([name, job]) => `${name}=${job.result}`).join(", ")}`);
+ }
+}
+
+module.exports = { dispatchEnterprise, reportEnterprise };
diff --git a/.github/scripts/release-workflows.test.ts b/.github/scripts/release-workflows.test.ts
new file mode 100644
index 000000000..2110c3065
--- /dev/null
+++ b/.github/scripts/release-workflows.test.ts
@@ -0,0 +1,125 @@
+// screenpipe — AI that knows everything you've seen, said, or heard
+// https://screenpipe.com
+
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { dispatchEnterprise, reportEnterprise } from "./enterprise-release.cjs";
+
+const root = new URL("../../", import.meta.url).pathname;
+const readYaml = (path: string): any => Bun.YAML.parse(readFileSync(join(root, path), "utf8"));
+const app = readYaml(".github/workflows/release-app.yml");
+const enterprise = readYaml(".github/workflows/release-enterprise.yml");
+const installAction = "install-windows-frontend-dependencies";
+const sha = "01afe5afda5fa75f3e4d733ef9a934b975347f48";
+const context = { repo: { owner: "screenpipe", repo: "screenpipe" }, runId: 123, ref: "refs/heads/main" };
+const platformJobs = ["resolve-release", "release-enterprise-windows", "release-enterprise-linux", "release-enterprise-macos"];
+
+function api(dispatchFails = false) {
+ const calls: { method: string; args: any }[] = [];
+ const github = { rest: {
+ repos: { createCommitStatus: async (args: any) => { calls.push({ method: "status", args }); } },
+ actions: { createWorkflowDispatch: async (args: any) => {
+ calls.push({ method: "dispatch", args });
+ if (dispatchFails) throw new Error("dispatch unavailable");
+ } },
+ } };
+ return { github, calls };
+}
+
+test("enterprise dispatch is mandatory after all consumer platforms, without waiting for enterprise", () => {
+ const job = app.jobs["dispatch-enterprise"];
+ expect(job.needs).toEqual(expect.arrayContaining(["check_commit", "publish-tauri"]));
+ expect(job.if).toBeUndefined();
+ expect(job["continue-on-error"]).toBeUndefined();
+ expect(job.permissions.actions).toBe("write");
+ const step = job.steps.find((step: any) => step.env?.RELEASE_SHA);
+ expect(step.env.RELEASE_SHA).toBe("${{ needs.check_commit.outputs.release_sha }}");
+ expect(step.env.RELEASE_VERSION).toBe("${{ needs.check_commit.outputs.release_version }}");
+ expect(step.env.DRY_RUN).toBe("${{ inputs.dry_run }}");
+ expect(step.env.FORCE_GITHUB_RUNNERS).toBe("${{ inputs.force_github_runners }}");
+ expect(step.with.script).toContain("await dispatchEnterprise(");
+ expect(Object.values(app.jobs).some((job: any) => job.uses?.includes("release-enterprise.yml"))).toBe(false);
+});
+
+for (const dryRun of [false, true]) {
+ test(`record pending before dispatch and preserve exact revision/flags (dry run=${dryRun})`, async () => {
+ const { github, calls } = api();
+ await dispatchEnterprise({ github, context, sha, version: "2.7.43", forceGithubRunners: true, dryRun });
+ expect(calls.map((call) => call.method)).toEqual(["status", "dispatch"]);
+ expect(calls[0].args).toMatchObject({ sha, state: "pending", context: dryRun ? "Enterprise artifacts (dry run)" : "Enterprise artifacts" });
+ expect(calls[1].args).toEqual({
+ ...context.repo, workflow_id: "release-enterprise.yml", ref: "main",
+ inputs: { commit_hash: sha, version: "2.7.43", force_github_runners: "true", dry_run: String(dryRun) },
+ });
+ });
+}
+
+test("an enterprise dispatch failure becomes a failed commit check and fails the caller", async () => {
+ const { github, calls } = api(true);
+ await expect(dispatchEnterprise({ github, context, sha, version: "2.7.43", forceGithubRunners: false, dryRun: false })).rejects.toThrow("dispatch unavailable");
+ expect(calls.map((call) => call.method)).toEqual(["status", "dispatch", "status"]);
+ expect(calls.at(-1)?.args.state).toBe("failure");
+});
+
+test("refuse a branch name where an immutable artifact SHA is required", async () => {
+ const { github, calls } = api();
+ await expect(dispatchEnterprise({ github, context, sha: "main", version: "2.7.43", forceGithubRunners: false, dryRun: false })).rejects.toThrow("full release SHA");
+ expect(calls).toHaveLength(0);
+});
+
+test("all versioned enterprise uploads honor the boolean dry-run input", () => {
+ for (const job of Object.values(enterprise.jobs) as any[]) {
+ for (const step of job.steps ?? []) {
+ if (step.env?.RELEASE_UPLOAD_TOKEN) expect(step.if).toBe("${{ !inputs.dry_run }}");
+ }
+ }
+});
+
+test("different versions cannot evict an older queued enterprise build", () => {
+ expect(enterprise.concurrency.group).toContain("inputs.commit_hash");
+ expect(enterprise.concurrency["cancel-in-progress"]).toBe(false);
+});
+
+test("both Windows builds use the shared install action from the workflow revision", () => {
+ for (const job of [app.jobs["publish-tauri"], enterprise.jobs["release-enterprise-windows"]]) {
+ expect(job.steps.filter((step: any) => step.uses === `./.release-workflow/.github/actions/${installAction}`)).toHaveLength(1);
+ const checkout = job.steps.find((step: any) => step.with?.["sparse-checkout"]?.includes(`.github/actions/${installAction}`));
+ // Recovery can build an older app SHA which does not contain this action.
+ expect(checkout.with.ref).toBe("${{ github.workflow_sha }}");
+ expect(checkout.with.path).toBe(".release-workflow");
+ expect(checkout.if ?? "").not.toContain("self-hosted");
+ }
+ const action = readYaml(`.github/actions/${installAction}/action.yml`);
+ expect(action.runs.using).toBe("composite");
+ expect(action.runs.steps[0].shell).toBe("pwsh");
+});
+
+test("completion reports every platform even if one is failed or skipped", () => {
+ const gate = enterprise.jobs["enterprise-complete"];
+ expect(gate.if).toBe("always()");
+ expect(gate.needs).toEqual(platformJobs);
+ expect(gate["continue-on-error"]).toBeUndefined();
+ const step = gate.steps.find((step: any) => step.env?.BUILD_RESULTS);
+ expect(step.env.BUILD_RESULTS).toBe("${{ toJSON(needs) }}");
+ expect(step.with.script).toContain("await reportEnterprise(");
+});
+
+for (const failedJob of platformJobs) {
+ for (const result of ["success", "failure", "skipped", "cancelled"]) {
+ test(`completion: ${failedJob}=${result}`, async () => {
+ const { github, calls } = api();
+ const results = Object.fromEntries(platformJobs.map((name) => [name, { result: name === failedJob ? result : "success" }]));
+ const report = reportEnterprise({ github, context, sha, dryRun: false, results });
+ if (result === "success") await report;
+ else await expect(report).rejects.toThrow("Enterprise artifacts incomplete");
+ expect(calls[0].args).toMatchObject({ sha, state: result === "success" ? "success" : "failure", context: "Enterprise artifacts" });
+ });
+ }
+}
+
+test("an empty result cannot mark enterprise ready", async () => {
+ const { github, calls } = api();
+ await expect(reportEnterprise({ github, context, sha, dryRun: false, results: {} })).rejects.toThrow("incomplete");
+ expect(calls[0].args.state).toBe("failure");
+});
diff --git a/.github/workflows/release-app.yml b/.github/workflows/release-app.yml
index ee6af0861..0cdaafbc1 100644
--- a/.github/workflows/release-app.yml
+++ b/.github/workflows/release-app.yml
@@ -237,13 +237,15 @@ jobs:
with:
target: ${{ matrix.target }}
- - name: Checkout persistent Windows cache action
- if: runner.environment == 'self-hosted' && matrix.os_type == 'windows'
+ - name: Checkout Windows release actions
+ if: matrix.os_type == 'windows'
uses: actions/checkout@v4
with:
ref: ${{ github.workflow_sha }}
path: .release-workflow
- sparse-checkout: .github/actions/setup-persistent-windows-cache
+ sparse-checkout: |
+ .github/actions/setup-persistent-windows-cache
+ .github/actions/install-windows-frontend-dependencies
- name: Attach persistent Azure Windows cache
if: runner.environment == 'self-hosted' && matrix.os_type == 'windows'
@@ -557,37 +559,7 @@ jobs:
- name: Install frontend dependencies without symlinks (Windows)
if: matrix.os_type == 'windows'
- working-directory: ${{ github.workspace }}/apps/screenpipe-app-tauri
- shell: pwsh
- # Bun forces per-file symlinks for ../ folder dependencies on Windows,
- # even with copyfile (oven-sh/bun#13379). Stage the exact checked-out
- # source inside the app so its normal copy backend is used. Keep the
- # locked dependency graph; only the local package location changes.
- run: |
- $ErrorActionPreference = 'Stop'
- $source = (Resolve-Path '../../packages/workflows-ui').Path
- $destination = Join-Path (Get-Location) 'node_modules/@screenpipe/workflows-ui'
- if (Test-Path -LiteralPath $destination) {
- $item = Get-Item -LiteralPath $destination -Force
- if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) {
- cmd /c rmdir "$destination"
- if ($LASTEXITCODE -ne 0) { throw 'failed to remove stale local package link' }
- } else {
- Remove-Item -LiteralPath $destination -Recurse -Force
- }
- }
- $staged = Join-Path (Get-Location) '.release-workflows-ui'
- New-Item -ItemType Directory -Force -Path $staged | Out-Null
- Copy-Item -LiteralPath "$source/package.json" -Destination $staged -Force
- Copy-Item -LiteralPath "$source/src" -Destination $staged -Recurse -Force
- foreach ($file in @('package.json', 'bun.lock')) {
- $path = Join-Path (Get-Location) $file
- $text = [IO.File]::ReadAllText($path)
- if (-not $text.Contains('file:../../packages/workflows-ui')) { throw "local dependency missing from $file" }
- [IO.File]::WriteAllText($path, $text.Replace('file:../../packages/workflows-ui', 'file:./.release-workflows-ui'))
- }
- bun install --frozen-lockfile --backend=copyfile
- if ($LASTEXITCODE -ne 0) { throw 'frontend dependency installation failed' }
+ uses: ./.release-workflow/.github/actions/install-windows-frontend-dependencies
- name: Set up MSVC
if: matrix.os_type == 'windows'
@@ -1843,3 +1815,36 @@ jobs:
BUILD_KC="$HOME/Library/Keychains/build.keychain-db"
security delete-keychain "$BUILD_KC" 2>/dev/null || true
security list-keychain -d user -s ~/Library/Keychains/login.keychain-db 2>/dev/null || true
+
+ dispatch-enterprise:
+ name: Start enterprise after consumer
+ needs: [check_commit, publish-tauri]
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ actions: write
+ statuses: write
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ ref: ${{ github.workflow_sha }}
+ - uses: actions/github-script@v7
+ env:
+ RELEASE_SHA: ${{ needs.check_commit.outputs.release_sha }}
+ RELEASE_VERSION: ${{ needs.check_commit.outputs.release_version }}
+ FORCE_GITHUB_RUNNERS: ${{ inputs.force_github_runners }}
+ DRY_RUN: ${{ inputs.dry_run }}
+ with:
+ script: |
+ const { dispatchEnterprise } = require('./.github/scripts/enterprise-release.cjs');
+ await dispatchEnterprise({
+ github, context,
+ sha: process.env.RELEASE_SHA,
+ version: process.env.RELEASE_VERSION,
+ forceGithubRunners: process.env.FORCE_GITHUB_RUNNERS === 'true',
+ dryRun: process.env.DRY_RUN === 'true',
+ });
+ await core.summary
+ .addHeading(`Consumer ${process.env.RELEASE_VERSION} ready; enterprise queued`)
+ .addRaw('The Enterprise artifacts commit check stays pending until its build finishes. Public publication remains a human action.')
+ .write();
diff --git a/.github/workflows/release-enterprise.yml b/.github/workflows/release-enterprise.yml
index bfa352700..1a1eb3a25 100644
--- a/.github/workflows/release-enterprise.yml
+++ b/.github/workflows/release-enterprise.yml
@@ -8,7 +8,7 @@
# macOS: signs with Apple Developer cert, notarizes/staples fresh-install and
# updater artifacts, then verifies the exact updater archive before upload.
# Linux: builds AppImage/deb artifacts and signs updater artifacts.
-# Does not run as part of consumer release — keeps consumer releases fast.
+# Dispatched automatically after consumer succeeds, or manually for recovery.
name: Release Enterprise
on:
@@ -30,8 +30,9 @@ on:
default: false
concurrency:
- # Serialize releases — aborting a release mid-flight is worse than waiting.
- group: ${{ github.workflow }}
+ # Manual recovery and automatic builds of one revision must not overlap.
+ # Different versions queue on their runners without cancelling older releases.
+ group: release-enterprise-${{ inputs.commit_hash || github.sha }}
cancel-in-progress: false
env:
@@ -53,8 +54,8 @@ jobs:
id: resolve
shell: bash
env:
- REQUESTED_SHA: ${{ github.event.inputs.commit_hash || github.sha }}
- REQUESTED_VERSION: ${{ github.event.inputs.version }}
+ REQUESTED_SHA: ${{ inputs.commit_hash || github.sha }}
+ REQUESTED_VERSION: ${{ inputs.version }}
run: |
set -euo pipefail
@@ -90,7 +91,7 @@ jobs:
# ─── Windows x64 ──────────────────────────────────────────────────────────
release-enterprise-windows:
needs: resolve-release
- runs-on: ${{ github.event.inputs.force_github_runners == 'true' && 'windows-2022' || 'screenpipe-release-windows' }}
+ runs-on: ${{ inputs.force_github_runners && 'windows-2022' || 'screenpipe-release-windows' }}
timeout-minutes: 120
steps:
- uses: actions/checkout@v4
@@ -105,13 +106,14 @@ jobs:
shell: pwsh
run: git clean -ffdx -e apps/screenpipe-app-tauri/node_modules/
- - name: Checkout persistent Windows cache action
- if: runner.environment == 'self-hosted'
+ - name: Checkout Windows release actions
uses: actions/checkout@v4
with:
ref: ${{ github.workflow_sha }}
path: .release-workflow
- sparse-checkout: .github/actions/setup-persistent-windows-cache
+ sparse-checkout: |
+ .github/actions/setup-persistent-windows-cache
+ .github/actions/install-windows-frontend-dependencies
- name: Attach persistent Azure Windows cache
if: runner.environment == 'self-hosted'
@@ -224,9 +226,8 @@ jobs:
restore-keys: |
windows-2022-x86_64-pc-windows-msvc-pre-build-
- - name: Install frontend dependencies
- working-directory: apps/screenpipe-app-tauri
- run: bun install
+ - name: Install frontend dependencies without symlinks (Windows)
+ uses: ./.release-workflow/.github/actions/install-windows-frontend-dependencies
- name: Set up MSVC
uses: ilammy/msvc-dev-cmd@v1
@@ -488,7 +489,7 @@ jobs:
} catch { Write-Host ".intunewin creation failed: $_" }
- name: Upload enterprise Windows artifacts
- if: github.event.inputs.dry_run != 'true'
+ if: ${{ !inputs.dry_run }}
shell: bash
env:
RELEASE_UPLOAD_URL: ${{ vars.RELEASE_UPLOAD_URL }}
@@ -513,7 +514,7 @@ jobs:
# ─── Linux x64 ────────────────────────────────────────────────────────────
release-enterprise-linux:
needs: resolve-release
- runs-on: ${{ github.event.inputs.force_github_runners == 'true' && 'ubuntu-24.04' || 'screenpipe-release-linux' }}
+ runs-on: ${{ inputs.force_github_runners && 'ubuntu-24.04' || 'screenpipe-release-linux' }}
timeout-minutes: 120
steps:
- uses: actions/checkout@v4
@@ -762,7 +763,7 @@ jobs:
done
- name: Upload to R2
- if: github.event.inputs.dry_run != 'true'
+ if: ${{ !inputs.dry_run }}
shell: bash
env:
RELEASE_UPLOAD_URL: ${{ vars.RELEASE_UPLOAD_URL }}
@@ -802,7 +803,7 @@ jobs:
target: x86_64-apple-darwin
features: metal,redact-onnx-coreml,enterprise-build
package_arch: x64
- runs-on: ${{ github.event.inputs.force_github_runners == 'true' && matrix.platform || 'screenpipe-release-macos' }}
+ runs-on: ${{ inputs.force_github_runners && matrix.platform || 'screenpipe-release-macos' }}
timeout-minutes: 120
steps:
- uses: actions/checkout@v4
@@ -1424,7 +1425,7 @@ jobs:
test -s "${PERSISTENT_PKG}.sig"
- name: Upload to R2
- if: github.event.inputs.dry_run != 'true'
+ if: ${{ !inputs.dry_run }}
shell: bash
env:
RELEASE_UPLOAD_URL: ${{ vars.RELEASE_UPLOAD_URL }}
@@ -1458,3 +1459,36 @@ jobs:
BUILD_KC="$HOME/Library/Keychains/build.keychain-db"
security delete-keychain "$BUILD_KC" 2>/dev/null || true
security list-keychain -d user -s ~/Library/Keychains/login.keychain-db 2>/dev/null || true
+
+ enterprise-complete:
+ name: Enterprise artifacts complete
+ if: always()
+ needs: [resolve-release, release-enterprise-windows, release-enterprise-linux, release-enterprise-macos]
+ runs-on: ubuntu-latest
+ permissions:
+ contents: read
+ statuses: write
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ ref: ${{ github.workflow_sha }}
+ - uses: actions/github-script@v7
+ env:
+ RELEASE_SHA: ${{ needs.resolve-release.outputs.release_sha || inputs.commit_hash || github.sha }}
+ DRY_RUN: ${{ inputs.dry_run }}
+ BUILD_RESULTS: ${{ toJSON(needs) }}
+ with:
+ script: |
+ const { reportEnterprise } = require('./.github/scripts/enterprise-release.cjs');
+ const results = JSON.parse(process.env.BUILD_RESULTS);
+ await core.summary.addHeading('Enterprise artifact results')
+ .addTable([
+ [{ data: 'Job', header: true }, { data: 'Result', header: true }],
+ ...Object.entries(results).map(([name, job]) => [name, job.result]),
+ ]).write();
+ await reportEnterprise({
+ github, context,
+ sha: process.env.RELEASE_SHA,
+ dryRun: process.env.DRY_RUN === 'true',
+ results,
+ });
diff --git a/.github/workflows/test-release-workflows.yml b/.github/workflows/test-release-workflows.yml
new file mode 100644
index 000000000..68d0549ee
--- /dev/null
+++ b/.github/workflows/test-release-workflows.yml
@@ -0,0 +1,36 @@
+# screenpipe — AI that knows everything you've seen, said, or heard
+# https://screenpipe.com
+
+name: Release workflow contracts
+
+on:
+ pull_request:
+ paths:
+ - .github/workflows/release-app.yml
+ - .github/workflows/release-enterprise.yml
+ - .github/workflows/test-release-workflows.yml
+ - .github/actions/install-windows-frontend-dependencies/**
+ - .github/scripts/release-workflows.test.ts
+ - .github/scripts/enterprise-release.cjs
+ push:
+ branches: [main]
+ paths:
+ - .github/workflows/release-app.yml
+ - .github/workflows/release-enterprise.yml
+ - .github/workflows/test-release-workflows.yml
+ - .github/actions/install-windows-frontend-dependencies/**
+ - .github/scripts/release-workflows.test.ts
+ - .github/scripts/enterprise-release.cjs
+
+permissions:
+ contents: read
+
+jobs:
+ release-contracts:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: oven-sh/setup-bun@v2
+ with:
+ bun-version: "1.3.10"
+ - run: bun test ./.github/scripts/release-workflows.test.ts
diff --git a/docs/human-only-app-publication.md b/docs/human-only-app-publication.md
index 1922a4e6e..82c4bdfe8 100644
--- a/docs/human-only-app-publication.md
+++ b/docs/human-only-app-publication.md
@@ -13,6 +13,8 @@ The app release pipeline deliberately separates artifact preparation from public
It has no route for updater pointers, enterprise publication state, GitHub tags, or GitHub releases. The service validates the version, target, filename, and scope before writing to R2.
+`Release App` builds consumer artifacts first, then dispatches `Release Enterprise` with the same validated commit and version. Before dispatch, it adds a pending `Enterprise artifacts` status to that release commit; enterprise completion changes it to success or failure. Consumer readiness remains independent, while a failed dispatch or missing/failed enterprise build cannot silently look complete. Dry runs use a separate status and preserve the no-upload setting. Manual `Release Enterprise` dispatch is retained for recovery, not as a separate step in a normal release.
+
## Only a human may publish
Public publication includes any of the following: