spawnfile 0.1.11 → 0.1.13

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[]>;

package/dist/status/runtimeProbes.js

@@ -0,0 +1,111 @@
+import { createDockerProbeGateway } from "../deployment/index.js";
+import { getRuntimeAdapter } from "../runtime/index.js";
+const createObservation = (input) => ({
+    ...input,
+    label: `${input.severity.toUpperCase()} ${input.key}`,
+    source: "runtime"
+});
+const instanceSubject = (instanceId) => `runtime-instance:${instanceId}`;
+const fromProbeObservation = (instance, probe) => createObservation({
+    ...(probe.details ? { details: probe.details } : {}),
+    key: probe.key,
+    message: probe.message,
+    severity: probe.severity,
+    subject: instanceSubject(instance.id)
+});
+const toRuntimeInstanceReport = (instance) => ({
+    config_path: instance.configPath ?? "",
+    home_path: instance.homePath,
+    id: instance.id,
+    internal_port: instance.internalPort,
+    model_auth_methods: {},
+    model_secrets_required: [],
+    node_ids: instance.nodeIds,
+    published_port: instance.publishedPort,
+    runtime: instance.runtime,
+    workspace_path: instance.workspacePath ?? undefined
+});
+const skippedSeverity = (running) => running === false ? "error" : "unknown";
+export const collectRuntimeProbeObservations = async (options) => {
+    if (options.loadedReport.kind !== "loaded") {
+        return [];
+    }
+    const observations = [];
+    const instances = new Map(options.loadedReport.report.runtimeInstances.map((instance) => [instance.id, instance]));
+    for (const deployment of options.deployments) {
+        const deploymentInspections = options.inspections.get(deployment.name);
+        for (const unit of deployment.units) {
+            const inspection = deploymentInspections?.get(unit.id);
+            for (const instanceId of unit.runtime_instances) {
+                const instance = instances.get(instanceId);
+                if (!instance) {
+                    observations.push(createObservation({
+                        key: "runtime.instance",
+                        message: `${instanceId} is referenced by deployment ${deployment.name}/${unit.id} but missing from the compile report`,
+                        severity: "warn",
+                        subject: instanceSubject(instanceId)
+                    }));
+                    continue;
+                }
+                if (inspection?.running !== true) {
+                    observations.push(createObservation({
+                        key: "runtime.probe",
+                        message: `${instance.id} runtime probe skipped because deployment unit ${unit.id} is not running`,
+                        severity: skippedSeverity(inspection?.running),
+                        subject: instanceSubject(instance.id)
+                    }));
+                    continue;
+                }
+                let adapter;
+                try {
+                    adapter = getRuntimeAdapter(instance.runtime);
+                }
+                catch (error) {
+                    observations.push(createObservation({
+                        key: "runtime.adapter",
+                        message: error instanceof Error ? error.message : String(error),
+                        severity: "unknown",
+                        subject: instanceSubject(instance.id)
+                    }));
+                    continue;
+                }
+                if (!adapter.statusProbes || adapter.statusProbes.length === 0) {
+                    observations.push(createObservation({
+                        key: "runtime.probe",
+                        message: `${instance.runtime} has no status probes`,
+                        severity: "unknown",
+                        subject: instanceSubject(instance.id)
+                    }));
+                    continue;
+                }
+                const manager = createDockerProbeGateway(deployment, unit, {
+                    dockerCommand: options.dockerCommand,
+                    execFile: options.execFile,
+                    inspection,
+                    timeoutMs: options.timeoutMs
+                });
+                for (const probe of adapter.statusProbes) {
+                    try {
+                        const probeObservations = await probe.run({
+                            deployment,
+                            instance: toRuntimeInstanceReport(instance),
+                            manager,
+                            timeoutMs: options.timeoutMs ?? 10_000,
+                            unit
+                        });
+                        observations.push(...probeObservations.map((entry) => fromProbeObservation(instance, entry)));
+                    }
+                    catch (error) {
+                        observations.push(createObservation({
+                            key: `runtime.${probe.id}`,
+                            message: `${probe.label} probe failed: ${error instanceof Error ? error.message : String(error)}`,
+                            severity: "unknown",
+                            subject: instanceSubject(instance.id)
+                        }));
+                    }
+                }
+            }
+        }
+    }
+    return observations;
+};

