@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/ports/workspace/distribution-archive.ts

@@ -19,17 +19,29 @@
  * version by construction, and source mode packs `distributionRoot()`, whose
  * package.json is the same file `readDistributionIdentity()` reads. The hosted
  * remote store enforces exact version lockstep — a client whose
- * `x-autobuild-version` differs from the server's is rejected (409) — so
- * guest, store, and dispatcher versions must move together through a release
- * cut (`tools/release.ts`) plus store/dispatcher upgrades; there is no code
- * path that safely mixes versions. Provisioning records the installed version
- * in the guest's `.distribution-version` marker and reinstalls the archive on
- * a later mismatch, so an upgraded dispatcher retrofits its persistent guests
- * (see `vercel-sandbox.ts`).
+ * `x-autobuild-version` or `x-autobuild-protocol-version` differs from the
+ * server's is rejected (409) — so guest, store, and dispatcher versions must
+ * move together through a release cut (`tools/release.ts`) plus
+ * store/dispatcher upgrades; there is no code path that safely mixes versions.
+ * Provisioning records the installed distribution's identity stamp
+ * (`readDistributionIdentityStamp()`) in the guest's `.distribution-version`
+ * marker and reinstalls the archive on a later mismatch, so an upgraded
+ * dispatcher retrofits its persistent guests (see `vercel-sandbox.ts`).
+ *
+ * The stamp carries the sha256 digest of the packed archive alongside the
+ * version and protocol, so a deploy that changes guest-visible code or
+ * formats without bumping either one still mismatches every marker computed
+ * over the previous archive (AUT-600). The archive and its digest are
+ * resolved together once per process (`resolveDistributionArchive()`) and
+ * the install paths reuse those same bytes, so the marker names exactly the
+ * bytes installed and resolution never adds a second pack per tick.
  */
