replicas-engine 0.1.16 → 0.1.18

package/dist/src/index.js

@@ -384,7 +384,7 @@ function convertCodexEvent(event, linearSessionId) {
 
 // src/utils/git.ts
 import { execSync } from "child_process";
-var cachedPrUrl = null;
+var cachedPr = null;
 function runGitCommand(command, cwd) {
   return execSync(command, {
     cwd,
@@ -443,16 +443,17 @@ function getGitDiff(cwd) {
   }
 }
 function getPullRequestUrl(cwd) {
-  if (cachedPrUrl) {
-    return cachedPrUrl;
-  }
   try {
-    const branch = getCurrentBranch(cwd);
-    if (!branch) {
+    const currentBranch = getCurrentBranch(cwd);
+    if (!currentBranch) {
       return null;
     }
+    if (cachedPr && cachedPr.branch === currentBranch) {
+      return cachedPr.prUrl;
+    }
+    cachedPr = null;
     try {
-      const remoteRef = execSync(`git ls-remote --heads origin ${branch}`, {
+      const remoteRef = execSync(`git ls-remote --heads origin ${currentBranch}`, {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -470,8 +471,11 @@ function getPullRequestUrl(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
       if (prInfo) {
-        cachedPrUrl = prInfo;
-        return cachedPrUrl;
+        cachedPr = {
+          prUrl: prInfo,
+          branch: currentBranch
+        };
+        return cachedPr.prUrl;
       }
     } catch {
       return null;
@@ -490,13 +494,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 +621,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 +694,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 +736,7 @@ var CodexManager = class {
   async reset() {
     this.currentThread = null;
     this.currentThreadId = null;
-    this.processing = false;
+    this.messageQueue.reset();
   }
   getThreadId() {
     return this.currentThreadId;
@@ -684,21 +818,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 +894,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 +944,7 @@ var ClaudeManager = class {
   historyFile;
   sessionId = null;
   initialized;
-  processing = false;
+  messageQueue;
   constructor(workingDirectory) {
     if (workingDirectory) {
       this.workingDirectory = workingDirectory;
@@ -816,17 +959,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 +1042,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 +1060,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 +1070,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 +1113,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 +1189,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();
@@ -1128,9 +1304,186 @@ var GitHubTokenManager = class {
 };
 var githubTokenManager = new GitHubTokenManager();
 
+// src/services/claude-token-manager.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var ClaudeTokenManager = class {
+  refreshInterval = null;
+  REFRESH_INTERVAL_MS = 45 * 60 * 1e3;
+  // 45 minutes
+  async start() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[ClaudeTokenManager] Skipping: missing MONOLITH_URL, WORKSPACE_ID, or REPLICAS_ENGINE_SECRET");
+      return;
+    }
+    console.log("[ClaudeTokenManager] Starting token refresh service");
+    await this.refreshCredentials();
+    this.refreshInterval = setInterval(() => {
+      this.refreshCredentials().catch((error) => {
+        console.error("[ClaudeTokenManager] Scheduled refresh failed:", error);
+      });
+    }, this.REFRESH_INTERVAL_MS);
+    console.log("[ClaudeTokenManager] Token refresh scheduled every 45 minutes");
+  }
+  stop() {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = null;
+      console.log("[ClaudeTokenManager] Stopped");
+    }
+  }
+  async refreshCredentials() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[ClaudeTokenManager] Refresh skipped: missing configuration");
+      return;
+    }
+    console.log("[ClaudeTokenManager] Refreshing Claude credentials...");
+    try {
+      const response = await fetch(`${monolithUrl}/v1/engine/claude/refresh-credentials`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${engineSecret}`,
+          "X-Workspace-Id": workspaceId,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Credentials refresh failed: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      await this.updateClaudeCredentials(data);
+      console.log(`[ClaudeTokenManager] Credentials refreshed successfully, expires at ${data.expiresAt}`);
+    } catch (error) {
+      console.error("[ClaudeTokenManager] Failed to refresh credentials:", error);
+    }
+  }
+  async updateClaudeCredentials(credentials) {
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
+    if (!workspaceHome) {
+      console.warn("[ClaudeTokenManager] No WORKSPACE_HOME or HOME set, skipping credentials update");
+      return;
+    }
+    const claudeDir = path2.join(workspaceHome, ".claude");
+    const credentialsPath = path2.join(claudeDir, ".credentials.json");
+    const claudeCliConfig = {
+      claudeAiOauth: {
+        accessToken: credentials.accessToken,
+        refreshToken: credentials.refreshToken,
+        expiresAt: new Date(credentials.expiresAt).getTime(),
+        scopes: credentials.scopes,
+        subscriptionType: credentials.subscriptionType
+      }
+    };
+    try {
+      await fs2.mkdir(claudeDir, { recursive: true, mode: 448 });
+      await fs2.writeFile(credentialsPath, JSON.stringify(claudeCliConfig, null, 2), { mode: 384 });
+      console.log(`[ClaudeTokenManager] Updated ${credentialsPath}`);
+    } catch (error) {
+      console.error("[ClaudeTokenManager] Failed to update credentials file:", error);
+    }
+  }
+};
+var claudeTokenManager = new ClaudeTokenManager();
+
+// src/services/codex-token-manager.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+var CodexTokenManager = class {
+  refreshInterval = null;
+  REFRESH_INTERVAL_MS = 45 * 60 * 1e3;
+  // 45 minutes
+  async start() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[CodexTokenManager] Skipping: missing MONOLITH_URL, WORKSPACE_ID, or REPLICAS_ENGINE_SECRET");
+      return;
+    }
+    console.log("[CodexTokenManager] Starting token refresh service");
+    await this.refreshCredentials();
+    this.refreshInterval = setInterval(() => {
+      this.refreshCredentials().catch((error) => {
+        console.error("[CodexTokenManager] Scheduled refresh failed:", error);
+      });
+    }, this.REFRESH_INTERVAL_MS);
+    console.log("[CodexTokenManager] Token refresh scheduled every 45 minutes");
+  }
+  stop() {
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = null;
+      console.log("[CodexTokenManager] Stopped");
+    }
+  }
+  async refreshCredentials() {
+    const monolithUrl = process.env.MONOLITH_URL;
+    const workspaceId = process.env.WORKSPACE_ID;
+    const engineSecret = process.env.REPLICAS_ENGINE_SECRET;
+    if (!monolithUrl || !workspaceId || !engineSecret) {
+      console.log("[CodexTokenManager] Refresh skipped: missing configuration");
+      return;
+    }
+    console.log("[CodexTokenManager] Refreshing Codex credentials...");
+    try {
+      const response = await fetch(`${monolithUrl}/v1/engine/codex/refresh-credentials`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${engineSecret}`,
+          "X-Workspace-Id": workspaceId,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Credentials refresh failed: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      await this.updateCodexCredentials(data);
+      console.log(`[CodexTokenManager] Credentials refreshed successfully, expires at ${data.expiresAt}`);
+    } catch (error) {
+      console.error("[CodexTokenManager] Failed to refresh credentials:", error);
+    }
+  }
+  async updateCodexCredentials(credentials) {
+    const workspaceHome = process.env.WORKSPACE_HOME || process.env.HOME;
+    if (!workspaceHome) {
+      console.warn("[CodexTokenManager] No WORKSPACE_HOME or HOME set, skipping credentials update");
+      return;
+    }
+    const codexDir = path3.join(workspaceHome, ".codex");
+    const authPath = path3.join(codexDir, "auth.json");
+    const codexAuthConfig = {
+      OPENAI_API_KEY: null,
+      tokens: {
+        id_token: credentials.idToken,
+        access_token: credentials.accessToken,
+        refresh_token: credentials.refreshToken,
+        account_id: credentials.accountId
+      },
+      last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await fs3.mkdir(codexDir, { recursive: true, mode: 448 });
+      await fs3.writeFile(authPath, JSON.stringify(codexAuthConfig, null, 2), { mode: 384 });
+      console.log(`[CodexTokenManager] Updated ${authPath}`);
+    } catch (error) {
+      console.error("[CodexTokenManager] Failed to update credentials file:", error);
+    }
+  }
+};
+var codexTokenManager = new CodexTokenManager();
+
 // src/services/git-init.ts
 import { existsSync } from "fs";
-import path2 from "path";
+import path4 from "path";
 var initializedBranch = null;
 function findAvailableBranchName(baseName, cwd) {
   if (!branchExists(baseName, cwd)) {
@@ -1164,7 +1517,7 @@ async function initializeGitRepository() {
       error: "No WORKSPACE_NAME environment variable set"
     };
   }
-  const repoPath = path2.join(workspaceHome, "workspaces", repoName);
+  const repoPath = path4.join(workspaceHome, "workspaces", repoName);
   if (!existsSync(repoPath)) {
     console.log(`[GitInit] Repository directory does not exist: ${repoPath}`);
     console.log("[GitInit] Waiting for initializer to clone the repository...");
@@ -1173,7 +1526,7 @@ async function initializeGitRepository() {
       branch: null
     };
   }
-  if (!existsSync(path2.join(repoPath, ".git"))) {
+  if (!existsSync(path4.join(repoPath, ".git"))) {
     return {
       success: false,
       branch: null,
@@ -1296,6 +1649,8 @@ serve(
       console.warn(`Git initialization warning: ${gitResult.error}`);
     }
     await githubTokenManager.start();
+    await claudeTokenManager.start();
+    await codexTokenManager.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.16",
+  "version": "0.1.18",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",