spawnfile 0.1.11 → 0.1.12

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.11",
+  "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;

package/dist/runtime/tinyclaw/adapter.js

@@ -1,284 +0,0 @@
-import { listEffectiveExecutionModelTargets } from "../../compiler/modelEnv.js";
-import { SpawnfileError } from "../../shared/index.js";
-import { createCapability, createAgentCapabilities, createDocumentFiles, createSkillFiles } from "../common.js";
-import { prepareTinyClawRuntimeAuth } from "./runAuth.js";
-import { createTinyClawAgentScaffold } from "./scaffold.js";
-import { assertSupportedTinyClawSurfaces, buildTinyClawChannels, resolveTinyClawSurfaceTokenBindings } from "./surfaces.js";
-import { createScheduleDiagnostics, createTinyClawSchedulesFile, scheduleOutcomeFor } from "./schedules.js";
-const WORKSPACE_PLACEHOLDER = "<workspace-path>";
-const SUPPORTED_TINYCLAW_OPENAI_MODEL_PREFIXES = ["gpt-5"];
-const TINYCLAW_START_SCRIPT = `
-set -euo pipefail
-PIDS=()
-node <runtime-root>/packages/main/dist/index.js &
-PIDS+=("$!")
-sleep 1
-while IFS= read -r channel; do
-  case "$channel" in
-    discord)
-      node <runtime-root>/packages/channels/dist/discord.js &
-      PIDS+=("$!")
-      ;;
-    telegram)
-      node <runtime-root>/packages/channels/dist/telegram.js &
-      PIDS+=("$!")
-      ;;
-    whatsapp)
-      node <runtime-root>/packages/channels/dist/whatsapp.js &
-      PIDS+=("$!")
-      ;;
-  esac
-done < <(python3 - <<'PY'
-import json
-import os
-
-settings_path = os.path.join(os.environ["TINYAGI_HOME"], "settings.json")
-try:
-    with open(settings_path, encoding="utf-8") as handle:
-        settings = json.load(handle)
-except FileNotFoundError:
-    raise SystemExit(0)
-
-for channel in settings.get("channels", {}).get("enabled", []):
-    print(channel)
-PY
-)
-terminate_children() {
-  for pid in "\${PIDS[@]:-}"; do
-    kill "$pid" 2>/dev/null || true
-  done
-}
-trap terminate_children INT TERM EXIT
-status=0
-for pid in "\${PIDS[@]}"; do
-  if ! wait "$pid"; then
-    status=1
-  fi
-done
-exit "$status"
-`.trim();
-const isSupportedTinyClawOpenAiModel = (modelName) => SUPPORTED_TINYCLAW_OPENAI_MODEL_PREFIXES.some((prefix) => modelName.startsWith(prefix));
-const buildTinyClawSettings = (node) => {
-    const [primary] = listEffectiveExecutionModelTargets(node.execution);
-    const agentEntry = {
-        name: node.name,
-        provider: primary?.provider ?? "anthropic",
-        model: primary?.name ?? "opus",
-        working_directory: `${WORKSPACE_PLACEHOLDER}/${node.name}`
-    };
-    const channels = buildTinyClawChannels(node.surfaces);
-    const config = {
-        workspace: {
-            path: WORKSPACE_PLACEHOLDER,
-            name: "workspace"
-        },
-        channels: {
-            enabled: channels.enabled,
-            ...channels.config
-        },
-        agents: {
-            [node.name]: agentEntry
-        },
-        models: {
-            provider: primary?.provider ?? "anthropic"
-        },
-        monitoring: {
-            heartbeat_interval: 3600
-        }
-    };
-    return `${JSON.stringify(config, null, 2)}\n`;
-};
-const parseJsonFile = (input, filePath) => {
-    const file = input.emittedFiles.find((entry) => entry.path === filePath);
-    if (!file) {
-        throw new Error(`TinyClaw target ${input.id} is missing ${filePath}`);
-    }
-    return JSON.parse(file.content);
-};
-const mergeTinyClawTargets = async (inputs) => {
-    const agentInputs = inputs.filter((input) => input.kind === "agent");
-    if (agentInputs.length === 0) {
-        return [];
-    }
-    const mergedAgents = {};
-    const mergedTeams = {};
-    const enabledChannels = new Set();
-    let hasDiscordChannel = false;
-    let hasWhatsappChannel = false;
-    let hasTelegramChannel = false;
-    const workspaceFiles = agentInputs.flatMap((input) => input.emittedFiles.filter((file) => file.path !== "settings.json"));
-    const schedulesFile = createTinyClawSchedulesFile(agentInputs);
-    let mergedBase = null;
-    for (const input of agentInputs) {
-        const settings = parseJsonFile(input, "settings.json");
-        const channels = settings.channels ?? {};
-        mergedBase ??= settings;
-        Object.assign(mergedAgents, settings.agents ?? {});
-        for (const channel of (channels.enabled ?? []).filter(Boolean)) {
-            enabledChannels.add(channel);
-        }
-        if (channels.discord) {
-            hasDiscordChannel = true;
-        }
-        if (channels.telegram) {
-            hasTelegramChannel = true;
-        }
-        if (channels.whatsapp) {
-            hasWhatsappChannel = true;
-        }
-    }
-    for (const input of inputs.filter((entry) => entry.kind === "team")) {
-        if (!input.emittedFiles.some((file) => file.path === "tinyclaw-team.json")) {
-            continue;
-        }
-        const teamConfig = parseJsonFile(input, "tinyclaw-team.json");
-        Object.assign(mergedTeams, teamConfig.teams ?? {});
-    }
-    const mergedSettings = {
-        ...(mergedBase ?? {}),
-        agents: mergedAgents,
-        ...(Object.keys(mergedTeams).length > 0 ? { teams: mergedTeams } : {}),
-        channels: {
-            ...((mergedBase?.channels ?? {})),
-            ...(hasDiscordChannel ? { discord: {} } : {}),
-            ...(hasTelegramChannel ? { telegram: {} } : {}),
-            ...(hasWhatsappChannel ? { whatsapp: {} } : {}),
-            enabled: [...enabledChannels].sort()
-        },
-        workspace: {
-            ...((mergedBase?.workspace ?? {})),
-            name: mergedBase?.workspace?.name ?? "workspace",
-            path: WORKSPACE_PLACEHOLDER
-        }
-    };
-    return [
-        {
-            files: [
-                ...workspaceFiles,
-                ...(schedulesFile ? [schedulesFile] : []),
-                {
-                    content: `${JSON.stringify(mergedSettings, null, 2)}\n`,
-                    path: "settings.json"
-                }
-            ],
-            configEnvBindings: resolveTinyClawSurfaceTokenBindings(agentInputs),
-            id: "tinyclaw-runtime",
-            sourceIds: agentInputs.map((input) => input.id)
-        }
-    ];
-};
-export const tinyClawAdapter = {
-    assertSupportedModelTarget(target) {
-        if (target.endpoint) {
-            throw new SpawnfileError("validation_error", "TinyClaw custom or local endpoints are not supported in Spawnfile v0.1");
-        }
-        if (target.provider === "anthropic") {
-            if (target.auth.method === "claude-code" || target.auth.method === "api_key") {
-                return;
-            }
-        }
-        else if (target.provider === "openai") {
-            if (!isSupportedTinyClawOpenAiModel(target.name)) {
-                throw new SpawnfileError("validation_error", `TinyClaw OpenAI models must use the runtime's Codex/GPT-5 path; received ${target.name}`);
-            }
-            if (target.auth.method === "codex" || target.auth.method === "api_key") {
-                return;
-            }
-        }
-        else if (target.provider === "opencode" && target.auth.method === "none") {
-            return;
-        }
-        throw new SpawnfileError("validation_error", `TinyClaw does not support model auth method ${target.auth.method} for provider ${target.provider}`);
-    },
-    assertSupportedSurfaces(surfaces) {
-        assertSupportedTinyClawSurfaces(surfaces);
-    },
-    container: {
-        configFileName: "settings.json",
-        configEnvBindings: [
-            {
-                envName: "ANTHROPIC_API_KEY",
-                jsonPath: "models.anthropic.api_key"
-            },
-            {
-                envName: "OPENAI_API_KEY",
-                jsonPath: "models.openai.api_key"
-            }
-        ],
-        homeEnv: "TINYAGI_HOME",
-        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex"],
-        instancePaths: {
-            configPathTemplate: "<instance-root>/tinyagi/<config-file>",
-            homePathTemplate: "<instance-root>/tinyagi",
-            sourceWorkspacePathTemplate: "<instance-root>/workspace/<agent-name>",
-            workspacePathTemplate: "<instance-root>/workspace"
-        },
-        port: 3777,
-        portEnv: "TINYAGI_API_PORT",
-        standaloneBaseImage: "node:22-bookworm-slim",
-        startCommand: ["bash", "-lc", TINYCLAW_START_SCRIPT],
-        systemDeps: ["bash", "ca-certificates", "curl", "g++", "make", "python3", "tar"]
-    },
-    systemInstructionSurface: {
-        placement: "append_pointer",
-        resolvePath({ node }) {
-            return `workspace/${node.name}/AGENTS.md`;
-        }
-    },
-    async compileAgent(node) {
-        const scheduleOutcome = scheduleOutcomeFor(node);
-        return {
-            capabilities: createAgentCapabilities(node, {
-                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
-                scheduleMessage: scheduleOutcome.message,
-                scheduleOutcome: scheduleOutcome.outcome
-            }),
-            diagnostics: createScheduleDiagnostics(node),
-            files: [
-                ...createDocumentFiles(`workspace/${node.name}`, node.docs),
-                ...createSkillFiles(`workspace/${node.name}/.agents/skills`, node.skills),
-                ...createSkillFiles(`workspace/${node.name}/.claude/skills`, node.skills),
-                {
-                    content: buildTinyClawSettings(node),
-                    path: "settings.json"
-                }
-            ]
-        };
-    },
-    async createContainerTargets(inputs) {
-        return mergeTinyClawTargets(inputs);
-    },
-    async compileTeam(node) {
-        const agentIds = node.members
-            .filter((member) => member.kind === "agent")
-            .map((member) => member.id);
-        const leadAgent = node.lead
-            ? node.members.find((member) => member.id === node.lead && member.kind === "agent")
-            : null;
-        const teamConfig = {
-            name: node.name,
-            agents: agentIds,
-            ...(leadAgent ? { leader_agent: leadAgent.id } : {})
-        };
-        return {
-            capabilities: [
-                createCapability("team.members", "supported"),
-                createCapability("team.mode", node.mode === "hierarchical" ? "supported" : "degraded", "TinyClaw only supports leader-led teams"),
-                createCapability("team.lead", leadAgent ? "supported" : "degraded", leadAgent ? "" : "TinyClaw requires a concrete leader_agent"),
-                createCapability("team.external", "degraded", "TinyClaw does not enforce external boundary"),
-                createCapability("team.shared", "supported"),
-                createCapability("team.nested", "degraded", "TinyClaw nested teams flatten in v0.1")
-            ],
-            diagnostics: [],
-            files: [
-                {
-                    content: `${JSON.stringify({ teams: { [node.name]: teamConfig } }, null, 2)}\n`,
-                    path: "tinyclaw-team.json"
-                }
-            ]
-        };
-    },
-    name: "tinyclaw",
-    prepareRuntimeAuth: prepareTinyClawRuntimeAuth,
-    scaffoldAgentProject: createTinyClawAgentScaffold
-};

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

