replicas-engine 0.1.212 → 0.1.213

package/dist/src/index.js

@@ -1493,7 +1493,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "25-05-2026-royal-york-v3";
+var DAYTONA_SNAPSHOT_ID = "26-05-2026-royal-york-v1";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1677,7 +1677,8 @@ function loadEngineEnv() {
     AWS_REGION: readEnv("AWS_REGION"),
     REPLICAS_CLAUDE_AUTH_METHOD: parseClaudeAuthMethod(readEnv("REPLICAS_CLAUDE_AUTH_METHOD")),
     REPLICAS_CODEX_AUTH_METHOD: parseCodexAuthMethod(readEnv("REPLICAS_CODEX_AUTH_METHOD")),
-    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT")
+    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
+    CODEX_ASP_ENABLED: readEnv("CODEX_ASP_ENABLED")?.toLowerCase() === "true"
   };
   if (!IS_WARMING_MODE && !env.WORKSPACE_ID) {
     console.error("WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
@@ -5384,6 +5385,580 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
   }
 };
 
+// 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((resolve3, 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: resolve3, 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);
+    }
+  }
+  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://"];
+var ENGINE_PACKAGE_VERSION = "0.1.213";
+var INITIALIZE_METHOD = "initialize";
+var INITIALIZED_NOTIFICATION = "initialized";
+var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
+var AppServerProcess = class {
+  binary;
+  args;
+  env;
+  cwd;
+  emitter = new EventEmitter2();
+  child = null;
+  client = null;
+  shuttingDown = false;
+  constructor(options = {}) {
+    this.binary = options.binary ?? DEFAULT_CODEX_BINARY;
+    this.args = options.args ?? DEFAULT_CODEX_ARGS;
+    this.env = options.env ?? buildCodexAgentEnv();
+    this.cwd = options.cwd ?? ENGINE_ENV.WORKSPACE_ROOT;
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  async start() {
+    if (this.child && this.client) {
+      return { client: this.client };
+    }
+    this.shuttingDown = false;
+    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) {
+        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;
+    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.loginWithConfiguredApiKey(client);
+      return { client };
+    } catch (error) {
+      cleanupEarlyFailureHandlers();
+      client.dispose();
+      await this.killAfterFailedStart();
+      throw error;
+    }
+  }
+  async loginWithConfiguredApiKey(client) {
+    if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !ENGINE_ENV.OPENAI_API_KEY) {
+      return;
+    }
+    const params = {
+      type: "apiKey",
+      apiKey: ENGINE_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((resolve3) => {
+      child.once("exit", () => resolve3());
+    });
+  }
+};
+
+// src/managers/codex-asp/asp-host.ts
+var hostPromise = null;
+async function getCodexAspHost() {
+  hostPromise ??= (async () => {
+    try {
+      const process2 = new AppServerProcess();
+      const { client } = await process2.start();
+      process2.on("exit", () => {
+        hostPromise = null;
+      });
+      return { client };
+    } catch (error) {
+      hostPromise = null;
+      throw error;
+    }
+  })();
+  return hostPromise;
+}
+
+// src/managers/codex-asp/codex-asp-manager.ts
+var DEFAULT_MODEL2 = "gpt-5.5";
+var THREAD_START_METHOD = "thread/start";
+var TURN_START_METHOD = "turn/start";
+var TURN_INTERRUPT_METHOD = "turn/interrupt";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var COMMAND_APPROVAL_METHOD = "item/commandExecution/requestApproval";
+var FILE_CHANGE_APPROVAL_METHOD = "item/fileChange/requestApproval";
+var CodexAspManager = class extends CodingAgentManager {
+  currentThreadId = null;
+  activeTurnId = null;
+  historyEvents = [];
+  constructor(options) {
+    super(options);
+    this.initializeManager(this.processMessageInternal.bind(this));
+  }
+  async initialize() {
+    if (this.initialSessionId) {
+      this.currentThreadId = this.initialSessionId;
+    }
+  }
+  async interruptActiveTurn() {
+    if (!this.currentThreadId || !this.activeTurnId) {
+      return;
+    }
+    try {
+      const host = await getCodexAspHost();
+      const params = {
+        threadId: this.currentThreadId,
+        turnId: this.activeTurnId
+      };
+      await host.client.request(TURN_INTERRUPT_METHOD, params);
+    } catch (error) {
+      console.warn("[CodexAspManager] Failed to interrupt active turn:", error);
+    }
+  }
+  async clearSessionState() {
+    this.currentThreadId = null;
+    this.activeTurnId = null;
+    await this.onSaveSessionId(null);
+  }
+  async getHistory() {
+    return {
+      thread_id: this.currentThreadId,
+      events: [...this.historyEvents]
+    };
+  }
+  async processMessageInternal(request) {
+    let host = null;
+    try {
+      host = await getCodexAspHost();
+      const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+      this.recordHistoryEvent("event_msg", {
+        type: "user_message",
+        message: request.message
+      });
+      if (!this.currentThreadId) {
+        const threadStartResponse = await host.client.request(
+          THREAD_START_METHOD,
+          await this.buildThreadStartParams(request, developerInstructions)
+        );
+        this.currentThreadId = threadStartResponse.thread.id;
+        await this.onSaveSessionId(this.currentThreadId);
+      }
+      const threadId = this.currentThreadId;
+      const completedTurn = await this.runTurn(host, threadId, request, developerInstructions);
+      if (completedTurn.status === "failed") {
+        const turnError = completedTurn.error;
+        if (!turnError) {
+          throw new Error("Codex ASP turn failed without error details");
+        }
+        const parts = [`Codex ASP turn failed: ${turnError.message}`];
+        if (turnError.codexErrorInfo !== null) {
+          parts.push(`codexErrorInfo=${JSON.stringify(turnError.codexErrorInfo)}`);
+        }
+        if (turnError.additionalDetails) {
+          parts.push(`details=${turnError.additionalDetails}`);
+        }
+        throw new Error(parts.join(" "));
+      }
+      if (completedTurn.status === "completed") {
+        this.emitFinalAgentMessage(completedTurn);
+      }
+    } finally {
+      this.activeTurnId = null;
+      if (host?.client.isDisposed) {
+        this.currentThreadId = null;
+        void this.onSaveSessionId(null).catch(() => {
+        });
+      }
+      await this.onTurnComplete();
+    }
+  }
+  async buildThreadStartParams(request, developerInstructions) {
+    const additionalDirectories = await getAgentAdditionalDirectories();
+    return {
+      model: request.model ?? DEFAULT_MODEL2,
+      cwd: this.workingDirectory,
+      runtimeWorkspaceRoots: additionalDirectories,
+      sandbox: "danger-full-access",
+      developerInstructions: developerInstructions ?? null,
+      config: { web_search: "live" },
+      experimentalRawEvents: false,
+      persistExtendedHistory: false
+    };
+  }
+  buildTurnStartParams(threadId, request, developerInstructions) {
+    const effort = request.thinkingLevel === "max" ? "xhigh" : request.thinkingLevel;
+    const model = request.model ?? DEFAULT_MODEL2;
+    return {
+      threadId,
+      input: [{
+        type: "text",
+        text: request.message,
+        text_elements: []
+      }],
+      model,
+      ...effort ? { effort } : {},
+      ...developerInstructions ? {
+        collaborationMode: {
+          mode: "default",
+          settings: {
+            model,
+            reasoning_effort: effort ?? null,
+            developer_instructions: developerInstructions
+          }
+        }
+      } : {}
+    };
+  }
+  async runTurn(host, threadId, request, developerInstructions) {
+    let resolveCompleted;
+    const completed = new Promise((resolve3) => {
+      resolveCompleted = resolve3;
+    });
+    let rejectDisposed = () => {
+    };
+    const disposed = new Promise((_resolve, reject) => {
+      rejectDisposed = reject;
+    });
+    void disposed.catch(() => {
+    });
+    let observedTurnId = null;
+    const completedItems = [];
+    const agentMessageDeltas = /* @__PURE__ */ new Map();
+    const onNotification = (notification) => {
+      if (notification.method === ITEM_COMPLETED_METHOD) {
+        if (notification.params.threadId === threadId && (!observedTurnId || notification.params.turnId === observedTurnId)) {
+          completedItems.push(notification.params.item);
+        }
+        return;
+      }
+      if (notification.method === AGENT_MESSAGE_DELTA_METHOD) {
+        if (notification.params.threadId === threadId && (!observedTurnId || notification.params.turnId === observedTurnId)) {
+          const currentText = agentMessageDeltas.get(notification.params.itemId) ?? "";
+          agentMessageDeltas.set(notification.params.itemId, currentText + notification.params.delta);
+        }
+        return;
+      }
+      if (notification.method === TURN_COMPLETED_METHOD) {
+        if (notification.params.threadId !== threadId) {
+          return;
+        }
+        observedTurnId = notification.params.turn.id;
+        const turn = notification.params.turn;
+        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)) {
+            items.push(item);
+            itemIds.add(item.id);
+          }
+        }
+        for (const [itemId, text] of agentMessageDeltas) {
+          if (!itemIds.has(itemId)) {
+            items.push({
+              type: "agentMessage",
+              id: itemId,
+              text,
+              phase: null,
+              memoryCitation: null
+            });
+          }
+        }
+        resolveCompleted(items.length > 0 ? { ...turn, items, itemsView: "full" } : turn);
+      }
+    };
+    const onServerRequest = (serverRequest) => {
+      if (serverRequest.method !== COMMAND_APPROVAL_METHOD && serverRequest.method !== FILE_CHANGE_APPROVAL_METHOD) {
+        return;
+      }
+      console.warn("[CodexAspManager] approval requested while sandbox is danger-full-access");
+      host.client.respond(serverRequest.id, { decision: "accept" });
+    };
+    const onDispose = (reason) => {
+      this.currentThreadId = null;
+      this.activeTurnId = null;
+      void this.onSaveSessionId(null).catch(() => {
+      });
+      const turnLabel = observedTurnId ? ` ${observedTurnId}` : "";
+      rejectDisposed(new Error(`Codex ASP client disposed before turn${turnLabel} completed: ${reason.message}`));
+    };
+    host.client.on("notification", onNotification);
+    host.client.on("serverRequest", onServerRequest);
+    host.client.on("dispose", onDispose);
+    try {
+      const turnStartResponse = await host.client.request(
+        TURN_START_METHOD,
+        this.buildTurnStartParams(threadId, request, developerInstructions)
+      );
+      observedTurnId = turnStartResponse.turn.id;
+      this.activeTurnId = turnStartResponse.turn.id;
+      return await Promise.race([completed, disposed]);
+    } finally {
+      host.client.off("notification", onNotification);
+      host.client.off("serverRequest", onServerRequest);
+      host.client.off("dispose", onDispose);
+    }
+  }
+  emitFinalAgentMessage(turn) {
+    let text = null;
+    for (let index = turn.items.length - 1; index >= 0; index -= 1) {
+      const item = turn.items[index];
+      if (item?.type === "agentMessage") {
+        text = item.text;
+        break;
+      }
+    }
+    if (!text) {
+      return;
+    }
+    this.captureCompactionText(text);
+    const event = this.recordHistoryEvent("response_item", {
+      type: "message",
+      role: "assistant",
+      content: [{
+        type: "output_text",
+        text
+      }]
+    });
+    this.onEvent(event);
+  }
+  recordHistoryEvent(type, payload) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload
+    };
+    this.historyEvents.push(event);
+    return event;
+  }
+};
+
 // src/managers/relay-tools.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
@@ -6299,7 +6874,8 @@ var ChatService = class {
         codexAvailable: isCodexAvailable()
       });
     } else {
-      provider = new CodexManager({
+      const CodexProviderCtor = ENGINE_ENV.CODEX_ASP_ENABLED ? CodexAspManager : CodexManager;
+      provider = new CodexProviderCtor({
         workingDirectory: this.workingDirectory,
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
@@ -6805,7 +7381,7 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { join as join18 } from "path";
@@ -6973,7 +7549,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve3) => {
-    const proc = spawn("bash", ["-lc", params.content], {
+    const proc = spawn2("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.212",
+  "version": "0.1.213",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -38,6 +38,7 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "@replicas/codex-asp-types": "file:../codex-asp-types",
     "@replicas/shared": "workspace:*",
     "@types/node": "^20.11.17",
     "tsup": "^8.5.0",