spawnfile 0.1.32 → 0.1.34

package/dist/runtime/pi/appActivitySource.js

@@ -1,199 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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;

package/dist/runtime/pi/appAgentConfig.js

@@ -1,264 +0,0 @@
-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

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

package/dist/runtime/pi/appCliEnginesSource.js

@@ -1,183 +0,0 @@
-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

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