package/dist/status/selectionSubjects.d.ts

@@ -0,0 +1,8 @@
+import type { OrganizationView } from "../compiler/index.js";
+import type { LoadedCompileReport } from "./compileReport.js";
+import type { StatusDeploymentSummary, StatusSelection } from "./types.js";
+export declare const expandStatusSelectionSubjects: (selection: StatusSelection | null, input: {
+    deployments: StatusDeploymentSummary[];
+    loadedReport: LoadedCompileReport;
+    view: OrganizationView;
+}) => StatusSelection | null;

package/dist/status/selectionSubjects.js

@@ -0,0 +1,77 @@
+const addRuntimeInstancesForNodes = (subjects, loadedReport, nodeIds) => {
+    if (loadedReport.kind !== "loaded") {
+        return;
+    }
+    for (const instance of loadedReport.report.runtimeInstances) {
+        if (instance.nodeIds.some((nodeId) => nodeIds.has(nodeId))) {
+            subjects.add(`runtime-instance:${instance.id}`);
+        }
+    }
+};
+const addRuntimeInstancesForRuntime = (subjects, loadedReport, runtimeName) => {
+    if (loadedReport.kind !== "loaded") {
+        return;
+    }
+    for (const instance of loadedReport.report.runtimeInstances) {
+        if (instance.runtime === runtimeName) {
+            subjects.add(`runtime-instance:${instance.id}`);
+            instance.nodeIds.forEach((nodeId) => subjects.add(nodeId));
+        }
+    }
+};
+const addDeploymentSubjects = (subjects, deployments) => {
+    for (const deployment of deployments) {
+        let deploymentMatches = false;
+        for (const unit of deployment.units) {
+            const unitMatches = unit.contains.some((entry) => subjects.has(entry.id))
+                || unit.runtimeInstances.some((instanceId) => subjects.has(`runtime-instance:${instanceId}`));
+            if (!unitMatches) {
+                continue;
+            }
+            deploymentMatches = true;
+            subjects.add(`deployment-unit:${deployment.name}:${unit.id}`);
+            unit.runtimeInstances.forEach((instanceId) => subjects.add(`runtime-instance:${instanceId}`));
+            unit.contains.forEach((entry) => subjects.add(entry.id));
+        }
+        if (deploymentMatches) {
+            subjects.add(`deployment:${deployment.name}`);
+        }
+    }
+};
+const addNetworkSubjects = (subjects, view, loadedReport, networkId) => {
+    const addRoom = (roomId, members) => {
+        subjects.add(`room:${networkId}:${roomId}`);
+        members.forEach((member) => subjects.add(`agent:${member}`));
+    };
+    const declaredNetwork = view.networks.find((network) => network.id === networkId);
+    declaredNetwork?.rooms.forEach((room) => addRoom(room.id, room.declaredMembers));
+    if (loadedReport.kind !== "loaded") {
+        return;
+    }
+    for (const server of loadedReport.report.moltnetServers ?? []) {
+        if (server.networkId === networkId) {
+            server.rooms.forEach((room) => addRoom(room.id, room.members));
+        }
+    }
+};
+export const expandStatusSelectionSubjects = (selection, input) => {
+    if (!selection) {
+        return null;
+    }
+    const subjects = new Set(selection.subjectKeys);
+    const nodeIds = new Set(selection.subjectKeys.filter((subject) => subject.startsWith("agent:") || subject.startsWith("team:")));
+    if (nodeIds.size > 0) {
+        addRuntimeInstancesForNodes(subjects, input.loadedReport, nodeIds);
+    }
+    if (selection.kind === "runtime") {
+        addRuntimeInstancesForRuntime(subjects, input.loadedReport, selection.value);
+    }
+    if (selection.kind === "network") {
+        addNetworkSubjects(subjects, input.view, input.loadedReport, selection.value);
+    }
+    addDeploymentSubjects(subjects, input.deployments);
+    return {
+        ...selection,
+        subjectKeys: [...subjects]
+    };
+};

