replicas-engine 0.1.396 → 0.1.398

package/dist/src/index.js

@@ -484,7 +484,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-04-v3";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-04-v5";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -3261,6 +3261,21 @@ var monolithService = new MonolithService();
 // src/utils/file.ts
 import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
 import { dirname } from "path";
+
+// src/utils/async-lock.ts
+var AsyncLock = class {
+  chain = Promise.resolve();
+  run(operation) {
+    const result = this.chain.then(operation, operation);
+    this.chain = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  async drain() {
+    await this.chain;
+  }
+};
+
+// src/utils/file.ts
 async function atomicWriteFile(path5, data, options) {
   const tmpFile = `${path5}.${process.pid}.${Date.now()}.tmp`;
   try {
@@ -3277,9 +3292,9 @@ async function writeSecureCredentialFile(filePath, content, options) {
   }
   await atomicWriteFile(filePath, content, { mode: 384 });
 }
-var credentialFileQueue = Promise.resolve();
+var credentialFileLock = new AsyncLock();
 function upsertCredentialFileLines(filePath, hosts, lines) {
-  const task = credentialFileQueue.then(async () => {
+  return credentialFileLock.run(async () => {
     let existing = [];
     try {
       existing = (await readFile(filePath, "utf-8")).split("\n").filter(Boolean);
@@ -3289,11 +3304,9 @@ function upsertCredentialFileLines(filePath, hosts, lines) {
     const kept = existing.filter((line) => !hosts.some((host) => line.endsWith(`@${host}`)));
     await writeSecureCredentialFile(filePath, [...lines, ...kept, ""].join("\n"));
   });
-  credentialFileQueue = task.catch(() => void 0);
-  return task;
 }
 function removeCredentialFileLines(filePath, shouldRemove) {
-  const task = credentialFileQueue.then(async () => {
+  return credentialFileLock.run(async () => {
     let existing = [];
     try {
       existing = (await readFile(filePath, "utf-8")).split("\n").filter(Boolean);
@@ -3303,8 +3316,6 @@ function removeCredentialFileLines(filePath, shouldRemove) {
     const kept = existing.filter((line) => !shouldRemove(line));
     await writeSecureCredentialFile(filePath, [...kept, ""].join("\n"));
   });
-  credentialFileQueue = task.catch(() => void 0);
-  return task;
 }
 
 // src/utils/git-identity.ts
@@ -3675,14 +3686,9 @@ var STATE_FILE = join3(STATE_DIR, "engine-state.json");
 var DEFAULT_STATE = {
   repos: {}
 };
-var stateWriteChain = Promise.resolve();
-function enqueueStateWrite(operation) {
-  const result = stateWriteChain.then(operation);
-  stateWriteChain = result.then(() => void 0, () => void 0);
-  return result;
-}
+var stateWriteLock = new AsyncLock();
 async function updateEngineState(updater) {
-  await enqueueStateWrite(async () => {
+  await stateWriteLock.run(async () => {
     await mkdir2(STATE_DIR, { recursive: true });
     const currentState = await loadEngineState();
     const nextState = updater(currentState);
@@ -5951,6 +5957,22 @@ var MessageQueueService = class {
     this.queue = [];
     return true;
   }
+  takeFromQueue(messageId) {
+    const index = this.queue.findIndex((m) => m.id === messageId);
+    if (index === -1) return null;
+    const [message] = this.queue.splice(index, 1);
+    return { message, index };
+  }
+  restoreToQueue(message, index) {
+    const clamped = Math.max(0, Math.min(index, this.queue.length));
+    this.queue.splice(clamped, 0, message);
+  }
+  resumeIfIdle() {
+    if (this.processing || this.queue.length === 0) return;
+    void this.processNextInQueue().catch((error) => {
+      console.error("[MessageQueue] Error resuming idle queue:", error);
+    });
+  }
   /**
    * Move a message to a new position in the queue
    * @returns true if the message was found and moved
@@ -6072,6 +6094,28 @@ var CodingAgentManager = class {
     await this.initialized;
     return this.messageQueue.enqueue(request);
   }
+  // Take the message off the queue before steering: a turn completing mid-steer could otherwise pop it too.
+  async steerFromQueue(messageId) {
+    await this.initialized;
+    const taken = this.messageQueue.takeFromQueue(messageId);
+    if (!taken) {
+      return { success: false, queue: this.getQueue() };
+    }
+    let steered = false;
+    try {
+      steered = await this.steerRequest(taken.message);
+    } catch (error) {
+      console.error("[CodingAgentManager] steerRequest threw, keeping message queued:", error);
+    }
+    if (!steered) {
+      this.messageQueue.restoreToQueue(taken.message, taken.index);
+      this.messageQueue.resumeIfIdle();
+    }
+    return { success: steered, queue: this.getQueue() };
+  }
+  steerRequest(_request) {
+    return Promise.resolve(false);
+  }
   emitContextUsage(payload) {
     const event = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6574,15 +6618,17 @@ var CodexHistoryFile = class {
     this.filePath = filePath;
   }
   filePath;
-  writeChain = Promise.resolve();
+  writeLock = new AsyncLock();
   /** Best-effort ordered append; failures must not disrupt the turn. */
   append(event) {
-    this.writeChain = this.writeChain.then(() => appendFile2(this.filePath, JSON.stringify(event) + "\n", "utf-8")).catch((error) => {
-      console.error("[CodexHistoryFile] Failed to append event:", error);
-    });
+    void this.writeLock.run(
+      () => appendFile2(this.filePath, JSON.stringify(event) + "\n", "utf-8").catch((error) => {
+        console.error("[CodexHistoryFile] Failed to append event:", error);
+      })
+    );
   }
   async flush() {
-    await this.writeChain;
+    await this.writeLock.drain();
   }
   async load() {
     try {
@@ -7893,7 +7939,7 @@ var AspClient = class {
 // 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.396";
+var ENGINE_PACKAGE_VERSION = "0.1.398";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -8146,6 +8192,7 @@ var THREAD_GOAL_CLEAR_METHOD = "thread/goal/clear";
 var THREAD_SETTINGS_UPDATE_METHOD = "thread/settings/update";
 var TURN_START_METHOD = "turn/start";
 var TURN_INTERRUPT_METHOD = "turn/interrupt";
+var TURN_STEER_METHOD = "turn/steer";
 var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
 var MODEL_LIST_METHOD = "model/list";
 var SKILLS_LIST_METHOD = "skills/list";
@@ -8759,6 +8806,8 @@ var CodexAspManager = class extends CodingAgentManager {
   activeServiceTier;
   slashCommandsCache = null;
   slashCommandsRequest = null;
+  steeredTempImagePaths = [];
+  steerLock = new AsyncLock();
   constructor(options) {
     super(options);
     this.historyFile = options.historyFilePath ? new CodexHistoryFile(options.historyFilePath) : null;
@@ -8789,6 +8838,36 @@ var CodexAspManager = class extends CodingAgentManager {
       console.warn("[CodexAspManager] Failed to interrupt active turn:", error);
     }
   }
+  // Serialize so concurrent steers can't race one `turn/steer` RPC ahead of another.
+  steerRequest(request) {
+    return this.steerLock.run(() => this.steerActiveTurnLocked(request));
+  }
+  async steerActiveTurnLocked(request) {
+    const threadId = this.currentThreadId;
+    const expectedTurnId = this.activeTurnId;
+    if (!threadId || !expectedTurnId || !this.messageQueue.isProcessing()) return false;
+    if (this.isCompacting()) return false;
+    if (getGoalCommand(request.message, request.goalMode)) return false;
+    const { input, tempImagePaths } = await buildTurnInput(request);
+    try {
+      const host = await getCodexAspHost();
+      await host.client.request(
+        TURN_STEER_METHOD,
+        { threadId, expectedTurnId, input }
+      );
+    } catch (error) {
+      await removeTempImageFiles(tempImagePaths);
+      console.warn("[CodexAspManager] Failed to steer active turn, keeping message queued:", error);
+      return false;
+    }
+    if (this.activeTurnId === expectedTurnId) {
+      this.steeredTempImagePaths.push(...tempImagePaths);
+    } else {
+      await removeTempImageFiles(tempImagePaths);
+    }
+    this.recordUserMessageEvent(request);
+    return true;
+  }
   async getHistory() {
     if (!this.currentThreadId) {
       return { thread_id: null, events: [], goal: null };
@@ -8879,18 +8958,21 @@ var CodexAspManager = class extends CodingAgentManager {
     this.recordGoalChange(null, true);
     return null;
   }
+  recordUserMessageEvent(request, extraPayload = {}) {
+    const images = imageContentToUserMessageImages(request.images);
+    this.recordHistoryEvent("event_msg", {
+      type: "user_message",
+      message: request.message,
+      ...images ? { images } : {},
+      ...extraPayload
+    });
+  }
   async processMessageInternal(request) {
     let userMessageRecorded = false;
     const recordUserMessage = (extraPayload = {}) => {
       if (userMessageRecorded) return;
       userMessageRecorded = true;
-      const images = imageContentToUserMessageImages(request.images);
-      this.recordHistoryEvent("event_msg", {
-        type: "user_message",
-        message: request.message,
-        ...images ? { images } : {},
-        ...extraPayload
-      });
+      this.recordUserMessageEvent(request, extraPayload);
     };
     const goalCommand = getGoalCommand(request.message, request.goalMode);
     const dispatch = async () => {
@@ -8924,6 +9006,7 @@ var CodexAspManager = class extends CodingAgentManager {
       this.transcriptUpdateCoalescer.flushPending();
       this.transcriptUpdateCoalescer.dispose();
       this.activeTurnId = null;
+      await removeTempImageFiles(this.steeredTempImagePaths.splice(0));
       await this.historyFile?.flush();
       await this.onTurnComplete();
     }
@@ -11129,6 +11212,9 @@ var RelayManager = class {
   reorderQueue(messageId, newPosition) {
     return this.inner.reorderQueue(messageId, newPosition);
   }
+  steerFromQueue(messageId) {
+    return this.inner.steerFromQueue(messageId);
+  }
 };
 
 // src/services/keep-alive-service.ts
@@ -11808,6 +11894,10 @@ var ChatService = class {
       queue: chat.provider.getQueue()
     };
   }
+  steerFromQueue(chatId, messageId) {
+    const chat = this.requireChat(chatId);
+    return chat.provider.steerFromQueue(messageId);
+  }
   async respondToToolInput(chatId, requestId, selectionId) {
     const chat = this.requireChat(chatId);
     if (!chat.provider.respondToToolInput) {
@@ -13162,6 +13252,17 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to remove from queue", error instanceof Error ? error.message : "Unknown error"), 500);
     }
   });
+  app2.post("/chats/:chatId/queue/:messageId/steer", async (c) => {
+    try {
+      const result = await deps.chatService.steerFromQueue(c.req.param("chatId"), c.req.param("messageId"));
+      return c.json(result);
+    } catch (error) {
+      if (error instanceof ChatNotFoundError) {
+        return c.json(jsonError("Chat not found", error.message), 404);
+      }
+      return c.json(jsonError("Failed to steer queued message", error instanceof Error ? error.message : "Unknown error"), 500);
+    }
+  });
   app2.patch("/chats/:chatId/queue/reorder", async (c) => {
     try {
       const body = await c.req.json();

package/package.json

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