spawnfile 0.1.10 → 0.1.12

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

package/dist/status/traversal.d.ts

@@ -0,0 +1,6 @@
+import type { OrganizationView, OrganizationViewTreeNode } from "../compiler/index.js";
+export declare const flattenOrganizationNodes: (view: OrganizationView) => OrganizationViewTreeNode[];
+export declare const countNodesByKind: (nodes: OrganizationViewTreeNode[]) => {
+    agents: number;
+    teams: number;
+};

package/dist/status/traversal.js

@@ -0,0 +1,15 @@
+export const flattenOrganizationNodes = (view) => {
+    const nodes = [];
+    const visit = (node) => {
+        nodes.push(node);
+        for (const child of node.children) {
+            visit(child.node);
+        }
+    };
+    visit(view.root);
+    return nodes;
+};
+export const countNodesByKind = (nodes) => ({
+    agents: nodes.filter((node) => node.kind === "agent").length,
+    teams: nodes.filter((node) => node.kind === "team").length
+});

package/dist/status/types.d.ts

@@ -0,0 +1,113 @@
+import type { OrganizationView } from "../compiler/index.js";
+export type StatusSeverity = "error" | "ok" | "unknown" | "warn";
+export type StatusExitCode = 0 | 1 | 2;
+export type StatusOutputMode = "json" | "pretty" | "quiet";
+export type StatusSelectorKind = "agent" | "network" | "runtime" | "team";
+export interface StatusObservation {
+    details?: Record<string, unknown>;
+    key: string;
+    label: string;
+    message: string;
+    severity: StatusSeverity;
+    source: "compile_report" | "declared" | "deployment" | "input" | "network" | "runtime";
+    subject: string;
+}
+export interface StatusObservationCounts {
+    error: number;
+    ok: number;
+    unknown: number;
+    warn: number;
+}
+export interface StatusSelection {
+    kind: StatusSelectorKind;
+    label: string;
+    subjectKeys: string[];
+    value: string;
+}
+export interface StatusInputFailure {
+    exitCode: 2;
+    message: string;
+}
+export interface StatusCompileReportInfo {
+    compileFingerprint: string | null;
+    generatedAt: string | null;
+    outputDirectory: string | null;
+    path: string;
+    present: boolean;
+    root: string | null;
+}
+export interface StaticStatusSummary {
+    agents: number;
+    deployments: number;
+    networks: number;
+    runtimes: number;
+    teams: number;
+}
+export interface StatusDeploymentUnitLive {
+    checked: boolean;
+    containerId: string | null;
+    drift: string[];
+    exists: boolean | null;
+    exitCode: number | null;
+    finishedAt: string | null;
+    imageId: string | null;
+    message: string;
+    restartCount: number | null;
+    running: boolean | null;
+    severity: StatusSeverity;
+    startedAt: string | null;
+    status: string | null;
+}
+export interface StatusDeploymentUnitSummary {
+    containerId: string | null;
+    containerName: string | null;
+    contains: Array<{
+        id: string;
+        kind: string;
+    }>;
+    id: string;
+    imageId: string | null;
+    imageTag: string;
+    kind: "container";
+    live: StatusDeploymentUnitLive | null;
+    runtimeInstances: string[];
+}
+export interface StatusDeploymentSummary {
+    authProfile: string | null;
+    compileFingerprint: string;
+    createdAt: string;
+    manager: string;
+    name: string;
+    recordPath: string;
+    target: string;
+    units: StatusDeploymentUnitSummary[];
+}
+export interface StatusLiveRequest {
+    context: string | null;
+    deploymentName: string | null;
+    logs: boolean;
+    recover: boolean;
+    requested: boolean;
+}
+export interface StaticStatus {
+    compile: StatusCompileReportInfo;
+    deployments: StatusDeploymentSummary[];
+    inputPath: string;
+    live: StatusLiveRequest;
+    observations: StatusObservation[];
+    outputDirectory: string;
+    projectRoot: string | null;
+    selection: StatusSelection | null;
+    summary: StaticStatusSummary;
+    view: OrganizationView;
+    version: "spawnfile.status.v1";
+}
+export interface StatusCommandResult {
+    error?: string;
+    exitCode: StatusExitCode;
+    output?: string;
+    status?: StaticStatus;
+}
+export interface StatusRenderOptions {
+    mode: StatusOutputMode;
+}

package/dist/status/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -31,7 +31,9 @@
     "test:e2e:moltnet-team-chat": "tsx src/e2e/cli.ts moltnet-team-chat",
     "test:e2e:operational-smoke": "tsx src/e2e/cli.ts operational-smoke",
     "test": "vitest run",
-    "typecheck": "tsc --project tsconfig.json --noEmit"
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test:e2e:distribution-image": "tsx src/e2e/cli.ts distribution-image",
+    "test:e2e:distribution-roundtrip": "tsx src/e2e/cli.ts distribution-roundtrip"
   },
   "dependencies": {
     "commander": "^14.0.1",

package/runtimes.yaml

@@ -16,47 +16,54 @@
 runtimes:
   openclaw:
     remote: git@github.com:openclaw/openclaw.git
-    ref: v2026.3.13-1
+    ref: v2026.6.5
     default_branch: main
     install:
       kind: npm
       package: openclaw
-      version: 2026.3.13
+      version: 2026.6.5
     status: active
 
   picoclaw:
     remote: git@github.com:sipeed/picoclaw.git
-    ref: v0.2.5
+    ref: v0.2.9
     default_branch: main
     install:
       kind: github_release_archive
       repository: sipeed/picoclaw
-      tag: v0.2.5
+      tag: v0.2.9
       binary: picoclaw
       assets:
         linux_amd64: picoclaw_Linux_x86_64.tar.gz
         linux_arm64: picoclaw_Linux_arm64.tar.gz
     status: active
 
-  tinyclaw:
-    remote: git@github.com:TinyAGI/tinyclaw.git
-    ref: v0.0.20
+  hermes-agent:
+    remote: git@github.com:NousResearch/hermes-agent.git
+    ref: v2026.6.5
     default_branch: main
-    install:
-      kind: github_release_bundle
-      repository: TinyAGI/tinyagi
-      tag: v0.0.20
-      asset: tinyagi-bundle.tar.gz
-    status: active
+    status: exploratory
 
   nullclaw:
     remote: git@github.com:nullclaw/nullclaw.git
-    ref: v2026.3.17
+    ref: v2026.5.29
+    default_branch: main
+    status: exploratory
+
+  opencode:
+    remote: git@github.com:anomalyco/opencode.git
+    ref: v1.16.2
+    default_branch: dev
+    status: exploratory
+
+  openfang:
+    remote: git@github.com:RightNow-AI/openfang.git
+    ref: v0.6.9
     default_branch: main
     status: exploratory
 
   zeroclaw:
     remote: git@github.com:zeroclaw-labs/zeroclaw.git
-    ref: v0.5.0
+    ref: v0.7.5
     default_branch: master
     status: exploratory

package/dist/runtime/tinyclaw/adapter.d.ts

@@ -1,2 +0,0 @@
-import type { RuntimeAdapter } from "../types.js";
-export declare const tinyClawAdapter: RuntimeAdapter;