replicas-engine 0.1.667 → 0.1.671

package/dist/src/chunk-XQW4B35Y.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+// src/utils/presigned-upload.ts
+import { createReadStream } from "fs";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+async function putPresignedFile(urlValue, filePath, size, contentType) {
+  await new Promise((resolve, reject) => {
+    const url = new URL(urlValue);
+    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
+      method: "PUT",
+      headers: {
+        "content-length": String(size),
+        "content-type": contentType
+      }
+    }, (response) => {
+      response.setEncoding("utf8");
+      let body = "";
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on("end", () => {
+        const status = response.statusCode ?? 0;
+        if (status >= 200 && status < 300) resolve();
+        else reject(new Error(`upload failed: ${status} ${body}`));
+      });
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+    const file = size > 0 ? createReadStream(filePath, { start: 0, end: size - 1 }) : createReadStream(filePath);
+    file.on("error", (error) => request.destroy(error));
+    file.pipe(request);
+  });
+}
+
+// src/utils/codex-agent-env.ts
+function buildCodexAgentEnv(source = process.env) {
+  const env = Object.fromEntries(
+    Object.entries(source).filter((entry) => typeof entry[1] === "string")
+  );
+  if (env.REPLICAS_CODEX_AUTH_METHOD === "oauth" || env.REPLICAS_CODEX_AUTH_METHOD === "foundry") {
+    delete env.OPENAI_API_KEY;
+  }
+  delete env.GH_TOKEN;
+  delete env.GITHUB_TOKEN;
+  delete env.GH_CONFIG_DIR;
+  return env;
+}
+
+// src/managers/codex-asp/notification-dispatch.ts
+var TURN_STARTED_METHOD = "turn/started";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
+var THREAD_GOAL_UPDATED_METHOD = "thread/goal/updated";
+var THREAD_GOAL_CLEARED_METHOD = "thread/goal/cleared";
+var ITEM_STARTED_METHOD = "item/started";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var REASONING_SUMMARY_TEXT_DELTA_METHOD = "item/reasoning/summaryTextDelta";
+var REASONING_TEXT_DELTA_METHOD = "item/reasoning/textDelta";
+var REASONING_SUMMARY_PART_ADDED_METHOD = "item/reasoning/summaryPartAdded";
+var COMMAND_EXECUTION_OUTPUT_DELTA_METHOD = "item/commandExecution/outputDelta";
+var FILE_CHANGE_OUTPUT_DELTA_METHOD = "item/fileChange/outputDelta";
+var ACCOUNT_RATE_LIMITS_UPDATED_METHOD = "account/rateLimits/updated";
+var THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
+var THREAD_COMPACTED_METHOD = "thread/compacted";
+function dispatchAspNotification(notification, handlers) {
+  const handler = handlers[notification.method];
+  if (!handler) return;
+  handler(notification);
+}
+function recoverCompletedTurn(turn, completedItems, agentMessageDeltas) {
+  const items = turn.items.length > 0 ? [...turn.items] : [];
+  const itemIds = new Set(items.map((item) => item.id));
+  for (const item of completedItems) {
+    if (itemIds.has(item.id)) continue;
+    items.push(item);
+    itemIds.add(item.id);
+  }
+  for (const [itemId, text] of agentMessageDeltas) {
+    if (itemIds.has(itemId)) continue;
+    items.push({ type: "agentMessage", id: itemId, text, phase: null, memoryCitation: null });
+  }
+  return items.length > 0 ? { ...turn, items, itemsView: "full" } : turn;
+}
+
+export {
+  putPresignedFile,
+  buildCodexAgentEnv,
+  TURN_STARTED_METHOD,
+  TURN_COMPLETED_METHOD,
+  TURN_PLAN_UPDATED_METHOD,
+  THREAD_GOAL_UPDATED_METHOD,
+  THREAD_GOAL_CLEARED_METHOD,
+  ITEM_STARTED_METHOD,
+  ITEM_COMPLETED_METHOD,
+  AGENT_MESSAGE_DELTA_METHOD,
+  REASONING_SUMMARY_TEXT_DELTA_METHOD,
+  REASONING_TEXT_DELTA_METHOD,
+  REASONING_SUMMARY_PART_ADDED_METHOD,
+  COMMAND_EXECUTION_OUTPUT_DELTA_METHOD,
+  FILE_CHANGE_OUTPUT_DELTA_METHOD,
+  ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
+  THREAD_TOKEN_USAGE_UPDATED_METHOD,
+  THREAD_COMPACTED_METHOD,
+  dispatchAspNotification,
+  recoverCompletedTurn
+};

