spawnfile 0.1.12 → 0.1.14

package/dist/runtime/pi/appAgentConfig.js

@@ -0,0 +1,264 @@
+import path from "node:path";
+import { listEffectiveExecutionModelTargets, resolveModelProviderEnvName } from "../../compiler/modelEnv.js";
+import { createShortHash, slugify, stableStringify } from "../../compiler/helpers.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { resolveScriptedEngineStagedPath } from "./appScriptedEngine.js";
+import { PI_BUILTIN_TOOLS, PI_ENGINE_KINDS, PI_HARNESS_SYSTEM_PROMPT, PI_THINKING_FORMATS, PI_THINKING_LEVELS } from "./appTemplateTypes.js";
+const serializeJson = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const isPiEveryScheduleValue = (value) => /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/u.test(value.trim());
+const isPiEngineKind = (value) => typeof value === "string" && PI_ENGINE_KINDS.includes(value);
+const isPiThinkingLevel = (value) => typeof value === "string" && PI_THINKING_LEVELS.includes(value);
+const isPiThinkingFormat = (value) => typeof value === "string" && PI_THINKING_FORMATS.includes(value);
+const formatDocumentInstructions = (node) => node.docs
+    .map((document) => `# ${document.role}\n\n${document.content}`)
+    .join("\n\n");
+const createCustomProviderId = (target) => {
+    const base = slugify(`${target.provider}-${target.endpoint?.compatibility ?? "builtin"}-${target.name}`);
+    return `${base || "model"}-${createShortHash(stableStringify({
+        auth: target.auth,
+        endpoint: target.endpoint,
+        name: target.name,
+        provider: target.provider
+    }))}`;
+};
+const resolveEndpointApi = (compatibility) => compatibility === "anthropic" ? "anthropic-messages" : "openai-completions";
+const OPENAI_THINKING_LEVEL_MAP = Object.freeze({
+    high: "high",
+    low: "low",
+    medium: "medium",
+    minimal: "low",
+    off: "none",
+    xhigh: "max"
+});
+const resolveEndpointApiKey = (target) => target.auth.method === "api_key"
+    ? `$${target.auth.key ?? resolveModelProviderEnvName(target.provider)}`
+    : "ollama";
+const resolvePiModel = (node) => {
+    const [target] = listEffectiveExecutionModelTargets(node.execution);
+    if (!target) {
+        return {
+            auth_method: "codex",
+            name: "gpt-5.4-mini",
+            provider: "openai-codex"
+        };
+    }
+    if (target.endpoint) {
+        return {
+            auth_method: target.auth.method,
+            name: target.name,
+            provider: createCustomProviderId(target)
+        };
+    }
+    if (target.provider === "openai" && target.auth.method === "codex") {
+        return {
+            auth_method: target.auth.method,
+            name: target.name,
+            provider: "openai-codex"
+        };
+    }
+    return {
+        auth_method: target.auth.method,
+        name: target.name,
+        provider: target.provider
+    };
+};
+export const resolvePiEngine = (node) => {
+    const value = node.runtime.options.engine;
+    if (value === undefined) {
+        return { kind: "pi" };
+    }
+    if (isPiEngineKind(value)) {
+        return { kind: value };
+    }
+    throw new SpawnfileError("validation_error", `Pi runtime option engine must be one of ${PI_ENGINE_KINDS.join(", ")}`);
+};
+export const resolvePiThinkingLevel = (node) => {
+    const value = node.runtime.options.thinking;
+    if (value === undefined)
+        return undefined;
+    if (isPiThinkingLevel(value))
+        return value;
+    throw new SpawnfileError("validation_error", `Pi runtime option thinking must be one of ${PI_THINKING_LEVELS.join(", ")}`);
+};
+export const resolvePiTools = (node) => {
+    const value = node.runtime.options.tools;
+    if (value === undefined)
+        return [...PI_BUILTIN_TOOLS];
+    if (Array.isArray(value)
+        && value.every((item) => typeof item === "string"
+            && PI_BUILTIN_TOOLS.includes(item))
+        && new Set(value).size === value.length) {
+        return [...value];
+    }
+    throw new SpawnfileError("validation_error", `Pi runtime option tools must contain unique values from ${PI_BUILTIN_TOOLS.join(", ")}`);
+};
+export const resolvePiThinkingFormat = (node) => {
+    const value = node.runtime.options.thinking_format;
+    if (value === undefined)
+        return undefined;
+    if (isPiThinkingFormat(value))
+        return value;
+    throw new SpawnfileError("validation_error", `Pi runtime option thinking_format must be one of ${PI_THINKING_FORMATS.join(", ")}`);
+};
+export const resolvePiRawTrainingCapture = (node) => {
+    const value = node.runtime.options.raw_training_capture_turns;
+    if (value === undefined)
+        return undefined;
+    if (Number.isSafeInteger(value)
+        && typeof value === "number"
+        && value >= 1
+        && value <= 100_000) {
+        return {
+            enabled: true,
+            retention: { maxTurns: value }
+        };
+    }
+    throw new SpawnfileError("validation_error", "Pi runtime option raw_training_capture_turns must be an integer between 1 and 100000");
+};
+export const renderPiModelsConfig = (nodes) => {
+    const providers = new Map();
+    for (const node of nodes) {
+        for (const target of listEffectiveExecutionModelTargets(node.execution)) {
+            if (!target.endpoint) {
+                continue;
+            }
+            const providerId = createCustomProviderId(target);
+            const api = resolveEndpointApi(target.endpoint.compatibility);
+            const provider = providers.get(providerId) ?? {
+                api,
+                apiKey: resolveEndpointApiKey(target),
+                baseUrl: target.endpoint.base_url,
+                models: []
+            };
+            if (!provider.models.some((model) => model.id === target.name)) {
+                const explicitOpenAiThinking = target.endpoint.compatibility === "openai"
+                    && node.runtime.options.thinking !== undefined;
+                const thinkingFormat = resolvePiThinkingFormat(node);
+                provider.models.push({
+                    api,
+                    baseUrl: target.endpoint.base_url,
+                    contextWindow: 128000,
+                    cost: {
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        input: 0,
+                        output: 0
+                    },
+                    id: target.name,
+                    input: ["text"],
+                    maxTokens: 16384,
+                    name: target.name,
+                    reasoning: explicitOpenAiThinking,
+                    ...(thinkingFormat === undefined || thinkingFormat === "openai"
+                        ? {}
+                        : { compat: { thinkingFormat } }),
+                    ...(explicitOpenAiThinking
+                        ? { thinkingLevelMap: OPENAI_THINKING_LEVEL_MAP }
+                        : {})
+                });
+            }
+            providers.set(providerId, provider);
+        }
+    }
+    return serializeJson({
+        providers: Object.fromEntries([...providers.entries()].sort(([left], [right]) => left.localeCompare(right)))
+    });
+};
+const resolveSchedule = (node) => {
+    if (!node.schedule || node.schedule.kind === "disabled") {
+        return node.schedule ? { kind: "disabled" } : undefined;
+    }
+    if (node.schedule.kind === "every") {
+        return {
+            every: node.schedule.every,
+            kind: "every",
+            ...(node.schedule.prompt ? { prompt: node.schedule.prompt } : {})
+        };
+    }
+    return undefined;
+};
+const resolveMemoryRuntimeHomePath = (node) => {
+    const [access] = [...(node.memoryAccess ?? [])].sort((left, right) => `${left.source}:${left.bank.id}`.localeCompare(`${right.source}:${right.bank.id}`));
+    if (!access) {
+        return undefined;
+    }
+    const store = access.bank.store;
+    if (store.kind === "postgres") {
+        return undefined;
+    }
+    const vector = access.bank.index?.vector;
+    const embedding = vector?.enabled && vector.model && (!vector.provider || vector.provider === "ollama")
+        ? {
+            ...(vector.base_url ? { base_url: vector.base_url } : {}),
+            ...(vector.dimensions ? { dimensions: vector.dimensions } : {}),
+            model: vector.model,
+            provider: "ollama",
+            ...(vector.timeout_ms ? { timeout_ms: vector.timeout_ms } : {})
+        }
+        : undefined;
+    if (store.kind === "memory") {
+        return {
+            bank_id: access.bank.id,
+            ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
+            ...(embedding ? { embedding } : {}),
+            runtime_home_path: `/var/lib/spawnfile/memory/${slugify(access.bank.declaredName) || "memory"}/${access.bank.id}`,
+            source: `spawnfile:${access.declaringKind}:${access.bank.id}`
+        };
+    }
+    const runtimeHomePath = store.persistence?.mount ?? path.posix.dirname(store.path ?? "");
+    if (!runtimeHomePath) {
+        return undefined;
+    }
+    return {
+        bank_id: access.bank.id,
+        ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
+        ...(embedding ? { embedding } : {}),
+        runtime_home_path: runtimeHomePath,
+        source: `spawnfile:${access.declaringKind}:${access.bank.id}`
+    };
+};
+const resolveMemoryConsolidation = (access) => {
+    if (access.bank.consolidation.mode !== "scheduled" || !access.bank.consolidation.schedule) {
+        return undefined;
+    }
+    if (!isPiEveryScheduleValue(access.bank.consolidation.schedule)) {
+        return undefined;
+    }
+    return {
+        every: access.bank.consolidation.schedule,
+        kind: "every",
+        prompt: [
+            `Dream over Mneme memory bank ${access.bank.id}.`,
+            "Search the active dream scope and read-only global scope for stale, duplicate, noisy, or important memories.",
+            "Use memory_summarize, memory_register, or memory_forget only when consolidation is evidence-backed."
+        ].join(" ")
+    };
+};
+export const createPiAgentConfig = (node, slug, id, worldBinding) => {
+    const engineCommand = resolveScriptedEngineStagedPath(node);
+    const engine = resolvePiEngine(node);
+    const thinkingLevel = resolvePiThinkingLevel(node);
+    const rawTrainingCapture = resolvePiRawTrainingCapture(node);
+    return {
+        engine,
+        ...(engineCommand ? { engine_command: engineCommand } : {}),
+        id,
+        instructions: [
+            `You are ${node.name}.`,
+            node.description,
+            formatDocumentInstructions(node),
+            PI_HARNESS_SYSTEM_PROMPT
+        ].filter((part) => part.trim().length > 0).join("\n\n"),
+        model: resolvePiModel(node),
+        ...(resolveMemoryRuntimeHomePath(node) ? { memory: resolveMemoryRuntimeHomePath(node) } : {}),
+        name: node.name,
+        ...(rawTrainingCapture ? { raw_training_capture: rawTrainingCapture } : {}),
+        ...(resolveSchedule(node) ? { schedule: resolveSchedule(node) } : {}),
+        slug,
+        ...(thinkingLevel ? { thinking_level: thinkingLevel } : {}),
+        tools: resolvePiTools(node),
+        ...(worldBinding && engine.kind === "pi"
+            ? { world: { url: worldBinding.json.url, tokenEnv: worldBinding.token_env } }
+            : {})
+    };
+};

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

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

