spawnfile 0.1.12 → 0.1.13

package/README.md

@@ -40,14 +40,20 @@ spawnfile compile                                # lower to runtime-native outpu
 spawnfile status .                               # read declared/compiled status
 spawnfile auth sync --profile dev --env-file .env
 spawnfile build  --tag my-agent                  # compile + docker build
+spawnfile up . --context gpu-4090 --detach       # build and run on a Docker context
+spawnfile dev up . --auth-profile dev            # detached dev loop in .spawn-dev
+spawnfile dev apply . --agent researcher         # hot-add/reload one Pi agent
+spawnfile dev activity . --agent researcher      # inspect buffered Pi activity events
 spawnfile run    --tag my-agent --auth-profile dev --detach
 spawnfile status . --live                        # inspect the detached deployment
 spawnfile publish . --tag you/my-agent:1.0.0     # compile + build + verify + push
 ```
 
-Compiled output lands under `.spawn/` by default, including a `Dockerfile`, `entrypoint.sh`, `.env.example`, and a prebuilt `container/rootfs/` tree. `spawnfile build` uses the pinned runtime artifacts from `runtimes.yaml`; it does not rebuild runtimes from source.
+Compiled output lands under `.spawn/` by default, including a `Dockerfile`, `entrypoint.sh`, `.env.example`, and a prebuilt `container/rootfs/` tree. `spawnfile build` uses the pinned runtime artifacts from `runtimes.yaml`; it does not rebuild runtimes from source. Daimon, OpenClaw, and PicoClaw use published copyable artifact images by default, so normal prompt/config edits reuse their dependency layers. To test a local runtime artifact instead, set `SPAWNFILE_DAIMON_RUNTIME_IMAGE`, `SPAWNFILE_OPENCLAW_RUNTIME_IMAGE`, or `SPAWNFILE_PICOCLAW_RUNTIME_IMAGE` to a local image tag. For Pi-heavy orgs, build a reusable runtime base with `npm run runtime:pi-base -- noopolis/spawnfile-pi-runtime:0.79.9-node24`, then set `SPAWNFILE_PI_RUNTIME_BASE_IMAGE` during `spawnfile up`. For `build`/`up` on a docker `--context`, Moltnet release assets are staged for that context's architecture (`amd64` or `arm64`); for local-only manual compile targeting a fixed architecture, set `SPAWNFILE_MOLTNET_TARGET_ARCH=amd64|arm64`.
 
-`spawnfile status` is read-only. By default it shows authored and compiled state without Docker, runtime, or Moltnet calls. With `--live`, it reads the selected detached deployment record, inspects the recorded Docker target, runs adapter-owned runtime probes, and checks Moltnet metadata without reading message bodies. Add `--logs` for a redacted Docker log tail, or `--watch` to refresh status continuously.
+`spawnfile status` is read-only. By default it shows authored and compiled state without Docker, runtime, or Moltnet calls. With `--live`, it reads the selected detached deployment record, inspects the recorded Docker target, runs adapter-owned runtime probes, and checks Moltnet metadata without reading message bodies. Add `--logs` for a redacted Docker log tail, or `--watch` to refresh status continuously. For a remote Docker context where the local record is missing, pass `--context <name>` with `--live` to recover the deployment from Spawnfile container labels.
+
+`spawnfile dev` is the source-backed interactive loop. It uses `.spawn-dev/` by default, starts a detached dev deployment with `spawnfile dev up`, and can hot-apply one Daimon runtime agent with `spawnfile dev apply --agent <id>` without restarting the rest of the org. Hot apply recompiles source, copies the selected agent workspace, Daimon config, matching Moltnet node configs, and managed Moltnet server configs into the running container, loads it through the Daimon control endpoint, and starts only that agent's Moltnet bridges when it is new. `spawnfile dev activity` reads the generated Daimon app's bounded activity buffer as JSON lines so operators can see queued wakes, turn starts/completions, runtime event types, output completions, and errors without mixing those diagnostics into Moltnet chat. Running managed Moltnet servers keep their current in-memory room membership until an operator-token `moltnet apply` or server restart reconciles the copied server config.
 
 Compiled images are self-describing: `spawnfile publish` pushes one to any OCI registry, and anyone can run it with no source — `spawnfile up you/my-agent:1.0.0 --deployment prod --detach --auth-profile me` — or inspect what it needs first with `spawnfile status you/my-agent:1.0.0`. See [`specs/DISTRIBUTION.md`](specs/DISTRIBUTION.md).
 
@@ -98,6 +104,7 @@ v0.1 targets autonomous agent runtimes that share a markdown workspace identity
 |-----------|---------------|---------|-----------------------------------------------|
 | OpenClaw  | active        | ✅      | Discord, Telegram, WhatsApp, Slack            |
 | PicoClaw  | active        |         | Discord, Telegram, Slack (WhatsApp blocked)   |
+| Pi        | active        |         | Embedded org app, Moltnet client config       |
 | NullClaw  | exploratory   |         | No active adapter yet                         |
 | ZeroClaw  | exploratory   |         | No active adapter yet                         |
 | OpenFang  | exploratory   |         | No active adapter yet                         |

package/dist/auth/runtimeCredentials.js

@@ -14,6 +14,21 @@ const parseJson = (filePath, content) => {
         throw new SpawnfileError("validation_error", `Invalid imported auth file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
 };
