replicas-engine 0.1.701 → 0.1.703

package/dist/src/{chunk-OI5T44T7.js → chunk-LPJ6WYD4.js}

@@ -6574,524 +6574,6 @@ function isSkillRegistryManifest(value) {
   );
 }
 
-// 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/utils/exec.ts
-import { exec, execFile } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var execFileAsync = promisify(execFile);
-var SUBPROCESS_MAX_BUFFER = HOOK_EXEC_MAX_BUFFER_BYTES;
-
-// src/managers/codex-asp/app-server-process.ts
-import { spawn } from "child_process";
-import { EventEmitter as EventEmitter2 } from "events";
-
-// src/managers/codex-asp/asp-client.ts
-import { EventEmitter } from "events";
-var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
-function hasOwn(record, key) {
-  return Object.prototype.hasOwnProperty.call(record, key);
-}
-var AspClient = class {
-  stdin;
-  stdout;
-  emitter = new EventEmitter();
-  pending = /* @__PURE__ */ new Map();
-  nextId = 1;
-  lineBuffer = "";
-  disposed = false;
-  get isDisposed() {
-    return this.disposed;
-  }
-  constructor(options) {
-    this.stdin = options.stdin;
-    this.stdout = options.stdout;
-    this.stdout.setEncoding("utf8");
-    this.stdout.on("data", this.handleStdoutData);
-    this.stdin.on("error", this.handleStdinError);
-  }
-  on(event, listener) {
-    this.emitter.on(event, listener);
-  }
-  off(event, listener) {
-    this.emitter.off(event, listener);
-  }
-  async request(method, params, opts) {
-    if (this.disposed) {
-      throw new Error(`Cannot send ${method}: ASP client disposed`);
-    }
-    const id = this.nextId;
-    this.nextId += 1;
-    const promise = new Promise((resolve, reject) => {
-      const timeoutMs = opts?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-      const timer = timeoutMs > 0 ? setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`ASP request timed out for ${method}`));
-      }, timeoutMs) : null;
-      this.pending.set(id, { resolve, reject, method, timer });
-    });
-    this.write({ method, id, params });
-    return promise;
-  }
-  notify(method, params) {
-    if (this.disposed) {
-      return;
-    }
-    try {
-      this.write(params === void 0 ? { method } : { method, params });
-    } catch (error) {
-      console.warn(`[AspClient] Failed to send notification ${method}:`, error);
-    }
-  }
-  respond(id, result) {
-    if (this.disposed) {
-      return;
-    }
-    try {
-      this.write({ id, result });
-    } catch (error) {
-      console.warn(`[AspClient] Failed to send response ${String(id)}:`, error);
-    }
-  }
-  reject(id, code, message, data) {
-    if (this.disposed) {
-      return;
-    }
-    try {
-      this.write({
-        id,
-        error: {
-          code,
-          message,
-          ...data !== void 0 ? { data } : {}
-        }
-      });
-    } catch (error) {
-      console.warn(`[AspClient] Failed to send error response ${String(id)}:`, error);
-    }
-  }
-  dispose(reason = new Error("ASP client disposed")) {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    this.stdout.off("data", this.handleStdoutData);
-    this.stdin.removeListener("error", this.handleStdinError);
-    for (const [id, pending] of this.pending) {
-      if (pending.timer) {
-        clearTimeout(pending.timer);
-      }
-      pending.reject(new Error(`${reason.message} while waiting for ${pending.method}`));
-      this.pending.delete(id);
-    }
-    this.lineBuffer = "";
-    this.emitter.emit("dispose", reason);
-    this.emitter.removeAllListeners();
-  }
-  handleStdoutData = (chunk) => {
-    this.lineBuffer += chunk.toString();
-    let newlineIndex = this.lineBuffer.indexOf("\n");
-    while (newlineIndex >= 0) {
-      const line = this.lineBuffer.slice(0, newlineIndex).trim();
-      this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
-      if (line.length > 0) {
-        this.handleLine(line);
-      }
-      newlineIndex = this.lineBuffer.indexOf("\n");
-    }
-  };
-  handleStdinError = (error) => {
-    this.dispose(new Error(`ASP stdin error: ${error.message}`));
-  };
-  handleLine(line) {
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch (error) {
-      console.warn("[AspClient] Failed to parse ASP JSON line:", error);
-      return;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      console.warn("[AspClient] Ignoring non-object ASP message");
-      return;
-    }
-    const message = parsed;
-    const hasRequestId = typeof message.id === "number" || typeof message.id === "string";
-    if (hasRequestId && (hasOwn(message, "result") || hasOwn(message, "error"))) {
-      this.handleResponse(message);
-      return;
-    }
-    if (hasRequestId && typeof message.method === "string") {
-      this.emitter.emit("serverRequest", message);
-      return;
-    }
-    if (!hasOwn(message, "id") && typeof message.method === "string") {
-      this.emitter.emit("notification", message);
-    }
-  }
-  handleResponse(message) {
-    if (typeof message.id !== "number") {
-      console.warn("[AspClient] Ignoring response with non-numeric request id");
-      return;
-    }
-    const pending = this.pending.get(message.id);
-    if (!pending) {
-      console.warn(`[AspClient] Ignoring response for unknown request id ${message.id}`);
-      return;
-    }
-    this.pending.delete(message.id);
-    if (pending.timer) {
-      clearTimeout(pending.timer);
-    }
-    if (hasOwn(message, "error")) {
-      pending.reject(this.createRpcError(pending.method, message.error));
-      return;
-    }
-    pending.resolve(message.result);
-  }
-  createRpcError(method, error) {
-    if (typeof error !== "object" || error === null || Array.isArray(error)) {
-      return new Error(`ASP request failed for ${method}`);
-    }
-    const rpcError = error;
-    const code = typeof rpcError.code === "number" ? ` ${rpcError.code}` : "";
-    const message = typeof rpcError.message === "string" ? rpcError.message : "Unknown ASP error";
-    const data = hasOwn(rpcError, "data") ? ` data=${JSON.stringify(rpcError.data)}` : "";
-    return new Error(`ASP request failed for ${method}:${code} ${message}${data}`);
-  }
-  write(message) {
-    try {
-      this.stdin.write(`${JSON.stringify(message)}
-`, (error) => {
-        if (error) {
-          this.dispose(new Error(`ASP write failed: ${error.message}`));
-        }
-      });
-    } catch (error) {
-      const writeError = error instanceof Error ? error : new Error("ASP write failed");
-      this.dispose(writeError);
-      throw writeError;
-    }
-  }
-};
-
-// src/managers/codex-asp/app-server-process.ts
-var DEFAULT_CODEX_BINARY = "codex";
-var DEFAULT_CODEX_ARGS = [
-  "app-server",
-  "--listen",
-  "stdio://",
-  "-c",
-  "features.memories=false",
-  "-c",
-  "memories.use_memories=false",
-  "-c",
-  "memories.generate_memories=false"
-];
-var MIN_CODEX_CLI_VERSION = "0.144.6";
-var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
-var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.701";
-var INITIALIZE_METHOD = "initialize";
-var INITIALIZED_NOTIFICATION = "initialized";
-var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
-var AppServerProcess = class {
-  binary;
-  args;
-  env;
-  cwd;
-  chatgptAuthTokens;
-  refreshChatgptAuthTokens;
-  emitter = new EventEmitter2();
-  child = null;
-  client = null;
-  shuttingDown = false;
-  invalidating = false;
-  constructor(options) {
-    this.binary = options.binary ?? DEFAULT_CODEX_BINARY;
-    const baseArgs = options.args ?? (options.env.REPLICAS_CODEX_AUTH_METHOD === "foundry" ? [
-      ...DEFAULT_CODEX_ARGS,
-      "-c",
-      `model=${JSON.stringify(options.env.CODEX_FOUNDRY_MODEL)}`,
-      "-c",
-      'model_provider="azure"',
-      "-c",
-      'model_providers.azure.name="Azure OpenAI"',
-      "-c",
-      `model_providers.azure.base_url=${JSON.stringify(options.env.CODEX_FOUNDRY_BASE_URL)}`,
-      "-c",
-      'model_providers.azure.env_key="AZURE_OPENAI_API_KEY"',
-      "-c",
-      'model_providers.azure.wire_api="responses"'
-    ] : DEFAULT_CODEX_ARGS);
-    this.args = [...baseArgs, ...(options.configOverrides ?? []).flatMap((override) => ["-c", override])];
-    this.env = options.env;
-    this.cwd = options.cwd;
-    this.chatgptAuthTokens = options.chatgptAuthTokens;
-    this.refreshChatgptAuthTokens = options.refreshChatgptAuthTokens;
-  }
-  on(event, listener) {
-    this.emitter.on(event, listener);
-  }
-  async start() {
-    if (this.child && this.client) {
-      return { client: this.client };
-    }
-    this.shuttingDown = false;
-    this.invalidating = false;
-    await this.ensureMinCodexCliVersion();
-    const child = spawn(this.binary, this.args, {
-      cwd: this.cwd,
-      env: this.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.child = child;
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      for (const line of chunk.toString().split("\n")) {
-        if (line.trim().length > 0) {
-          console.error(`[codex-app-server] ${line}`);
-        }
-      }
-    });
-    child.on("exit", (code, signal) => {
-      this.client?.dispose();
-      this.client = null;
-      this.child = null;
-      if (!this.shuttingDown) {
-        if (!this.invalidating) {
-          console.warn(`[AppServerProcess] codex app-server exited unexpectedly code=${code ?? "null"} signal=${signal ?? "null"}`);
-        }
-        this.emitter.emit("exit", code, signal);
-      }
-    });
-    const client = new AspClient({ stdin: child.stdin, stdout: child.stdout });
-    this.client = client;
-    client.on("serverRequest", (serverRequest) => {
-      if (serverRequest.method !== "account/chatgptAuthTokens/refresh") return;
-      if (!this.refreshChatgptAuthTokens) {
-        client.reject(serverRequest.id, -32603, "Codex OAuth refresh is not configured");
-        return;
-      }
-      void this.refreshChatgptAuthTokens(serverRequest.params).then((tokens) => {
-        client.respond(serverRequest.id, tokens);
-      }).catch((error) => {
-        if (error instanceof Error && error.name === "CodexAspAuthMethodChangedError") {
-          this.invalidating = true;
-          client.dispose(error);
-          if (!child.killed) child.kill("SIGTERM");
-          return;
-        }
-        client.reject(
-          serverRequest.id,
-          -32603,
-          error instanceof Error ? error.message : "Failed to refresh Codex OAuth credentials"
-        );
-      });
-    });
-    let cleanupEarlyFailureHandlers = () => {
-    };
-    const earlyFailure = new Promise((_resolve, reject) => {
-      const onError = (error) => {
-        reject(error);
-      };
-      const onExit = (code, signal) => {
-        reject(new Error(`codex app-server exited before initialize completed code=${code ?? "null"} signal=${signal ?? "null"}`));
-      };
-      child.once("error", onError);
-      child.once("exit", onExit);
-      cleanupEarlyFailureHandlers = () => {
-        child.off("error", onError);
-        child.off("exit", onExit);
-      };
-    });
-    try {
-      const initializeParams = {
-        clientInfo: {
-          name: "replicas_engine",
-          title: "Replicas Engine",
-          version: ENGINE_PACKAGE_VERSION
-        },
-        capabilities: {
-          experimentalApi: true,
-          requestAttestation: false,
-          optOutNotificationMethods: null
-        }
-      };
-      await Promise.race([
-        client.request(INITIALIZE_METHOD, initializeParams),
-        earlyFailure
-      ]);
-      cleanupEarlyFailureHandlers();
-      client.notify(INITIALIZED_NOTIFICATION);
-      await this.loginWithConfiguredCredentials(client);
-      return { client };
-    } catch (error) {
-      cleanupEarlyFailureHandlers();
-      client.dispose();
-      await this.killAfterFailedStart();
-      throw error;
-    }
-  }
-  async stop() {
-    const child = this.child;
-    this.shuttingDown = true;
-    this.client?.dispose(new Error("ASP process stopped"));
-    this.client = null;
-    this.child = null;
-    if (!child || child.killed) {
-      return;
-    }
-    await new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        child.kill("SIGKILL");
-      }, 2e3);
-      child.once("exit", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-      child.kill("SIGTERM");
-    });
-  }
-  ensureMinCodexCliVersion() {
-    codexCliVersionEnsured ??= this.runEnsureMinCodexCliVersion().catch((error) => {
-      codexCliVersionEnsured = null;
-      console.warn("[AppServerProcess] Failed to ensure minimum codex CLI version, continuing with installed binary:", error);
-    });
-    return codexCliVersionEnsured;
-  }
-  async runEnsureMinCodexCliVersion() {
-    const { stdout } = await execFileAsync(this.binary, ["--version"], { env: this.env });
-    const version = stdout.match(/(\d+\.\d+\.\d+)/)?.[1];
-    if (version && !isVersionBelow(version, MIN_CODEX_CLI_VERSION)) {
-      return;
-    }
-    console.warn(`[AppServerProcess] codex CLI ${version ?? "unknown"} is below ${MIN_CODEX_CLI_VERSION}; upgrading @openai/codex`);
-    await execFileAsync(
-      "npm",
-      ["install", "-g", "--no-audit", "--no-fund", `@openai/codex@${MIN_CODEX_CLI_VERSION}`],
-      { env: this.env, timeout: CODEX_UPGRADE_TIMEOUT_MS }
-    );
-    console.warn(`[AppServerProcess] upgraded codex CLI to ${MIN_CODEX_CLI_VERSION}`);
-  }
-  async loginWithConfiguredCredentials(client) {
-    if (this.env.REPLICAS_CODEX_AUTH_METHOD === "oauth") {
-      if (!this.chatgptAuthTokens) {
-        throw new Error("Codex OAuth credentials were not prepared before app-server startup");
-      }
-      const params2 = {
-        type: "chatgptAuthTokens",
-        ...this.chatgptAuthTokens
-      };
-      await client.request(ACCOUNT_LOGIN_START_METHOD, params2);
-      return;
-    }
-    if (this.env.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !this.env.OPENAI_API_KEY) return;
-    const params = {
-      type: "apiKey",
-      apiKey: this.env.OPENAI_API_KEY
-    };
-    await client.request(ACCOUNT_LOGIN_START_METHOD, params);
-  }
-  async killAfterFailedStart() {
-    const child = this.child;
-    this.child = null;
-    this.client = null;
-    if (!child || child.killed) {
-      return;
-    }
-    this.shuttingDown = true;
-    child.kill("SIGKILL");
-    await new Promise((resolve) => {
-      child.once("exit", () => resolve());
-    });
-  }
-};
-
-// 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";
-var MODEL_REROUTED_METHOD = "model/rerouted";
-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 {
   isRecord,
   isNonEmptyString,
@@ -7207,6 +6689,7 @@ export {
   isTransientErrorText,
   isClaudeAuthErrorText,
   isCodexAuthError,
+  isVersionBelow,
   hasChatStarted,
   DESKTOP_STREAM_PORT,
   MERGED_MESSAGE_SEPARATOR,
@@ -7271,30 +6754,5 @@ export {
   MEMORY_SUMMARY_FILENAME,
   MEMORY_INDEX_FILENAME,
   getMemoryOutputSafetyViolation,
-  isSkillRegistryManifest,
-  putPresignedFile,
-  buildCodexAgentEnv,
-  execAsync,
-  execFileAsync,
-  SUBPROCESS_MAX_BUFFER,
-  AppServerProcess,
-  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,
-  MODEL_REROUTED_METHOD,
-  dispatchAspNotification,
-  recoverCompletedTurn
+  isSkillRegistryManifest
 };