spawnfile 0.1.13 → 0.1.17

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;

package/dist/runtime/pi/appCliSource.js

@@ -0,0 +1,353 @@
+export const renderPiCliSource = () => String.raw `const cliEngineKinds = new Set(["agy", "claude", "codex", "grok", "scripted"]);
+const maxCapturedOutputBytes = 1024 * 256;
+const cliOutputOptions = {
+  maxBuffer: 1024 * 1024 * 8,
+  timeout: Number(process.env.SPAWNFILE_CLI_ENGINE_TIMEOUT_MS ?? "300000")
+};
+
+const normalizeAgentEngineKind = (config) => {
+  const kind = typeof config?.engine?.kind === "string" ? config.engine.kind : "pi";
+  return cliEngineKinds.has(kind) ? kind : "pi";
+};
+
+const stripAnsi = (value) =>
+  value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "").trim();
+
+const cleanCliFinalText = (value) => {
+  const text = stripAnsi(value);
+  const progressLine = /^(running|handling|following|consulting|reading|querying|gathering|verifying|command succeeded|spawning the verifier|i have responded|summary of actions|actions?:)/iu;
+  const lines = text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  const filtered = lines.filter((line) => !progressLine.test(line));
+  return (filtered.length > 0 ? filtered : lines).join("\n").trim();
+};
+
+const pushCapped = (chunks, chunk, state) => {
+  if (state.bytes >= maxCapturedOutputBytes) {
+    return;
+  }
+  const remaining = maxCapturedOutputBytes - state.bytes;
+  const next = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+  chunks.push(next);
+  state.bytes += next.length;
+};
+
+const readBounded = async (filePath) => {
+  const stats = await stat(filePath);
+  if (stats.size <= maxCapturedOutputBytes) {
+    return readFile(filePath, "utf8");
+  }
+  const content = await readFile(filePath);
+  const head = content.subarray(0, maxCapturedOutputBytes).toString("utf8");
+  return head + "\n[truncated " + (stats.size - maxCapturedOutputBytes) + " bytes]";
+};
+
+const copyDirectoryIfExists = async (sourcePath, targetPath) => {
+  try {
+    await stat(sourcePath);
+  } catch {
+    return;
+  }
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  await cp(sourcePath, targetPath, {
+    force: true,
+    recursive: true
+  });
+};
+
+const createEngineEnv = (paths, engineHomePath, extraEnv = {}) => ({
+  ...process.env,
+  CODEX_HOME: path.join(engineHomePath, ".codex"),
+  HOME: engineHomePath,
+  XDG_CACHE_HOME: path.join(engineHomePath, ".cache"),
+  XDG_CONFIG_HOME: path.join(engineHomePath, ".config"),
+  XDG_DATA_HOME: path.join(engineHomePath, ".local", "share"),
+  ...extraEnv
+});
+
+const grokHomePreparations = new Map();
+
+const prepareSharedGrokHome = async (paths) => {
+  const sharedHomePath = path.join(path.dirname(path.dirname(paths.runtimeHomePath)), "grok-home");
+  const grokHomePath = path.join(sharedHomePath, ".grok");
+  const markerPath = path.join(sharedHomePath, ".spawnfile-grok-home-ready");
+  await mkdir(sharedHomePath, { recursive: true });
+  try {
+    await stat(markerPath);
+  } catch {
+    await copyDirectoryIfExists(path.join(paths.homePath, ".grok"), grokHomePath);
+    await mkdir(grokHomePath, { recursive: true });
+    await writeFile(markerPath, "ready\n");
+  }
+  return { grokHomePath, sharedHomePath };
+};
+
+const getSharedGrokHome = (paths) => {
+  const sharedHomePath = path.join(path.dirname(path.dirname(paths.runtimeHomePath)), "grok-home");
+  let preparation = grokHomePreparations.get(sharedHomePath);
+  if (!preparation) {
+    preparation = prepareSharedGrokHome(paths).catch((error) => {
+      grokHomePreparations.delete(sharedHomePath);
+      throw error;
+    });
+    grokHomePreparations.set(sharedHomePath, preparation);
+  }
+  return preparation;
+};
+
+const spawnWithInput = (command, args, input, options) => new Promise((resolve, reject) => {
+  const child = spawn(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const timer = setTimeout(() => {
+    child.kill("SIGTERM");
+    reject(new Error(command + " timed out after " + cliOutputOptions.timeout + "ms"));
+  }, cliOutputOptions.timeout);
+  const stdout = [];
+  const stderr = [];
+  const stdoutState = { bytes: 0 };
+  const stderrState = { bytes: 0 };
+  child.stdout.on("data", (chunk) => pushCapped(stdout, chunk, stdoutState));
+  child.stderr.on("data", (chunk) => pushCapped(stderr, chunk, stderrState));
+  child.on("error", (error) => {
+    clearTimeout(timer);
+    reject(error);
+  });
+  child.on("close", (code, signal) => {
+    clearTimeout(timer);
+    const output = {
+      stderr: Buffer.concat(stderr).toString("utf8"),
+      stdout: Buffer.concat(stdout).toString("utf8")
+    };
+    if (code === 0) {
+      resolve(output);
+      return;
+    }
+    reject(new Error(command + " exited " + (code ?? signal) + ": " + (output.stderr || output.stdout)));
+  });
+  child.stdin.end(input);
+});
+
+const spawnToFiles = (command, args, options) => new Promise((resolve, reject) => {
+  const stdoutFd = openSync(options.stdoutPath, "w");
+  const stderrFd = openSync(options.stderrPath, "w");
+  const closeFiles = () => {
+    closeSync(stdoutFd);
+    closeSync(stderrFd);
+  };
+  const child = spawn(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["ignore", stdoutFd, stderrFd]
+  });
+  const timer = setTimeout(() => {
+    child.kill("SIGTERM");
+    closeFiles();
+    reject(new Error(command + " timed out after " + cliOutputOptions.timeout + "ms; stderr=" + options.stderrPath));
+  }, cliOutputOptions.timeout);
+  child.on("error", (error) => {
+    clearTimeout(timer);
+    closeFiles();
+    reject(error);
+  });
+  child.on("close", (code, signal) => {
+    clearTimeout(timer);
+    closeFiles();
+    if (code === 0) {
+      resolve();
+      return;
+    }
+    reject(new Error(command + " exited " + (code ?? signal) + "; stderr=" + options.stderrPath + "; stdout=" + options.stdoutPath));
+  });
+});
+
+const formatCliWakePrompt = (event) => [
+  "Wake event:",
+  "- id: " + event.id,
+  "- kind: " + event.kind,
+  "- from: " + (event.from ?? "operator"),
+  "",
+  event.text
+].join("\n");
+
+const buildCliMemoryRequest = (event) => {
+  const context = readMemoryContext({ kind: event.kind, id: event.id, from: event.from, text: event.text, context: event.context });
+  return {
+    context,
+    request: {
+      eventId: event.id,
+      kind: event.kind,
+      text: event.text,
+      from: event.from,
+      context
+    }
+  };
+};
+
+const createCliEnginePrompt = (config, paths, event, memoryPromptText) => [
+  createAgentInstructions(config, paths.workspacePath),
+  "",
+  memoryPromptText ?? formatCliWakePrompt(event),
+  "",
+  "Use the workspace and Moltnet skill/CLI according to your instructions.",
+  "Use recalled Daimon memory as authoritative context when it is relevant.",
+  "The Daimon runtime publishes your final CLI output as your reply to the wake source.",
+  "Return only the exact message body that should be published. Do not include summaries, markdown headings, tool reports, or action logs.",
+  "Do not return progress reports such as 'handling', 'reading', 'querying', 'I will', or 'I have responded'. If your instructions require a tool or Moltnet action, execute it before the final reply.",
+  "If your instructions include an exact shell command, run that command before answering.",
+  "Use moltnet send only when you need to coordinate with a different room or agent before your final reply; do not use it for the final reply itself.",
+  "If no response is needed, return one short sentence explaining why."
+].join("\n");
+
+const formatTurnError = (error) =>
+  error instanceof Error ? error.message : String(error);
+
+const recordCliMemoryTurn = async (memory, prepared, request, result, outputText, error) => {
+  if (!memory || !prepared) {
+    return;
+  }
+
+  await memory.recordTurn({
+    error,
+    outputText,
+    principal: prepared.principal,
+    prompt: prepared.packet,
+    recall: prepared.recall,
+    request,
+    result
+  });
+};
+
+class CliEngineAgentHandle {
+  constructor(config, paths) {
+    this.config = config;
+    this.paths = paths;
+    this.engine = normalizeAgentEngineKind(config);
+    this.memory = config.memory ? createMemoryRuntime(createMemoryRuntimeOptions(config)) : null;
+  }
+
+  async wake(event) {
+    const startedAt = new Date();
+    const { request } = buildCliMemoryRequest(event);
+    let engineMs;
+    let memoryPrepareMs;
+    let memoryPrepareStatus;
+    let memoryRecordMs;
+    let outputText = "";
+    let prepared;
+    let prompt = createCliEnginePrompt(this.config, this.paths, event);
+
+    try {
+      if (this.memory) {
+        const memoryStartedAt = Date.now();
+        try {
+          prepared = await this.memory.prepareTurn(request);
+        } catch (error) {
+          memoryPrepareMs = Date.now() - memoryStartedAt;
+          memoryPrepareStatus = "failed";
+          throw error;
+        }
+        memoryPrepareMs = Date.now() - memoryStartedAt;
+        memoryPrepareStatus = "completed";
+        prompt = createCliEnginePrompt(this.config, this.paths, event, prepared.promptText);
+      }
+
+      // prompt is final here; stamp turn.input.submitted before the CLI engine
+      // sees it, chained to the real WakeEvent id (event.id) — matching
+      // daimon's own PiAgentHandle.wake() placement/shape (turnCausal.ts).
+      const turnInputSubmitted = await stampTurnInputSubmitted({
+        agentId: normalizeMemoryAgentId(this.config.id),
+        event,
+        prepared,
+        promptText: prompt,
+        runtimeHomePath: this.paths.runtimeHomePath
+      });
+
+      const result = await runCliEngine(this.engine, prompt, this.paths, this.config);
+      engineMs = result.durationMs;
+      outputText = typeof result.text === "string" ? result.text : "";
+
+      // Success path only; chained to turnInputSubmitted above, per
+      // turnCausal.ts's stampTurnOutputCompleted contract.
+      await stampTurnOutputCompleted({
+        agentId: normalizeMemoryAgentId(this.config.id),
+        causeEventId: turnInputSubmitted.event_id,
+        outputText,
+        runtimeHomePath: this.paths.runtimeHomePath,
+        turnId: event.id
+      });
+
+      const memoryRecordStartedAt = Date.now();
+      await recordCliMemoryTurn(
+        this.memory,
+        prepared,
+        request,
+        "completed",
+        outputText,
+        undefined
+      );
+      memoryRecordMs = this.memory && prepared ? Date.now() - memoryRecordStartedAt : undefined;
+      await writeTurnTrace(this.paths, createGeneratedTurnTrace({
+        config: this.config,
+        engine: this.engine,
+        engineMs,
+        event,
+        memoryPrepareMs,
+        memoryPrepareStatus,
+        memoryRecall: prepared ? {
+          redaction_count: prepared.recall.redactionCount,
+          selected_count: prepared.recall.selectedEventIds.length,
+          token_budget_used: prepared.recall.tokenBudgetUsed,
+          total_candidates: prepared.recall.totalCandidates
+        } : undefined,
+        memoryRecordMs,
+        outputText,
+        prompt,
+        startedAt,
+        status: "completed"
+      }));
+      return result;
+    } catch (error) {
+      if (this.memory && memoryPrepareStatus === undefined) {
+        memoryPrepareStatus = "failed";
+      }
+      await recordCliMemoryTurn(
+        this.memory,
+        prepared,
+        request,
+        "failed",
+        "",
+        formatTurnError(error)
+      );
+      await writeTurnTrace(this.paths, createGeneratedTurnTrace({
+        config: this.config,
+        engine: this.engine,
+        engineMs,
+        error: formatTurnError(error),
+        errorStage: memoryPrepareStatus === "failed" && !prepared ? "memory_prepare" : "engine_prompt",
+        event,
+        memoryPrepareMs,
+        memoryPrepareStatus,
+        memoryRecall: prepared ? {
+          redaction_count: prepared.recall.redactionCount,
+          selected_count: prepared.recall.selectedEventIds.length,
+          token_budget_used: prepared.recall.tokenBudgetUsed,
+          total_candidates: prepared.recall.totalCandidates
+        } : undefined,
+        memoryRecordMs,
+        outputText,
+        prompt,
+        startedAt,
+        status: "failed"
+      }));
+      throw error;
+    }
+  }
+
+  stop() {}
+}
+`;

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

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