@defrex/autobuild 0.8.0 → 0.9.0

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

@@ -1,5 +1,7 @@
 import type { Config } from '../config/schema'
 import { configSchema } from '../config/schema'
+import { BUILD_OWNED_CONFIG_PATHS } from '../config/live'
+import { isPipelineSourceRef, type PipelineSourceMeta } from '../config/pipeline-source'
 import type { AbEvent } from '../events/catalog'
 import type { Artifact, ArtifactInput } from '../store/types'
 
@@ -46,6 +48,41 @@ export function parseEffectiveBuildConfig(artifact: Artifact): Config {
   return result.data
 }
 
+/** Read the artifact metadata's revision + pipeline-source projection. Old
+ * deposits (and externally written ones) carry no `pipelineSource`; status and
+ * the dashboard render that as "unknown (pre-pin)" instead of guessing. */
+export function parseBuildConfigMetadata(artifact: Artifact): {
+  revision?: number
+  pipelineSource?: PipelineSourceMeta
+} {
+  const metadata = artifact.meta.metadata
+  const revision = metadata.revision
+  const raw = metadata.pipelineSource
+  let pipelineSource: PipelineSourceMeta | undefined
+  if (typeof raw === 'object' && raw !== null) {
+    const value = raw as Record<string, unknown>
+    if (isPipelineSourceRef(value.ref)) {
+      pipelineSource = {
+        ref: value.ref,
+        ...(typeof value.commit === 'string' ? { commit: value.commit } : {}),
+      }
+    }
+  }
+  return {
+    ...(typeof revision === 'number' ? { revision } : {}),
+    ...(pipelineSource !== undefined ? { pipelineSource } : {}),
+  }
+}
+
+/** True when two configs' build-owned sections differ — the guest's defensive
+ * guard against a deposit that rewrites the pinned pipeline without a recorded
+ * pipeline-source commit advance. */
+export function buildOwnedSectionsDiffer(a: Config, b: Config): boolean {
+  return BUILD_OWNED_CONFIG_PATHS.some(
+    (path) => JSON.stringify(a[path]) !== JSON.stringify(b[path]),
+  )
+}
+
 /** Latest workspace location not followed by release. Historical events use
  * the provider ref as the path compatibility fallback. */
 export function selectOpenWorkspace(events: readonly AbEvent[]): {

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

@@ -48,6 +48,7 @@ import type { Config } from '../config/schema'
 import type { AbEvent, EventWrite } from '../events/catalog'
 import type { EventPayload } from '../events/payloads'
 import { KERNEL, agentActor, type Actor } from '../events/envelope'
+import { isRemoteWorkspace } from '../events/workspace-remote'
 import type { IdSource } from '../ids'
 import { decideNext, type Decision } from '../kernel/engine'
 import { PHASE_SPECS } from '../kernel/phases'
@@ -240,6 +241,12 @@ interface SessionSpec {
 /** Longest tail of check output preserved in a verify report (§8.2). */
 const REPORT_TAIL_CHARS = 10_000
 
+/** Per-section cap for the finalize preflight's dirty-worktree diff capture:
+ * each diff view (working tree, staged) is truncated at this many characters
+ * so a large dirty diff cannot bloat the failure record unboundedly — worst
+ * case ≈ porcelain + 2 × (cap + header). */
+const FINALIZE_DIFF_CAPTURE_CAP = 20_000
+
 /**
  * One session bracket's live stream (SPEC §9): the sink the build-runner
  * opened through the resolved target's streaming capability, the store id it
@@ -260,6 +267,14 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
+/** Bound one captured diff section: unchanged within the cap, otherwise the
+ * first FINALIZE_DIFF_CAPTURE_CAP characters plus an explicit truncation
+ * marker, so truncation is visible in the record itself. */
+function capDiffOutput(output: string): string {
+  if (output.length <= FINALIZE_DIFF_CAPTURE_CAP) return output
+  return `${output.slice(0, FINALIZE_DIFF_CAPTURE_CAP)}\n... (truncated at ${FINALIZE_DIFF_CAPTURE_CAP} characters)`
+}
+
 function sessionBudgetError(seconds: number): string {
   return `phase session budget expired after ${seconds} seconds`
 }
@@ -1137,8 +1152,7 @@ export class BuildRunner {
           )
           if (scratchPaths.length > 0) throw phaseScratchRejection(scratchPaths)
           const remote = events.some(
-            (event) =>
-              event.type === 'workspace.provisioned' && event.payload.provider === 'vercel-sandbox',
+            (event) => event.type === 'workspace.provisioned' && isRemoteWorkspace(event.payload),
           )
           if (remote) {
             await this.deps.store.append(this.deps.slug, {
@@ -1490,13 +1504,50 @@ export class BuildRunner {
       )
     }
     if (result.stdout.length > 0) {
+      // The failure record must characterize the dirtiness on its own: the
+      // build workspace is disposable, and porcelain lists paths and status
+      // codes only — a mode-only flip (AUT-439) is indistinguishable from a
+      // content modification once the workspace is gone. Append both diff
+      // views so the record shows what actually changed.
       throw new Error(
         `workspace must be clean ${when}; commit intended files and remove ` +
-          `temporary files before finishing:\n${result.stdout.trimEnd()}`,
+          `temporary files before finishing:\n${result.stdout.trimEnd()}\n\n` +
+          (await this.collectWorktreeDiffSections()),
       )
     }
   }
 
+  /** Labeled working-tree and staged diff sections for a dirty finalize
+   * preflight record. Runs only on the dirty branch (a clean worktree or a
+   * failed status command never executes a diff), caps each section at
+   * FINALIZE_DIFF_CAPTURE_CAP characters, and is best-effort: a failing `git
+   * diff` command annotates its own section instead of masking the
+   * dirty-worktree failure it is annotating. */
+  private async collectWorktreeDiffSections(): Promise<string> {
+    const views = [
+      { args: ['git', 'diff'], header: '--- git diff (working tree) ---' },
+      { args: ['git', 'diff', '--cached'], header: '--- git diff --cached (staged) ---' },
+    ] as const
+    const sections: string[] = []
+    for (const { args, header } of views) {
+      const command = args.join(' ')
+      let body: string
+      try {
+        const result = await this.deps.exec([...args], { cwd: this.deps.workspacePath })
+        if (result.exitCode !== 0) {
+          const detail = result.stderr.trim() || result.stdout.trim() || '(no output)'
+          body = `(${command} failed: exit ${result.exitCode}: ${capDiffOutput(detail)})`
+        } else {
+          body = capDiffOutput(result.stdout) || '(no output)'
+        }
+      } catch (error) {
+        body = `(${command} failed: ${capDiffOutput(errorMessage(error))})`
+      }
+      sections.push(`${header}\n${body}`)
+    }
+    return sections.join('\n\n')
+  }
+
   private async resolveFinalizeHead(): Promise<string> {
     const args = ['git', 'rev-parse', 'HEAD']
     const result = await this.deps.exec(args, { cwd: this.deps.workspacePath })