@episoda/cli 0.2.169 → 0.2.171

package/dist/daemon/daemon-process.js

@@ -2978,7 +2978,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.169",
+      version: "0.2.171",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -7928,10 +7928,12 @@ function getAgentCommandQueue() {
 }
 var AgentCommandQueue = class {
   constructor() {
-    /** Map of sessionId -> PendingCommand */
+    /** Map of sessionId -> FIFO commands */
     this.pendingCommands = /* @__PURE__ */ new Map();
     /** Maximum retry attempts before giving up */
     this.maxRetries = 3;
+    /** Bounded queue depth per session to avoid unbounded backlog */
+    this.maxDepthPerSession = parseInt(process.env.AGENT_COMMAND_QUEUE_MAX_DEPTH || "8", 10);
     /** Command timeout in ms (commands older than this are discarded) */
     this.commandTimeout = 6e4;
     // 1 minute
@@ -7943,25 +7945,36 @@ var AgentCommandQueue = class {
   }
   /**
    * Add a command to the queue before processing.
-   * If a command for this session already exists, it's replaced.
+   * Commands are tracked in FIFO order per session.
    *
    * @param sessionId - Agent session ID
    * @param command - The agent command to execute
    * @param commandId - WebSocket message ID for response routing
    */
   enqueue(sessionId, command, commandId) {
-    const existing = this.pendingCommands.get(sessionId);
-    if (existing) {
-      console.log(`[AgentCommandQueue] EP1237: Replacing existing command for session ${sessionId}`);
+    const queue = this.pendingCommands.get(sessionId) || [];
+    if (queue.length >= this.maxDepthPerSession) {
+      console.warn(
+        `[AgentCommandQueue] EP1398: Queue full for session ${sessionId} (${queue.length}/${this.maxDepthPerSession})`
+      );
+      return {
+        enqueued: false,
+        queueDepth: queue.length,
+        reason: "QUEUE_DEPTH_EXCEEDED"
+      };
     }
-    this.pendingCommands.set(sessionId, {
+    queue.push({
       command,
       commandId,
       receivedAt: Date.now(),
       retryCount: 0,
       state: "pending"
     });
-    console.log(`[AgentCommandQueue] EP1237: Enqueued command for session ${sessionId} (action: ${command.action})`);
+    this.pendingCommands.set(sessionId, queue);
+    console.log(
+      `[AgentCommandQueue] EP1237: Enqueued command for session ${sessionId} (action: ${command.action}, depth: ${queue.length})`
+    );
+    return { enqueued: true, queueDepth: queue.length };
   }
   /**
    * Mark a command as being processed.
@@ -7969,11 +7982,11 @@ var AgentCommandQueue = class {
    *
    * @param sessionId - Agent session ID
    */
-  markProcessing(sessionId) {
-    const pending = this.pendingCommands.get(sessionId);
+  markProcessing(sessionId, commandId) {
+    const pending = this.getCommand(sessionId, commandId);
     if (pending) {
       pending.state = "processing";
-      console.log(`[AgentCommandQueue] EP1237: Marked session ${sessionId} as processing`);
+      console.log(`[AgentCommandQueue] EP1237: Marked session ${sessionId} command ${pending.commandId} as processing`);
     }
   }
   /**
@@ -7981,12 +7994,8 @@ var AgentCommandQueue = class {
    *
    * @param sessionId - Agent session ID
    */
-  complete(sessionId) {
-    const pending = this.pendingCommands.get(sessionId);
-    if (pending) {
-      console.log(`[AgentCommandQueue] EP1237: Completed command for session ${sessionId}`);
-      this.pendingCommands.delete(sessionId);
-    }
+  complete(sessionId, commandId) {
+    this.removeCommand(sessionId, commandId, "completed");
   }
   /**
    * Mark a command as failed (will not be retried).
@@ -7994,13 +8003,13 @@ var AgentCommandQueue = class {
    * @param sessionId - Agent session ID
    * @param error - Error message for logging
    */
-  fail(sessionId, error) {
-    const pending = this.pendingCommands.get(sessionId);
+  fail(sessionId, error, commandId) {
+    const pending = this.getCommand(sessionId, commandId);
     if (pending) {
       pending.state = "failed";
-      console.log(`[AgentCommandQueue] EP1237: Failed command for session ${sessionId}: ${error}`);
-      this.pendingCommands.delete(sessionId);
+      console.log(`[AgentCommandQueue] EP1237: Failed command for session ${sessionId} (${pending.commandId}): ${error}`);
     }
+    this.removeCommand(sessionId, commandId, "failed");
   }
   /**
    * Check if a session has a pending command.
@@ -8009,7 +8018,7 @@ var AgentCommandQueue = class {
    * @returns True if there's a pending or processing command
    */
   has(sessionId) {
-    return this.pendingCommands.has(sessionId);
+    return (this.pendingCommands.get(sessionId)?.length || 0) > 0;
   }
   /**
    * Get a pending command by session ID.
@@ -8018,7 +8027,7 @@ var AgentCommandQueue = class {
    * @returns The pending command or undefined
    */
   get(sessionId) {
-    return this.pendingCommands.get(sessionId);
+    return this.pendingCommands.get(sessionId)?.[0];
   }
   /**
    * Get all commands that need retry after reconnect.
@@ -8032,20 +8041,19 @@ var AgentCommandQueue = class {
   getPendingCommands() {
     const now = Date.now();
     const retryable = [];
-    for (const [sessionId, pending] of this.pendingCommands) {
-      if (pending.state === "completed" || pending.state === "failed") {
-        continue;
-      }
-      if (now - pending.receivedAt > this.commandTimeout) {
-        console.log(`[AgentCommandQueue] EP1237: Command for session ${sessionId} timed out`);
-        this.pendingCommands.delete(sessionId);
-        continue;
-      }
-      if (pending.retryCount >= this.maxRetries) {
-        console.log(`[AgentCommandQueue] EP1237: Command for session ${sessionId} exceeded max retries`);
-        continue;
+    for (const [sessionId, queue] of this.pendingCommands) {
+      for (const pending of queue) {
+        if (pending.state === "completed" || pending.state === "failed") continue;
+        if (now - pending.receivedAt > this.commandTimeout) {
+          console.log(`[AgentCommandQueue] EP1237: Command for session ${sessionId} timed out`);
+          continue;
+        }
+        if (pending.retryCount >= this.maxRetries) {
+          console.log(`[AgentCommandQueue] EP1237: Command for session ${sessionId} exceeded max retries`);
+          continue;
+        }
+        retryable.push(pending);
       }
-      retryable.push(pending);
     }
     return retryable;
   }
@@ -8055,13 +8063,20 @@ var AgentCommandQueue = class {
    *
    * @param sessionId - Agent session ID
    */
-  incrementRetryCount(sessionId) {
-    const pending = this.pendingCommands.get(sessionId);
+  incrementRetryCount(sessionId, commandId) {
+    const pending = this.getCommand(sessionId, commandId);
     if (pending) {
+      if (pending.retryCount >= this.maxRetries) {
+        return false;
+      }
       pending.retryCount++;
       pending.state = "pending";
-      console.log(`[AgentCommandQueue] EP1237: Retry ${pending.retryCount}/${this.maxRetries} for session ${sessionId}`);
+      console.log(
+        `[AgentCommandQueue] EP1237: Retry ${pending.retryCount}/${this.maxRetries} for session ${sessionId} (${pending.commandId})`
+      );
+      return true;
     }
+    return false;
   }
   /**
    * Get commands that have exceeded the retry limit.
@@ -8071,9 +8086,11 @@ var AgentCommandQueue = class {
    */
   getFailedCommands() {
     const failed = [];
-    for (const pending of this.pendingCommands.values()) {
-      if (pending.retryCount >= this.maxRetries && pending.state !== "completed" && pending.state !== "failed") {
-        failed.push(pending);
+    for (const queue of this.pendingCommands.values()) {
+      for (const pending of queue) {
+        if (pending.retryCount >= this.maxRetries && pending.state !== "completed" && pending.state !== "failed") {
+          failed.push(pending);
+        }
       }
     }
     return failed;
@@ -8085,10 +8102,13 @@ var AgentCommandQueue = class {
   cleanup() {
     const now = Date.now();
     let cleaned = 0;
-    for (const [sessionId, pending] of this.pendingCommands) {
-      if (now - pending.receivedAt > this.commandTimeout) {
+    for (const [sessionId, queue] of this.pendingCommands) {
+      const valid3 = queue.filter((pending) => now - pending.receivedAt <= this.commandTimeout);
+      cleaned += queue.length - valid3.length;
+      if (valid3.length === 0) {
         this.pendingCommands.delete(sessionId);
-        cleaned++;
+      } else {
+        this.pendingCommands.set(sessionId, valid3);
       }
     }
     if (cleaned > 0) {
@@ -8105,7 +8125,14 @@ var AgentCommandQueue = class {
    * Get the current queue size.
    */
   size() {
-    return this.pendingCommands.size;
+    let total = 0;
+    for (const queue of this.pendingCommands.values()) {
+      total += queue.length;
+    }
+    return total;
+  }
+  getMaxDepthPerSession() {
+    return this.maxDepthPerSession;
   }
   /**
    * Shutdown the queue (stop cleanup interval).
@@ -8116,7 +8143,29 @@ var AgentCommandQueue = class {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
-    console.log(`[AgentCommandQueue] EP1237: Shutdown with ${this.pendingCommands.size} pending command(s)`);
+    console.log(`[AgentCommandQueue] EP1237: Shutdown with ${this.size()} pending command(s)`);
+  }
+  getCommand(sessionId, commandId) {
+    const queue = this.pendingCommands.get(sessionId);
+    if (!queue || queue.length === 0) return void 0;
+    if (!commandId) return queue[0];
+    return queue.find((pending) => pending.commandId === commandId);
+  }
+  removeCommand(sessionId, commandId, state) {
+    const queue = this.pendingCommands.get(sessionId);
+    if (!queue || queue.length === 0) return;
+    const index = commandId ? queue.findIndex((pending) => pending.commandId === commandId) : 0;
+    if (index < 0) return;
+    const [removed] = queue.splice(index, 1);
+    removed.state = state;
+    console.log(
+      `[AgentCommandQueue] EP1237: ${state} command for session ${sessionId} (${removed.commandId}), depth=${queue.length}`
+    );
+    if (queue.length === 0) {
+      this.pendingCommands.delete(sessionId);
+    } else {
+      this.pendingCommands.set(sessionId, queue);
+    }
   }
 };
 
@@ -14710,8 +14759,24 @@ var Daemon = class _Daemon {
         client.updateActivity();
         const commandQueue = getAgentCommandQueue();
         if (shouldQueueAgentCommandForRetry(cmd.action)) {
-          commandQueue.enqueue(cmd.sessionId, cmd, message.id);
-          commandQueue.markProcessing(cmd.sessionId);
+          const queueResult = commandQueue.enqueue(cmd.sessionId, cmd, message.id);
+          if (!queueResult.enqueued) {
+            const errorMessage = `TURN_IN_PROGRESS: Session queue is full (${queueResult.queueDepth}/${commandQueue.getMaxDepthPerSession()}). Please retry.`;
+            await client.send({
+              type: "agent_result",
+              commandId: message.id,
+              result: {
+                success: false,
+                status: "error",
+                sessionId: cmd.sessionId,
+                seq: this.nextAgentSeq(cmd.sessionId),
+                error: errorMessage
+              }
+            });
+            console.warn(`[Daemon] EP1398: Rejected command due to bounded queue depth for session ${cmd.sessionId}`);
+            return;
+          }
+          commandQueue.markProcessing(cmd.sessionId, message.id);
         }
         let daemonChunkCount = 0;
         let daemonToolUseCount = 0;
@@ -14792,7 +14857,7 @@ var Daemon = class _Daemon {
           onComplete: async (claudeSessionId, resultMetadata) => {
             const duration = Date.now() - daemonStreamStart;
             console.log(`[Daemon] EP1191: Stream complete - ${daemonChunkCount} chunks, ${daemonToolUseCount} tool uses forwarded in ${duration}ms`);
-            commandQueue.complete(sessionId);
+            commandQueue.complete(sessionId, commandId);
             try {
               await client.send({
                 type: "agent_result",
@@ -14806,7 +14871,7 @@ var Daemon = class _Daemon {
           onError: async (error) => {
             const duration = Date.now() - daemonStreamStart;
             console.log(`[Daemon] EP1191: Stream error after ${daemonChunkCount} chunks in ${duration}ms - ${error}`);
-            commandQueue.complete(sessionId);
+            commandQueue.complete(sessionId, commandId);
             try {
               await client.send({
                 type: "agent_result",
@@ -14922,7 +14987,7 @@ var Daemon = class _Daemon {
                 error: errorMsg
               }
             });
-            commandQueue.complete(sessionId);
+            commandQueue.complete(sessionId, message.id);
           } catch (sendError) {
             console.error(`[Daemon] EP1237: Failed to send error result (WebSocket disconnected), command will be retried on reconnect`);
           }
@@ -15480,7 +15545,7 @@ var Daemon = class _Daemon {
             error: `Command failed after ${pending.retryCount} retry attempts during WebSocket reconnection`
           }
         });
-        commandQueue.fail(sessionId, "Max retries exceeded");
+        commandQueue.fail(sessionId, "Max retries exceeded", pending.commandId);
       } catch (sendError) {
         console.error("[Daemon] EP1237: Failed to report max retry failure:", sendError);
       }
@@ -15490,10 +15555,14 @@ var Daemon = class _Daemon {
       const sessionId = cmd.sessionId || "unknown";
       if (pending.retryCount >= commandQueue.getMaxRetries()) {
         console.log(`[Daemon] EP1237: Command for session ${sessionId} will exceed max retries on next attempt`);
-        commandQueue.fail(sessionId, "Max retries exceeded");
+        commandQueue.fail(sessionId, "Max retries exceeded", pending.commandId);
+        continue;
+      }
+      const incremented = commandQueue.incrementRetryCount(sessionId, pending.commandId);
+      if (!incremented) {
+        commandQueue.fail(sessionId, "Max retries exceeded", pending.commandId);
         continue;
       }
-      commandQueue.incrementRetryCount(sessionId);
       console.log(`[Daemon] EP1237: Command for session ${sessionId} ready for retry (attempt ${pending.retryCount + 1}/${commandQueue.getMaxRetries()})`);
     }
   }