replicas-engine 0.1.35 → 0.1.37

package/dist/src/index.js

@@ -716,6 +716,21 @@ var MessageQueue = class {
   clearQueue() {
     this.queue = [];
   }
+  drainQueue(options) {
+    const maxItems = options?.maxItems ?? this.queue.length;
+    const maxChars = options?.maxChars ?? Number.POSITIVE_INFINITY;
+    const drained = [];
+    let totalChars = 0;
+    for (const message of this.queue) {
+      if (drained.length >= maxItems) break;
+      const text = message.message;
+      if (totalChars + text.length > maxChars) break;
+      drained.push(text);
+      totalChars += text.length;
+    }
+    this.queue = [];
+    return drained;
+  }
   /**
    * Reset everything including clearing processing state
    */
@@ -1016,6 +1031,8 @@ var replicasConfigService = new ReplicasConfigService();
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 var DEFAULT_MODEL = "gpt-5.2-codex";
 var CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
+var MAX_INTERRUPT_QUEUE_ITEMS = 1e3;
+var MAX_INTERRUPT_QUEUE_CHARS = 2e5;
 var CodexManager = class {
   codex;
   currentThreadId = null;
@@ -1025,6 +1042,7 @@ var CodexManager = class {
   baseSystemPrompt;
   tempImageDir;
   initialized;
+  activeAbortController = null;
   constructor(workingDirectory) {
     this.codex = new Codex();
     if (workingDirectory) {
@@ -1067,6 +1085,33 @@ var CodexManager = class {
   getQueueStatus() {
     return this.messageQueue.getStatus();
   }
+  async interrupt() {
+    const queue = this.messageQueue.drainQueue({
+      maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
+      maxChars: MAX_INTERRUPT_QUEUE_CHARS
+    });
+    const isProcessing = this.messageQueue.isProcessing();
+    if (isProcessing && this.activeAbortController) {
+      try {
+        this.activeAbortController.abort();
+      } catch {
+      }
+    }
+    const linearSessionId = process.env.LINEAR_SESSION_ID;
+    if (linearSessionId && queue.length > 0) {
+      const body = ["Interrupted. Cleared queue:", ...queue].join("\n");
+      const thoughtEvent = {
+        linearSessionId,
+        content: {
+          type: "thought",
+          body
+        }
+      };
+      monolithService.sendEvent({ type: "agent_update", payload: thoughtEvent }).catch(() => {
+      });
+    }
+    return { interrupted: isProcessing || queue.length > 0, queue };
+  }
   /**
    * Set the base system prompt from replicas.json
    * This will be combined with any custom instructions passed to individual messages
@@ -1172,11 +1217,13 @@ var CodexManager = class {
         model: model || DEFAULT_MODEL,
         webSearchMode: "live"
       };
+      const abortController = new AbortController();
+      this.activeAbortController = abortController;
       if (this.currentThreadId) {
         this.currentThread = this.codex.resumeThread(this.currentThreadId, threadOptions);
       } else {
         this.currentThread = this.codex.startThread(threadOptions);
-        const { events: events2 } = await this.currentThread.runStreamed("Hello");
+        const { events: events2 } = await this.currentThread.runStreamed("Hello", { signal: abortController.signal });
         for await (const event of events2) {
           if (event.type === "thread.started") {
             this.currentThreadId = event.thread_id;
@@ -1200,7 +1247,7 @@ var CodexManager = class {
       } else {
         input = message;
       }
-      const { events } = await this.currentThread.runStreamed(input);
+      const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
       let latestThoughtEvent = null;
       for await (const event of events) {
         if (linearSessionId) {
@@ -1226,6 +1273,7 @@ var CodexManager = class {
         });
       }
     } finally {
+      this.activeAbortController = null;
       const status = await getGitStatus(this.workingDirectory);
       const payload = linearSessionId ? { linearSessionId, status } : { status };
       monolithService.sendEvent({ type: "agent_turn_complete", payload }).catch(() => {
@@ -1514,6 +1562,22 @@ codex.post("/reset", async (c) => {
     );
   }
 });
+codex.post("/interrupt", async (c) => {
+  try {
+    const result = await codexManager.interrupt();
+    const response = result;
+    return c.json(response);
+  } catch (error) {
+    console.error("Error in /codex/interrupt:", error);
+    return c.json(
+      {
+        error: "Failed to interrupt thread",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
 var codex_default = codex;
 
 // src/routes/claude.ts
@@ -1526,6 +1590,46 @@ import {
 import { join as join4 } from "path";
 import { mkdir as mkdir4, appendFile as appendFile2, rm } from "fs/promises";
 import { homedir as homedir4 } from "os";
+var MAX_INTERRUPT_QUEUE_ITEMS2 = 1e3;
+var MAX_INTERRUPT_QUEUE_CHARS2 = 2e5;
+var PromptStream = class {
+  queue = [];
+  closed = false;
+  waiters = [];
+  push(message) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ value: message, done: false });
+      return;
+    }
+    this.queue.push(message);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.waiters) {
+      waiter({ value: void 0, done: true });
+    }
+    this.waiters = [];
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const nextItem = this.queue.shift();
+        if (nextItem) {
+          return Promise.resolve({ value: nextItem, done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this.waiters.push(resolve);
+        });
+      }
+    };
+  }
+};
 var ClaudeManager = class {
   workingDirectory;
   historyFile;
@@ -1533,6 +1637,9 @@ var ClaudeManager = class {
   initialized;
   messageQueue;
   baseSystemPrompt;
+  activeQuery = null;
+  activePromptStream = null;
+  pendingInterrupt = false;
   constructor(workingDirectory) {
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
@@ -1567,6 +1674,37 @@ var ClaudeManager = class {
   getQueueStatus() {
     return this.messageQueue.getStatus();
   }
+  async interrupt() {
+    const queue = this.messageQueue.drainQueue({
+      maxItems: MAX_INTERRUPT_QUEUE_ITEMS2,
+      maxChars: MAX_INTERRUPT_QUEUE_CHARS2
+    });
+    const isProcessing = this.messageQueue.isProcessing();
+    if (isProcessing) {
+      this.pendingInterrupt = true;
+      this.activePromptStream?.close();
+      if (this.activeQuery) {
+        try {
+          await this.activeQuery.interrupt();
+        } catch {
+        }
+      }
+    }
+    const linearSessionId = process.env.LINEAR_SESSION_ID;
+    if (linearSessionId && queue.length > 0) {
+      const body = ["Interrupted. Cleared queue:", ...queue].join("\n");
+      const thoughtEvent = {
+        linearSessionId,
+        content: {
+          type: "thought",
+          body
+        }
+      };
+      monolithService.sendEvent({ type: "agent_update", payload: thoughtEvent }).catch(() => {
+      });
+    }
+    return { interrupted: isProcessing || queue.length > 0, queue };
+  }
   /**
    * Set the base system prompt from replicas.json
    * This will be combined with any custom instructions passed to individual messages
@@ -1640,9 +1778,9 @@ var ClaudeManager = class {
         session_id: this.sessionId ?? ""
       };
       await this.recordEvent(userMessage);
-      const promptIterable = (async function* () {
-        yield userMessage;
-      })();
+      const promptStream = new PromptStream();
+      promptStream.push(userMessage);
+      this.activePromptStream = promptStream;
       const startHooksInstruction = this.getStartHooksInstruction();
       const parts = [];
       if (this.baseSystemPrompt) {
@@ -1656,7 +1794,7 @@ var ClaudeManager = class {
       }
       const combinedInstructions = parts.length > 0 ? parts.join("\n\n") : void 0;
       const response = query({
-        prompt: promptIterable,
+        prompt: promptStream,
         options: {
           resume: this.sessionId || void 0,
           cwd: this.workingDirectory,
@@ -1674,6 +1812,15 @@ var ClaudeManager = class {
           model: model || "opus"
         }
       });
+      this.activeQuery = response;
+      if (this.pendingInterrupt) {
+        this.pendingInterrupt = false;
+        this.activePromptStream?.close();
+        try {
+          await this.activeQuery.interrupt();
+        } catch {
+        }
+      }
       let latestThoughtEvent = null;
       for await (const msg of response) {
         await this.handleMessage(msg);
@@ -1693,6 +1840,9 @@ var ClaudeManager = class {
             }
           }
         }
+        if (msg.type === "result") {
+          this.activePromptStream?.close();
+        }
       }
       if (linearSessionId && latestThoughtEvent) {
         const responseEvent = linearThoughtToResponse(latestThoughtEvent);
@@ -1700,6 +1850,10 @@ var ClaudeManager = class {
         });
       }
     } finally {
+      this.activeQuery = null;
+      this.activePromptStream?.close();
+      this.activePromptStream = null;
+      this.pendingInterrupt = false;
       const status = await getGitStatus(this.workingDirectory);
       const payload = linearSessionId ? { linearSessionId, status } : { status };
       monolithService.sendEvent({ type: "agent_turn_complete", payload }).catch(() => {
@@ -1926,6 +2080,22 @@ claude.post("/reset", async (c) => {
     );
   }
 });
+claude.post("/interrupt", async (c) => {
+  try {
+    const result = await claudeManager.interrupt();
+    const response = result;
+    return c.json(response);
+  } catch (error) {
+    console.error("Error in /claude/interrupt:", error);
+    return c.json(
+      {
+        error: "Failed to interrupt session",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
 var claude_default = claude;
 
 // src/routes/plans.ts
@@ -2111,6 +2281,10 @@ var ClaudeTokenManager = class {
   REFRESH_INTERVAL_MS = 45 * 60 * 1e3;
   // 45 minutes
   async start() {
+    if (process.env.ANTHROPIC_API_KEY) {
+      console.log("[ClaudeTokenManager] Skipping: ANTHROPIC_API_KEY is set");
+      return;
+    }
     const monolithUrl = process.env.MONOLITH_URL;
     const workspaceId = process.env.WORKSPACE_ID;
     const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
@@ -2135,6 +2309,9 @@ var ClaudeTokenManager = class {
     }
   }
   async refreshCredentials() {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return;
+    }
     const monolithUrl = process.env.MONOLITH_URL;
     const workspaceId = process.env.WORKSPACE_ID;
     const engineSecret = process.env.REPLICAS_ENGINE_SECRET;

package/package.json

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