spawnfile 0.1.10 → 0.1.12

package/dist/status/moltnetProbes.js

@@ -0,0 +1,240 @@
+import { createDockerProbeGateway } from "../deployment/index.js";
+const createObservation = (input) => ({
+    ...input,
+    label: `${input.severity.toUpperCase()} ${input.key}`,
+    source: "network"
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toString = (value) => typeof value === "string" ? value : null;
+const toStringArray = (value) => Array.isArray(value)
+    ? value.filter((entry) => typeof entry === "string")
+    : [];
+const parseRooms = (value) => {
+    const entries = isRecord(value) && Array.isArray(value.rooms) ? value.rooms : [];
+    return entries.flatMap((entry) => {
+        if (!isRecord(entry))
+            return [];
+        const id = toString(entry.id);
+        return id ? [{ id, members: toStringArray(entry.members) }] : [];
+    });
+};
+const parseAgents = (value) => {
+    const entries = isRecord(value) && Array.isArray(value.agents) ? value.agents : [];
+    return entries.flatMap((entry) => {
+        if (!isRecord(entry))
+            return [];
+        const id = toString(entry.id);
+        return id
+            ? [{ connected: entry.connected === true, id, rooms: toStringArray(entry.rooms) }]
+            : [];
+    });
+};
+const parseNetwork = (value) => ({
+    directMessages: isRecord(value) && isRecord(value.capabilities) && typeof value.capabilities.direct_messages === "boolean"
+        ? value.capabilities.direct_messages
+        : null,
+    networkId: isRecord(value) ? toString(value.id) : null
+});
+const defaultFetchJson = async (url, headers, timeoutMs) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { headers, signal: controller.signal });
+        if (!response.ok) {
+            return { error: `HTTP ${response.status}`, json: null, ok: false };
+        }
+        return { json: await response.json(), ok: true };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), json: null, ok: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const authHeadersFor = (server, authValues = {}) => {
+    if (!server.operatorTokenSecret) {
+        return {};
+    }
+    const token = authValues[server.operatorTokenSecret] ?? process.env[server.operatorTokenSecret];
+    return token ? { Authorization: `Bearer ${token}` } : null;
+};
+const readManagedJson = async (gateway, server, path, headers) => {
+    if (!server.port) {
+        return { error: "managed Moltnet server has no internal port", json: null, ok: false };
+    }
+    const response = await gateway.httpGet(server.port, path, headers);
+    if (!response.ok) {
+        return { error: response.error, json: null, ok: false };
+    }
+    try {
+        return { json: JSON.parse(response.body), ok: true };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error), json: null, ok: false };
+    }
+};
+const readExternalJson = async (fetchJson, server, path, headers, timeoutMs) => fetchJson(`${server.baseUrl.replace(/\/$/u, "")}${path}`, headers, timeoutMs);
+const createManagedGateway = (deployments, inspections, options) => {
+    for (const deployment of deployments) {
+        const inspectionMap = inspections.get(deployment.name);
+        const unit = deployment.units[0];
+        if (!unit)
+            continue;
+        const inspection = inspectionMap?.get(unit.id);
+        if (inspection?.running === true) {
+            return createDockerProbeGateway(deployment, unit, {
+                execFile: options.execFile,
+                inspection,
+                timeoutMs: options.timeoutMs
+            });
+        }
+    }
+    return null;
+};
+const readSnapshot = async (server, options, headers) => {
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    const gateway = server.mode === "managed"
+        ? createManagedGateway(options.deployments, options.inspections, options)
+        : null;
+    if (server.mode === "managed" && !gateway) {
+        return { error: "no running deployment unit hosts the managed Moltnet server", json: null, ok: false };
+    }
+    const readJson = (path) => gateway
+        ? readManagedJson(gateway, server, path, headers)
+        : readExternalJson(options.fetchJson ?? defaultFetchJson, server, path, headers, timeoutMs);
+    const health = await readJson("/healthz");
+    if (!health.ok)
+        return health;
+    const network = await readJson("/v1/network");
+    if (!network.ok)
+        return network;
+    const rooms = await readJson("/v1/rooms");
+    if (!rooms.ok)
+        return rooms;
+    const agents = await readJson("/v1/agents");
+    if (!agents.ok)
+        return agents;
+    const parsedNetwork = parseNetwork(network.json);
+    return {
+        json: null,
+        ok: true,
+        snapshot: {
+            agents: parseAgents(agents.json),
+            directMessages: parsedNetwork.directMessages,
+            networkId: parsedNetwork.networkId,
+            rooms: parseRooms(rooms.json)
+        }
+    };
+};
+const compareSnapshot = (server, snapshot) => {
+    const observations = [];
+    observations.push(createObservation({
+        key: "network.reachable",
+        message: `${server.networkId} Moltnet server is reachable`,
+        severity: "ok",
+        subject: `network:${server.networkId}`
+    }));
+    if (snapshot.networkId && snapshot.networkId !== server.networkId) {
+        observations.push(createObservation({
+            key: "network.id",
+            message: `expected network ${server.networkId}, live network is ${snapshot.networkId}`,
+            severity: "error",
+            subject: `network:${server.networkId}`
+        }));
+    }
+    const liveRooms = new Map(snapshot.rooms.map((room) => [room.id, room]));
+    const liveAgents = new Map(snapshot.agents.map((agent) => [agent.id, agent]));
+    for (const room of server.rooms) {
+        const liveRoom = liveRooms.get(room.id);
+        if (!liveRoom) {
+            observations.push(createObservation({
+                key: "network.room",
+                message: `${server.networkId}/${room.id} is missing from live Moltnet`,
+                severity: "error",
+                subject: `room:${server.networkId}:${room.id}`
+            }));
+            continue;
+        }
+        observations.push(createObservation({
+            key: "network.room",
+            message: `${server.networkId}/${room.id} exists with ${liveRoom.members.length} member(s)`,
+            severity: "ok",
+            subject: `room:${server.networkId}:${room.id}`
+        }));
+        for (const member of room.members) {
+            const liveAgent = liveAgents.get(member);
+            if (!liveAgent) {
+                observations.push(createObservation({
+                    key: "network.member",
+                    message: `${member} is expected in ${room.id} but is not registered`,
+                    severity: "warn",
+                    subject: `agent:${member}`
+                }));
+            }
+            else if (!liveAgent.rooms.includes(room.id)) {
+                observations.push(createObservation({
+                    key: "network.member",
+                    message: `${member} is registered but not attached to ${room.id}`,
+                    severity: "warn",
+                    subject: `agent:${member}`
+                }));
+            }
+            else if (!liveAgent.connected) {
+                observations.push(createObservation({
+                    key: "network.agent.connected",
+                    message: `${member} is attached to ${room.id} but disconnected`,
+                    severity: "warn",
+                    subject: `agent:${member}`
+                }));
+            }
+            else {
+                observations.push(createObservation({
+                    key: "network.agent.connected",
+                    message: `${member} is connected to ${room.id}`,
+                    severity: "ok",
+                    subject: `agent:${member}`
+                }));
+            }
+        }
+    }
+    if (snapshot.directMessages !== null && server.directMessages !== null && snapshot.directMessages !== server.directMessages) {
+        observations.push(createObservation({
+            key: "network.direct_messages",
+            message: `direct messages expected ${server.directMessages}, live value is ${snapshot.directMessages}`,
+            severity: "warn",
+            subject: `network:${server.networkId}`
+        }));
+    }
+    return observations;
+};
+export const collectMoltnetProbeObservations = async (options) => {
+    if (options.loadedReport.kind !== "loaded") {
+        return [];
+    }
+    const observations = [];
+    for (const server of options.loadedReport.report.moltnetServers ?? []) {
+        const headers = authHeadersFor(server, options.authValues);
+        if (headers === null) {
+            observations.push(createObservation({
+                key: "network.auth",
+                message: `${server.networkId} requires operator token ${server.operatorTokenSecret}, but no value is available`,
+                severity: "unknown",
+                subject: `network:${server.networkId}`
+            }));
+            continue;
+        }
+        const response = await readSnapshot(server, options, headers);
+        if (!response.ok || !response.snapshot) {
+            observations.push(createObservation({
+                key: "network.reachable",
+                message: `${server.networkId} Moltnet metadata probe failed: ${response.error ?? "unknown failure"}`,
+                severity: "unknown",
+                subject: `network:${server.networkId}`
+            }));
+            continue;
+        }
+        observations.push(...compareSnapshot(server, response.snapshot));
+    }
+    return observations;
+};

