spawnfile 0.1.12 → 0.1.14

package/dist/cli/runPublishCommands.js

@@ -0,0 +1,70 @@
+import { SpawnfileError } from "../shared/index.js";
+import { resolveCommandInput } from "./resolveCommandInput.js";
+export const registerRunPublishCommands = (program, handlers, streams) => {
+    program
+        .command("run")
+        .description("Compile, build, and run the organization container locally")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .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("--name <container>", "Docker container name")
+        .option("--env-file <file>", "Path to an env file for runtime secrets")
+        .option("--world-bindings <file>", "Path to a versioned world-bindings artifact")
+        .option("--image", "Interpret the argument as an image reference")
+        .option("-d, --detach", "Run the container in detached mode")
+        .action(async (inputPath, options) => {
+        const runInput = resolveCommandInput(inputPath, { forceImage: options.image });
+        if (runInput.kind === "image" || (runInput.kind === "invalid" && options.image)) {
+            throw new SpawnfileError("validation_error", `Image-mode run is not supported. Deploy the image with: ` +
+                `spawnfile up ${inputPath} --auth-profile <profile> ` +
+                "(add --env-file for any extra secrets; image deployments always detach).");
+        }
+        if (runInput.kind === "invalid") {
+            throw new SpawnfileError("validation_error", `Cannot resolve "${inputPath}" as a project path or image reference. ` +
+                "Pass a project directory, a Spawnfile path, or an image like 'name:tag' (use --image to force image mode).");
+        }
+        const result = await handlers.runProject(inputPath, {
+            authProfile: options.authProfile,
+            containerName: options.name,
+            detach: options.detach,
+            deploymentName: options.deployment,
+            dockerCommand: options.dockerCommand,
+            dockerContext: options.context,
+            envFilePath: options.envFile,
+            imageTag: options.tag,
+            outputDirectory: options.out,
+            ...(options.worldBindings !== undefined
+                ? { worldBindingsPath: options.worldBindings }
+                : {})
+        });
+        if (options.detach) {
+            streams.stdout(`running container ${result.containerName ?? "unknown"}`);
+            streams.stdout(`image: ${result.imageTag}`);
+        }
+    });
+    program
+        .command("publish")
+        .description("Compile, build, verify, and push the organization image to a registry")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .requiredOption("-t, --tag <image>", "Registry image reference to push")
+        .option("-o, --out <directory>", "Output directory")
+        .option("--docker-command <command>", "Docker command")
+        .action(async (inputPath, options) => {
+        const publishInput = resolveCommandInput(inputPath);
+        if (publishInput.kind !== "project") {
+            throw new SpawnfileError("validation_error", "publish operates on a project path, not an image reference");
+        }
+        const result = await handlers.publishProject(inputPath, {
+            dockerCommand: options.dockerCommand,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        streams.stdout(`published ${result.imageTag}`);
+        streams.stdout(`digest: ${result.digest ?? "unknown"}`);
+        streams.stdout(`next: spawnfile up ${result.imageTag} --detach --auth-profile <profile>`);
+    });
+};

package/dist/cli/statusCommand.d.ts

@@ -1,36 +1,8 @@
 import { Command } from "commander";
-import { inspectDockerDeployment } from "../deployment/index.js";
-import { collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations, type StatusCommandResult, type StatusExitCode } from "../status/index.js";
+import { 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;
-};
-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;
-}
+import { type StatusCommandHandlersWithLive, type StatusCommandOptions } from "./statusCommandOptions.js";
+export type { StatusCommandOptions } from "./statusCommandOptions.js";
 export interface StatusWatchOptions {
     intervalMs?: number;
     iterations?: number;
@@ -39,4 +11,3 @@ export interface StatusWatchOptions {
 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

@@ -1,95 +1,11 @@
-import { inspectDockerDeployment, listDeploymentRecords, listHomeDeploymentRecords, readHomeDeploymentRecord, readHomeDeploymentReport } from "../deployment/index.js";
-import { extractImageReport, parseDistributionReport, projectImageOrganizationView, renderImageInterface } from "../distribution/index.js";
-import { collectRegistryDriftObservations } from "../status/index.js";
+import { listDeploymentRecords } from "../deployment/index.js";
+import { normalizeProjectLabelSlug } from "../distribution/index.js";
 import { resolveProjectOutputDirectory } from "../filesystem/index.js";
-import { DEFAULT_OUTPUT_DIRECTORY, errorExitCode, SpawnfileError } from "../shared/index.js";
+import { DEFAULT_OUTPUT_DIRECTORY, errorExitCode } from "../shared/index.js";
+import { collectCompiledProbeObservations, collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations, createDeploymentSummaries, createStaticStatus, exitCodeForStatus, loadCompileReport, readCompiledProbeFile, renderStatus, resolveStatusSelector } from "../status/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";
-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 || options.recover) {
-        return new Map();
-    }
-    const inspect = handlers.inspectDockerDeployment ?? inspectDockerDeployment;
-    const inspections = await Promise.all(records.map(async ({ record }) => [
-        record.name,
-        await inspect(record, { timeoutMs })
-    ]));
-    return new Map(inspections);
-};
-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);
-    }
-};
+import { inspectDeployments, recoverContextDeployments, resolveDeploymentRecords, resolveStatusAuthValues, runHomeDeploymentStatus, runStaticImageStatus } from "./statusCommandLive.js";
+import { emitStatusOutput, resolveStatusOutputMode, resolveStatusSelectorInput, resolveStatusTimeoutMs, statusInputFailure } from "./statusCommandOptions.js";
 const wait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -109,171 +25,45 @@ export const executeStatusWatch = async (inputPath, options, handlers, streams,
             return;
         }
         if (result.output) {
-            emitOutput(streams, result.output);
+            emitStatusOutput(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, 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);
+    const mode = resolveStatusOutputMode(options);
     if (typeof mode !== "string") {
         return mode;
     }
     if (options.logs && !options.live) {
-        return inputFailure("status --logs requires --live");
+        return statusInputFailure("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 && (commandInput.kind === "image" || usedDefaultPath)) {
-        const timeoutForHome = resolveTimeoutMs(options);
+    if (options.deployment && !options.context && (commandInput.kind === "image" || usedDefaultPath)) {
+        const timeoutForHome = resolveStatusTimeoutMs(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 statusInputFailure("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");
+        return statusInputFailure("status --logs requires --live");
     }
     if (options.recover && !options.context) {
-        return inputFailure("status --recover requires --context");
+        return statusInputFailure("status --recover requires --context");
     }
-    const timeoutMs = resolveTimeoutMs(options);
+    const timeoutMs = resolveStatusTimeoutMs(options);
     if (typeof timeoutMs !== "number" && timeoutMs !== undefined) {
         return timeoutMs;
     }
-    const selectorInput = resolveSelectorInput(options);
+    const selectorInput = resolveStatusSelectorInput(options);
     if (selectorInput && "exitCode" in selectorInput) {
         return selectorInput;
     }
@@ -289,12 +79,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);
@@ -304,7 +105,7 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
     const deploymentInspections = await inspectDeployments(selectedDeploymentRecords, handlers, options, timeoutMs);
     const selectedDeploymentRecordValues = selectedDeploymentRecords.map(({ record }) => record);
     const authValues = options.live
-        ? await resolveAuthValues(selectedDeploymentRecords, handlers)
+        ? await resolveStatusAuthValues(selectedDeploymentRecords, handlers)
         : {};
     const collectRuntimeProbes = handlers.collectRuntimeProbeObservations ?? collectRuntimeProbeObservations;
     const collectMoltnetProbes = handlers.collectMoltnetProbeObservations ?? collectMoltnetProbeObservations;
@@ -327,20 +128,23 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
             ...(options.logs
                 ? await collectDeploymentLogs({
                     deployments: selectedDeploymentRecordValues,
+                    dockerCommand: options.dockerCommand,
                     loadedReport,
                     timeoutMs
                 })
                 : [])
         ]
         : [];
+    const compiledProbeObservations = await collectCompiledProbeObservations(loadedReport, outputDirectory, readCompiledProbeFile, handlers.compiledProbeCollectors);
     const status = createStaticStatus(view, loadedReport, {
+        compiledProbeObservations,
         deployments: createDeploymentSummaries(selectedDeploymentRecords, deploymentInspections),
         inputPath,
         live: {
             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 +172,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")
@@ -388,7 +192,7 @@ export const registerStatusCommand = (program, handlers, streams, setExitCode) =
             streams.stderr(`error: ${result.error}`);
         }
         if (result.output) {
-            emitOutput(streams, result.output);
+            emitStatusOutput(streams, result.output);
         }
     });
 };

package/dist/cli/statusCommandLive.d.ts

@@ -0,0 +1,20 @@
+import type { OrganizationView } from "../compiler/index.js";
+import { listDeploymentRecords, type DockerInspectionResult } from "../deployment/index.js";
+import { loadCompileReport, type StatusCommandResult, type StatusOutputMode } from "../status/index.js";
+import { type StatusCommandHandlers, type StatusCommandHandlersWithLive, type StatusCommandLiveHandlers, type StatusCommandOptions } from "./statusCommandOptions.js";
+export type LoadedDeploymentRecord = Awaited<ReturnType<typeof listDeploymentRecords>>[number];
+export declare const resolveDeploymentRecords: (records: LoadedDeploymentRecord[], options: StatusCommandOptions) => LoadedDeploymentRecord[] | StatusCommandResult;
+export declare const inspectDeployments: (records: LoadedDeploymentRecord[], handlers: StatusCommandLiveHandlers, options: StatusCommandOptions, timeoutMs: number | undefined) => Promise<Map<string, DockerInspectionResult>>;
+export declare const recoverContextDeployments: (input: {
+    handlers: StatusCommandLiveHandlers;
+    loadedReport: Awaited<ReturnType<typeof loadCompileReport>>;
+    options: StatusCommandOptions;
+    outputDirectory: string;
+    projectLabel: string;
+    sourceRoot: string;
+    timeoutMs: number | undefined;
+    view: OrganizationView;
+}) => Promise<LoadedDeploymentRecord[]>;
+export declare const resolveStatusAuthValues: (records: LoadedDeploymentRecord[], handlers: StatusCommandHandlers) => Promise<Record<string, string>>;
+export declare const runStaticImageStatus: (imageRef: string, options: StatusCommandOptions, json: boolean) => Promise<StatusCommandResult>;
+export declare const runHomeDeploymentStatus: (options: StatusCommandOptions, handlers: StatusCommandHandlersWithLive, mode: StatusOutputMode, timeoutMs: number | undefined) => Promise<StatusCommandResult>;