package/dist/src/codex-token-manager-RX4N2W22.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  CodexAspAuthMethodChangedError,
+  CodexTokenManager,
+  codexTokenManager
+} from "./chunk-6WY7NPCL.js";
+import "./chunk-4FTBKGMO.js";
+import "./chunk-TMERKNQV.js";
+export {
+  CodexAspAuthMethodChangedError,
+  CodexTokenManager,
+  codexTokenManager
+};

package/dist/src/engine-env-A2FZA66L.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  ENGINE_ENV,
+  IS_WARMING_MODE,
+  loadEngineEnv,
+  setAgentCredentialSnapshot
+} from "./chunk-4FTBKGMO.js";
+import "./chunk-TMERKNQV.js";
+export {
+  ENGINE_ENV,
+  IS_WARMING_MODE,
+  loadEngineEnv,
+  setAgentCredentialSnapshot
+};

package/dist/src/headless-agent.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
-  AGENT,
-  AppServerProcess,
   buildCodexAgentEnv,
-  getMemoryOutputSafetyViolation,
-  headlessAgentRequestSchema,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-P2Q47GLV.js";
+} from "./chunk-XQW4B35Y.js";
+import {
+  AGENT,
+  getMemoryOutputSafetyViolation,
+  headlessAgentRequestSchema
+} from "./chunk-TMERKNQV.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";
@@ -171,38 +172,52 @@ function runCodexTurn(client, params, timeoutMs) {
   });
 }
 async function runCodex(request) {
-  const appServer = new AppServerProcess({
-    cwd: request.workingDirectory,
-    env: buildCodexAgentEnv(),
-    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,
+  const [{ AppServerProcess }, { codexTokenManager }, { ENGINE_ENV }] = await Promise.all([
+    import("./app-server-process-S2SD6PQE.js"),
+    import("./codex-token-manager-RX4N2W22.js"),
+    import("./engine-env-A2FZA66L.js")
+  ]);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const authMethod = ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD;
+    const oauthOptions = await codexTokenManager.prepareAspOauthOptions();
+    const appServer = new AppServerProcess({
       cwd: request.workingDirectory,
-      approvalPolicy: "never",
-      approvalsReviewer: "user",
-      sandbox: request.mode === "filesystem" ? "workspace-write" : "read-only",
-      ephemeral: true
+      env: buildCodexAgentEnv(),
+      configOverrides: ["shell_environment_policy.inherit=none", "tools.web_search=false"],
+      ...oauthOptions
     });
-    const { turn, message } = await runCodexTurn(client, {
-      threadId: thread.thread.id,
-      input: [{ type: "text", text: request.prompt, text_elements: [] }],
-      ...request.mode === "structured" ? { outputSchema: request.outputSchema } : {},
-      approvalPolicy: "never",
-      approvalsReviewer: "user"
-    }, request.timeoutSeconds * 1e3);
-    if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
-    if (!message) throw new Error("Codex ASP returned no final message");
-    if (request.mode === "filesystem") return message;
-    return JSON.parse(message);
-  } finally {
-    await appServer.stop();
+    try {
+      const { client } = await appServer.start();
+      client.on("serverRequest", (serverRequest) => {
+        if (serverRequest.method === "account/chatgptAuthTokens/refresh") return;
+        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: request.mode === "filesystem" ? "workspace-write" : "read-only",
+        ephemeral: true
+      });
+      const { turn, message } = await runCodexTurn(client, {
+        threadId: thread.thread.id,
+        input: [{ type: "text", text: request.prompt, text_elements: [] }],
+        ...request.mode === "structured" ? { outputSchema: request.outputSchema } : {},
+        approvalPolicy: "never",
+        approvalsReviewer: "user"
+      }, request.timeoutSeconds * 1e3);
+      if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
+      if (!message) throw new Error("Codex ASP returned no final message");
+      if (request.mode === "filesystem") return message;
+      return JSON.parse(message);
+    } catch (error) {
+      if (attempt > 0 || ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD === authMethod) throw error;
+    } finally {
+      await appServer.stop();
+    }
   }
+  throw new Error("Codex ASP could not restart with fallback credentials");
 }
 async function main() {
   const [requestPath, outputPath] = process.argv.slice(2);