@defrex/autobuild 0.8.0

package/packages/core/src/processes/build-child-exit.ts

@@ -0,0 +1,78 @@
+import type { ProcessGroupReaperOptions } from './process-group-reaper'
+import { launchProcessGroupReaper, processGroupReaperOptions } from './process-group-reaper'
+
+interface ParentWatch {
+  close(): void
+}
+
+export interface BuildChildExitCoordinatorOptions {
+  groupId: number
+  stopTimeoutMs?: number
+  launchReaper?: (options: ProcessGroupReaperOptions) => number
+  exit?: (code: number) => void
+  retryDelayMs?: number
+}
+
+/**
+ * Transfers teardown ownership before a build-child leader exits. Every
+ * terminal path shares this coordinator so signal/watchdog races preserve the
+ * first exit intent and create exactly one detached group reaper.
+ */
+export class BuildChildExitCoordinator {
+  private readonly reaperOptions: ProcessGroupReaperOptions
+  private readonly launchReaper: (options: ProcessGroupReaperOptions) => number
+  private readonly exit: (code: number) => void
+  private readonly retryDelayMs: number
+  private parentWatch: ParentWatch | undefined
+  private parentWatchClosed = false
+  private intendedExitCode: number | undefined
+  private retry: ReturnType<typeof setTimeout> | undefined
+  private handedOff = false
+
+  constructor(options: BuildChildExitCoordinatorOptions) {
+    this.reaperOptions =
+      options.stopTimeoutMs === undefined
+        ? processGroupReaperOptions(options.groupId)
+        : { groupId: options.groupId, stopTimeoutMs: options.stopTimeoutMs }
+    this.launchReaper = options.launchReaper ?? launchProcessGroupReaper
+    this.exit = options.exit ?? process.exit
+    this.retryDelayMs = options.retryDelayMs ?? 10
+  }
+
+  setParentWatch(parentWatch: ParentWatch): void {
+    this.parentWatch = parentWatch
+    if (this.intendedExitCode !== undefined) this.closeParentWatch()
+  }
+
+  terminate(exitCode: number): void {
+    if (this.intendedExitCode === undefined) this.intendedExitCode = exitCode
+    if (this.handedOff) return
+
+    this.closeParentWatch()
+    this.tryHandoff()
+  }
+
+  private closeParentWatch(): void {
+    if (this.parentWatch === undefined || this.parentWatchClosed) return
+    this.parentWatchClosed = true
+    this.parentWatch.close()
+  }
+
+  private tryHandoff(): void {
+    if (this.handedOff || this.retry !== undefined) return
+    try {
+      this.launchReaper(this.reaperOptions)
+    } catch {
+      // Do not let the leader disappear while detached ownership is absent.
+      // A referenced retry keeps natural completion alive until spawn succeeds.
+      this.retry = setTimeout(() => {
+        this.retry = undefined
+        this.tryHandoff()
+      }, this.retryDelayMs)
+      return
+    }
+
+    this.handedOff = true
+    this.exit(this.intendedExitCode!)
+  }
+}

package/packages/core/src/processes/build-child.ts

