replicas-engine 0.1.15 → 0.1.17

package/dist/src/index.js

@@ -5,6 +5,7 @@ import "dotenv/config";
 import { serve } from "@hono/node-server";
 import { Hono as Hono3 } from "hono";
 import { readFile as readFile2 } from "fs/promises";
+import { execSync as execSync2 } from "child_process";
 
 // src/middleware/auth.ts
 var authMiddleware = async (c, next) => {
@@ -218,25 +219,25 @@ function convertCodexEvent(event, linearSessionId) {
     const item = event.item;
     if (!item) return null;
     if (item.type === "agent_message") {
-      const content = "content" in item ? String(item.content || "") : "";
-      if (content) {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
         return {
           linearSessionId,
           content: {
             type: "thought",
-            body: content
+            body: text
           }
         };
       }
     }
     if (item.type === "reasoning") {
-      const content = "content" in item ? String(item.content || "") : "";
-      if (content) {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
         return {
           linearSessionId,
           content: {
             type: "thought",
-            body: content
+            body: text
           }
         };
       }
@@ -253,23 +254,24 @@ function convertCodexEvent(event, linearSessionId) {
       };
     }
     if (item.type === "file_change") {
-      const filePath = "file_path" in item ? String(item.file_path || "") : "";
+      const changes = "changes" in item && Array.isArray(item.changes) ? item.changes : [];
+      const paths = changes.map((c) => c.path || "").filter(Boolean);
       return {
         linearSessionId,
         content: {
           type: "action",
           action: "File change",
-          parameter: filePath
+          parameter: paths.join(", ") || ""
         }
       };
     }
     if (item.type === "mcp_tool_call") {
-      const toolName = "tool_name" in item ? String(item.tool_name || "") : "";
+      const tool = "tool" in item ? String(item.tool || "") : "";
       return {
         linearSessionId,
         content: {
           type: "action",
-          action: toolName || "Tool call",
+          action: tool || "MCP tool call",
           parameter: ""
         }
       };
@@ -299,45 +301,45 @@ function convertCodexEvent(event, linearSessionId) {
   if (event.type === "item.completed") {
     const item = event.item;
     if (!item) return null;
-    const getResult = () => {
-      if ("output" in item && item.output) return String(item.output);
-      if ("result" in item && item.result) return String(item.result);
-      if ("exit_code" in item) return `Exit code: ${item.exit_code}`;
-      return "Done";
-    };
     if (item.type === "command_execution") {
       const command = "command" in item ? String(item.command || "") : "";
+      const output = "aggregated_output" in item ? String(item.aggregated_output || "") : "";
+      const exitCode = "exit_code" in item ? item.exit_code : void 0;
+      const result = exitCode !== void 0 ? `Exit code: ${exitCode}` : output || "Done";
       return {
         linearSessionId,
         content: {
           type: "action",
           action: "Running command",
           parameter: command,
-          result: getResult()
+          result
         }
       };
     }
     if (item.type === "file_change") {
-      const filePath = "file_path" in item ? String(item.file_path || "") : "";
+      const changes = "changes" in item && Array.isArray(item.changes) ? item.changes : [];
+      const paths = changes.map((c) => c.path || "").filter(Boolean);
+      const status = "status" in item ? String(item.status || "") : "";
       return {
         linearSessionId,
         content: {
           type: "action",
           action: "File change",
-          parameter: filePath,
-          result: getResult()
+          parameter: paths.join(", ") || "",
+          result: status === "completed" ? "Done" : status || "Done"
         }
       };
     }
     if (item.type === "mcp_tool_call") {
-      const toolName = "tool_name" in item ? String(item.tool_name || "") : "";
+      const tool = "tool" in item ? String(item.tool || "") : "";
+      const status = "status" in item ? String(item.status || "") : "";
       return {
         linearSessionId,
         content: {
           type: "action",
-          action: toolName || "Tool call",
+          action: tool || "MCP tool call",
           parameter: "",
-          result: getResult()
+          result: status === "completed" ? "Done" : status || "Done"
         }
       };
     }
@@ -349,7 +351,7 @@ function convertCodexEvent(event, linearSessionId) {
           type: "action",
           action: "Web search",
           parameter: query2,
-          result: getResult()
+          result: "Done"
         }
       };
     }
@@ -360,18 +362,18 @@ function convertCodexEvent(event, linearSessionId) {
           type: "action",
           action: "Updating plan",
           parameter: "",
-          result: getResult()
+          result: "Done"
         }
       };
     }
     if (item.type === "agent_message") {
-      const content = "content" in item ? String(item.content || "") : "";
-      if (content) {
+      const text = "text" in item ? String(item.text || "") : "";
+      if (text) {
         return {
           linearSessionId,
           content: {
             type: "thought",
-            body: content
+            body: text
           }
         };
       }
@@ -488,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) {
@@ -508,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, {
@@ -557,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(() => {
@@ -600,7 +732,7 @@ var CodexManager = class {
   async reset() {
     this.currentThread = null;
     this.currentThreadId = null;
-    this.processing = false;
+    this.messageQueue.reset();
   }
   getThreadId() {
     return this.currentThreadId;
@@ -682,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(
@@ -764,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();
@@ -799,7 +940,7 @@ var ClaudeManager = class {
   historyFile;
   sessionId = null;
   initialized;
-  processing = false;
+  messageQueue;
   constructor(workingDirectory) {
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
@@ -814,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",
@@ -872,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(() => {
@@ -891,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
     };
@@ -901,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 {
@@ -944,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(
@@ -1026,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();
@@ -1216,6 +1390,15 @@ async function initializeGitRepository() {
 // src/index.ts
 var READY_MESSAGE = "========= REPLICAS WORKSPACE READY ==========";
 var COMPLETION_MESSAGE = "========= REPLICAS WORKSPACE INITIALIZATION COMPLETE ==========";
+function checkActiveSSHSessions() {
+  try {
+    const output = execSync2('who | grep -v "^$" | wc -l', { encoding: "utf-8" });
+    const sessionCount = parseInt(output.trim(), 10);
+    return sessionCount > 0;
+  } catch {
+    return false;
+  }
+}
 var app = new Hono3();
 app.get("/health", async (c) => {
   try {
@@ -1243,11 +1426,13 @@ app.get("/status", async (c) => {
     const isClaudeUsed = claudeHistory.thread_id !== null;
     const claudeStatus = await claudeManager.getStatus();
     const workingDirectory = claudeStatus.working_directory;
+    const hasActiveSSHSessions = checkActiveSSHSessions();
     return c.json({
       isCodexProcessing,
       isClaudeProcessing,
       isCodexUsed,
       isClaudeUsed,
+      hasActiveSSHSessions,
       ...getGitStatus(workingDirectory),
       linearBetaEnabled: true
       // TODO: delete
@@ -1283,5 +1468,7 @@ serve(
       console.warn(`Git initialization warning: ${gitResult.error}`);
     }
     await githubTokenManager.start();
+    const monolithService2 = new MonolithService();
+    await monolithService2.sendEvent({ type: "workspace_ready", payload: {} });
   }
 );

package/package.json

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