replicas-engine 0.1.419 → 0.1.421

package/dist/src/index.js

@@ -9,6 +9,24 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// ../shared/src/async.ts
+var TIMEOUT = /* @__PURE__ */ Symbol("timeout");
+async function raceWithTimeout(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4(TIMEOUT), ms);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+    promise.catch(() => {
+    });
+  }
+}
+
 // ../shared/src/agent.ts
 var VALID_AGENT_PROVIDERS = ["claude", "codex", "cursor", "opencode", "relay"];
 var VALID_CODING_AGENT_PROVIDERS = VALID_AGENT_PROVIDERS.filter(
@@ -490,7 +508,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-09-v8";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-10-v2";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -2802,6 +2820,7 @@ var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
 var WORKSPACE_FILE_CONTENT_MAX_SIZE_BYTES = 1 * 1024 * 1024;
 var WORKSPACE_STATUS_FILTERS = WORKSPACE_STATUSES.map((status) => status === "error" ? "failed" : status);
 var WORKSPACE_SORT_CHOICES = [
+  ["manual", "Custom"],
   ["activity", "Last activity"],
   ["created", "Created date"],
   ["status", "Status"]
@@ -8272,7 +8291,7 @@ var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
 var MIN_CODEX_CLI_VERSION = "0.144.0";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.419";
+var ENGINE_PACKAGE_VERSION = "0.1.421";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -10390,6 +10409,10 @@ import { basename, dirname as dirname5, extname, join as join17 } from "path";
 import { parse as parseYaml2 } from "yaml";
 import { Agent as CursorAgent } from "@cursor/sdk";
 var CURSOR_SLASH_COMMANDS_CACHE_MS = 3e4;
+var CURSOR_STREAM_INACTIVITY_TIMEOUT_MS = 30 * 6e4;
+var CURSOR_RUN_SETTLE_TIMEOUT_MS = 3e4;
+var CURSOR_CANCEL_TIMEOUT_MS = 1e4;
+var TURN_ABORTED = /* @__PURE__ */ Symbol("cursor-turn-aborted");
 var CURSOR_COMPOSER_CONTEXT_WINDOW = 2e5;
 var CURSOR_CATEGORY_COLORS = {
   input: "#3eeba3",
@@ -10453,6 +10476,7 @@ var CursorManager = class extends CodingAgentManager {
   agent = null;
   activeRun = null;
   activeModel = null;
+  abortActiveTurn = null;
   blockedToolCallIds = /* @__PURE__ */ new Set();
   pendingCursorBlockReason = null;
   historyFilePath;
@@ -10469,7 +10493,27 @@ var CursorManager = class extends CodingAgentManager {
     await mkdir11(dirname5(this.historyFilePath), { recursive: true });
   }
   async interruptActiveTurn() {
-    await this.activeRun?.cancel();
+    await this.cancelRun(this.activeRun);
+    this.abortActiveTurn?.();
+  }
+  async cancelRun(run) {
+    if (!run || run.status !== "running") return;
+    try {
+      const result = await raceWithTimeout(run.cancel(), CURSOR_CANCEL_TIMEOUT_MS);
+      if (result === TIMEOUT) {
+        console.error("[CursorManager] Timed out cancelling Cursor run:", run.id);
+      }
+    } catch (error) {
+      console.error("[CursorManager] Failed to cancel Cursor run:", error);
+    }
+  }
+  dispose() {
+    try {
+      this.agent?.close();
+    } catch (error) {
+      console.error("[CursorManager] Failed to close Cursor agent:", error);
+    }
+    this.agent = null;
   }
   async getHistory() {
     await this.historyFile.flush();
@@ -10521,6 +10565,10 @@ var CursorManager = class extends CodingAgentManager {
     return this.agent;
   }
   async processMessageInternal(request) {
+    let run = null;
+    const aborted = new Promise((resolve4) => {
+      this.abortActiveTurn = () => resolve4(TURN_ABORTED);
+    });
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     const linearForwarder = new LinearEventForwarder(linearSessionId);
     try {
@@ -10531,7 +10579,7 @@ var CursorManager = class extends CodingAgentManager {
         type: "user_message",
         message: request.message
       }, this.historyFile);
-      const run = await agent.send(message, {
+      run = await agent.send(message, {
         model: { id: model },
         mode: request.planMode ? "plan" : "agent",
         onDelta: async (args) => {
@@ -10544,7 +10592,25 @@ var CursorManager = class extends CodingAgentManager {
         await run.cancel();
         throw new Error(this.pendingCursorBlockReason);
       }
-      for await (const event of run.stream()) {
+      const events = run.stream()[Symbol.asyncIterator]();
+      let interrupted = false;
+      while (true) {
+        const nextPromise = events.next();
+        nextPromise.catch(() => {
+        });
+        const next = await raceWithTimeout(
+          Promise.race([nextPromise, aborted]),
+          CURSOR_STREAM_INACTIVITY_TIMEOUT_MS
+        );
+        if (next === TIMEOUT) {
+          throw new Error(`Cursor run stalled: no events for ${CURSOR_STREAM_INACTIVITY_TIMEOUT_MS / 6e4} minutes; cancelling the run`);
+        }
+        if (next === TURN_ABORTED) {
+          interrupted = true;
+          break;
+        }
+        if (next.done) break;
+        const event = next.value;
         this.recordCursorEvent(event);
         if (event.type === "tool_call" && event.status === "running") {
           await this.handleCursorToolCall(cursorToolInputFromMessage(event));
@@ -10553,7 +10619,14 @@ var CursorManager = class extends CodingAgentManager {
           linearForwarder.sendEvent(convertCursorEvent(event, linearSessionId));
         }
       }
-      const result = await run.wait();
+      if (interrupted) {
+        await this.cancelRun(run);
+        return;
+      }
+      const result = await raceWithTimeout(run.wait(), CURSOR_RUN_SETTLE_TIMEOUT_MS);
+      if (result === TIMEOUT) {
+        throw new Error("Cursor run did not report a result after its event stream ended");
+      }
       if (result.status === "error") {
         this.recordHistoryEvent("cursor-error", {
           type: "error",
@@ -10564,11 +10637,13 @@ var CursorManager = class extends CodingAgentManager {
         linearForwarder.flushThoughtAsResponse();
       }
     } catch (error) {
+      await this.cancelRun(run);
       this.recordHistoryEvent("cursor-error", {
         type: "error",
         message: error instanceof Error ? error.message : String(error)
       }, this.historyFile);
     } finally {
+      this.abortActiveTurn = null;
       this.activeRun = null;
       this.activeModel = null;
       this.blockedToolCallIds.clear();
@@ -12305,6 +12380,7 @@ function acceptedEventInCodexTranscript(acceptedEvent, transcript) {
   return getCodexTranscriptUserMessages(transcript).includes(message);
 }
 var LAST_MESSAGE_PREVIEW_MAX = 200;
+var MAX_ACCEPTED_SEND_RESPONSES = 50;
 function isChatActive(chat) {
   return chat.provider.isProcessing() || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
 }
@@ -12463,7 +12539,20 @@ var ChatService = class {
   }
   async sendMessage(chatId, request) {
     const chat = this.requireChat(chatId);
+    if (request.idempotencyKey) {
+      const accepted = chat.acceptedSendResponses.get(request.idempotencyKey);
+      if (accepted) {
+        return accepted;
+      }
+    }
     const result = await chat.provider.enqueueMessage(request);
+    if (request.idempotencyKey) {
+      chat.acceptedSendResponses.set(request.idempotencyKey, result);
+      for (const key of chat.acceptedSendResponses.keys()) {
+        if (chat.acceptedSendResponses.size <= MAX_ACCEPTED_SEND_RESPONSES) break;
+        chat.acceptedSendResponses.delete(key);
+      }
+    }
     const acceptedEvent = createUserMessageEvent(request.message, result.messageId, request.images);
     chat.pendingMessageIds.push(result.messageId);
     chat.acceptedUserEvents.set(result.messageId, acceptedEvent);
@@ -12644,6 +12733,7 @@ var ChatService = class {
       const target = this.chats.get(id);
       if (!target) continue;
       this.chats.delete(id);
+      target.provider.dispose?.();
       await this.deleteHistoryFile(target.persisted);
       await this.publish({ type: "chat.deleted", payload: { chatId: id } });
     }
@@ -12788,6 +12878,7 @@ var ChatService = class {
       provider,
       pendingMessageIds: [],
       acceptedUserEvents: /* @__PURE__ */ new Map(),
+      acceptedSendResponses: /* @__PURE__ */ new Map(),
       activeMessageId: null,
       hasActiveTurn: false,
       observedBranchesByRepo: /* @__PURE__ */ new Map()
@@ -13726,6 +13817,7 @@ var sendMessageSchema = z2.object({
   enableInteractiveTools: z2.boolean().optional(),
   type: z2.string().min(1).optional(),
   merge: z2.boolean().optional(),
+  idempotencyKey: z2.string().min(1).max(128).optional(),
   senderUserId: z2.string().optional(),
   senderEmail: z2.string().optional(),
   senderDisplayName: z2.string().optional()
@@ -14566,7 +14658,16 @@ process.on("uncaughtException", (error) => {
   console.error("[FATAL] Uncaught exception:", error);
   engineLogger.flush().finally(() => process.exit(1));
 });
+function isCursorSdkRejection(reason) {
+  const text = reason instanceof Error ? `${reason.stack ?? ""}
+${reason.message}` : String(reason);
+  return text.includes("@cursor/sdk");
+}
 process.on("unhandledRejection", (reason) => {
+  if (isCursorSdkRejection(reason)) {
+    console.error("[CursorSDK] Unhandled rejection (non-fatal):", reason);
+    return;
+  }
   console.error("[FATAL] Unhandled rejection:", reason);
   engineLogger.flush().finally(() => process.exit(1));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.419",
+  "version": "0.1.421",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",