@@ -0,0 +1,119 @@
+import { hostname } from 'node:os'
+import { createForge } from '../ports/forge/create'
+import { createProductionRuntimes } from '../ports/runner/production'
+import { spawnExec } from '../ports/workspace/git-worktree'
+import { loadPlugins } from '../plugins/load'
+import { materializePluginRuntimes } from '../plugins/runtimes'
+import { randomIds } from '../ids'
+import { systemClock, type BuildStore } from '../store/types'
+import { openProductionStore } from '../cli/store-opening'
+import { BuildRunner, LeaseHeldError, SetupFailureError } from './build-runner'
+import {
+  BUILD_EFFECTIVE_CONFIG_ARTIFACT,
+  diagnosticArtifact,
+  parseEffectiveBuildConfig,
+  selectOpenWorkspace,
+  type BuildRunnerDiagnosticOutcome,
+} from './build-execution-state'
+import type { BuildExecutionStart } from '../ports/workspace/build-execution'
+
+function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/** Child-side composition. The launch envelope supplies identity only; all
+ * execution location/configuration is discovered through the scoped Store. */
+export async function runBuildChild(
+  input: BuildExecutionStart,
+  env: Record<string, string | undefined> = process.env,
+  openStore: (ref: string, token?: string) => BuildStore = openProductionStore,
+): Promise<void> {
+  const fullStore = openStore(input.storeRef, env.AB_TOKEN)
+  const store = fullStore.scopeBuild(input.slug)
+  try {
+    const record = await store.getBuild(input.slug)
+    if (record === null) throw new Error(`unknown build ${JSON.stringify(input.slug)}`)
+    const workspace = selectOpenWorkspace(await store.getEvents(input.slug))
+    if (workspace === null) {
+      throw new Error(`build ${JSON.stringify(input.slug)} has no open durable workspace`)
+    }
+    if (workspace.ref !== input.workspaceRef) {
+      throw new Error(
+        `build ${JSON.stringify(input.slug)} workspace changed from launch ref ` +
+          `${JSON.stringify(input.workspaceRef)} to ${JSON.stringify(workspace.ref)}`,
+      )
+    }
+    const configArtifact = await store.getArtifact(input.slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
+    if (configArtifact === null) {
+      throw new Error(`build ${JSON.stringify(input.slug)} has no effective config artifact`)
+    }
+    let currentConfig = parseEffectiveBuildConfig(configArtifact)
+    const plugins = await loadPlugins(currentConfig.plugins, workspace.path, {
+      packageRoot: record.repo,
+    })
+    const { runtimes: builtins } = createProductionRuntimes()
+    const runtimes = await materializePluginRuntimes(builtins, plugins, {
+      repoRoot: workspace.path,
+      env,
+    })
+    const forge = await createForge({
+      name: currentConfig.forge,
+      registry: plugins,
+      env,
+      repoRoot: workspace.path,
+    })
+    const getConfig = async () => {
+      const latest = await store.getArtifact(input.slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)
+      if (latest === null) return currentConfig
+      try {
+        currentConfig = parseEffectiveBuildConfig(latest)
+      } catch {
+        // The dispatcher publishes only validated snapshots. If storage is
+        // externally corrupted, preserve the child's last valid boundary.
+      }
+      return currentConfig
+    }
+
+    const runner = new BuildRunner({
+      store,
+      config: currentConfig,
+      getConfig,
+      runtimes,
+      workspacePath: workspace.path,
+      branch: workspace.branch,
+      slug: input.slug,
+      exec: spawnExec,
+      forge,
+      ids: randomIds(),
+      clock: systemClock,
+      instance: input.instance,
+      host: hostname(),
+      sessionEnv: {
+        AB_STORE: input.storeRef,
+        ...(env.AB_TOKEN !== undefined && env.AB_TOKEN !== '' ? { AB_TOKEN: env.AB_TOKEN } : {}),
+      },
+    })
+    await runner.run()
+  } catch (error) {
+    let outcome: BuildRunnerDiagnosticOutcome = 'failed'
+    if (error instanceof LeaseHeldError) outcome = 'lease-held'
+    else if (error instanceof SetupFailureError) outcome = 'setup-failed'
+    try {
+      await store.putArtifact(
+        input.slug,
+        diagnosticArtifact({ instance: input.instance, outcome, error: message(error) }),
+      )
+    } catch {
+      // Store reachability failures cannot be diagnosed through that Store.
+    }
+    throw error
+  } finally {
+    try {
+      await fullStore.close()
+    } catch {
+      // Process teardown cannot change the already-durable runner outcome. A
+      // close failure after a clean park must not turn truthful Store state
+      // into a synthetic failed child settlement.
+    }
+  }
+}

package/packages/core/src/processes/build-execution-state.ts

@@ -0,0 +1,95 @@
+import type { Config } from '../config/schema'
+import { configSchema } from '../config/schema'
+import type { AbEvent } from '../events/catalog'
+import type { Artifact, ArtifactInput } from '../store/types'
+
+export const BUILD_EFFECTIVE_CONFIG_ARTIFACT = 'build-runner-effective-config'
+export const BUILD_RUNNER_DIAGNOSTIC_ARTIFACT = 'build-runner-diagnostic'
+
+export type BuildRunnerDiagnosticOutcome = 'lease-held' | 'setup-failed' | 'failed'
+
+export interface BuildRunnerDiagnostic {
+  instance: string
+  outcome: BuildRunnerDiagnosticOutcome
+  error: string
+}
+
+/** JSON form of the normalized config's strict declarative input shape. */
+export function effectiveBuildConfigContent(config: Config): string {
+  const { verify, finalize, ...root } = config
+  return JSON.stringify({
+    ...root,
+    verify: { steps: verify.steps, ...verify.stepConfigs },
+    finalize: { steps: finalize.steps, ...finalize.stepConfigs },
+  })
+}
+
+export function parseEffectiveBuildConfig(artifact: Artifact): Config {
+  let value: unknown
+  try {
+    value = JSON.parse(new TextDecoder().decode(artifact.content))
+  } catch (error) {
+    throw new Error(
+      `invalid ${BUILD_EFFECTIVE_CONFIG_ARTIFACT} JSON: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  const result = configSchema.safeParse(value)
+  if (!result.success) {
+    throw new Error(
+      `invalid ${BUILD_EFFECTIVE_CONFIG_ARTIFACT}: ${result.error.issues
+        .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
+        .join('; ')}`,
+    )
+  }
+  return result.data
+}
+
+/** Latest workspace location not followed by release. Historical events use
+ * the provider ref as the path compatibility fallback. */
+export function selectOpenWorkspace(events: readonly AbEvent[]): {
+  ref: string
+  path: string
+  branch: string
+} | null {
+  let open: { ref: string; path: string; branch: string } | null = null
+  for (const event of events) {
+    if (event.type === 'workspace.provisioned') {
+      open = {
+        ref: event.payload.ref,
+        path: event.payload.path ?? event.payload.ref,
+        branch: event.payload.branch,
+      }
+    } else if (event.type === 'workspace.released') {
+      open = null
+    }
+  }
+  return open
+}
+
+export function diagnosticArtifact(diagnostic: BuildRunnerDiagnostic): ArtifactInput {
+  return {
+    kind: BUILD_RUNNER_DIAGNOSTIC_ARTIFACT,
+    content: JSON.stringify(diagnostic),
+    metadata: { instance: diagnostic.instance, outcome: diagnostic.outcome },
+  }
+}
+
+export function parseDiagnostic(artifact: Artifact): BuildRunnerDiagnostic | null {
+  try {
+    const value = JSON.parse(
+      new TextDecoder().decode(artifact.content),
+    ) as Partial<BuildRunnerDiagnostic>
+    if (
+      typeof value.instance !== 'string' ||
+      typeof value.error !== 'string' ||
+      !['lease-held', 'setup-failed', 'failed'].includes(value.outcome ?? '')
+    ) {
+      return null
+    }
+    return value as BuildRunnerDiagnostic
+  } catch {
+    return null
+  }
+}

package/packages/core/src/processes/build-parent-watch.ts

@@ -0,0 +1,35 @@
+/** Parent-liveness watchdog for a local build child. `expectedParentPid` comes
+ * from the immutable launch envelope rather than a possibly already-reparented
+ * `process.ppid`, closing the module-startup death window. The child
+ * deliberately terminates without releasing its lease; ordinary expiry is the
+ * durable recovery mechanism after an abrupt kernel death. */
+export function watchBuildParent(
+  expectedParentPid: number,
+  onDeath: () => never | void,
+  intervalMs = 500,
+): { close(): void } {
+  let closed = false
+  const check = (): void => {
+    if (closed) return
+    if (process.ppid !== expectedParentPid || process.ppid === 1) {
+      closed = true
+      onDeath()
+      return
+    }
+    try {
+      process.kill(expectedParentPid, 0)
+    } catch {
+      closed = true
+      onDeath()
+    }
+  }
+  const timer = setInterval(check, intervalMs)
+  timer.unref()
+  return {
+    close() {
+      if (closed) return
+      closed = true
+      clearInterval(timer)
+    },
+  }
+}