+const decodeJwtExpiry = (token) => {
+    const payload = token.split(".")[1];
+    if (!payload) {
+        return null;
+    }
+    try {
+        const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+        return typeof decoded.exp === "number" && Number.isFinite(decoded.exp)
+            ? decoded.exp * 1000
+            : null;
+    }
+    catch {
+        return null;
+    }
+};
 export const loadImportedClaudeCodeCredential = async (sourceDirectory) => {
     const credentialsPath = path.join(sourceDirectory, ".credentials.json");
     if (!(await fileExists(credentialsPath))) {
@@ -66,11 +81,12 @@ export const loadImportedCodexCredential = async (sourceDirectory) => {
         refresh.length === 0) {
         return null;
     }
-    const fileStats = await stat(authPath);
+    const jwtExpiry = decodeJwtExpiry(access);
+    const expires = jwtExpiry ?? (await stat(authPath)).mtimeMs + 60 * 60 * 1000;
     return {
         access,
         ...(typeof accountId === "string" && accountId.length > 0 ? { accountId } : {}),
-        expires: fileStats.mtimeMs + 60 * 60 * 1000,
+        expires,
         refresh
     };
 };

package/dist/cli/devCommands.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from "commander";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export declare const registerDevCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/devCommands.js

@@ -0,0 +1,115 @@
+import { InvalidArgumentError } from "commander";
+const parsePositiveIntegerOption = (value) => {
+    if (!/^[1-9]\d*$/u.test(value)) {
+        throw new InvalidArgumentError("must be a positive integer");
+    }
+    return Number(value);
+};
+export const registerDevCommands = (program, handlers, streams) => {
+    const dev = program.command("dev").description("Run an interactive Spawnfile development deployment");
+    dev
+        .command("up")
+        .description("Compile, build, and start a detached dev deployment under .spawn-dev")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--auth-profile <name>", "Local Spawnfile auth profile")
+        .option("--context <name>", "Docker context for the deployment target")
+        .option("--deployment <name>", "Detached deployment record name")
+        .option("--docker-command <command>", "Docker command")
+        .option("--env-file <file>", "Path to an env file for runtime secrets")
+        .option("--name <container>", "Docker container name")
+        .option("-o, --out <directory>", "Dev output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .action(async (inputPath, options) => {
+        const result = await handlers.devUpProject(inputPath, {
+            authProfile: options.authProfile,
+            containerName: options.name,
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            dockerContext: options.context,
+            envFilePath: options.envFile,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        streams.stdout(`dev deployment: ${result.containerName ?? "unknown"}`);
+        streams.stdout(`image: ${result.imageTag}`);
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        if (result.deploymentRecordPath) {
+            streams.stdout(`record: ${result.deploymentRecordPath}`);
+        }
+    });
+    dev
+        .command("apply")
+        .description("Hot-apply one agent into a running dev deployment")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .requiredOption("--agent <id>", "Agent id, slug, or name to hot-apply")
+        .option("--deployment <name>", "Detached deployment record name")
+        .option("--docker-command <command>", "Docker command")
+        .option("-o, --out <directory>", "Dev output directory")
+        .action(async (inputPath, options) => {
+        const result = await handlers.devApplyProject(inputPath, {
+            agent: options.agent,
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            outputDirectory: options.out
+        });
+        streams.stdout(`applied agent ${result.agentId}`);
+        streams.stdout(`container: ${result.containerName}`);
+        streams.stdout(`bridge: ${result.bridgeStarted ? "started" : "unchanged"}`);
+    });
+    dev
+        .command("restart")
+        .description("Reload one agent in a running dev deployment")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .requiredOption("--agent <id>", "Agent id, slug, or name to reload")
+        .option("--deployment <name>", "Detached deployment record name")
+        .option("--docker-command <command>", "Docker command")
+        .option("-o, --out <directory>", "Dev output directory")
+        .action(async (inputPath, options) => {
+        const result = await handlers.devRestartProject(inputPath, {
+            agent: options.agent,
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            outputDirectory: options.out
+        });
+        streams.stdout(`restarted agent ${result.agentId}`);
+        streams.stdout(`container: ${result.containerName}`);
+        streams.stdout(`bridge: ${result.bridgeStarted ? "started" : "unchanged"}`);
+    });
+    dev
+        .command("activity")
+        .description("Print the current Pi agent activity buffer from a running dev deployment")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--agent <id>", "Only show events for one agent id, slug, or name")
+        .option("--deployment <name>", "Detached deployment record name")
+        .option("--docker-command <command>", "Docker command")
+        .option("-o, --out <directory>", "Dev output directory")
+        .option("--tail <count>", "Maximum buffered events to print", parsePositiveIntegerOption)
+        .action(async (inputPath, options) => {
+        const result = await handlers.devActivityProject(inputPath, {
+            agent: options.agent,
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            outputDirectory: options.out,
+            tail: options.tail
+        });
+        for (const event of result.events) {
+            streams.stdout(JSON.stringify(event));
+        }
+    });
+    dev
+        .command("stop")
+        .description("Stop the recorded dev deployment container")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--deployment <name>", "Detached deployment record name")
+        .option("--docker-command <command>", "Docker command")
+        .option("-o, --out <directory>", "Dev output directory")
+        .action(async (inputPath, options) => {
+        const result = await handlers.devStopProject(inputPath, {
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            outputDirectory: options.out
+        });
+        streams.stdout(`stopped dev deployment ${result.deploymentName}`);
+        streams.stdout(`container: ${result.containerName}`);
+    });
+};

package/dist/cli/lifecycleCommands.js

@@ -33,11 +33,13 @@ export const registerLifecycleCommands = (program, handlers, streams) => {
         .command("build")
         .description("Compile and build the organization Docker image")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--context <name>", "Docker context for the build target")
         .option("--docker-command <command>", "Docker command")
         .option("-o, --out <directory>", "Output directory")
         .option("-t, --tag <image>", "Docker image tag")
         .action(async (inputPath, options) => {
         const result = await handlers.buildProject(inputPath, {
+            dockerContext: options.context,
             dockerCommand: options.dockerCommand,
             imageTag: options.tag,
             outputDirectory: options.out

package/dist/cli/runCli.d.ts

@@ -1,5 +1,6 @@
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
 import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, publishProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
+import { devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject } from "../dev/index.js";
 import { consumeImageUp } from "../distribution/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
 export interface CliStreams {
@@ -33,6 +34,11 @@ export interface CliHandlers {
     runProject: typeof runProject;
     upProject: typeof upProject;
     consumeImageUp: typeof consumeImageUp;
+    devActivityProject: typeof devActivityProject;
+    devApplyProject: typeof devApplyProject;
+    devRestartProject: typeof devRestartProject;
+    devStopProject: typeof devStopProject;
+    devUpProject: typeof devUpProject;
     setProjectPrimaryModel: typeof setProjectPrimaryModel;
     setProjectRuntime: typeof setProjectRuntime;
     setProjectSurfaceAccess: typeof setProjectSurfaceAccess;

package/dist/cli/runCli.js

@@ -2,9 +2,11 @@ import { readFileSync } from "node:fs";
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
 import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, publishProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
+import { devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject } from "../dev/index.js";
 import { consumeImageUp } from "../distribution/index.js";
 import { errorExitCode, isSpawnfileError } from "../shared/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
+import { registerDevCommands } from "./devCommands.js";
 import { registerLifecycleCommands } from "./lifecycleCommands.js";
 import { registerModelCommands } from "./modelCommands.js";
 import { registerRuntimeCommands } from "./runtimeCommands.js";
@@ -32,6 +34,7 @@ const createDefaultHandlers = () => ({
     importClaudeCodeAuth, importCodexAuth, importEnvFile,
     initProject, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,
     runProject, setProjectPrimaryModel, setProjectRuntime, upProject, consumeImageUp,
+    devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject,
     setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth
 });
 const isCliStreams = (value) => {
@@ -104,6 +107,7 @@ export const runCli = async (argv, optionsOrStreams, handlerOverrides = {}) => {
         writeOut: (message) => writeCommanderOutput(streams.stdout, message)
     });
     registerLifecycleCommands(program, handlers, streams);
+    registerDevCommands(program, handlers, streams);
     program
         .command("init")
         .description("Scaffold a new Spawnfile project or team in a directory")

package/dist/cli/statusCommand.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { inspectDockerDeployment } from "../deployment/index.js";
+import { inspectDockerDeployment, recoverDockerDeploymentRecords } from "../deployment/index.js";
 import { collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations, type StatusCommandResult, type StatusExitCode } from "../status/index.js";
 import type { CliHandlers, CliStreams } from "./runCli.js";
 type StatusCommandHandlers = Pick<CliHandlers, "buildOrganizationView"> & Partial<Pick<CliHandlers, "requireAuthProfile">>;
@@ -8,6 +8,7 @@ type StatusCommandLiveHandlers = {
     collectMoltnetProbeObservations?: typeof collectMoltnetProbeObservations;
     collectRuntimeProbeObservations?: typeof collectRuntimeProbeObservations;
     inspectDockerDeployment?: typeof inspectDockerDeployment;
+    recoverDockerDeploymentRecords?: typeof recoverDockerDeploymentRecords;
 };
 type StatusCommandHandlersWithLive = StatusCommandHandlers & StatusCommandLiveHandlers;
 export interface StatusCommandOptions {

package/dist/cli/statusCommand.js

@@ -1,11 +1,11 @@
-import { inspectDockerDeployment, listDeploymentRecords, listHomeDeploymentRecords, readHomeDeploymentRecord, readHomeDeploymentReport } from "../deployment/index.js";
-import { extractImageReport, parseDistributionReport, projectImageOrganizationView, renderImageInterface } from "../distribution/index.js";
+import { inspectDockerDeployment, listDeploymentRecords, listHomeDeploymentRecords, readHomeDeploymentRecord, readHomeDeploymentReport, recoverDockerDeploymentRecords } from "../deployment/index.js";
+import { extractImageReport, normalizeProjectLabelSlug, parseDistributionReport, projectImageOrganizationView, renderImageInterface } from "../distribution/index.js";
 import { collectRegistryDriftObservations } from "../status/index.js";
 import { resolveProjectOutputDirectory } from "../filesystem/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY, errorExitCode, SpawnfileError } from "../shared/index.js";
 import { resolveCommandInput } from "./resolveCommandInput.js";
 import { loadedImageCompileReport } from "../status/index.js";
-import { createStaticStatus, createDeploymentSummaries, collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations, exitCodeForStatus, loadCompileReport, renderStatus, resolveStatusSelector } from "../status/index.js";
+import { createStaticStatus, createDeploymentSummaries, collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations, exitCodeForStatus, flattenOrganizationNodes, loadCompileReport, renderStatus, resolveStatusSelector } from "../status/index.js";
 const inputFailure = (message) => ({
     error: message,
     exitCode: 2
@@ -56,16 +56,36 @@ const resolveDeploymentRecords = (records, options) => {
     return records;
 };
 const inspectDeployments = async (records, handlers, options, timeoutMs) => {
-    if (!options.live || options.recover) {
+    if (!options.live) {
         return new Map();
     }
     const inspect = handlers.inspectDockerDeployment ?? inspectDockerDeployment;
     const inspections = await Promise.all(records.map(async ({ record }) => [
         record.name,
-        await inspect(record, { timeoutMs })
+        await inspect(record, {
+            dockerCommand: options.dockerCommand,
+            timeoutMs
+        })
     ]));
     return new Map(inspections);
 };
+const containsFromView = (view) => flattenOrganizationNodes(view).map((node) => ({ id: node.id, kind: node.kind }));
+const runtimeInstanceIdsFromReport = (loadedReport) => loadedReport.kind === "loaded"
+    ? loadedReport.report.runtimeInstances.map((instance) => instance.id).sort()
+    : [];
+const recoverContextDeployments = async (input) => {
+    const recover = input.handlers.recoverDockerDeploymentRecords ?? recoverDockerDeploymentRecords;
+    return recover({
+        contains: containsFromView(input.view),
+        context: input.options.context,
+        dockerCommand: input.options.dockerCommand,
+        outputDirectory: input.outputDirectory,
+        projectLabel: input.projectLabel,
+        runtimeInstanceIds: runtimeInstanceIdsFromReport(input.loadedReport),
+        sourceRoot: input.sourceRoot,
+        timeoutMs: input.timeoutMs
+    });
+};
 const resolveAuthValues = async (records, handlers) => {
     const values = {};
     if (!handlers.requireAuthProfile) {
@@ -204,7 +224,12 @@ const runHomeDeploymentStatus = async (options, handlers, mode, timeoutMs) => {
                 timeoutMs
             }),
             ...(options.logs
-                ? await collectDeploymentLogs({ deployments: recordValues, loadedReport, timeoutMs })
+                ? await collectDeploymentLogs({
+                    deployments: recordValues,
+                    dockerCommand: options.dockerCommand,
+                    loadedReport,
+                    timeoutMs
+                })
                 : []),
             ...(options.pullCheck
                 ? await collectRegistryDriftObservations({
@@ -250,22 +275,19 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
     if (commandInput.kind === "image" && !options.deployment) {
         return runStaticImageStatus(commandInput.ref, options, mode === "json");
     }
-    if (options.deployment && (commandInput.kind === "image" || usedDefaultPath)) {
+    if (options.deployment && !options.context && (commandInput.kind === "image" || usedDefaultPath)) {
         const timeoutForHome = resolveTimeoutMs(options);
         if (typeof timeoutForHome !== "number" && timeoutForHome !== undefined) {
             return timeoutForHome;
         }
         return runHomeDeploymentStatus(options, handlers, mode, timeoutForHome);
     }
-    if (options.context && !options.recover) {
-        return inputFailure("status accepts --context only with --recover");
+    if (options.context && !options.live) {
+        return inputFailure("status --context requires --live");
     }
     if (options.logs && !options.live) {
         return inputFailure("status --logs requires --live");
     }
-    if (options.logs && options.recover) {
-        return inputFailure("status --logs is not available with --recover");
-    }
     if (options.recover && !options.context) {
         return inputFailure("status --recover requires --context");
     }
@@ -289,12 +311,23 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
     }
     let deploymentRecords;
     try {
-        deploymentRecords = await listDeploymentRecords(outputDirectory);
+        deploymentRecords = options.context
+            ? await recoverContextDeployments({
+                handlers,
+                loadedReport,
+                options,
+                outputDirectory,
+                projectLabel: normalizeProjectLabelSlug(view.root.name),
+                sourceRoot: view.root.source,
+                timeoutMs,
+                view
+            })
+            : await listDeploymentRecords(outputDirectory);
     }
     catch (error) {
         return {
             error: error instanceof Error ? error.message : String(error),
-            exitCode: 2
+            exitCode: errorExitCode(error)
         };
     }
     const selectedDeploymentRecords = resolveDeploymentRecords(deploymentRecords, options);
@@ -327,6 +360,7 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
             ...(options.logs
                 ? await collectDeploymentLogs({
                     deployments: selectedDeploymentRecordValues,
+                    dockerCommand: options.dockerCommand,
                     loadedReport,
                     timeoutMs
                 })
@@ -340,7 +374,7 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
             context: options.context ?? null,
             deploymentName: options.deployment ?? null,
             logs: options.logs ?? false,
-            recover: options.recover ?? false,
+            recover: options.recover === true || Boolean(options.context),
             requested: options.live ?? false
         },
         liveObservations,
@@ -368,7 +402,7 @@ export const registerStatusCommand = (program, handlers, streams, setExitCode) =
         .option("--pull", "Pull the image before inspecting (image references only)")
         .option("--pull-check", "Check the registry for a newer image digest (networked)")
         .option("--docker-command <command>", "Docker command")
-        .option("--context <name>", "Docker context for label recovery only")
+        .option("--context <name>", "Docker context for live remote deployment recovery")
         .option("--recover", "Recover live status from labels instead of a deployment record")
         .option("--logs", "Include redacted logs when supported")
         .option("--timeout <ms>", "Bound live Docker/runtime checks in milliseconds")

package/dist/compiler/buildProject.d.ts

@@ -1,20 +1,28 @@
 import { type CompileProjectOptions, type CompileProjectResult } from "./compileProject.js";
+import type { MoltnetTargetArchitecture } from "./moltnetBinaries.js";
 export interface DockerBuildInvocation {
     args: string[];
     command: string;
     cwd: string;
+    dockerContext?: string | null;
     imageTag: string;
 }
 export type DockerBuildRunner = (invocation: DockerBuildInvocation) => Promise<void>;
 export interface BuildProjectOptions extends CompileProjectOptions {
     buildRunner?: DockerBuildRunner;
     dockerCommand?: string;
+    dockerContext?: string;
     imageTag?: string;
 }
 export interface BuildProjectResult extends CompileProjectResult {
     imageTag: string;
 }
 export declare const createDefaultImageTag: (projectRoot: string) => string;
-export declare const createDockerBuildInvocation: (outputDirectory: string, imageTag: string, dockerCommand?: string) => DockerBuildInvocation;
+export declare const createDockerBuildInvocation: (outputDirectory: string, imageTag: string, options?: string | {
+    dockerCommand?: string;
+    dockerContext?: string;
+}) => DockerBuildInvocation;
+export declare const normalizeDockerArchitecture: (architecture: string) => MoltnetTargetArchitecture;
+export declare const resolveDockerBuildArchitecture: (options: Pick<BuildProjectOptions, "dockerCommand" | "dockerContext">) => Promise<MoltnetTargetArchitecture | undefined>;
 export declare const runDockerBuild: DockerBuildRunner;
 export declare const buildProject: (inputPath: string, options?: BuildProjectOptions) => Promise<BuildProjectResult>;

package/dist/compiler/buildProject.js

@@ -1,8 +1,10 @@
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { execFile as execFileCallback, spawn } from "node:child_process";
+import { promisify } from "node:util";
 import { SpawnfileError } from "../shared/index.js";
 import { compileProject } from "./compileProject.js";
 import { slugify } from "./helpers.js";
+const execFile = promisify(execFileCallback);
 export const createDefaultImageTag = (projectRoot) => {
     const baseName = slugify(path.basename(projectRoot));
     return `spawnfile-${baseName || "project"}`;
@@ -13,12 +15,44 @@ const resolveImageTagRoot = (inputPath) => {
         ? path.dirname(resolvedPath)
         : resolvedPath;
 };
-export const createDockerBuildInvocation = (outputDirectory, imageTag, dockerCommand = "docker") => ({
-    args: ["build", "-t", imageTag, "."],
-    command: dockerCommand,
+export const createDockerBuildInvocation = (outputDirectory, imageTag, options = "docker") => ({
+    args: typeof options === "string" || !options.dockerContext
+        ? ["build", "-t", imageTag, "."]
+        : ["--context", options.dockerContext, "build", "-t", imageTag, "."],
+    command: typeof options === "string" ? options : options.dockerCommand ?? "docker",
     cwd: outputDirectory,
+    dockerContext: typeof options === "string" ? null : options.dockerContext ?? null,
     imageTag
 });
+export const normalizeDockerArchitecture = (architecture) => {
+    switch (architecture.trim()) {
+        case "amd64":
+        case "x64":
+        case "x86_64":
+            return "amd64";
+        case "aarch64":
+        case "arm64":
+            return "arm64";
+        default:
+            throw new SpawnfileError("compile_error", `Docker target architecture ${architecture.trim() || "unknown"} is not supported by staged Moltnet binaries`);
+    }
+};
+export const resolveDockerBuildArchitecture = async (options) => {
+    if (!options.dockerContext) {
+        return undefined;
+    }
+    try {
+        const { stdout } = await execFile(options.dockerCommand ?? "docker", ["--context", options.dockerContext, "info", "--format", "{{.Architecture}}"], { timeout: 10_000 });
+        return normalizeDockerArchitecture(stdout);
+    }
+    catch (error) {
+        if (error instanceof SpawnfileError) {
+            throw error;
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to resolve Docker context ${options.dockerContext} architecture: ${reason}`);
+    }
+};
 export const runDockerBuild = async (invocation) => new Promise((resolve, reject) => {
     const child = spawn(invocation.command, invocation.args, {
         cwd: invocation.cwd,
@@ -38,12 +72,17 @@ export const runDockerBuild = async (invocation) => new Promise((resolve, reject
     });
 });
 export const buildProject = async (inputPath, options = {}) => {
+    const targetArchitecture = options.containerArchitecture ?? await resolveDockerBuildArchitecture(options);
     const compileResult = await compileProject(inputPath, {
         clean: options.clean,
+        containerArchitecture: targetArchitecture,
         outputDirectory: options.outputDirectory
     });
     const imageTag = options.imageTag ?? createDefaultImageTag(resolveImageTagRoot(inputPath));
-    const invocation = createDockerBuildInvocation(compileResult.outputDirectory, imageTag, options.dockerCommand);
+    const invocation = createDockerBuildInvocation(compileResult.outputDirectory, imageTag, {
+        dockerCommand: options.dockerCommand,
+        dockerContext: options.dockerContext
+    });
     await (options.buildRunner ?? runDockerBuild)(invocation);
     return {
         ...compileResult,

package/dist/compiler/compileProject.d.ts

@@ -1,6 +1,8 @@
 import { CompileReport } from "../report/index.js";
+import { type MoltnetTargetArchitecture } from "./moltnetBinaries.js";
 export interface CompileProjectOptions {
     clean?: boolean;
+    containerArchitecture?: MoltnetTargetArchitecture;
     outputDirectory?: string;
 }
 export interface CompileProjectResult {

package/dist/compiler/compileProject.js

@@ -232,7 +232,9 @@ export const compileProject = async (inputPath, options = {}) => {
     }
     const moltnetArtifacts = await generateMoltnetArtifacts(plan);
     const hasStagedMoltnetBinaries = moltnetArtifacts
-        ? await stageMoltnetBinaries(outputDirectory)
+        ? await stageMoltnetBinaries(outputDirectory, {
+            architecture: options.containerArchitecture
+        })
         : false;
     await injectMoltnetWorkspaceFiles(outputDirectory, compiledNodes, moltnetArtifacts);
     const generatedAt = new Date().toISOString();