replicas-engine 0.1.630 → 0.1.632

package/dist/src/headless-agent.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import {
+  AGENT,
+  AppServerProcess,
+  headlessAgentRequestSchema
+} from "./chunk-2WNJA3MT.js";
+
+// src/headless-agent.ts
+import { readFile, writeFile } from "fs/promises";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var TURN_TIMEOUT_MS = 3e5;
+async function runClaude(request) {
+  const response = query({
+    prompt: request.prompt,
+    options: {
+      cwd: request.workingDirectory,
+      model: request.model,
+      tools: [],
+      permissionMode: "dontAsk",
+      settingSources: [],
+      persistSession: false,
+      outputFormat: { type: "json_schema", schema: request.outputSchema },
+      env: { ...process.env, CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" }
+    }
+  });
+  let result = null;
+  try {
+    for await (const message of response) {
+      if (message.type === "result") result = message;
+    }
+  } finally {
+    response.close();
+  }
+  if (!result) throw new Error("Claude Agent SDK returned no result");
+  if (result.subtype !== "success") throw new Error(result.errors.join("\n") || result.subtype);
+  return result.structured_output ?? JSON.parse(result.result);
+}
+function runCodexTurn(client, params) {
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      clearTimeout(timeout);
+      client.off("notification", onNotification);
+      client.off("dispose", onDispose);
+    };
+    const onNotification = (notification) => {
+      if (notification.method !== "turn/completed" || notification.params.threadId !== params.threadId) return;
+      cleanup();
+      resolve(notification.params.turn);
+    };
+    const onDispose = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Codex ASP turn timed out"));
+    }, TURN_TIMEOUT_MS);
+    client.on("notification", onNotification);
+    client.on("dispose", onDispose);
+    void client.request("turn/start", params).catch((error) => {
+      cleanup();
+      reject(error);
+    });
+  });
+}
+async function runCodex(request) {
+  const appServer = new AppServerProcess({
+    cwd: request.workingDirectory,
+    configOverrides: ["shell_environment_policy.inherit=none", "tools.web_search=false"]
+  });
+  try {
+    const { client } = await appServer.start();
+    client.on("serverRequest", (serverRequest) => {
+      client.reject(serverRequest.id, -32601, "Headless agents do not accept server requests");
+    });
+    const thread = await client.request("thread/start", {
+      model: request.model,
+      cwd: request.workingDirectory,
+      approvalPolicy: "never",
+      approvalsReviewer: "user",
+      sandbox: "read-only",
+      ephemeral: true,
+      environments: [],
+      dynamicTools: [],
+      selectedCapabilityRoots: []
+    });
+    const turn = await runCodexTurn(client, {
+      threadId: thread.thread.id,
+      input: [{ type: "text", text: request.prompt, text_elements: [] }],
+      outputSchema: request.outputSchema,
+      approvalPolicy: "never",
+      approvalsReviewer: "user",
+      environments: []
+    });
+    if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
+    const message = turn.items.findLast((item) => item.type === "agentMessage");
+    if (!message || message.type !== "agentMessage") throw new Error("Codex ASP returned no final message");
+    return JSON.parse(message.text);
+  } finally {
+    await appServer.stop();
+  }
+}
+async function main() {
+  const [requestPath, outputPath] = process.argv.slice(2);
+  if (!requestPath || !outputPath) throw new Error("Usage: replicas-headless-agent <request.json> <output.json>");
+  const request = headlessAgentRequestSchema.parse(JSON.parse(await readFile(requestPath, "utf8")));
+  let result;
+  switch (request.agent) {
+    case AGENT.CLAUDE:
+      result = await runClaude(request);
+      break;
+    case AGENT.CODEX:
+      result = await runCodex(request);
+      break;
+    default:
+      throw new Error(`Unsupported headless agent: ${request.agent}`);
+  }
+  await writeFile(outputPath, JSON.stringify(result), { mode: 384 });
+}
+main().catch((error) => {
+  process.exitCode = 1;
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+});