package/dist/status/selectors.d.ts

@@ -0,0 +1,14 @@
+import type { OrganizationView } from "../compiler/index.js";
+import type { StatusInputFailure, StatusSelection, StatusSelectorKind } from "./types.js";
+export interface StatusSelectorInput {
+    kind: StatusSelectorKind;
+    value: string;
+}
+export type StatusSelectorResult = {
+    kind: "failure";
+    failure: StatusInputFailure;
+} | {
+    kind: "selected";
+    selection: StatusSelection;
+};
+export declare const resolveStatusSelector: (view: OrganizationView, selector: StatusSelectorInput | null) => StatusSelectorResult | null;

package/dist/status/selectors.js

@@ -0,0 +1,90 @@
+import { flattenOrganizationNodes } from "./traversal.js";
+const failure = (message) => ({
+    failure: { exitCode: 2, message },
+    kind: "failure"
+});
+const validValuesMessage = (label, values) => values.length > 0 ? `${label}: ${values.join(", ")}` : `${label}: none`;
+const selectNode = (nodes, kind, value) => {
+    const candidates = nodes.filter((node) => node.kind === kind);
+    const exactId = candidates.filter((node) => node.id === value);
+    if (exactId.length === 1) {
+        const [node] = exactId;
+        return {
+            kind: "selected",
+            selection: { kind, label: node.displayName, subjectKeys: [node.id], value }
+        };
+    }
+    const named = candidates.filter((node) => node.name === value || node.slug === value);
+    if (named.length === 1) {
+        const [node] = named;
+        return {
+            kind: "selected",
+            selection: { kind, label: node.displayName, subjectKeys: [node.id], value }
+        };
+    }
+    if (named.length > 1 || exactId.length > 1) {
+        const matches = [...exactId, ...named].map((node) => node.id).sort();
+        return failure(`Ambiguous ${kind} selector "${value}". Candidates: ${matches.join(", ")}`);
+    }
+    return failure(`Unknown ${kind} selector "${value}". ${validValuesMessage(`Valid ${kind} ids`, candidates.map((node) => node.id).sort())}`);
+};
+const selectNetwork = (view, value) => {
+    const exactId = view.networks.filter((network) => network.id === value);
+    if (exactId.length === 1) {
+        const [network] = exactId;
+        return {
+            kind: "selected",
+            selection: {
+                kind: "network",
+                label: network.name,
+                subjectKeys: [`network:${network.id}`],
+                value
+            }
+        };
+    }
+    const named = view.networks.filter((network) => network.name === value);
+    if (named.length === 1) {
+        const [network] = named;
+        return {
+            kind: "selected",
+            selection: {
+                kind: "network",
+                label: network.name,
+                subjectKeys: [`network:${network.id}`],
+                value
+            }
+        };
+    }
+    if (named.length > 1 || exactId.length > 1) {
+        const matches = [...exactId, ...named].map((network) => network.id).sort();
+        return failure(`Ambiguous network selector "${value}". Candidates: ${matches.join(", ")}`);
+    }
+    return failure(`Unknown network selector "${value}". ${validValuesMessage("Valid network ids", view.networks.map((network) => network.id).sort())}`);
+};
+const selectRuntime = (view, value) => {
+    const runtime = view.runtimes.find((entry) => entry.name === value);
+    if (!runtime) {
+        return failure(`Unknown runtime selector "${value}". ${validValuesMessage("Valid runtime names", view.runtimes.map((entry) => entry.name).sort())}`);
+    }
+    return {
+        kind: "selected",
+        selection: {
+            kind: "runtime",
+            label: runtime.name,
+            subjectKeys: [`runtime:${runtime.name}`, ...runtime.nodeIds],
+            value
+        }
+    };
+};
+export const resolveStatusSelector = (view, selector) => {
+    if (!selector) {
+        return null;
+    }
+    if (selector.kind === "network") {
+        return selectNetwork(view, selector.value);
+    }
+    if (selector.kind === "runtime") {
+        return selectRuntime(view, selector.value);
+    }
+    return selectNode(flattenOrganizationNodes(view), selector.kind, selector.value);
+};