replicas-engine 0.1.16 → 0.1.17

package/dist/src/index.js

@@ -490,13 +490,120 @@ function getGitStatus(workingDirectory) {
   };
 }
 
+// src/services/message-queue.ts
+var MessageQueue = class {
+  queue = [];
+  processing = false;
+  currentMessageId = null;
+  messageIdCounter = 0;
+  processMessage;
+  constructor(processMessage) {
+    this.processMessage = processMessage;
+  }
+  generateMessageId() {
+    return `msg_${Date.now()}_${++this.messageIdCounter}`;
+  }
+  /**
+   * Add a message to the queue or start processing immediately if not busy
+   * @returns Object indicating whether the message was queued or started processing
+   */
+  async enqueue(message, model, customInstructions) {
+    const messageId = this.generateMessageId();
+    const queuedMessage = {
+      id: messageId,
+      message,
+      model,
+      customInstructions,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.processing) {
+      this.queue.push(queuedMessage);
+      return {
+        queued: true,
+        messageId,
+        position: this.queue.length
+      };
+    }
+    this.startProcessing(queuedMessage);
+    return {
+      queued: false,
+      messageId,
+      position: 0
+    };
+  }
+  async startProcessing(queuedMessage) {
+    this.processing = true;
+    this.currentMessageId = queuedMessage.id;
+    try {
+      await this.processMessage(
+        queuedMessage.message,
+        queuedMessage.model,
+        queuedMessage.customInstructions
+      );
+    } catch (error) {
+      console.error("[MessageQueue] Error processing message:", error);
+    } finally {
+      this.processing = false;
+      this.currentMessageId = null;
+      await this.processNextInQueue();
+    }
+  }
+  async processNextInQueue() {
+    const nextMessage = this.queue.shift();
+    if (nextMessage) {
+      await this.startProcessing(nextMessage);
+    }
+  }
+  /**
+   * Check if currently processing a message
+   */
+  isProcessing() {
+    return this.processing;
+  }
+  /**
+   * Get the current queue length
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+  /**
+   * Get full queue status
+   */
+  getStatus() {
+    return {
+      isProcessing: this.processing,
+      queueLength: this.queue.length,
+      currentMessageId: this.currentMessageId,
+      queuedMessages: this.queue.map((msg, index) => ({
+        id: msg.id,
+        queuedAt: msg.queuedAt,
+        position: index + 1
+      }))
+    };
+  }
+  /**
+   * Clear the queue (does not stop current processing)
+   */
+  clearQueue() {
+    this.queue = [];
+  }
+  /**
+   * Reset everything including clearing processing state
+   */
+  reset() {
+    this.queue = [];
+    this.processing = false;
+    this.currentMessageId = null;
+  }
+};
+
 // src/services/codex-manager.ts
 var CodexManager = class {
   codex;
   currentThreadId = null;
   currentThread = null;
   workingDirectory;
-  processing = false;
+  messageQueue;
   constructor(workingDirectory) {
     this.codex = new Codex();
     if (workingDirectory) {
@@ -510,14 +617,38 @@ var CodexManager = class {
         this.workingDirectory = workspaceHome;
       }
     }
+    this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
   }
   isProcessing() {
-    return this.processing;
+    return this.messageQueue.isProcessing();
+  }
+  /**
+   * Enqueue a message for processing. If not currently processing, starts immediately.
+   * If already processing, adds to queue.
+   * @returns Object with queued status, messageId, and position in queue
+   */
+  async enqueueMessage(message, model, customInstructions) {
+    return this.messageQueue.enqueue(message, model, customInstructions);
+  }
+  /**
+   * Get the current queue status
+   */
+  getQueueStatus() {
+    return this.messageQueue.getStatus();
   }
+  /**
+   * Legacy sendMessage method - now uses the queue internally
+   * @deprecated Use enqueueMessage for better control over queue status
+   */
   async sendMessage(message, model, customInstructions) {
+    await this.enqueueMessage(message, model, customInstructions);
+  }
+  /**
+   * Internal method that actually processes the message
+   */
+  async processMessageInternal(message, model, customInstructions) {
     const linearSessionId = process.env.LINEAR_SESSION_ID;
     try {
-      this.processing = true;
       if (!this.currentThread) {
         if (this.currentThreadId) {
           this.currentThread = this.codex.resumeThread(this.currentThreadId, {
@@ -559,7 +690,6 @@ var CodexManager = class {
         }
       }
     } finally {
-      this.processing = false;
       if (linearSessionId) {
         const status = getGitStatus(this.workingDirectory);
         monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
@@ -602,7 +732,7 @@ var CodexManager = class {
   async reset() {
     this.currentThread = null;
     this.currentThreadId = null;
-    this.processing = false;
+    this.messageQueue.reset();
   }
   getThreadId() {
     return this.currentThreadId;
@@ -684,21 +814,15 @@ codex.post("/send", async (c) => {
     if (!message || typeof message !== "string") {
       return c.json({ error: "Message is required and must be a string" }, 400);
     }
-    if (codexManager.isProcessing()) {
-      return c.json(
-        {
-          error: "A turn is already in progress. Please wait."
-        },
-        400
-      );
-    }
-    codexManager.sendMessage(message, model, customInstructions).catch((error) => {
-      console.error("[Codex Route] Error in background message processing:", error);
-    });
-    return c.json({
+    const result = await codexManager.enqueueMessage(message, model, customInstructions);
+    const response = {
       success: true,
-      message: "Message sent successfully"
-    });
+      message: result.queued ? `Message queued at position ${result.position}` : "Message sent successfully",
+      queued: result.queued,
+      messageId: result.messageId,
+      position: result.position
+    };
+    return c.json(response);
   } catch (error) {
     console.error("Error in /codex/send:", error);
     return c.json(
@@ -766,6 +890,21 @@ codex.get("/status", async (c) => {
     );
   }
 });
+codex.get("/queue", async (c) => {
+  try {
+    const queueStatus = codexManager.getQueueStatus();
+    return c.json(queueStatus);
+  } catch (error) {
+    console.error("Error in /codex/queue:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve queue status",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
 codex.post("/reset", async (c) => {
   try {
     await codexManager.reset();
@@ -801,7 +940,7 @@ var ClaudeManager = class {
   historyFile;
   sessionId = null;
   initialized;
-  processing = false;
+  messageQueue;
   constructor(workingDirectory) {
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
@@ -816,17 +955,42 @@ var ClaudeManager = class {
     }
     this.historyFile = join2(homedir2(), ".replicas", "claude", "history.jsonl");
     this.initialized = this.initialize();
+    this.messageQueue = new MessageQueue(this.processMessageInternal.bind(this));
   }
   isProcessing() {
-    return this.processing;
+    return this.messageQueue.isProcessing();
+  }
+  /**
+   * Enqueue a message for processing. If not currently processing, starts immediately.
+   * If already processing, adds to queue.
+   * @returns Object with queued status, messageId, and position in queue
+   */
+  async enqueueMessage(message, model, customInstructions) {
+    await this.initialized;
+    return this.messageQueue.enqueue(message, model, customInstructions);
   }
+  /**
+   * Get the current queue status
+   */
+  getQueueStatus() {
+    return this.messageQueue.getStatus();
+  }
+  /**
+   * Legacy sendMessage method - now uses the queue internally
+   * @deprecated Use enqueueMessage for better control over queue status
+   */
   async sendMessage(message, model, customInstructions) {
+    await this.enqueueMessage(message, model, customInstructions);
+  }
+  /**
+   * Internal method that actually processes the message
+   */
+  async processMessageInternal(message, model, customInstructions) {
     const linearSessionId = process.env.LINEAR_SESSION_ID;
     if (!message || !message.trim()) {
       throw new Error("Message cannot be empty");
     }
     await this.initialized;
-    this.processing = true;
     try {
       const userMessage = {
         type: "user",
@@ -874,7 +1038,6 @@ var ClaudeManager = class {
         }
       }
     } finally {
-      this.processing = false;
       if (linearSessionId) {
         const status = getGitStatus(this.workingDirectory);
         monolithService.sendEvent({ type: "agent_turn_complete", payload: { linearSessionId, status } }).catch(() => {
@@ -893,7 +1056,7 @@ var ClaudeManager = class {
   async getStatus() {
     await this.initialized;
     const status = {
-      has_active_thread: this.processing,
+      has_active_thread: this.messageQueue.isProcessing(),
       thread_id: this.sessionId,
       working_directory: this.workingDirectory
     };
@@ -903,13 +1066,13 @@ var ClaudeManager = class {
     await this.initialized;
     const allEvents = await readJSONL(this.historyFile);
     const events = allEvents.filter((event) => event.timestamp > since);
-    const isComplete = !this.processing;
+    const isComplete = !this.messageQueue.isProcessing();
     return { events, isComplete };
   }
   async reset() {
     await this.initialized;
     this.sessionId = null;
-    this.processing = false;
+    this.messageQueue.reset();
     try {
       await rm(this.historyFile, { force: true });
     } catch {
@@ -946,21 +1109,15 @@ claude.post("/send", async (c) => {
     if (!message || typeof message !== "string") {
       return c.json({ error: "Message is required and must be a string" }, 400);
     }
-    if (claudeManager.isProcessing()) {
-      return c.json(
-        {
-          error: "A turn is already in progress. Please wait."
-        },
-        400
-      );
-    }
-    claudeManager.sendMessage(message, model, customInstructions).catch((error) => {
-      console.error("[Claude Route] Error in background message processing:", error);
-    });
-    return c.json({
+    const result = await claudeManager.enqueueMessage(message, model, customInstructions);
+    const response = {
       success: true,
-      message: "Message sent successfully"
-    });
+      message: result.queued ? `Message queued at position ${result.position}` : "Message sent successfully",
+      queued: result.queued,
+      messageId: result.messageId,
+      position: result.position
+    };
+    return c.json(response);
   } catch (error) {
     console.error("Error in /claude/send:", error);
     return c.json(
@@ -1028,6 +1185,21 @@ claude.get("/status", async (c) => {
     );
   }
 });
+claude.get("/queue", async (c) => {
+  try {
+    const queueStatus = claudeManager.getQueueStatus();
+    return c.json(queueStatus);
+  } catch (error) {
+    console.error("Error in /claude/queue:", error);
+    return c.json(
+      {
+        error: "Failed to retrieve queue status",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
 claude.post("/reset", async (c) => {
   try {
     await claudeManager.reset();

package/package.json

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