spawnfile 0.1.12 → 0.1.13

package/dist/runtime/container.js

@@ -1,6 +1,14 @@
 import { SpawnfileError } from "../shared/index.js";
 import { resolveRuntimeInstallSelection } from "./install.js";
 export const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
+const PI_RUNTIME_BASE_IMAGE_ENV = "SPAWNFILE_PI_RUNTIME_BASE_IMAGE";
+const DAIMON_RUNTIME_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_IMAGE";
+const DAIMON_RUNTIME_BASE_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_BASE_IMAGE";
+const OPENCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_OPENCLAW_RUNTIME_IMAGE";
+const PICOCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_PICOCLAW_RUNTIME_IMAGE";
+const PI_AI_PACKAGE_NAME = "@earendil-works/pi-ai";
+const PI_CODING_AGENT_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+const PI_PACKAGE_VERSION = "0.79.9";
 const assertArtifactInstallSelection = (runtimeName, selection) => {
     if (selection.kind !== "source_repo") {
         return;
@@ -11,29 +19,50 @@ const createPicoClawArchiveInstallCommands = (runtimeRoot, selection) => [
     `mkdir -p ${runtimeRoot}/bin`,
     `arch="$(dpkg --print-architecture)" && case "$arch" in amd64) asset=${JSON.stringify(selection.versionedAssets.linux_amd64)} ;; arm64) asset=${JSON.stringify(selection.versionedAssets.linux_arm64)} ;; *) echo "Unsupported PicoClaw release architecture: $arch" >&2; exit 1 ;; esac && url="https://github.com/${selection.repository}/releases/download/${selection.tag}/$asset" && curl -fsSL -o /tmp/picoclaw.tar.gz "$url" && rm -rf /tmp/picoclaw-extract && mkdir -p /tmp/picoclaw-extract && tar -xzf /tmp/picoclaw.tar.gz -C /tmp/picoclaw-extract && binary_path="$(find /tmp/picoclaw-extract -type f -name ${JSON.stringify(selection.binaryName)} | head -n 1)" && [ -n "$binary_path" ] && install -m 0755 "$binary_path" ${runtimeRoot}/bin/${selection.binaryName} && ln -sf ${runtimeRoot}/bin/${selection.binaryName} /usr/local/bin/${selection.binaryName} && rm -rf /tmp/picoclaw.tar.gz /tmp/picoclaw-extract`
 ];
+const createRuntimeImageCopyCommand = (imageRef, runtimeRoot) => `COPY --from=${imageRef} ${runtimeRoot} ${runtimeRoot}`;
+const resolveRuntimeImageRef = (envName, selection) => process.env[envName]?.trim() ||
+    (selection.kind === "container_image"
+        ? `${selection.image}:${selection.tag}`
+        : undefined);
 export const createRuntimeInstallRecipe = async (runtimeName) => {
     const selection = await resolveRuntimeInstallSelection(runtimeName);
     assertArtifactInstallSelection(runtimeName, selection);
     const installRoot = `${RUNTIME_INSTALL_ROOT}/${runtimeName}`;
     switch (runtimeName) {
         case "openclaw": {
-            if (selection.kind !== "container_image" && selection.kind !== "npm") {
+            const openClawRuntimeImage = resolveRuntimeImageRef(OPENCLAW_RUNTIME_IMAGE_ENV, selection);
+            if (openClawRuntimeImage) {
+                return {
+                    commands: [],
+                    copyCommands: [createRuntimeImageCopyCommand(openClawRuntimeImage, installRoot)],
+                    runtimeName,
+                    runtimeRoot: installRoot
+                };
+            }
+            if (selection.kind !== "npm") {
                 throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
             }
             return {
-                commands: selection.kind === "container_image"
-                    ? []
-                    : [`npm install -g --omit=dev --no-fund --no-audit ${selection.packageName}@${selection.version}`],
-                copyCommands: selection.kind === "container_image"
-                    ? [`COPY --from=${selection.image}:${selection.tag} /app ${installRoot}`]
-                    : [],
+                commands: [
+                    `npm install -g --omit=dev --no-fund --no-audit ${selection.packageName}@${selection.version}`
+                ],
+                copyCommands: [],
                 runtimeName,
-                runtimeRoot: selection.kind === "container_image"
-                    ? installRoot
-                    : `/usr/local/lib/node_modules/${selection.packageName}`
+                runtimeRoot: `/usr/local/lib/node_modules/${selection.packageName}`
             };
         }
         case "picoclaw": {
+            const picoClawRuntimeImage = resolveRuntimeImageRef(PICOCLAW_RUNTIME_IMAGE_ENV, selection);
+            if (picoClawRuntimeImage) {
+                return {
+                    commands: [
+                        `mkdir -p /usr/local/bin && ln -sf ${installRoot}/bin/picoclaw /usr/local/bin/picoclaw`
+                    ],
+                    copyCommands: [createRuntimeImageCopyCommand(picoClawRuntimeImage, installRoot)],
+                    runtimeName,
+                    runtimeRoot: installRoot
+                };
+            }
             if (selection.kind !== "github_release_archive") {
                 throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
             }
@@ -44,6 +73,60 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                 runtimeRoot: installRoot
             };
         }
+        case "daimon": {
+            const daimonRuntimeImage = process.env[DAIMON_RUNTIME_IMAGE_ENV]?.trim() ||
+                process.env[DAIMON_RUNTIME_BASE_IMAGE_ENV]?.trim() ||
+                (selection.kind === "container_image"
+                    ? `${selection.image}:${selection.tag}`
+                    : undefined);
+            if (daimonRuntimeImage) {
+                return {
+                    commands: [],
+                    copyCommands: [createRuntimeImageCopyCommand(daimonRuntimeImage, installRoot)],
+                    runtimeName,
+                    runtimeRoot: installRoot
+                };
+            }
+            if (selection.kind !== "npm") {
+                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
+            }
+            const npmPackages = [
+                `${selection.packageName}@${selection.version}`,
+                `${PI_CODING_AGENT_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`,
+                `${PI_AI_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`
+            ];
+            return {
+                commands: [
+                    `mkdir -p ${installRoot}`,
+                    `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
+                ],
+                copyCommands: [],
+                runtimeName,
+                runtimeRoot: installRoot
+            };
+        }
+        case "pi": {
+            if (selection.kind !== "npm") {
+                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
+            }
+            const prebuiltBaseImage = process.env[PI_RUNTIME_BASE_IMAGE_ENV]?.trim() || undefined;
+            const npmPackages = [
+                `${selection.packageName}@${selection.version}`,
+                `${PI_AI_PACKAGE_NAME}@${selection.version}`
+            ];
+            return {
+                ...(prebuiltBaseImage ? { baseImage: prebuiltBaseImage } : {}),
+                commands: prebuiltBaseImage
+                    ? [`mkdir -p ${installRoot}`]
+                    : [
+                        `mkdir -p ${installRoot}`,
+                        `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
+                    ],
+                copyCommands: [],
+                runtimeName,
+                runtimeRoot: installRoot
+            };
+        }
         /* c8 ignore next 5 -- compileable runtimes are exhaustively covered above */
         default:
             throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no container install recipe`);

package/dist/runtime/install.d.ts

@@ -1,5 +1,5 @@
 export type RuntimeInstallSelection = {
-    ecosystem: "node";
+    ecosystem: "go" | "node";
     image: string;
     installHint: string;
     kind: "container_image";

package/dist/runtime/install.js

@@ -9,6 +9,27 @@ const convertRemoteToHttps = (remote) => {
     return remote.replace(/^git\+/, "");
 };
 const installHints = new Map([
+    [
+        "daimon",
+        {
+            container_image: {
+                ecosystem: "node",
+                installHint: "Copy a pinned Daimon runtime image."
+            },
+            github_release_archive: {
+                ecosystem: "node",
+                installHint: "Download a pinned Daimon runtime release archive."
+            },
+            npm: {
+                ecosystem: "node",
+                installHint: "Install the pinned Daimon package and Pi SDK dependencies inside the generated runtime app."
+            },
+            source_repo: {
+                ecosystem: "node",
+                installHint: "Checkout the pinned Daimon repo ref and install from the repository root."
+            }
+        }
+    ],
     [
         "openclaw",
         {
@@ -50,6 +71,27 @@ const installHints = new Map([
                 installHint: "Checkout the pinned repo ref and build/install from the repository root."
             }
         }
+    ],
+    [
+        "pi",
+        {
+            container_image: {
+                ecosystem: "node",
+                installHint: "Copy a pinned Pi harness runtime image."
+            },
+            github_release_archive: {
+                ecosystem: "node",
+                installHint: "Download a pinned Pi harness release archive."
+            },
+            npm: {
+                ecosystem: "node",
+                installHint: "Install pinned Pi SDK dependencies inside the generated runtime app."
+            },
+            source_repo: {
+                ecosystem: "node",
+                installHint: "Checkout the pinned Pi repo ref and install from the repository root."
+            }
+        }
     ]
 ]);
 export const resolveRuntimeInstallSelection = async (runtimeName) => {
@@ -61,7 +103,7 @@ export const resolveRuntimeInstallSelection = async (runtimeName) => {
     switch (runtime.install?.kind) {
         case "container_image":
             return {
-                ecosystem: "node",
+                ecosystem: installProfile.container_image.ecosystem,
                 image: runtime.install.image,
                 installHint: installProfile.container_image.installHint,
                 kind: "container_image",

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

@@ -0,0 +1,4 @@
+import type { RuntimeAdapter } from "../types.js";
+export declare const piAdapter: RuntimeAdapter;
+export declare const daimonAdapter: RuntimeAdapter;
+export declare const PI_RUNTIME_PACKAGE = "@earendil-works/pi-coding-agent@0.79.9";

package/dist/runtime/pi/adapter.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import { listExecutionModelSecretNames } from "../../compiler/modelEnv.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { createPiAgentConfig, PI_PACKAGE_NAME, PI_PACKAGE_VERSION, renderPiApp, renderPiAppConfig, renderPiModelsConfig, renderPiPackageJson } from "./appTemplate.js";
+import { preparePiRuntimeAuth } from "./runAuth.js";
+const PI_CONFIG_FILE = "pi-app.json";
+const PI_CONTROL_PORT = 19690;
+const PI_MODELS_FILE = "home/.pi/agent/models.json";
+const moveWorkspaceFileToAgentWorkspace = (file, agentSlug) => {
+    if (!file.path.startsWith("workspace/")) {
+        return file;
+    }
+    const relativePath = file.path.slice("workspace/".length);
+    return {
+        ...file,
+        path: path.posix.join("workspace", "agents", agentSlug, relativePath)
+    };
+};
+const createContainerTargets = async (inputs) => {
+    const agentInputs = inputs.filter((input) => input.kind === "agent" && input.value.kind === "agent");
+    if (agentInputs.length === 0) {
+        return [];
+    }
+    const agents = agentInputs.map((input) => createPiAgentConfig(input.value, input.slug, input.id));
+    const envFiles = [
+        ...new Set(agentInputs.flatMap((input) => listExecutionModelSecretNames(input.value.execution)))
+    ].map((secretName) => ({
+        envName: secretName,
+        relativePath: `secrets/${secretName}`
+    }));
+    return [
+        {
+            envFiles,
+            files: [
+                ...agentInputs.flatMap((input) => input.emittedFiles.map((file) => moveWorkspaceFileToAgentWorkspace(file, input.slug))),
+                {
+                    content: renderPiAppConfig(agents),
+                    path: PI_CONFIG_FILE
+                },
+                {
+                    content: renderPiModelsConfig(agentInputs.map((input) => input.value)),
+                    path: PI_MODELS_FILE
+                },
+                {
+                    content: renderPiPackageJson(),
+                    path: "runtime/package.json"
+                },
+                {
+                    content: renderPiApp(),
+                    mode: 0o755,
+                    path: "runtime/app.mjs"
+                }
+            ],
+            id: "pi-app",
+            sourceIds: agentInputs.map((input) => input.id).sort()
+        }
+    ];
+};
+const scheduleOutcomeFor = (node) => {
+    if (!node.schedule) {
+        return {};
+    }
+    if (node.schedule.kind === "every" || node.schedule.kind === "disabled") {
+        return {
+            message: "Pi generated runtime app owns this schedule",
+            outcome: "supported"
+        };
+    }
+    return {
+        message: "Pi generated runtime app supports every schedules in Spawnfile v0.1",
+        outcome: "degraded"
+    };
+};
+const createScheduleDiagnostics = (node) => node.schedule?.kind === "cron"
+    ? [
+        createDiagnostic("warn", "Pi generated runtime app supports every schedules in Spawnfile v0.1; cron schedules are degraded")
+    ]
+    : [];
+const moltnetCapabilityOptions = (node) => node.surfaces?.moltnet
+    ? {
+        moltnetMessage: "Pi generated runtime app exposes a control endpoint for Moltnet bridge wake delivery",
+        moltnetOutcome: "supported"
+    }
+    : {};
+const assertSupportedPiSurfaces = (surfaces) => {
+    if (!surfaces) {
+        return;
+    }
+    const unsupported = [
+        surfaces.discord ? "discord" : null,
+        surfaces.http ? "http" : null,
+        surfaces.slack ? "slack" : null,
+        surfaces.telegram ? "telegram" : null,
+        surfaces.webhook ? "webhook" : null,
+        surfaces.whatsapp ? "whatsapp" : null
+    ].filter((surface) => surface !== null);
+    if (unsupported.length > 0) {
+        throw new SpawnfileError("validation_error", `Pi runtime only supports Moltnet surfaces in Spawnfile v0.1; unsupported surfaces: ${unsupported.join(", ")}`);
+    }
+};
+export const piAdapter = {
+    assertSupportedModelTarget(target) {
+        if (target.endpoint) {
+            if (target.provider !== "custom" && target.provider !== "local") {
+                throw new SpawnfileError("validation_error", "Pi runtime only supports endpoints on custom or local model providers");
+            }
+            if (target.auth.method === "none" || target.auth.method === "api_key") {
+                return;
+            }
+            throw new SpawnfileError("validation_error", `Pi runtime endpoint models only support none or api_key auth, got ${target.auth.method}`);
+        }
+        if (target.provider === "openai") {
+            if (target.auth.method === "api_key" || target.auth.method === "codex") {
+                return;
+            }
+        }
+        if (target.provider === "anthropic" && target.auth.method === "api_key") {
+            return;
+        }
+        if (target.provider === "anthropic" && target.auth.method === "claude-code") {
+            return;
+        }
+        throw new SpawnfileError("validation_error", `Pi runtime does not support model auth method ${target.auth.method} for provider ${target.provider}`);
+    },
+    assertSupportedSurfaces(surfaces) {
+        assertSupportedPiSurfaces(surfaces);
+    },
+    container: {
+        configFileName: PI_CONFIG_FILE,
+        configPathEnv: "SPAWNFILE_PI_CONFIG",
+        homeEnv: "SPAWNFILE_PI_HOME",
+        instancePaths: {
+            configPathTemplate: "<instance-root>/pi/<config-file>",
+            homePathTemplate: "<instance-root>/home",
+            sourceWorkspacePathTemplate: "<instance-root>/workspace/agents/<source-slug>",
+            workspacePathTemplate: "<instance-root>/workspace"
+        },
+        port: PI_CONTROL_PORT,
+        portEnv: "SPAWNFILE_PI_CONTROL_PORT",
+        standaloneBaseImage: "node:24-bookworm-slim",
+        startCommand: ["node", "<runtime-root>/app.mjs", "<config-path>"],
+        systemDeps: ["bash", "ca-certificates", "curl", "git", "procps"]
+    },
+    systemInstructionSurface: {
+        placement: "append_pointer",
+        resolvePath() {
+            return "workspace/AGENTS.md";
+        }
+    },
+    async compileAgent(node) {
+        const scheduleOutcome = scheduleOutcomeFor(node);
+        return {
+            capabilities: createAgentCapabilities(node, {
+                ...moltnetCapabilityOptions(node),
+                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
+                sandboxOutcome: node.execution?.sandbox ? "degraded" : "supported",
+                scheduleMessage: scheduleOutcome.message,
+                scheduleOutcome: scheduleOutcome.outcome,
+                subagentOutcome: node.subagents.length > 0 ? "degraded" : "supported"
+            }),
+            diagnostics: [
+                ...createScheduleDiagnostics(node),
+                ...(node.execution?.sandbox
+                    ? [createDiagnostic("warn", "Pi runtime relies on container and workspace isolation; Pi itself is not a sandbox engine")]
+                    : []),
+                ...(node.mcpServers.length > 0
+                    ? [createDiagnostic("warn", "Pi runtime does not lower MCP server declarations in Spawnfile v0.1")]
+                    : []),
+                ...(node.subagents.length > 0
+                    ? [createDiagnostic("warn", "Pi runtime groups compiled agents but does not preserve native parent-owned subagent semantics in v0.1")]
+                    : [])
+            ],
+            files: [
+                ...createDocumentFiles("workspace", node.docs),
+                ...createSkillFiles("workspace/skills", node.skills)
+            ]
+        };
+    },
+    async createContainerTargets(inputs) {
+        return createContainerTargets(inputs);
+    },
+    name: "pi",
+    prepareRuntimeAuth: preparePiRuntimeAuth,
+    validateRuntimeOptions(options) {
+        const diagnostics = [];
+        const unsupported = Object.keys(options).filter((key) => key !== "restrict_to_workspace");
+        for (const key of unsupported) {
+            diagnostics.push(createDiagnostic("warn", `Pi runtime option ${key} is not used yet`));
+        }
+        return diagnostics;
+    }
+};
+export const daimonAdapter = {
+    ...piAdapter,
+    name: "daimon"
+};
+export const PI_RUNTIME_PACKAGE = `${PI_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`;

package/dist/runtime/pi/appActivitySource.d.ts

@@ -0,0 +1 @@
+export declare const renderPiActivitySource: () => string;

package/dist/runtime/pi/appActivitySource.js

@@ -0,0 +1,87 @@
+export const renderPiActivitySource = () => String.raw `
+const maxActivityEvents = 500;
+
+const createActivityBroker = () => {
+  let sequence = 0;
+  const events = [];
+  const clients = new Set();
+
+  const normalizeFilter = (value) => typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : "";
+  const matchesFilter = (event, filter) => {
+    const normalized = normalizeFilter(filter);
+    return normalized === "" ||
+      event.agent_id === normalized ||
+      event.agent_slug === normalized ||
+      event.agent_name === normalized ||
+      event.agent_id === "agent:" + normalized;
+  };
+  const parseTail = (value) => {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : maxActivityEvents;
+  };
+
+  const publish = (event) => {
+    const full = {
+      version: "spawnfile.activity.v1",
+      sequence: ++sequence,
+      created_at: new Date().toISOString(),
+      ...event
+    };
+    events.push(full);
+    if (events.length > maxActivityEvents) {
+      events.splice(0, events.length - maxActivityEvents);
+    }
+    const frame = "data: " + JSON.stringify(full) + "\n\n";
+    for (const client of [...clients]) {
+      if (!matchesFilter(full, client.filter)) {
+        continue;
+      }
+      try {
+        client.response.write(frame);
+      } catch {
+        clients.delete(client);
+      }
+    }
+    return full;
+  };
+
+  const list = (filter, tail) => {
+    const selected = events.filter((event) => matchesFilter(event, filter));
+    return selected.slice(Math.max(0, selected.length - parseTail(tail)));
+  };
+
+  const stream = (request, response, filter, tail) => {
+    response.writeHead(200, {
+      "cache-control": "no-cache",
+      "connection": "keep-alive",
+      "content-type": "text/event-stream"
+    });
+    response.write("event: ready\ndata: {\"status\":\"ok\"}\n\n");
+    for (const event of list(filter, tail)) {
+      response.write("data: " + JSON.stringify(event) + "\n\n");
+    }
+    const client = { filter: normalizeFilter(filter), response };
+    clients.add(client);
+    request.on("close", () => clients.delete(client));
+  };
+
+  return { list, publish, stream };
+};
+
+const redactActivityText = (value) => {
+  let redacted = String(value);
+  redacted = redacted.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer [REDACTED]");
+  redacted = redacted.replace(/\bmagt_v1_[A-Za-z0-9_-]{16,}\b/g, "[REDACTED]");
+  redacted = redacted.replace(/\b(?:sk|sk-proj)-[A-Za-z0-9_-]{20,}\b/g, "[REDACTED]");
+  redacted = redacted.replace(
+    /("([^"]*(?:api[_-]?key|token|secret|password)[^"]*)"\s*:\s*")([^"]+)(")/gi,
+    "$1[REDACTED]$4"
+  );
+  redacted = redacted.replace(/\/(?:Users|home|private|tmp|var|opt|run)\/[^\s"']+/g, "[path]");
+  return redacted.length > 1000 ? redacted.slice(0, 1000) + "..." : redacted;
+};
+
+const formatActivityError = (error) => redactActivityText(error instanceof Error ? error.message : String(error));
+`;

package/dist/runtime/pi/appCoreSource.d.ts

@@ -0,0 +1 @@
+export declare const renderPiCoreSource: () => string;