spawnfile 0.1.11 → 0.1.13

package/dist/cli/runtimeCommands.js

@@ -4,6 +4,7 @@ export const registerRuntimeCommands = (program, handlers, streams) => {
         .description("Edit runtime declarations");
     runtimeCommand
         .command("set")
+        .description("Set an agent's runtime binding")
         .argument("<name>", "Runtime name")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .option("--recursive", "Update the target project and its descendants")

package/dist/cli/statusCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+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">>;
+type StatusCommandLiveHandlers = {
+    collectDeploymentLogObservations?: typeof collectDeploymentLogObservations;
+    collectMoltnetProbeObservations?: typeof collectMoltnetProbeObservations;
+    collectRuntimeProbeObservations?: typeof collectRuntimeProbeObservations;
+    inspectDockerDeployment?: typeof inspectDockerDeployment;
+    recoverDockerDeploymentRecords?: typeof recoverDockerDeploymentRecords;
+};
+type StatusCommandHandlersWithLive = StatusCommandHandlers & StatusCommandLiveHandlers;
+export interface StatusCommandOptions {
+    agent?: string;
+    context?: string;
+    deployment?: string;
+    dockerCommand?: string;
+    image?: boolean;
+    json?: boolean;
+    live?: boolean;
+    logs?: boolean;
+    network?: string;
+    out?: string;
+    pretty?: boolean;
+    pull?: boolean;
+    pullCheck?: boolean;
+    quiet?: boolean;
+    recover?: boolean;
+    runtime?: string;
+    team?: string;
+    timeout?: string;
+    watch?: boolean;
+}
+export interface StatusWatchOptions {
+    intervalMs?: number;
+    iterations?: number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare const executeStatusWatch: (inputPath: string, options: StatusCommandOptions, handlers: StatusCommandHandlersWithLive, streams: CliStreams, setExitCode: (exitCode: StatusExitCode) => void, watchOptions?: StatusWatchOptions) => Promise<void>;
+export declare const executeStatusCommand: (inputPath: string, options: StatusCommandOptions, handlers: StatusCommandHandlersWithLive) => Promise<StatusCommandResult>;
+export declare const registerStatusCommand: (program: Command, handlers: CliHandlers, streams: CliStreams, setExitCode: (exitCode: StatusExitCode) => void) => void;
+export {};

package/dist/cli/statusCommand.js

@@ -0,0 +1,428 @@
+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, flattenOrganizationNodes, loadCompileReport, renderStatus, resolveStatusSelector } from "../status/index.js";
+const inputFailure = (message) => ({
+    error: message,
+    exitCode: 2
+});
+const resolveOutputMode = (options) => {
+    const modes = [
+        ...(options.json ? ["json"] : []),
+        ...(options.pretty ? ["pretty"] : []),
+        ...(options.quiet ? ["quiet"] : [])
+    ];
+    if (modes.length > 1) {
+        return inputFailure("Choose only one status output mode: --pretty, --json, or --quiet");
+    }
+    return modes[0] ?? "pretty";
+};
+const resolveSelectorInput = (options) => {
+    const selectors = [
+        ...(options.agent ? [{ kind: "agent", value: options.agent }] : []),
+        ...(options.team ? [{ kind: "team", value: options.team }] : []),
+        ...(options.network ? [{ kind: "network", value: options.network }] : []),
+        ...(options.runtime ? [{ kind: "runtime", value: options.runtime }] : [])
+    ];
+    if (selectors.length > 1) {
+        return inputFailure("Choose only one status selector: --agent, --team, --network, or --runtime");
+    }
+    return selectors[0] ?? null;
+};
+const resolveTimeoutMs = (options) => {
+    if (!options.timeout) {
+        return undefined;
+    }
+    const parsed = Number(options.timeout);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return inputFailure("status --timeout must be a positive integer number of milliseconds");
+    }
+    return parsed;
+};
+const resolveDeploymentRecords = (records, options) => {
+    if (options.deployment) {
+        const record = records.find((entry) => entry.record.name === options.deployment);
+        return record
+            ? [record]
+            : inputFailure(`Unknown deployment "${options.deployment}". Valid deployments: ${records.map((entry) => entry.record.name).sort().join(", ") || "none"}`);
+    }
+    if (options.live && records.length > 1) {
+        return inputFailure(`status --live requires --deployment when multiple records exist: ${records.map((entry) => entry.record.name).sort().join(", ")}`);
+    }
+    return records;
+};
+const inspectDeployments = async (records, handlers, options, timeoutMs) => {
+    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, {
+            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) {
+        return values;
+    }
+    const profileNames = [...new Set(records
+            .map(({ record }) => record.auth_profile)
+            .filter((profileName) => typeof profileName === "string" && profileName.length > 0))];
+    for (const profileName of profileNames) {
+        try {
+            const profile = await handlers.requireAuthProfile(profileName);
+            Object.assign(values, profile.env);
+        }
+        catch {
+            // Missing profile values are reported by the metadata layer as unknown credentials.
+        }
+    }
+    return values;
+};
+const emitOutput = (streams, output) => {
+    for (const line of output.split("\n")) {
+        streams.stdout(line);
+    }
+};
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export const executeStatusWatch = async (inputPath, options, handlers, streams, setExitCode, watchOptions = {}) => {
+    const intervalMs = watchOptions.intervalMs ?? 5_000;
+    const sleep = watchOptions.sleep ?? wait;
+    let iteration = 0;
+    while (watchOptions.iterations === undefined || iteration < watchOptions.iterations) {
+        if (iteration > 0) {
+            await sleep(intervalMs);
+            streams.stdout("");
+        }
+        const result = await executeStatusCommand(inputPath, options, handlers);
+        setExitCode(result.exitCode);
+        if (result.error) {
+            streams.stderr(`error: ${result.error}`);
+            return;
+        }
+        if (result.output) {
+            emitOutput(streams, result.output);
+        }
+        iteration += 1;
+    }
+};
+/* v8 ignore start -- docker extraction is covered by distribution E2E */
+const runStaticImageStatus = async (imageRef, options, json) => {
+    try {
+        const inspection = await extractImageReport(imageRef, {
+            dockerCommand: options.dockerCommand,
+            dockerContext: options.context,
+            pull: options.pull
+        });
+        return {
+            exitCode: 0,
+            output: renderImageInterface(inspection.report, { imageRef, json })
+        };
+    }
+    catch (error) {
+        // Input errors (bad labels, non-JSON report, fingerprint mismatch) exit 2;
+        // Docker/runtime failures (daemon down, pull/create failure) exit 1.
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            exitCode: errorExitCode(error)
+        };
+    }
+};
+/* v8 ignore stop */
+const runHomeDeploymentStatus = async (options, handlers, mode, timeoutMs) => {
+    let records;
+    try {
+        records = await listHomeDeploymentRecords();
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), exitCode: errorExitCode(error) };
+    }
+    if (!options.deployment) {
+        if (records.length === 0) {
+            return inputFailure("No image deployments found in the home store");
+        }
+        if (records.length > 1) {
+            return inputFailure(`status --deployment is required: ${records.map((entry) => entry.record.name).sort().join(", ")}`);
+        }
+    }
+    const targetName = options.deployment ?? records[0].record.name;
+    const match = records.find((entry) => entry.record.name === targetName);
+    if (!match) {
+        return inputFailure(`Unknown deployment "${targetName}". Valid deployments: ${records.map((entry) => entry.record.name).sort().join(", ") || "none"}`);
+    }
+    let report;
+    try {
+        const record = await readHomeDeploymentRecord(targetName);
+        void record;
+        const raw = await readHomeDeploymentReport(targetName);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            // A corrupt cached report is bad input, not a runtime failure: exit 2.
+            throw new SpawnfileError("validation_error", `Cached report for "${targetName}" is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        report = parseDistributionReport(parsed);
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), exitCode: errorExitCode(error) };
+    }
+    const view = projectImageOrganizationView(report, match.record.source.kind === "image"
+        ? match.record.source.ref
+        : targetName);
+    const reportPath = match.path.replace(/record\.json$/, "spawnfile-report.json");
+    const loadedReport = loadedImageCompileReport(report, reportPath);
+    const selectedRecords = [match];
+    const deploymentInspections = await inspectDeployments(selectedRecords, handlers, options, timeoutMs);
+    const recordValues = selectedRecords.map(({ record }) => record);
+    const authValues = options.live ? await resolveAuthValues(selectedRecords, handlers) : {};
+    const collectRuntimeProbes = handlers.collectRuntimeProbeObservations ?? collectRuntimeProbeObservations;
+    const collectMoltnetProbes = handlers.collectMoltnetProbeObservations ?? collectMoltnetProbeObservations;
+    const collectDeploymentLogs = handlers.collectDeploymentLogObservations ?? collectDeploymentLogObservations;
+    const liveObservations = options.live && !options.recover
+        ? [
+            ...await collectRuntimeProbes({
+                deployments: recordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...await collectMoltnetProbes({
+                authValues,
+                deployments: recordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...(options.logs
+                ? await collectDeploymentLogs({
+                    deployments: recordValues,
+                    dockerCommand: options.dockerCommand,
+                    loadedReport,
+                    timeoutMs
+                })
+                : []),
+            ...(options.pullCheck
+                ? await collectRegistryDriftObservations({
+                    deployments: recordValues,
+                    dockerCommand: options.dockerCommand,
+                    timeoutMs
+                })
+                : [])
+        ]
+        : [];
+    const status = createStaticStatus(view, loadedReport, {
+        deployments: createDeploymentSummaries(selectedRecords, deploymentInspections),
+        inputPath: view.inputPath,
+        live: {
+            context: null,
+            deploymentName: targetName,
+            logs: options.logs ?? false,
+            recover: false,
+            requested: options.live ?? false
+        },
+        liveObservations,
+        outputDirectory: "",
+        selection: null
+    });
+    return { exitCode: exitCodeForStatus(status), output: renderStatus(status, { mode }), status };
+};
+export const executeStatusCommand = async (inputPath, options, handlers) => {
+    const mode = resolveOutputMode(options);
+    if (typeof mode !== "string") {
+        return mode;
+    }
+    if (options.logs && !options.live) {
+        return inputFailure("status --logs requires --live");
+    }
+    // A positional image reference without --deployment renders the static
+    // interface from the embedded report. Image ref with --deployment, or a bare
+    // --deployment on the default path, reads the home store.
+    // A clear image reference (tag/digest/registry, or forced with --image)
+    // without --deployment renders the static interface; any other positional is
+    // treated as a project path (the view builder reports a missing path).
+    const commandInput = resolveCommandInput(inputPath, { forceImage: options.image });
+    const usedDefaultPath = inputPath === process.cwd();
+    if (commandInput.kind === "image" && !options.deployment) {
+        return runStaticImageStatus(commandInput.ref, options, mode === "json");
+    }
+    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.live) {
+        return inputFailure("status --context requires --live");
+    }
+    if (options.logs && !options.live) {
+        return inputFailure("status --logs requires --live");
+    }
+    if (options.recover && !options.context) {
+        return inputFailure("status --recover requires --context");
+    }
+    const timeoutMs = resolveTimeoutMs(options);
+    if (typeof timeoutMs !== "number" && timeoutMs !== undefined) {
+        return timeoutMs;
+    }
+    const selectorInput = resolveSelectorInput(options);
+    if (selectorInput && "exitCode" in selectorInput) {
+        return selectorInput;
+    }
+    const outputDirectory = resolveProjectOutputDirectory(inputPath, options.out, DEFAULT_OUTPUT_DIRECTORY);
+    const view = await handlers.buildOrganizationView(inputPath);
+    const selectorResult = resolveStatusSelector(view, selectorInput);
+    if (selectorResult?.kind === "failure") {
+        return { error: selectorResult.failure.message, exitCode: 2 };
+    }
+    const loadedReport = await loadCompileReport(outputDirectory);
+    if (loadedReport.kind === "failure") {
+        return { error: loadedReport.failure.message, exitCode: 2 };
+    }
+    let deploymentRecords;
+    try {
+        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: errorExitCode(error)
+        };
+    }
+    const selectedDeploymentRecords = resolveDeploymentRecords(deploymentRecords, options);
+    if ("exitCode" in selectedDeploymentRecords) {
+        return selectedDeploymentRecords;
+    }
+    const deploymentInspections = await inspectDeployments(selectedDeploymentRecords, handlers, options, timeoutMs);
+    const selectedDeploymentRecordValues = selectedDeploymentRecords.map(({ record }) => record);
+    const authValues = options.live
+        ? await resolveAuthValues(selectedDeploymentRecords, handlers)
+        : {};
+    const collectRuntimeProbes = handlers.collectRuntimeProbeObservations ?? collectRuntimeProbeObservations;
+    const collectMoltnetProbes = handlers.collectMoltnetProbeObservations ?? collectMoltnetProbeObservations;
+    const collectDeploymentLogs = handlers.collectDeploymentLogObservations ?? collectDeploymentLogObservations;
+    const liveObservations = options.live && !options.recover
+        ? [
+            ...await collectRuntimeProbes({
+                deployments: selectedDeploymentRecordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...await collectMoltnetProbes({
+                authValues,
+                deployments: selectedDeploymentRecordValues,
+                inspections: deploymentInspections,
+                loadedReport,
+                timeoutMs
+            }),
+            ...(options.logs
+                ? await collectDeploymentLogs({
+                    deployments: selectedDeploymentRecordValues,
+                    dockerCommand: options.dockerCommand,
+                    loadedReport,
+                    timeoutMs
+                })
+                : [])
+        ]
+        : [];
+    const status = createStaticStatus(view, loadedReport, {
+        deployments: createDeploymentSummaries(selectedDeploymentRecords, deploymentInspections),
+        inputPath,
+        live: {
+            context: options.context ?? null,
+            deploymentName: options.deployment ?? null,
+            logs: options.logs ?? false,
+            recover: options.recover === true || Boolean(options.context),
+            requested: options.live ?? false
+        },
+        liveObservations,
+        outputDirectory,
+        selection: selectorResult?.selection ?? null
+    });
+    return {
+        exitCode: exitCodeForStatus(status),
+        output: renderStatus(status, { mode }),
+        status
+    };
+};
+export const registerStatusCommand = (program, handlers, streams, setExitCode) => {
+    program
+        .command("status")
+        .description("Show static Spawnfile organization status")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--out <dir>", "Compile output directory")
+        .option("--json", "Render machine-readable JSON")
+        .option("--pretty", "Render human output")
+        .option("--quiet", "Render only summary and non-ok observations")
+        .option("--live", "Inspect the recorded live deployment")
+        .option("--deployment <name>", "Deployment record name")
+        .option("--image", "Interpret the argument as an image reference")
+        .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 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")
+        .option("--watch", "Refresh status every five seconds until interrupted")
+        .option("--agent <id>", "Show one agent")
+        .option("--team <id>", "Show one team")
+        .option("--network <id>", "Show one network")
+        .option("--runtime <name>", "Show one runtime")
+        .action(async (inputPath, options) => {
+        if (options.watch) {
+            await executeStatusWatch(inputPath, options, handlers, streams, setExitCode);
+            return;
+        }
+        const result = await executeStatusCommand(inputPath, options, handlers);
+        setExitCode(result.exitCode);
+        if (result.error) {
+            streams.stderr(`error: ${result.error}`);
+        }
+        if (result.output) {
+            emitOutput(streams, result.output);
+        }
+    });
+};

package/dist/cli/surfaceCommands.js

@@ -22,6 +22,7 @@ export const registerSurfaceCommands = (program, handlers, streams) => {
         .description("Edit agent surfaces");
     surfaceCommand
         .command("add")
+        .description("Attach a surface to an agent")
         .argument("<surface>", "Surface name")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .option("--bot-token-secret <env>", "Override the bot token env var name")
@@ -42,6 +43,7 @@ export const registerSurfaceCommands = (program, handlers, streams) => {
     });
     surfaceCommand
         .command("remove")
+        .description("Detach a surface from an agent")
         .argument("<surface>", "Surface name")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .option("--recursive", "Update the target project and its descendants")
@@ -58,6 +60,7 @@ export const registerSurfaceCommands = (program, handlers, streams) => {
     });
     surfaceCommand
         .command("set-access")
+        .description("Set an agent's access mode for a surface")
         .argument("<surface>", "Surface name")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .requiredOption("--mode <mode>", "Access mode")
@@ -86,6 +89,7 @@ export const registerSurfaceCommands = (program, handlers, streams) => {
     });
     surfaceCommand
         .command("show")
+        .description("Show an agent's resolved surfaces")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .option("--recursive", "Show descendant agent surfaces too")
         .action(async (inputPath, options) => {

package/dist/compiler/agentSurfaces.js

@@ -27,8 +27,7 @@ export const resolveAgentSurfaces = (surfaces) => {
                 ? {
                     dms: {
                         enabled: attachment.dms.enabled,
-                        ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
-                        ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                        ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {})
                     }
                 }
                 : {}),
@@ -41,8 +40,7 @@ export const resolveAgentSurfaces = (surfaces) => {
                         .map(([roomId, behavior]) => [
                         roomId,
                         {
-                            ...(behavior.read ? { read: behavior.read } : {}),
-                            ...(behavior.reply ? { reply: behavior.reply } : {})
+                            ...(behavior.wake ? { wake: behavior.wake } : {})
                         }
                     ]))
                 }

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 {