package/dist/status/registryDrift.d.ts

@@ -0,0 +1,28 @@
+import { type DeploymentRecord } from "../deployment/index.js";
+import type { StatusObservation } from "./types.js";
+export type RegistryDigestResolver = (imageRef: string, baseArgs: string[]) => Promise<string | null>;
+export interface RegistryDriftInput {
+    deployments: DeploymentRecord[];
+    dockerCommand?: string;
+    resolveDigest?: RegistryDigestResolver;
+    timeoutMs?: number;
+}
+/**
+ * Extracts the comparable digest from `docker manifest inspect --verbose` output.
+ *
+ * A single-arch tag resolves to one manifest object whose `Descriptor.digest`
+ * equals the digest RepoDigests records at deploy time. A multi-arch tag resolves
+ * to a JSON ARRAY of per-platform manifests; each `Descriptor.digest` is a CHILD
+ * digest, never the manifest-list (index) digest that was recorded — comparing one
+ * would report drift on every check. We cannot derive the index digest from this
+ * command, so multi-arch (and any unparseable output) yields null → "unknown"
+ * rather than a false positive.
+ */
+export declare const parseManifestInspectDigest: (output: string) => string | null;
+/**
+ * Compares each image deployment's recorded source.digest against the digest
+ * the registry tag currently resolves to. Networked: runs only behind the
+ * explicit --pull-check flag. A digest-pinned ref needs no lookup; a null
+ * recorded digest renders unknown.
+ */
+export declare const collectRegistryDriftObservations: (input: RegistryDriftInput) => Promise<StatusObservation[]>;

