spawnfile 0.1.12 → 0.1.14

package/dist/runtime/pi/adapter.js

@@ -0,0 +1,231 @@
+import { readUtf8File, resolveProjectPath } from "../../filesystem/index.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { resolveScriptedEngineCommandOption, resolveScriptedEngineStagedPath } from "./appScriptedEngine.js";
+import { isPiEveryScheduleValue, PI_BUILTIN_TOOLS, PI_ENGINE_KINDS, PI_PACKAGE_NAME, PI_PACKAGE_VERSION, PI_THINKING_FORMATS, PI_THINKING_LEVELS } from "./appTemplate.js";
+import { createPiContainerTargets, PI_CONFIG_FILE, PI_CONTROL_PORT, } from "./containerTargets.js";
+import { preparePiRuntimeAuth } from "./runAuth.js";
+/**
+ * Stages a `scripted`-engine's `engine_command` script into this agent's
+ * emitted workspace files, the same way `createDocumentFiles`/
+ * `createSkillFiles` stage docs/skills: read once at compile time (relative
+ * to the declaring manifest, via `resolveProjectPath(node.sourcePath ?? node.source, ...)`,
+ * mirroring `surfaces.ts`'s `loadResolvedDocuments`) and emitted as a
+ * `workspace/...` file, which `createContainerTargets` below relocates to
+ * `workspace/agents/<slug>/...` (`moveWorkspaceFileToAgentWorkspace`) just
+ * like every other per-agent workspace file. Returns `[]` for every engine
+ * other than `scripted` (and defensively for a `scripted` engine missing
+ * `engine_command`, though `validateRuntimeOptions` below already rejects
+ * that before `compileAgent` ever runs).
+ */
+const createScriptedEngineFiles = async (node) => {
+    const option = resolveScriptedEngineCommandOption(node);
+    const stagedPath = resolveScriptedEngineStagedPath(node);
+    if (!option || !stagedPath) {
+        return [];
+    }
+    const sourcePath = resolveProjectPath(node.sourcePath ?? node.source, option);
+    const content = await readUtf8File(sourcePath);
+    return [
+        {
+            content,
+            mode: 0o755,
+            path: `workspace/${stagedPath}`
+        }
+    ];
+};
+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 createMemoryConsolidationDiagnostics = (node) => (node.memoryAccess ?? []).flatMap((access) => access.bank.consolidation.mode === "scheduled" &&
+    access.bank.consolidation.schedule &&
+    !isPiEveryScheduleValue(access.bank.consolidation.schedule)
+    ? [
+        createDiagnostic("warn", `Pi generated runtime app supports every memory consolidation schedules in Spawnfile v0.1; memory bank ${access.bank.id} consolidation is 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",
+        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex@0.142.3"],
+        postRootfsCommands: [
+            "curl -fsSL https://x.ai/cli/install.sh | GROK_BIN_DIR=/usr/local/bin bash",
+            "if [ -L /usr/local/bin/grok ]; then cp -L /usr/local/bin/grok /usr/local/bin/grok.real && mv /usr/local/bin/grok.real /usr/local/bin/grok && chmod 0755 /usr/local/bin/grok && ln -sf /usr/local/bin/grok /usr/local/bin/agent; fi",
+            "curl -fsSL https://antigravity.google/cli/install.sh | bash -s -- --dir /usr/local/bin"
+        ],
+        standaloneBaseImage: "node:24-bookworm-slim",
+        startCommand: ["node", "<runtime-root>/app.mjs", "<config-path>"],
+        systemDeps: ["bash", "ca-certificates", "curl", "git", "procps", "tar"]
+    },
+    systemInstructionSurface: {
+        placement: "append_pointer",
+        resolvePath() {
+            return "workspace/AGENTS.md";
+        }
+    },
+    async compileAgent(node) {
+        const scheduleOutcome = scheduleOutcomeFor(node);
+        return {
+            capabilities: createAgentCapabilities(node, {
+                memoryMessage: "Daimon exposes Mneme memory through generated runtime turns",
+                memoryOutcome: "supported",
+                ...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),
+                ...createMemoryConsolidationDiagnostics(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),
+                ...(await createScriptedEngineFiles(node))
+            ]
+        };
+    },
+    async createContainerTargets(inputs) {
+        return createPiContainerTargets(inputs);
+    },
+    name: "pi",
+    prepareRuntimeAuth: preparePiRuntimeAuth,
+    validateRuntimeOptions(options) {
+        const diagnostics = [];
+        if (options.engine !== undefined &&
+            (typeof options.engine !== "string" ||
+                !PI_ENGINE_KINDS.includes(options.engine))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option engine must be one of ${PI_ENGINE_KINDS.join(", ")}`));
+        }
+        if (options.engine === "scripted" &&
+            (typeof options.engine_command !== "string" || options.engine_command.trim().length === 0)) {
+            diagnostics.push(createDiagnostic("error", "Pi runtime option engine_command is required (a fixture-relative script path) when engine is scripted"));
+        }
+        if (options.thinking !== undefined &&
+            (typeof options.thinking !== "string" ||
+                !PI_THINKING_LEVELS.includes(options.thinking))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option thinking must be one of ${PI_THINKING_LEVELS.join(", ")}`));
+        }
+        if (options.thinking_format !== undefined &&
+            (typeof options.thinking_format !== "string" ||
+                !PI_THINKING_FORMATS.includes(options.thinking_format))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option thinking_format must be one of ${PI_THINKING_FORMATS.join(", ")}`));
+        }
+        if (options.tools !== undefined &&
+            (!Array.isArray(options.tools)
+                || options.tools.some((item) => typeof item !== "string"
+                    || !PI_BUILTIN_TOOLS.includes(item))
+                || new Set(options.tools).size !== options.tools.length)) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option tools must contain unique values from ${PI_BUILTIN_TOOLS.join(", ")}`));
+        }
+        if (options.raw_training_capture_turns !== undefined
+            && (!Number.isSafeInteger(options.raw_training_capture_turns)
+                || typeof options.raw_training_capture_turns !== "number"
+                || options.raw_training_capture_turns < 1
+                || options.raw_training_capture_turns > 100_000)) {
+            diagnostics.push(createDiagnostic("error", "Pi runtime option raw_training_capture_turns must be an integer between 1 and 100000"));
+        }
+        const unsupported = Object.keys(options).filter((key) => key !== "restrict_to_workspace"
+            && key !== "engine"
+            && key !== "engine_command"
+            && key !== "thinking"
+            && key !== "thinking_format"
+            && key !== "tools"
+            && key !== "raw_training_capture_turns");
+        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,199 @@
+export const renderPiActivitySource = () => String.raw `
+const maxActivityEvents = 500;
+
+const createActivityBroker = (options = {}) => {
+  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);
+    }
+    if (typeof options.logPath === "string" && options.logPath.length > 0) {
+      appendFileSync(options.logPath, JSON.stringify(full) + "\n", "utf8");
+    }
+    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|authorization|credential|password|secret|session[_-]?key|token)[^"]*)"\s*:\s*")([^"]+)(")/gi,
+    "$1[REDACTED]$4"
+  );
+  redacted = redacted.replace(
+    /\b((?:api[_-]?key|authorization|credential|password|secret|session\s+key|session[_-]?key|token)\s*[:=]\s*)([^\r\n]+)/gi,
+    "$1[REDACTED]"
+  );
+  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));
+
+const traceSha256 = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+
+const sensitiveTraceKeyPattern = /(?:api[_-]?key|authorization|credential|password|secret|session[_-]?key|token)/iu;
+
+const sanitizeTraceValue = (value, key = "") => {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (sensitiveTraceKeyPattern.test(String(key))) {
+    return "[REDACTED]";
+  }
+  if (typeof value === "string") {
+    return redactActivityText(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeTraceValue(entry));
+  }
+  if (typeof value === "object") {
+    const sanitized = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+      sanitized[entryKey] = sanitizeTraceValue(entryValue, entryKey);
+    }
+    return sanitized;
+  }
+  return redactActivityText(String(value));
+};
+
+const summarizeTurnPrompt = (prompt) => ({
+  chars: typeof prompt === "string" ? prompt.length : 0,
+  has_active_environment: typeof prompt === "string" && prompt.includes("Active environment context:"),
+  has_dream_mode: typeof prompt === "string" && prompt.includes("## Dream Mode"),
+  has_memory_context: typeof prompt === "string" && prompt.includes("Memory context"),
+  lines: typeof prompt === "string" && prompt.length > 0 ? prompt.split(/\r?\n/u).length : 0,
+  sha256: traceSha256(typeof prompt === "string" ? prompt : "")
+});
+
+const sanitizeTraceFileId = (value) => {
+  const normalized = String(value).replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 128);
+  return normalized.length > 0 ? normalized : "turn";
+};
+
+const turnTracePath = (paths, wakeId) =>
+  path.join(paths.runtimeHomePath, "telemetry", "turns", sanitizeTraceFileId(wakeId) + ".json");
+
+const writeTurnTrace = async (paths, record) => {
+  const telemetryPath = path.join(paths.runtimeHomePath, "telemetry");
+  const turnsPath = path.join(telemetryPath, "turns");
+  await mkdir(turnsPath, { recursive: true });
+  await writeFile(turnTracePath(paths, record.turn_id), JSON.stringify(record, null, 2) + "\n", "utf8");
+  await writeFile(path.join(telemetryPath, "turns.ndjson"), JSON.stringify(record) + "\n", { flag: "a" });
+};
+
+const createGeneratedTurnTrace = (input) => ({
+  agent_id: input.config.id,
+  completed_at: new Date().toISOString(),
+  engine: {
+    auth_method: input.config.model?.auth_method ?? "unknown",
+    kind: input.engine,
+    model: input.config.model?.name ?? "unknown",
+    provider: input.config.model?.provider ?? "unknown"
+  },
+  ...(input.error ? { error: { message: formatActivityError(input.error), stage: input.errorStage ?? "wake" } } : {}),
+  memory: {
+    enabled: Boolean(input.config.memory),
+    ...(input.memoryPrepareMs !== undefined || input.memoryRecall ? {
+      prepare: {
+        duration_ms: input.memoryPrepareMs ?? 0,
+        ...(input.memoryRecall ? { recall: input.memoryRecall } : {}),
+        status: input.memoryPrepareStatus ?? "completed"
+      }
+    } : {}),
+    ...(input.memoryRecordMs !== undefined ? { record_ms: input.memoryRecordMs } : {})
+  },
+  prompt: summarizeTurnPrompt(input.prompt),
+  reply: {
+    output_chars: input.outputText.length,
+    reply_given: input.outputText.trim().length > 0
+  },
+  schema: "daimon.turn_trace.v1",
+  session: {
+    mode: input.event.kind === "dream" ? "dream" : "awake",
+    thread_id: input.event.context_id ? redactActivityText(input.event.context_id) : input.event.id
+  },
+  started_at: input.startedAt.toISOString(),
+  status: input.status,
+  timings_ms: {
+    ...(input.engineMs !== undefined ? { engine_prompt: input.engineMs } : {}),
+    ...(input.memoryPrepareMs !== undefined ? { memory_prepare: input.memoryPrepareMs } : {}),
+    ...(input.memoryRecordMs !== undefined ? { memory_record: input.memoryRecordMs } : {}),
+    total: Date.now() - input.startedAt.getTime()
+  },
+  tools: [],
+  turn_id: input.event.id,
+  wake: {
+    ...(input.event.context ? { context: sanitizeTraceValue(input.event.context) } : {}),
+    ...(input.event.context_id ? { context_id: redactActivityText(input.event.context_id) } : {}),
+    event_id: input.event.id,
+    ...(input.event.from ? { from: redactActivityText(input.event.from) } : {}),
+    kind: input.event.kind
+  }
+});
+`;

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

@@ -0,0 +1,11 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { SimfileWorldBindingV1 } from "../../compiler/worldBindings.js";
+import { PI_THINKING_FORMATS, type PiGeneratedAgent } from "./appTemplateTypes.js";
+export declare const isPiEveryScheduleValue: (value: string) => boolean;
+export declare const resolvePiEngine: (node: ResolvedAgentNode) => PiGeneratedAgent["engine"];
+export declare const resolvePiThinkingLevel: (node: ResolvedAgentNode) => PiGeneratedAgent["thinking_level"] | undefined;
+export declare const resolvePiTools: (node: ResolvedAgentNode) => string[];
+export declare const resolvePiThinkingFormat: (node: ResolvedAgentNode) => (typeof PI_THINKING_FORMATS)[number] | undefined;
+export declare const resolvePiRawTrainingCapture: (node: ResolvedAgentNode) => PiGeneratedAgent["raw_training_capture"] | undefined;
+export declare const renderPiModelsConfig: (nodes: ResolvedAgentNode[]) => string;
+export declare const createPiAgentConfig: (node: ResolvedAgentNode, slug: string, id: string, worldBinding?: SimfileWorldBindingV1) => PiGeneratedAgent;