-import { access, mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
-import { join, resolve } from 'node:path'
+import { createHash } from 'node:crypto'
+import { access, cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
 import { distributionRoot, distributionPath } from '../../distribution'
+import { REMOTE_STORE_PROTOCOL_VERSION } from '../../store/remote/version'
 import { registryBaseUrl, registryVersionUrl } from '../../registry'
 import { parseRepoCoordinates } from '../forge/github'
 import {
@@ -38,19 +50,28 @@ import {
   githubTokenFromEnv,
   type GitHubRequest,
 } from '../forge/github-transport'
-import { packageAutobuildDistribution } from './vercel-sandbox'
+import { spawnExec } from './git-worktree'
 
 /** The canonical repository the release assets are published to. Shared with
  * `tools/release.ts`, which uploads them. */
 export const CANONICAL_REPOSITORY_URL = 'https://github.com/defrex/autobuild'
 
+/** The shipped manifest `readDistributionPackage()` reads. A bundled
+ * deployment must carry this exact file into its function bundle; the hosted
+ * service's post-build trace step appends it to the dispatch route's trace. */
+export { distributionPath, distributionRoot } from '../../distribution'
+
+export function distributionManifestPath(): string {
+  return distributionPath('package.json')
+}
+
 /** The running distribution's package name and version, from the shipped
  * package.json. Deployed distributions must ship `package.json` — a
  * deployment requirement the hosted entry point owns. Absence is a hard,
  * actionable error. */
 export async function readDistributionPackage(): Promise<{ name: string; version: string }> {
   try {
-    const manifest = JSON.parse(await Bun.file(distributionPath('package.json')).text()) as {
+    const manifest = JSON.parse(await Bun.file(distributionManifestPath()).text()) as {
       name?: unknown
       version?: unknown
     }
@@ -85,6 +106,59 @@ export async function readDistributionIdentity(): Promise<string> {
   return (await readDistributionPackage()).version
 }
 
+/** The distribution identity stamp the guest marker records: everything the
+ * hosted store's skew check compares — the package version
+ * (`x-autobuild-version`) *and* the remote-store protocol version
+ * (`x-autobuild-protocol-version`; either mismatch is a 409 at handshake) —
+ * plus the sha256 digest of the exact packed archive the dispatcher would
+ * install, combined into one opaque string. A protocol-only bump, a
+ * version-only release, or a code-only deploy that changes the archive bytes
+ * without touching either (AUT-600) each count as a mismatch against a guest
+ * whose marker carries the older stamp, and any future skew dimension the
+ * store's handshake gains must be folded into this stamp the same way or the
+ * marker comparison misses it. */
+export async function distributionStampFor(archive: Uint8Array): Promise<string> {
+  const digest = createHash('sha256').update(archive).digest('hex')
+  return `${await readDistributionIdentity()}+protocol${REMOTE_STORE_PROTOCOL_VERSION}+sha256-${digest}`
+}
+
+/** Per-process memo of the running distribution's archive and its digest.
+ * Holds the fulfilled promise so concurrent first callers share one
+ * resolution; a rejected resolution clears itself so the next call retries
+ * instead of a transient fetch/pack failure poisoning a long-lived process. */
+let distributionArchiveMemo: Promise<{ archive: Uint8Array; digest: string }> | undefined
+
+/** Resolve the archive the dispatcher would install together with its sha256
+ * digest, at most once per process: the memoized resolution wraps
+ * `defaultDistributionArchive()` (see the module docs for the source
+ * precedence), so repeated stamp reads and installs cost no second pack. */
+export function resolveDistributionArchive(): Promise<{ archive: Uint8Array; digest: string }> {
+  if (distributionArchiveMemo === undefined) {
+    const pending = defaultDistributionArchive().then((archive) => ({
+      archive,
+      digest: createHash('sha256').update(archive).digest('hex'),
+    }))
+    distributionArchiveMemo = pending
+    pending.catch(() => {
+      if (distributionArchiveMemo === pending) distributionArchiveMemo = undefined
+    })
+  }
+  return distributionArchiveMemo
+}
+
+/** Test-only: drop the per-process archive memo so each test resolves its own
+ * source. The memo otherwise outlives a single test. */
+export function resetDistributionArchiveCacheForTest(): void {
+  distributionArchiveMemo = undefined
+}
+
+/** The identity stamp of the running distribution: the version + protocol
+ * skew stamp extended with the digest of the memoized running archive. */
+export async function readDistributionIdentityStamp(): Promise<string> {
+  const { archive } = await resolveDistributionArchive()
+  return distributionStampFor(archive)
+}
+
 /** The release asset a version's distribution ships under. */
 export function distributionAssetName(version: string): string {
   return `autobuild-${version}.tgz`
@@ -211,7 +285,7 @@ export async function fetchDistributionReleaseAsset(
 }
 
 /** Directory, relative to a distribution root, where a deployment ships the
- * archive it packed at build time (`ab-hosted-store pack-distribution`). A
+ * archive it packed at build time (`ab-hosted-dispatcher pack-distribution`). A
  * bundled deployment — the hosted service on Vercel — has neither `bun` nor a
  * source tree at runtime, so the archive must be produced while both exist
  * and carried into the function bundle. */
@@ -221,6 +295,91 @@ export const PREBUILT_DISTRIBUTION_DIR = '.autobuild-dist'
  * that place it somewhere other than `PREBUILT_DISTRIBUTION_DIR`. */
 export const DISTRIBUTION_ARCHIVE_ENV = 'AB_DISTRIBUTION_ARCHIVE'
 
+async function execOrThrow(cmd: string[], cwd: string): Promise<string> {
+  const result = await spawnExec(cmd, { cwd })
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `${cmd.join(' ')} exited ${result.exitCode}: ${result.stderr.trim() || result.stdout.trim()}`,
+    )
+  }
+  return result.stdout.trim()
+}
+
+/** Manifest fields that name repo-local packaging state and must never reach
+ * the packed distribution manifest. `patchedDependencies` entries are resolved
+ * by bun against the consuming project's root, and bun 1.4.0 panics
+ * (`Option::unwrap`, exit 134) when a consumed manifest declares a patch for a
+ * package the consumer tree contains — so a packed manifest carrying the
+ * repo's better-auth patch declaration breaks any consumer that installs
+ * autobuild next to better-auth. The packed artifact ships no patched
+ * package, so the declaration is stripped from the packed manifest while the
+ * repo manifest keeps it for workspace installs. The strip is an enforced
+ * invariant, not a local detail: the `patchedDependencies` rule in
+ * `tools/workspace-manifest-check.ts` rejects a root manifest whose packed
+ * dependency set contains a patched package, and the negative control in
+ * `packages/core/src/plugin-sdk/package.test.ts` (the packed-distribution
+ * better-auth canary) pins the consumed-manifest failure shape this strip
+ * guards, so removing the field from this list fails the suite loudly.
+ *
+ * `devDependencies` is stripped for two reasons. First, the workspace link
+ * specifiers it may carry (for example the root's
+ * `@defrex/autobuild-postgres-store: workspace:*`) cannot be resolved in the
+ * staging tree — it stages only the manifest's `files` set, with no
+ * `bun.lock`, no `node_modules`, and no workspace packages — so `bun pm pack`
+ * fails there with "Failed to resolve workspace version". Second, the guest
+ * installs the distribution with `bun install --production --ignore-scripts`,
+ * which ignores devDependencies entirely; the packed artifact ships no
+ * dev-only tooling, so the declaration is dead weight in the packed manifest
+ * while the repo manifest keeps it for workspace installs. */
+const packedManifestOmittedFields = ['patchedDependencies', 'devDependencies'] as const
+
+export async function packageAutobuildDistribution(): Promise<Uint8Array> {
+  const staging = await mkdtemp(join(tmpdir(), 'autobuild-pack-staging-'))
+  const destination = await mkdtemp(join(tmpdir(), 'autobuild-pack-'))
+  try {
+    // Pack from a staging copy of the repo's `files` set rather than the repo
+    // root: the packed manifest must differ from the repo manifest (above), and
+    // rewriting the repo manifest in place would leave a window where tracked
+    // files are dirty.
+    const manifestPath = join(distributionRoot(), 'package.json')
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as Record<string, unknown>
+    const files = manifest.files
+    if (!Array.isArray(files) || files.some((entry) => typeof entry !== 'string')) {
+      throw new Error(
+        'Autobuild packaging requires the root package.json to list its files as an array of paths',
+      )
+    }
+    for (const entry of files as string[]) {
+      // npm `files` entries may be negated globs (for example
+      // `!packages/core/src/**/*.test.ts`, which keeps test files out of the
+      // published package). Only positive entries name a path to stage: the
+      // negations stay in the staged manifest and `bun pm pack` applies them,
+      // so the packed set still excludes those paths.
+      if (entry.startsWith('!')) continue
+      const target = join(staging, entry)
+      await mkdir(dirname(target), { recursive: true })
+      await cp(join(distributionRoot(), entry), target, {
+        recursive: true,
+        errorOnExist: true,
+        force: false,
+      })
+    }
+    for (const field of packedManifestOmittedFields) delete manifest[field]
+    await writeFile(join(staging, 'package.json'), `${JSON.stringify(manifest, null, 2)}\n`)
+    await execOrThrow(
+      ['bun', 'pm', 'pack', '--ignore-scripts', '--destination', destination],
+      staging,
+    )
+    const archives = (await readdir(destination)).filter((name) => name.endsWith('.tgz'))
+    if (archives.length !== 1)
+      throw new Error('Autobuild packaging did not produce exactly one archive')
+    return new Uint8Array(await readFile(join(destination, archives[0]!)))
+  } finally {
+    await rm(staging, { recursive: true, force: true })
+    await rm(destination, { recursive: true, force: true })
+  }
+}
+
 /** Pack the running distribution into `<root>/.autobuild-dist/autobuild-<version>.tgz`
  * (the same bytes `bun pm pack` produces) and return the archive path. Meant
  * for a deployment's build step, where `bun` and the source tree exist. */

package/packages/core/src/ports/workspace/fake.ts

@@ -28,7 +28,12 @@ import {
   type SandboxEnvironmentIdentity,
   type SandboxWaitResult,
 } from './operator-sandbox'
-import type { WorkspaceHandle, WorkspaceProvider, WorkspaceProvisionResult } from '../types'
+import type {
+  WorkspaceHandle,
+  WorkspaceProvider,
+  WorkspaceProvisionResult,
+  WorkspacePublication,
+} from '../types'
 
 export interface ProvisionRecord {
   repo: string
@@ -51,10 +56,23 @@ async function pathExists(path: string): Promise<boolean> {
 export class FakeWorkspaceProvider implements WorkspaceProvider {
   readonly name = 'fake'
   readonly orchestratorSandbox: OperatorSandboxExecution
+  readonly sandboxPublication: WorkspacePublication
 
   /** Journals — public so tests assert directly on call order and args. */
   readonly provisions: ProvisionRecord[] = []
   readonly releases: WorkspaceHandle[] = []
+  /** Journal — per-spawn guest environments, recorded by the operator-sandbox
+   * capability's spawn sites (`exec`, `start`, and the setup-command spawn)
+   * just before the child launches. Credential-freeness is asserted against
+   * these records directly: what the provider constructed, not what a shell
+   * reported. */
+  readonly sandboxExecEnvironments: Array<{
+    op: 'exec' | 'start' | 'setup'
+    command: string
+    env: Record<string, string>
+  }> = []
+  /** Journal — sandbox publication pushes, in call order. */
+  readonly publications: Array<{ ref: string; sha: string; branch: string }> = []
 
   private readonly root: string
   private readonly initialBase: WorkspaceBase
@@ -68,6 +86,12 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
   /** Durable fake branch heads survive release, like real Git branches. */
   private readonly branchHeads = new Map<string, string>()
   private readonly failures = new Map<'provision' | 'release', Error>()
+  /** Injectable publication failure: while set, `sandboxPublication.publish`
+   * throws it on every call (pass `null` to clear). */
+  private publicationFailure: Error | null = null
+  /** environmentId → the base branch the fresh provision selected, so the
+   * publication capability can refuse the base branch as defense in depth. */
+  private readonly sandboxBaseBranches = new Map<string, string>()
 
   constructor(
     opts: {
@@ -102,6 +126,30 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
       stop: () => Promise.resolve({ outcome: 'stopped' as const }),
       release: (input) => this.sandboxRelease(input),
     }
+    this.sandboxPublication = {
+      isPublished: (input) =>
+        Promise.resolve(
+          this.publications.some(
+            (entry) => entry.branch === input.branch && entry.sha === input.sha,
+          ),
+        ),
+      publish: (input) => this.publishSandbox(input),
+    }
+  }
+
+  /** Injectable publication failure: while set, the sandbox publication push
+   * throws `error` on every call (pass `null` to clear). */
+  setPublicationFailure(error: Error | null): void {
+    this.publicationFailure = error
+  }
+
+  private async publishSandbox(input: { ref: string; sha: string; branch: string }): Promise<void> {
+    if (this.publicationFailure) throw this.publicationFailure
+    const baseBranch = this.sandboxBaseBranches.get(input.ref)
+    if (baseBranch !== undefined && input.branch === baseBranch) {
+      throw new Error(`publication refuses the base branch ${baseBranch}`)
+    }
+    this.publications.push({ ...input })
   }
 
   /**
@@ -240,6 +288,12 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
   }): Promise<SandboxEnvironmentIdentity> {
     const identity = this.sandboxIdentity(input.repo, input.operator)
     if (await pathExists(join(identity.workspacePath, '.autobuild-sandbox-provisioned'))) {
+      // Pre-existing sandboxes provisioned before the info/exclude write
+      // landed (AUT-580) keep an unexcluded marker; write the exclusion on
+      // every ensure, mirroring GitWorktreeProvider, so the publish
+      // service's untracked-inclusive dirty check never counts the marker
+      // as dirt.
+      await this.excludeProvisioningMarker(identity.workspacePath)
       return identity
     }
     if (this.mode !== 'filesystem') {
@@ -252,7 +306,55 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
     await rm(identity.workspacePath, { recursive: true, force: true })
     await cp(input.repo, identity.workspacePath, { recursive: true })
     try {
+      // Real git checkout (publish-service parity): the three git checks the
+      // publish service runs through capability.exec (rev-parse, status,
+      // merge-base) must work against the fake exactly as against the real
+      // providers, which serve a genuine checkout. A plain fixture source is
+      // not a git repository, so the fake initializes one from the base
+      // branch and makes a seed commit; a source that already IS a git
+      // repository is used as-is. baseSha is the base branch's head after
+      // provisioning — the same value the real providers resolve.
+      if (!(await pathExists(join(identity.workspacePath, '.git')))) {
+        await this.runSandboxGit(identity.workspacePath, ['init', '-b', input.baseBranch])
+        await this.runSandboxGit(identity.workspacePath, ['config', 'user.name', 'autobuild[bot]'])
+        await this.runSandboxGit(identity.workspacePath, [
+          'config',
+          'user.email',
+          'autobuild[bot]@users.noreply.github.com',
+        ])
+        await this.runSandboxGit(identity.workspacePath, ['add', '-A'])
+        const committed = await this.runSandboxGit(identity.workspacePath, [
+          'commit',
+          '--allow-empty',
+          '-q',
+          '-m',
+          'sandbox seed',
+        ])
+        if (committed.exitCode !== 0) {
+          throw new SandboxOperationError(
+            'provision',
+            `operator sandbox git seed failed: ${committed.stderr.trim() || committed.stdout.trim()}`,
+          )
+        }
+      }
+      const head = await this.runSandboxGit(identity.workspacePath, [
+        'rev-parse',
+        `refs/heads/${input.baseBranch}`,
+      ])
+      if (head.exitCode !== 0 || head.stdout.trim() === '') {
+        throw new SandboxOperationError(
+          'provision',
+          `operator sandbox could not resolve base branch ${input.baseBranch}: ${head.stderr.trim() || head.stdout.trim() || `exit ${head.exitCode}`}`,
+        )
+      }
+      const baseSha = head.stdout.trim()
+      this.sandboxBaseBranches.set(identity.environmentId, input.baseBranch)
       if (this.sandboxSetupCommand !== undefined && this.sandboxSetupCommand.trim() !== '') {
+        this.sandboxExecEnvironments.push({
+          op: 'setup',
+          command: this.sandboxSetupCommand,
+          env: this.sandboxEnv(),
+        })
         const proc = Bun.spawn(['sh', '-c', this.sandboxSetupCommand], {
           cwd: identity.workspacePath,
           stdin: 'ignore',
@@ -272,12 +374,71 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
           )
         }
       }
+      await this.excludeProvisioningMarker(identity.workspacePath)
+      // The marker file write deliberately stays outside
+      // excludeProvisioningMarker: that helper is the info/exclude exclusion
+      // logic alone (the early-return heal runs it too), while this write is
+      // provisioning-specific.
       await fsWriteFile(join(identity.workspacePath, '.autobuild-sandbox-provisioned'), '')
+      return { ...identity, baseSha }
     } catch (error) {
       await rm(identity.workspacePath, { recursive: true, force: true })
       throw error
     }
-    return identity
+  }
+
+  /** Idempotently exclude the provisioning marker in the checkout's
+   * info/exclude so the publish service's untracked-inclusive dirty check
+   * never counts it as dirt (f_c748dc6a). Runs on both ensure paths —
+   * fresh provisioning and the marker-exists early return — so sandboxes
+   * provisioned before the write landed are healed the next time they are
+   * ensured. Mirrors GitWorktreeProvider. */
+  private async excludeProvisioningMarker(workspacePath: string): Promise<void> {
+    const exclude = await this.runSandboxGit(workspacePath, [
+      'rev-parse',
+      '--git-path',
+      'info/exclude',
+    ])
+    if (exclude.exitCode !== 0 || exclude.stdout.trim() === '') {
+      throw new SandboxOperationError(
+        'provision',
+        `operator sandbox could not resolve info/exclude: ${exclude.stderr.trim() || `exit ${exclude.exitCode}`}`,
+      )
+    }
+    const excludePath = resolve(workspacePath, exclude.stdout.trim())
+    await mkdir(dirname(excludePath), { recursive: true })
+    const existingExclude = await fsReadFile(excludePath, 'utf8').then(
+      (content) => content,
+      () => '',
+    )
+    if (!existingExclude.split('\n').includes('.autobuild-sandbox-provisioned')) {
+      const prefix =
+        existingExclude === '' || existingExclude.endsWith('\n')
+          ? existingExclude
+          : `${existingExclude}\n`
+      await fsWriteFile(excludePath, `${prefix}.autobuild-sandbox-provisioned\n`)
+    }
+  }
+
+  /** One git invocation inside the sandbox checkout with the same
+   * credential-free guest environment as every exec. */
+  private async runSandboxGit(
+    cwd: string,
+    args: string[],
+  ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+    const proc = Bun.spawn(['git', ...args], {
+      cwd,
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: this.sandboxEnv(),
+    })
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+    return { exitCode: exitCode ?? -1, stdout, stderr }
   }
 
   private sandboxCwd(handle: SandboxEnvironmentIdentity, cwd: string | undefined): string {
@@ -289,12 +450,14 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
     request: { command: string; cwd?: string; timeoutSeconds?: number },
   ): Promise<SandboxCommandResult> {
     const timeoutSeconds = Math.min(Math.max(request.timeoutSeconds ?? 120, 1), 300)
+    const env = this.sandboxEnv()
+    this.sandboxExecEnvironments.push({ op: 'exec', command: request.command, env })
     const proc = Bun.spawn(['sh', '-c', request.command], {
       cwd: this.sandboxCwd(handle, request.cwd),
       stdin: 'ignore',
       stdout: 'pipe',
       stderr: 'pipe',
-      env: this.sandboxEnv(),
+      env,
     })
     const timer = AbortSignal.timeout(timeoutSeconds * 1000)
     const outcome = await Promise.race([
@@ -331,12 +494,14 @@ export class FakeWorkspaceProvider implements WorkspaceProvider {
     handle: SandboxEnvironmentIdentity,
     request: { command: string; cwd?: string },
   ): Promise<{ commandId: string }> {
+    const env = this.sandboxEnv()
+    this.sandboxExecEnvironments.push({ op: 'start', command: request.command, env })
     const proc = Bun.spawn(['sh', '-c', request.command], {
       cwd: this.sandboxCwd(handle, request.cwd),
       stdin: 'ignore',
       stdout: 'pipe',
       stderr: 'pipe',
-      env: this.sandboxEnv(),
+      env,
     })
     const commandId = `sbcmd-${Math.random().toString(36).slice(2, 12)}`
     const tracked = { proc, stdout: '', stderr: '', exitCode: null as number | null }