package/dist/status/registryDrift.js

@@ -0,0 +1,119 @@
+import { spawn } from "node:child_process";
+import { dockerContextNameForTarget, dockerHostValueForTarget } from "../deployment/index.js";
+/**
+ * Extracts the comparable digest from `docker manifest inspect --verbose` output.
+ *
+ * A single-arch tag resolves to one manifest object whose `Descriptor.digest`
+ * equals the digest RepoDigests records at deploy time. A multi-arch tag resolves
+ * to a JSON ARRAY of per-platform manifests; each `Descriptor.digest` is a CHILD
+ * digest, never the manifest-list (index) digest that was recorded — comparing one
+ * would report drift on every check. We cannot derive the index digest from this
+ * command, so multi-arch (and any unparseable output) yields null → "unknown"
+ * rather than a false positive.
+ */
+export const parseManifestInspectDigest = (output) => {
+    try {
+        const parsed = JSON.parse(output);
+        if (Array.isArray(parsed)) {
+            return null;
+        }
+        const digest = parsed.Descriptor?.digest ??
+            parsed.digest;
+        return typeof digest === "string" && digest.length > 0 ? digest : null;
+    }
+    catch {
+        return null;
+    }
+};
+/* v8 ignore start -- the docker spawn boundary is covered by distribution E2E */
+const defaultResolveDigest = async (imageRef, baseArgs) => new Promise((resolve) => {
+    const child = spawn("docker", [...baseArgs, "manifest", "inspect", "--verbose", imageRef], {
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = [];
+    child.stdout.on("data", (chunk) => stdout.push(String(chunk)));
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => {
+        resolve(code === 0 ? parseManifestInspectDigest(stdout.join("")) : null);
+    });
+});
+/* v8 ignore stop */
+const baseArgsForTarget = (record) => {
+    const context = dockerContextNameForTarget(record.target);
+    if (context) {
+        return ["--context", context];
+    }
+    const host = dockerHostValueForTarget(record.target);
+    return host ? ["--host", host] : [];
+};
+/**
+ * Compares each image deployment's recorded source.digest against the digest
+ * the registry tag currently resolves to. Networked: runs only behind the
+ * explicit --pull-check flag. A digest-pinned ref needs no lookup; a null
+ * recorded digest renders unknown.
+ */
+export const collectRegistryDriftObservations = async (input) => {
+    const resolveDigest = input.resolveDigest ?? defaultResolveDigest;
+    const observations = [];
+    for (const record of input.deployments) {
+        if (record.source.kind !== "image") {
+            continue;
+        }
+        const subject = `deployment-unit:${record.name}`;
+        const ref = record.source.ref;
+        if (ref.includes("@sha256:")) {
+            observations.push({
+                key: "registry.drift",
+                label: "registry",
+                message: `${ref} is digest-pinned; registry drift does not apply`,
+                severity: "ok",
+                source: "deployment",
+                subject
+            });
+            continue;
+        }
+        if (!record.source.digest) {
+            observations.push({
+                key: "registry.drift",
+                label: "registry",
+                message: `${ref} has no recorded registry digest; drift is unknown`,
+                severity: "unknown",
+                source: "deployment",
+                subject
+            });
+            continue;
+        }
+        const current = await resolveDigest(ref, baseArgsForTarget(record));
+        if (!current) {
+            observations.push({
+                key: "registry.drift",
+                label: "registry",
+                message: `Unable to resolve the current registry digest for ${ref}`,
+                severity: "unknown",
+                source: "deployment",
+                subject
+            });
+            continue;
+        }
+        if (current === record.source.digest) {
+            observations.push({
+                key: "registry.drift",
+                label: "registry",
+                message: `${ref} matches the recorded registry digest`,
+                severity: "ok",
+                source: "deployment",
+                subject
+            });
+            continue;
+        }
+        observations.push({
+            key: "registry.drift",
+            label: "registry",
+            message: `A newer build of ${ref} has been published since this deployment`,
+            severity: "warn",
+            source: "deployment",
+            subject
+        });
+    }
+    return observations;
+};

package/dist/status/renderStatus.d.ts

@@ -0,0 +1,2 @@
+import type { StaticStatus, StatusRenderOptions } from "./types.js";
+export declare const renderStatus: (status: StaticStatus, options: StatusRenderOptions) => string;

package/dist/status/renderStatus.js

@@ -0,0 +1,230 @@
+import path from "node:path";
+import { renderOrganizationTree } from "../compiler/index.js";
+import { countObservations, getVisibleObservations } from "./buildStatus.js";
+import { flattenOrganizationNodes } from "./traversal.js";
+const SEVERITY_ORDER = ["error", "warn", "unknown", "ok"];
+const relativePath = (value, root) => {
+    if (!root) {
+        return value;
+    }
+    const relative = path.relative(root, value) || ".";
+    // A relative path that escapes the project root (e.g. an --out under /tmp) is
+    // never more readable than the absolute path — show the absolute one instead.
+    return relative.startsWith("..") ? value : relative;
+};
+const formatCounts = (counts) => `${counts.ok} ok, ${counts.warn} warn, ${counts.error} error, ${counts.unknown} unknown`;
+const severityForSubject = (observations, subject, source) => {
+    const subjectObservations = observations.filter((observation) => observation.subject === subject && (!source || observation.source === source));
+    for (const severity of SEVERITY_ORDER) {
+        if (subjectObservations.some((observation) => observation.severity === severity)) {
+            return severity;
+        }
+    }
+    return "unknown";
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const humanizeMessagePaths = (message, projectRoot) => {
+    if (!projectRoot) {
+        return message;
+    }
+    return message.replace(new RegExp(escapeRegExp(projectRoot), "g"), ".");
+};
+const formatObservation = (observation, projectRoot) => `[${observation.severity}] ${observation.subject} ${observation.key}: ${humanizeMessagePaths(observation.message, projectRoot)}`;
+const nonOkObservations = (observations) => observations.filter((observation) => observation.severity !== "ok");
+const observationsWithDetails = (observations) => observations.filter((observation) => observation.details && Object.keys(observation.details).length > 0);
+const formatDetailValue = (value) => typeof value === "string" ? value : JSON.stringify(value);
+const formatObservationDetails = (observation, projectRoot) => {
+    const details = observation.details ?? {};
+    const lines = [`  ${formatObservation(observation, projectRoot)}`];
+    const logTail = details.log_tail;
+    if (typeof logTail === "string") {
+        lines.push("    log_tail:");
+        const text = logTail.replace(/\n$/u, "");
+        if (text.length === 0) {
+            lines.push("      (empty)");
+        }
+        else {
+            lines.push(...text.split("\n").map((line) => `      ${humanizeMessagePaths(line, projectRoot)}`));
+        }
+    }
+    for (const [key, value] of Object.entries(details)) {
+        if (key === "log_tail") {
+            continue;
+        }
+        lines.push(`    ${key}: ${humanizeMessagePaths(formatDetailValue(value), projectRoot)}`);
+    }
+    return lines;
+};
+const formatDocRoles = (node) => node.declared?.docs.map((doc) => doc.role).sort().join(", ") || "none";
+const formatNodeDetails = (node, observations, projectRoot) => {
+    const declared = node.declared;
+    const details = [
+        `  ${node.name} (${node.id})${node.runtimeName ? ` runtime=${node.runtimeName}` : ""}`,
+        `    source: ${relativePath(node.source, projectRoot)}`,
+        `    declared: ${severityForSubject(observations, node.id, "declared")}`,
+        `    compiled: ${severityForSubject(observations, node.id, "compile_report")}`,
+        `    docs: ${formatDocRoles(node)}`
+    ];
+    if (!declared) {
+        return details;
+    }
+    details.push(`    skills: ${declared.skills.map((skill) => skill.name).join(", ") || "none"}`);
+    details.push(`    resources: ${declared.resources.map((resource) => `${resource.id}@${resource.mount}(${resource.sharing})`).join(", ") || "none"}`);
+    details.push(`    packages: ${declared.packages.map((pkg) => pkg.id).join(", ") || "none"}`);
+    details.push(`    mcp: ${declared.mcpServers.map((server) => `${server.name}:${server.transport}`).join(", ") || "none"}`);
+    details.push(`    model: ${declared.model
+        ? `${declared.model.provider}/${declared.model.name} auth=${declared.model.authMethod}`
+        : "none"}`);
+    details.push(`    schedule: ${declared.schedule
+        ? `${declared.schedule.kind}${declared.schedule.expression ? ` ${declared.schedule.expression}` : ""}`
+        : "none"}`);
+    details.push(`    surfaces: ${declared.surfaces.map((surface) => `${surface.name}[${surface.scopes.join(",")}]`).join(", ") || "none"}`);
+    details.push(`    policy: mode=${declared.policy.mode ?? "default"} on_degrade=${declared.policy.onDegrade ?? "default"}`);
+    return details;
+};
+const formatNetwork = (network, observations) => [
+    `  ${network.id} "${network.name}"`,
+    `    declared: ${severityForSubject(observations, `network:${network.id}`, "declared")}`,
+    `    provider: ${network.provider}`,
+    `    server: ${network.serverMode ?? "unspecified"}`,
+    `    rooms: ${network.rooms.map((room) => `${room.id}[${room.declaredMembers.join(",")}]`).join(", ") || "none"}`
+];
+const formatRuntime = (runtime, observations) => [
+    `  ${runtime.name}`,
+    `    declared: ${severityForSubject(observations, `runtime:${runtime.name}`, "declared")}`,
+    `    nodes: ${runtime.nodeIds.join(", ") || "none"}`
+];
+const formatDeployment = (deployment, projectRoot) => [
+    `  ${deployment.name} ${deployment.manager} ${deployment.target}`,
+    `    record: ${relativePath(deployment.recordPath, projectRoot)}`,
+    `    compile: ${deployment.compileFingerprint}`,
+    `    created: ${deployment.createdAt}`,
+    `    auth-profile: ${deployment.authProfile ?? "none"}`,
+    ...deployment.units.flatMap((unit) => [
+        `    unit ${unit.id}`,
+        `      image: ${unit.imageTag}${unit.imageId ? ` (${unit.imageId})` : ""}`,
+        `      container: ${unit.containerName ?? "none"}${unit.containerId ? ` (${unit.containerId})` : ""}`,
+        `      contains: ${unit.contains.map((entry) => entry.id).join(", ") || "none"}`,
+        `      runtimes: ${unit.runtimeInstances.join(", ") || "none"}`,
+        `      live: ${unit.live ? unit.live.message : "not checked"}`
+    ])
+];
+const renderHeader = (status, observations) => {
+    const counts = countObservations(observations);
+    const count = (value, noun) => `${value} ${noun}${value === 1 ? "" : "s"}`;
+    return [
+        `Spawnfile status: ${relativePath(status.inputPath, status.projectRoot)}`,
+        `Output: ${relativePath(status.outputDirectory, status.projectRoot)}`,
+        `Summary: ${count(status.summary.agents, "agent")}, ${count(status.summary.teams, "team")}, ${count(status.summary.networks, "network")}, ${count(status.summary.runtimes, "runtime")}, ${count(status.summary.deployments, "deployment")}`,
+        `Status: ${formatCounts(counts)}`,
+        status.live.requested ? `Live: requested${status.live.deploymentName ? ` deployment=${status.live.deploymentName}` : ""}` : "",
+        status.selection ? `Selection: ${status.selection.kind} ${status.selection.label}` : ""
+    ].filter(Boolean);
+};
+const selectedNodes = (status) => {
+    const nodes = flattenOrganizationNodes(status.view);
+    if (!status.selection) {
+        return nodes;
+    }
+    if (status.selection.kind === "agent" || status.selection.kind === "team") {
+        const subjects = new Set(status.selection.subjectKeys);
+        return nodes.filter((node) => subjects.has(node.id));
+    }
+    if (status.selection.kind === "runtime") {
+        const subjects = new Set(status.selection.subjectKeys);
+        return nodes.filter((node) => subjects.has(node.id));
+    }
+    return [];
+};
+const selectedNetworks = (status) => {
+    if (status.selection?.kind !== "network") {
+        return status.selection ? [] : status.view.networks;
+    }
+    const subjects = new Set(status.selection.subjectKeys);
+    return status.view.networks.filter((network) => subjects.has(`network:${network.id}`));
+};
+const selectedRuntimes = (status) => {
+    if (status.selection?.kind !== "runtime") {
+        return status.selection ? [] : status.view.runtimes;
+    }
+    return status.view.runtimes.filter((runtime) => runtime.name === status.selection?.value);
+};
+const selectedDeployments = (status) => {
+    if (!status.selection) {
+        return status.deployments;
+    }
+    if (status.selection.kind === "network") {
+        return [];
+    }
+    const subjects = new Set(status.selection.subjectKeys);
+    return status.deployments.filter((deployment) => deployment.units.some((unit) => unit.contains.some((entry) => subjects.has(entry.id))
+        || unit.runtimeInstances.some((runtimeInstance) => subjects.has(`runtime-instance:${runtimeInstance}`))));
+};
+const renderPrettyStatus = (status) => {
+    const observations = getVisibleObservations(status);
+    const annotations = (subject) => {
+        const severity = severityForSubject(observations, subject);
+        return [`status=${severity}`];
+    };
+    const lines = [
+        ...renderHeader(status, observations),
+        "",
+        `Compile: ${status.compile.present ? "present" : "missing"} ${relativePath(status.compile.path, status.projectRoot)}`,
+        ...(status.compile.present ? [] : ["  run 'spawnfile compile' to populate compiled status"])
+    ];
+    if (!status.selection) {
+        lines.push("", "Organization", renderOrganizationTree(status.view, { annotationFor: annotations }));
+    }
+    const deployments = selectedDeployments(status);
+    if (deployments.length > 0) {
+        lines.push("", "Deployments", ...deployments.flatMap((deployment) => formatDeployment(deployment, status.projectRoot)));
+    }
+    const nodes = selectedNodes(status);
+    if (nodes.length > 0) {
+        lines.push("", "Nodes", ...nodes.flatMap((node) => formatNodeDetails(node, observations, status.projectRoot)));
+    }
+    const networks = selectedNetworks(status);
+    if (networks.length > 0) {
+        lines.push("", "Networks", ...networks.flatMap((network) => formatNetwork(network, observations)));
+    }
+    const runtimes = selectedRuntimes(status);
+    if (runtimes.length > 0) {
+        lines.push("", "Runtimes", ...runtimes.flatMap((runtime) => formatRuntime(runtime, observations)));
+    }
+    const notable = nonOkObservations(observations);
+    if (notable.length > 0) {
+        lines.push("", "Observations", ...notable.map((observation) => `  ${formatObservation(observation, status.projectRoot)}`));
+    }
+    const details = observationsWithDetails(observations);
+    if (details.length > 0) {
+        lines.push("", "Details", ...details.flatMap((observation) => formatObservationDetails(observation, status.projectRoot)));
+    }
+    return lines.join("\n");
+};
+const renderQuietStatus = (status) => {
+    const observations = getVisibleObservations(status);
+    const notable = nonOkObservations(observations);
+    return [
+        ...renderHeader(status, observations),
+        ...notable.map((observation) => formatObservation(observation, status.projectRoot))
+    ].join("\n");
+};
+const renderJsonStatus = (status) => JSON.stringify({
+    compile: status.compile,
+    deployments: status.deployments,
+    input_path: status.inputPath,
+    live: status.live,
+    observations: getVisibleObservations(status),
+    output_directory: status.outputDirectory,
+    project_root: status.projectRoot,
+    selection: status.selection,
+    summary: status.summary,
+    version: status.version,
+    view: status.view
+}, null, 2);
+export const renderStatus = (status, options) => {
+    if (options.mode === "json") {
+        return renderJsonStatus(status);
+    }
+    return options.mode === "quiet" ? renderQuietStatus(status) : renderPrettyStatus(status);
+};

package/dist/status/runtimeProbes.d.ts

@@ -0,0 +1,13 @@
+import type { DeploymentRecord, DockerInspectionResult, DockerProbeExecFile } from "../deployment/index.js";
+import type { LoadedCompileReport } from "./compileReport.js";
+import type { StatusObservation } from "./types.js";
+export type StatusRuntimeInspections = Map<string, DockerInspectionResult>;
+export interface CollectRuntimeProbeOptions {
+    deployments: DeploymentRecord[];
+    dockerCommand?: string;
+    execFile?: DockerProbeExecFile;
+    inspections: StatusRuntimeInspections;
+    loadedReport: LoadedCompileReport;
+    timeoutMs?: number;
+}
+export declare const collectRuntimeProbeObservations: (options: CollectRuntimeProbeOptions) => Promise<StatusObservation[]>;