spawnfile 0.1.13 → 0.1.17

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,37 +1,8 @@
 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 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;
-}
+import { type StatusCommandHandlersWithLive, type StatusCommandOptions } from "./statusCommandOptions.js";
+export type { StatusCommandOptions } from "./statusCommandOptions.js";
 export interface StatusWatchOptions {
     intervalMs?: number;
     iterations?: number;
@@ -40,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,115 +1,11 @@
-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 { 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, 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);
-    }
-};
+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);
 });
@@ -129,173 +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,
-                    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);
+    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 && !options.context && (commandInput.kind === "image" || usedDefaultPath)) {
-        const timeoutForHome = resolveTimeoutMs(options);
+        const timeoutForHome = resolveStatusTimeoutMs(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");
+        return statusInputFailure("status --context requires --live");
     }
     if (options.logs && !options.live) {
-        return inputFailure("status --logs requires --live");
+        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;
     }
@@ -337,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;
@@ -367,7 +135,9 @@ export const executeStatusCommand = async (inputPath, options, handlers) => {
                 : [])
         ]
         : [];
+    const compiledProbeObservations = await collectCompiledProbeObservations(loadedReport, outputDirectory, readCompiledProbeFile, handlers.compiledProbeCollectors);
     const status = createStaticStatus(view, loadedReport, {
+        compiledProbeObservations,
         deployments: createDeploymentSummaries(selectedDeploymentRecords, deploymentInspections),
         inputPath,
         live: {
@@ -422,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>;

package/dist/cli/statusCommandLive.js

@@ -0,0 +1,188 @@
+import { inspectDockerDeployment, listHomeDeploymentRecords, readHomeDeploymentRecord, readHomeDeploymentReport, recoverDockerDeploymentRecords } from "../deployment/index.js";
+import { extractImageReport, parseDistributionReport, projectImageOrganizationView, renderImageInterface } from "../distribution/index.js";
+import { collectCompiledProbeObservations, collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRegistryDriftObservations, collectRuntimeProbeObservations, createDeploymentSummaries, createStaticStatus, exitCodeForStatus, flattenOrganizationNodes, loadedImageCompileReport, renderStatus, unavailableCompiledProbeFile } from "../status/index.js";
+import { errorExitCode, SpawnfileError } from "../shared/index.js";
+import { statusInputFailure } from "./statusCommandOptions.js";
+export const resolveDeploymentRecords = (records, options) => {
+    if (options.deployment) {
+        const record = records.find((entry) => entry.record.name === options.deployment);
+        return record
+            ? [record]
+            : statusInputFailure(`Unknown deployment "${options.deployment}". Valid deployments: ${records.map((entry) => entry.record.name).sort().join(", ") || "none"}`);
+    }
+    if (options.live && records.length > 1) {
+        return statusInputFailure(`status --live requires --deployment when multiple records exist: ${records.map((entry) => entry.record.name).sort().join(", ")}`);
+    }
+    return records;
+};
+export 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()
+    : [];
+export 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
+    });
+};
+export const resolveStatusAuthValues = 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;
+};
+/* v8 ignore start -- docker extraction is covered by distribution E2E */
+export 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) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            exitCode: errorExitCode(error)
+        };
+    }
+};
+/* v8 ignore stop */
+export 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 statusInputFailure("No image deployments found in the home store");
+        }
+        if (records.length > 1) {
+            return statusInputFailure(`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 statusInputFailure(`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) {
+            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 resolveStatusAuthValues(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 compiledProbeObservations = await collectCompiledProbeObservations(loadedReport, null, unavailableCompiledProbeFile, handlers.compiledProbeCollectors);
+    const status = createStaticStatus(view, loadedReport, {
+        compiledProbeObservations,
+        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 };
+};