package/dist/runtime/pi/appCliEnginesSource.js

@@ -0,0 +1,183 @@
+export const renderPiCliEnginesSource = () => String.raw `const runCodexEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "codex-home");
+  await mkdir(path.join(engineHomePath, ".codex"), { recursive: true });
+  try {
+    const authSource = path.join(paths.homePath, ".codex", "auth.json");
+    const authTarget = path.join(engineHomePath, ".codex", "auth.json");
+    await writeFile(authTarget, await readFile(authSource, "utf8"));
+  } catch {}
+  const outputPath = path.join(paths.runtimeHomePath, "codex-" + Date.now() + ".txt");
+  const args = [
+    "exec",
+    "--sandbox",
+    process.env.SPAWNFILE_CODEX_SANDBOX ?? "danger-full-access",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "--ignore-rules",
+    "--color",
+    "never",
+    "-C",
+    paths.workspacePath,
+    "--output-last-message",
+    outputPath,
+    "-m",
+    process.env.DAIMON_CODEX_MODEL ?? "gpt-5.4-mini",
+    "-"
+  ];
+  const { stderr, stdout } = await spawnWithInput("codex", args, prompt, {
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath)
+  });
+  try {
+    return stripAnsi(await readFile(outputPath, "utf8"));
+  } catch {
+    return stripAnsi([stdout, stderr].filter(Boolean).join("\n"));
+  }
+};
+
+const runClaudeEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "claude-home");
+  await mkdir(path.join(engineHomePath, ".claude"), { recursive: true });
+  await copyDirectoryIfExists(path.join(paths.homePath, ".claude"), path.join(engineHomePath, ".claude"));
+  await copyDirectoryIfExists(path.join(paths.homePath, ".claude.json"), path.join(engineHomePath, ".claude.json"));
+  const env = process.env.DAIMON_CLAUDE_USE_HOST_HOME === "1"
+    ? process.env
+    : createEngineEnv(paths, engineHomePath);
+  const output = await spawnWithInput("claude", [
+    "--print",
+    "--output-format",
+    "text",
+    "--no-session-persistence",
+    "--permission-mode",
+    process.env.DAIMON_CLAUDE_PERMISSION_MODE ?? "bypassPermissions",
+    "--model",
+    process.env.DAIMON_CLAUDE_MODEL ?? "sonnet",
+    "--add-dir",
+    paths.workspacePath
+  ], prompt, {
+    cwd: paths.workspacePath,
+    env
+  });
+  return cleanCliFinalText(output.stdout);
+};
+
+const runGrokEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "grok-home");
+  await mkdir(engineHomePath, { recursive: true });
+  const sharedGrok = await getSharedGrokHome(paths);
+  const promptPath = path.join(paths.runtimeHomePath, "grok-prompt-" + Date.now() + ".txt");
+  await writeFile(promptPath, prompt);
+  const output = await execFileAsync("grok", [
+    "--prompt-file",
+    promptPath,
+    "--max-turns",
+    process.env.DAIMON_GROK_MAX_TURNS ?? "24",
+    "--no-memory",
+    "--disable-web-search",
+    "--model",
+    process.env.DAIMON_GROK_MODEL ?? "grok-composer-2.5-fast",
+    "--cwd",
+    paths.workspacePath,
+    "--output-format",
+    "plain",
+    "--always-approve",
+    "--permission-mode",
+    process.env.DAIMON_GROK_PERMISSION_MODE ?? "auto",
+    "--allow",
+    "Bash"
+  ], {
+    ...cliOutputOptions,
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath, {
+      GROK_HOME: sharedGrok.grokHomePath
+    })
+  });
+  await unlink(promptPath).catch(() => undefined);
+  return cleanCliFinalText(output.stdout);
+};
+
+const runAgyEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "agy-home");
+  await mkdir(engineHomePath, { recursive: true });
+  await copyDirectoryIfExists(
+    path.join(paths.homePath, ".config", "Antigravity"),
+    path.join(engineHomePath, ".config", "Antigravity")
+  );
+  await copyDirectoryIfExists(
+    path.join(paths.homePath, ".gemini", "antigravity-cli"),
+    path.join(engineHomePath, ".gemini", "antigravity-cli")
+  );
+  const outputPath = path.join(paths.runtimeHomePath, "agy-output-" + Date.now() + ".txt");
+  const errorPath = path.join(paths.runtimeHomePath, "agy-error-" + Date.now() + ".txt");
+  await spawnToFiles("agy", [
+    "--print",
+    prompt,
+    "--print-timeout",
+    process.env.DAIMON_AGY_TIMEOUT ?? "300s",
+    "--model",
+    process.env.DAIMON_AGY_MODEL ?? "Gemini 3.5 Flash (Low)",
+    "--new-project",
+    "--add-dir",
+    paths.workspacePath,
+    "--dangerously-skip-permissions"
+  ], {
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath),
+    stderrPath: errorPath,
+    stdoutPath: outputPath
+  });
+  const text = cleanCliFinalText(await readBounded(outputPath));
+  await Promise.all([unlink(outputPath), unlink(errorPath)].map((promise) => promise.catch(() => undefined)));
+  return text;
+};
+
+const runScriptedEngine = async (config, prompt, paths) => {
+  if (typeof config?.engine_command !== "string" || config.engine_command.length === 0) {
+    throw new Error("Scripted Pi engine is missing its staged engine_command path");
+  }
+  const scriptPath = path.join(paths.workspacePath, config.engine_command);
+  await mkdir(paths.runtimeHomePath, { recursive: true });
+  const promptPath = path.join(paths.runtimeHomePath, "scripted-prompt-" + Date.now() + ".txt");
+  await writeFile(promptPath, prompt);
+  const args = ["--prompt-file", promptPath, "--cwd", paths.workspacePath];
+  let output;
+  try {
+    output = await execFileAsync("node", [scriptPath, ...args], {
+      ...cliOutputOptions,
+      cwd: paths.workspacePath,
+      env: process.env
+    });
+  } finally {
+    await unlink(promptPath).catch(() => undefined);
+  }
+  appendFileSync(
+    path.join(paths.runtimeHomePath, "scripted-engine-calls.jsonl"),
+    JSON.stringify({
+      args,
+      script: scriptPath,
+      timestamp: new Date().toISOString()
+    }) + "\n"
+  );
+  return output.stdout.trim();
+};
+
+const runCliEngine = async (engine, prompt, paths, config) => {
+  const startedAt = Date.now();
+  let text;
+  if (engine === "codex") {
+    text = await runCodexEngine(prompt, paths);
+  } else if (engine === "claude") {
+    text = await runClaudeEngine(prompt, paths);
+  } else if (engine === "grok") {
+    text = await runGrokEngine(prompt, paths);
+  } else if (engine === "scripted") {
+    text = await runScriptedEngine(config, prompt, paths);
+  } else {
+    text = await runAgyEngine(prompt, paths);
+  }
+  return {
+    durationMs: Date.now() - startedAt,
+    text
+  };
+};
+`;

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

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