spawnfile 0.1.13 → 0.1.14

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 };
+};

package/dist/cli/statusCommandOptions.d.ts

@@ -0,0 +1,40 @@
+import type { CompiledProbeCollectors, StatusCommandResult, StatusOutputMode, StatusSelectorInput } from "../status/index.js";
+import { collectDeploymentLogObservations, collectMoltnetProbeObservations, collectRuntimeProbeObservations } from "../status/index.js";
+import { inspectDockerDeployment, recoverDockerDeploymentRecords } from "../deployment/index.js";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export type StatusCommandHandlers = Pick<CliHandlers, "buildOrganizationView"> & Partial<Pick<CliHandlers, "requireAuthProfile">>;
+export interface StatusCommandLiveHandlers {
+    collectDeploymentLogObservations?: typeof collectDeploymentLogObservations;
+    collectMoltnetProbeObservations?: typeof collectMoltnetProbeObservations;
+    collectRuntimeProbeObservations?: typeof collectRuntimeProbeObservations;
+    compiledProbeCollectors?: CompiledProbeCollectors;
+    inspectDockerDeployment?: typeof inspectDockerDeployment;
+    recoverDockerDeploymentRecords?: typeof recoverDockerDeploymentRecords;
+}
+export 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 declare const statusInputFailure: (message: string) => StatusCommandResult;
+export declare const resolveStatusOutputMode: (options: StatusCommandOptions) => StatusOutputMode | StatusCommandResult;
+export declare const resolveStatusSelectorInput: (options: StatusCommandOptions) => StatusSelectorInput | null | StatusCommandResult;
+export declare const resolveStatusTimeoutMs: (options: StatusCommandOptions) => number | undefined | StatusCommandResult;
+export declare const emitStatusOutput: (streams: CliStreams, output: string) => void;

package/dist/cli/statusCommandOptions.js

@@ -0,0 +1,42 @@
+export const statusInputFailure = (message) => ({
+    error: message,
+    exitCode: 2
+});
+export const resolveStatusOutputMode = (options) => {
+    const modes = [
+        ...(options.json ? ["json"] : []),
+        ...(options.pretty ? ["pretty"] : []),
+        ...(options.quiet ? ["quiet"] : [])
+    ];
+    if (modes.length > 1) {
+        return statusInputFailure("Choose only one status output mode: --pretty, --json, or --quiet");
+    }
+    return modes[0] ?? "pretty";
+};
+export const resolveStatusSelectorInput = (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 statusInputFailure("Choose only one status selector: --agent, --team, --network, or --runtime");
+    }
+    return selectors[0] ?? null;
+};
+export const resolveStatusTimeoutMs = (options) => {
+    if (!options.timeout) {
+        return undefined;
+    }
+    const parsed = Number(options.timeout);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return statusInputFailure("status --timeout must be a positive integer number of milliseconds");
+    }
+    return parsed;
+};
+export const emitStatusOutput = (streams, output) => {
+    for (const line of output.split("\n")) {
+        streams.stdout(line);
+    }
+};

package/dist/cli/targetCliRoute.d.ts

@@ -0,0 +1,2 @@
+/** Routes only when the first actual target subcommand is lookup_operation. */
+export declare const isTargetLookupInvocation: (raw: readonly unknown[]) => boolean;

package/dist/cli/targetCliRoute.js

@@ -0,0 +1,30 @@
+const MAX_ARGUMENTS = 64;
+const MAX_ARGUMENT_BYTES = 4_096;
+const bounded = (value) => typeof value === "string"
+    && value.length > 0
+    && Buffer.byteLength(value, "utf8") <= MAX_ARGUMENT_BYTES;
+/** Routes only when the first actual target subcommand is lookup_operation. */
+export const isTargetLookupInvocation = (raw) => {
+    if (!Array.isArray(raw) || raw.length < 2 || raw.length > MAX_ARGUMENTS
+        || raw.some((value) => !bounded(value)) || raw[0] !== "target")
+        return false;
+    const argv = raw;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--config") {
+            if (!bounded(argv[index + 1]))
+                return false;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--config=")) {
+            if (token.length === "--config=".length)
+                return false;
+            continue;
+        }
+        if (token.startsWith("-"))
+            return false;
+        return token === "lookup_operation";
+    }
+    return false;
+};