@@ -1,2 +0,0 @@
-import type { RuntimeAuthPreparationInput, RuntimeAuthPreparationResult } from "../types.js";
-export declare const prepareTinyClawRuntimeAuth: (input: RuntimeAuthPreparationInput) => Promise<RuntimeAuthPreparationResult>;

package/dist/runtime/tinyclaw/runAuth.js

@@ -1,49 +0,0 @@
-import path from "node:path";
-import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
-import { ensureDirectory, readUtf8File, writeUtf8File } from "../../filesystem/index.js";
-const resolveRootfsSourcePath = (outputDirectory, containerPath) => path.join(outputDirectory, "container", "rootfs", ...path.posix.relative("/", containerPath).split("/"));
-const createMountArgs = (hostPath, containerPath) => [
-    "-v",
-    `${hostPath}:${containerPath}`
-];
-const writeRuntimeAuthFile = async (input, relativePath, content) => {
-    const hostPath = path.join(input.tempRoot, "runtime-auth", "tinyclaw", input.instance.id, ...relativePath.split("/"));
-    await ensureDirectory(path.dirname(hostPath));
-    await writeUtf8File(hostPath, content);
-    return hostPath;
-};
-const writePatchedSettings = async (input, config) => {
-    return writeRuntimeAuthFile(input, "settings.json", `${JSON.stringify(config, null, 2)}\n`);
-};
-export const prepareTinyClawRuntimeAuth = async (input) => {
-    const coveredModelSecrets = [];
-    const claudeCode = input.authProfile.imports["claude-code"]
-        ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
-        : null;
-    const codex = input.authProfile.imports.codex
-        ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
-        : null;
-    if (input.instance.model_auth_methods.anthropic === "claude-code" &&
-        claudeCode) {
-        coveredModelSecrets.push("ANTHROPIC_API_KEY");
-    }
-    if (input.instance.model_auth_methods.openai === "codex" &&
-        codex) {
-        coveredModelSecrets.push("OPENAI_API_KEY");
-    }
-    const sourceConfig = JSON.parse(await readUtf8File(resolveRootfsSourcePath(input.outputDirectory, input.instance.config_path)));
-    const patchedConfigPath = await writePatchedSettings(input, sourceConfig);
-    const mountArgs = createMountArgs(patchedConfigPath, input.instance.config_path);
-    if (input.instance.home_path && input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode) {
-        const mountedClaudePath = await writeRuntimeAuthFile(input, ".claude/.credentials.json", await readUtf8File(path.join(input.authProfile.imports["claude-code"].path, ".credentials.json")));
-        mountArgs.push(...createMountArgs(mountedClaudePath, path.posix.join(input.instance.home_path, ".claude", ".credentials.json")));
-    }
-    if (input.instance.home_path && input.instance.model_auth_methods.openai === "codex" && codex) {
-        const mountedAuthPath = await writeRuntimeAuthFile(input, ".codex/auth.json", await readUtf8File(path.join(input.authProfile.imports.codex.path, "auth.json")));
-        mountArgs.push(...createMountArgs(mountedAuthPath, path.posix.join(input.instance.home_path, ".codex", "auth.json")));
-    }
-    return {
-        coveredModelSecrets,
-        mountArgs
-    };
-};