episoda 0.2.115 → 0.2.118

package/dist/daemon/daemon-process.js

@@ -2815,7 +2815,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.114",
+      version: "0.2.117",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8939,9 +8939,19 @@ If changes are needed, explain what needs to be done.`;
           session.claudeSessionId = resumeSessionId;
         }
         const mcpServersToRegister = this.getMcpServersForSession(session);
-        for (const mcpServer of mcpServersToRegister) {
-          args.push("--mcp", ...mcpServer.command.split(" "));
-          console.log(`[AgentManager] EP1233: Registering MCP server: ${mcpServer.name}`);
+        if (mcpServersToRegister.length > 0) {
+          const mcpConfig = {};
+          for (const mcpServer of mcpServersToRegister) {
+            const parts = mcpServer.command.split(" ");
+            mcpConfig[mcpServer.name] = {
+              command: parts[0],
+              args: parts.slice(1)
+            };
+            console.log(`[AgentManager] EP1233: Registering MCP server: ${mcpServer.name}`);
+          }
+          const mcpConfigJson = JSON.stringify({ mcpServers: mcpConfig });
+          args.push("--mcp-config", mcpConfigJson);
+          console.log(`[AgentManager] EP1233: MCP config: ${mcpConfigJson}`);
         }
         args.push("--", message);
       }
@@ -9323,6 +9333,48 @@ If changes are needed, explain what needs to be done.`;
   getAllSessions() {
     return Array.from(this.sessions.values());
   }
+  /**
+   * EP1237: Get all active sessions with their current status
+   * Used for reconciliation after WebSocket reconnection.
+   *
+   * Returns session info needed for server to compare with DB state:
+   * - sessionId: Local session identifier
+   * - moduleId: Module UUID for DB lookup
+   * - moduleUid: Module UID for logging
+   * - status: Current local status
+   * - agentSessionId: Provider's session ID for resume
+   * - lastActivityAt: For staleness detection
+   */
+  getActiveSessionsForReconciliation() {
+    const result = [];
+    for (const [sessionId, session] of this.sessions) {
+      let reconStatus;
+      switch (session.status) {
+        case "starting":
+        case "running":
+          reconStatus = "running";
+          break;
+        case "stopping":
+        case "stopped":
+          reconStatus = "idle";
+          break;
+        case "error":
+          reconStatus = "error";
+          break;
+        default:
+          reconStatus = "idle";
+      }
+      result.push({
+        sessionId,
+        moduleId: session.moduleId,
+        moduleUid: session.moduleUid,
+        status: reconStatus,
+        agentSessionId: session.agentSessionId || session.claudeSessionId,
+        lastActivityAt: session.lastActivityAt
+      });
+    }
+    return result;
+  }
   /**
    * Check if a session exists
    */
@@ -9386,6 +9438,208 @@ If changes are needed, explain what needs to be done.`;
   }
 };
 
+// src/agent/agent-command-queue.ts
+var instance4 = null;
+function getAgentCommandQueue() {
+  if (!instance4) {
+    instance4 = new AgentCommandQueue();
+  }
+  return instance4;
+}
+var AgentCommandQueue = class {
+  constructor() {
+    /** Map of sessionId -> PendingCommand */
+    this.pendingCommands = /* @__PURE__ */ new Map();
+    /** Maximum retry attempts before giving up */
+    this.maxRetries = 3;
+    /** Command timeout in ms (commands older than this are discarded) */
+    this.commandTimeout = 6e4;
+    // 1 minute
+    /** Cleanup interval handle */
+    this.cleanupInterval = null;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanup();
+    }, 3e4);
+  }
+  /**
+   * Add a command to the queue before processing.
+   * If a command for this session already exists, it's replaced.
+   *
+   * @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}`);
+    }
+    this.pendingCommands.set(sessionId, {
+      command,
+      commandId,
+      receivedAt: Date.now(),
+      retryCount: 0,
+      state: "pending"
+    });
+    console.log(`[AgentCommandQueue] EP1237: Enqueued command for session ${sessionId} (action: ${command.action})`);
+  }
+  /**
+   * Mark a command as being processed.
+   * This prevents duplicate processing attempts.
+   *
+   * @param sessionId - Agent session ID
+   */
+  markProcessing(sessionId) {
+    const pending = this.pendingCommands.get(sessionId);
+    if (pending) {
+      pending.state = "processing";
+      console.log(`[AgentCommandQueue] EP1237: Marked session ${sessionId} as processing`);
+    }
+  }
+  /**
+   * Remove a command from the queue after successful completion.
+   *
+   * @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);
+    }
+  }
+  /**
+   * Mark a command as failed (will not be retried).
+   *
+   * @param sessionId - Agent session ID
+   * @param error - Error message for logging
+   */
+  fail(sessionId, error) {
+    const pending = this.pendingCommands.get(sessionId);
+    if (pending) {
+      pending.state = "failed";
+      console.log(`[AgentCommandQueue] EP1237: Failed command for session ${sessionId}: ${error}`);
+      this.pendingCommands.delete(sessionId);
+    }
+  }
+  /**
+   * Check if a session has a pending command.
+   *
+   * @param sessionId - Agent session ID
+   * @returns True if there's a pending or processing command
+   */
+  has(sessionId) {
+    return this.pendingCommands.has(sessionId);
+  }
+  /**
+   * Get a pending command by session ID.
+   *
+   * @param sessionId - Agent session ID
+   * @returns The pending command or undefined
+   */
+  get(sessionId) {
+    return this.pendingCommands.get(sessionId);
+  }
+  /**
+   * Get all commands that need retry after reconnect.
+   * Returns commands that are:
+   * - In 'pending' or 'processing' state (processing may have failed mid-way)
+   * - Within the retry limit
+   * - Not timed out
+   *
+   * @returns Array of pending commands eligible for retry
+   */
+  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;
+      }
+      retryable.push(pending);
+    }
+    return retryable;
+  }
+  /**
+   * Increment the retry count for a command.
+   * Call this before retrying a command.
+   *
+   * @param sessionId - Agent session ID
+   */
+  incrementRetryCount(sessionId) {
+    const pending = this.pendingCommands.get(sessionId);
+    if (pending) {
+      pending.retryCount++;
+      pending.state = "pending";
+      console.log(`[AgentCommandQueue] EP1237: Retry ${pending.retryCount}/${this.maxRetries} for session ${sessionId}`);
+    }
+  }
+  /**
+   * Get commands that have exceeded the retry limit.
+   * These should be reported as permanently failed.
+   *
+   * @returns Array of commands that exceeded retry limit
+   */
+  getFailedCommands() {
+    const failed = [];
+    for (const pending of this.pendingCommands.values()) {
+      if (pending.retryCount >= this.maxRetries && pending.state !== "completed" && pending.state !== "failed") {
+        failed.push(pending);
+      }
+    }
+    return failed;
+  }
+  /**
+   * Clean up stale commands (older than timeout).
+   * Called periodically and on reconnect.
+   */
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [sessionId, pending] of this.pendingCommands) {
+      if (now - pending.receivedAt > this.commandTimeout) {
+        this.pendingCommands.delete(sessionId);
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      console.log(`[AgentCommandQueue] EP1237: Cleaned up ${cleaned} stale command(s)`);
+    }
+  }
+  /**
+   * Get the maximum number of retries.
+   */
+  getMaxRetries() {
+    return this.maxRetries;
+  }
+  /**
+   * Get the current queue size.
+   */
+  size() {
+    return this.pendingCommands.size;
+  }
+  /**
+   * Shutdown the queue (stop cleanup interval).
+   * Call this when the daemon is shutting down.
+   */
+  shutdown() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    console.log(`[AgentCommandQueue] EP1237: Shutdown with ${this.pendingCommands.size} pending command(s)`);
+  }
+};
+
 // src/utils/dev-server.ts
 var import_child_process13 = require("child_process");
 var import_core11 = __toESM(require_dist());
@@ -10697,6 +10951,11 @@ var Daemon = class _Daemon {
         const cmd = message.command;
         console.log(`[Daemon] EP912: Received agent command for ${projectId}:`, cmd.action);
         client.updateActivity();
+        const commandQueue = getAgentCommandQueue();
+        if (cmd.action === "start" || cmd.action === "message") {
+          commandQueue.enqueue(cmd.sessionId, cmd, message.id);
+          commandQueue.markProcessing(cmd.sessionId);
+        }
         let daemonChunkCount = 0;
         let daemonToolUseCount = 0;
         const daemonStreamStart = Date.now();
@@ -10738,6 +10997,7 @@ var Daemon = class _Daemon {
           onComplete: async (claudeSessionId) => {
             const duration = Date.now() - daemonStreamStart;
             console.log(`[Daemon] EP1191: Stream complete - ${daemonChunkCount} chunks, ${daemonToolUseCount} tool uses forwarded in ${duration}ms`);
+            commandQueue.complete(sessionId);
             try {
               await client.send({
                 type: "agent_result",
@@ -10751,6 +11011,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);
             try {
               await client.send({
                 type: "agent_result",
@@ -10869,6 +11130,8 @@ var Daemon = class _Daemon {
           });
           console.log(`[Daemon] EP912: Agent command ${cmd.action} completed for session ${cmd.action === "start" || cmd.action === "message" ? cmd.sessionId : cmd.sessionId}`);
         } catch (error) {
+          const sessionId = cmd.sessionId || "unknown";
+          const errorMsg = error instanceof Error ? error.message : String(error);
           try {
             await client.send({
               type: "agent_result",
@@ -10876,12 +11139,13 @@ var Daemon = class _Daemon {
               result: {
                 success: false,
                 status: "error",
-                sessionId: cmd.sessionId || "unknown",
-                error: error instanceof Error ? error.message : String(error)
+                sessionId,
+                error: errorMsg
               }
             });
+            commandQueue.complete(sessionId);
           } catch (sendError) {
-            console.error(`[Daemon] EP912: Failed to send error result (WebSocket may be disconnected):`, sendError);
+            console.error(`[Daemon] EP1237: Failed to send error result (WebSocket disconnected), command will be retried on reconnect`);
           }
           console.error(`[Daemon] EP912: Agent command execution error:`, error);
         }
@@ -11011,6 +11275,9 @@ var Daemon = class _Daemon {
       this.reconcileWorktrees(projectId, projectPath, client).catch((err) => {
         console.warn("[Daemon] EP1003: Reconciliation report failed:", err.message);
       });
+      this.runAgentReconciliation(projectId, projectPath, client).catch((err) => {
+        console.warn("[Daemon] EP1237: Agent reconciliation failed:", err.message);
+      });
     });
     client.on("module_state_changed", async (message) => {
       if (message.type === "module_state_changed") {
@@ -11064,6 +11331,22 @@ var Daemon = class _Daemon {
         console.error("[Daemon] EP1095: Error handling machine_uuid_update:", error instanceof Error ? error.message : error);
       }
     });
+    client.on("agent_reconciliation_commands", async (message) => {
+      try {
+        const cmdMsg = message;
+        console.log(`[Daemon] EP1237: Received agent reconciliation commands - abort: ${cmdMsg.abort.length}, restart: ${cmdMsg.restart.length}`);
+        const agentManager = getAgentManager();
+        for (const sessionId of cmdMsg.abort) {
+          console.log(`[Daemon] EP1237: Aborting orphaned session ${sessionId}`);
+          await agentManager.abortSession(sessionId);
+        }
+        if (cmdMsg.restart.length > 0) {
+          console.log(`[Daemon] EP1237: Server will send agent_command for ${cmdMsg.restart.length} session(s) that need restart`);
+        }
+      } catch (error) {
+        console.error("[Daemon] EP1237: Error handling agent_reconciliation_commands:", error instanceof Error ? error.message : error);
+      }
+    });
     client.on("disconnected", (event) => {
       const disconnectEvent = event;
       console.log(`[Daemon] Connection closed for ${projectId}: code=${disconnectEvent.code}, willReconnect=${disconnectEvent.willReconnect}`);
@@ -11545,6 +11828,121 @@ var Daemon = class _Daemon {
   // EP1025: Removed cleanupModuleWorktree - was dead code (never called).
   // EP1188: Background ops queue removed - worktree cleanup now handled by Inngest events
   // (worktree/cleanup) which send WebSocket commands to connected daemons via ws-proxy.
+  /**
+   * EP1237: Run agent reconciliation steps sequentially.
+   *
+   * This orchestrates the two reconciliation steps in order:
+   * 1. Report pending commands (updates retry counts, reports failures)
+   * 2. Reconcile sessions (reports active sessions to server)
+   *
+   * Running these sequentially avoids race conditions where retry logic
+   * might modify state while reconciliation is reading it.
+   */
+  async runAgentReconciliation(projectId, projectPath, client) {
+    console.log("[Daemon] EP1237: Running agent reconciliation sequence");
+    try {
+      await this.reportPendingAgentCommands(projectId, projectPath, client);
+    } catch (err) {
+      console.warn("[Daemon] EP1237: Report pending commands failed:", err instanceof Error ? err.message : err);
+    }
+    try {
+      await this.reconcileAgentSessions(projectId, client);
+    } catch (err) {
+      console.warn("[Daemon] EP1237: Reconcile sessions failed:", err instanceof Error ? err.message : err);
+    }
+    console.log("[Daemon] EP1237: Agent reconciliation sequence complete");
+  }
+  /**
+   * EP1237: Report pending agent commands after WebSocket reconnection.
+   *
+   * Commands that were processing when the WebSocket disconnected need attention.
+   * We report their status via agent_reconciliation_report, and the server will
+   * re-send commands for sessions that need to be restarted.
+   *
+   * This is safer than trying to re-process locally because:
+   * 1. Credentials may have expired and server needs to refresh them
+   * 2. Session state in DB needs to be consistent with our local state
+   * 3. Server can make informed decisions about which sessions to restart
+   */
+  async reportPendingAgentCommands(projectId, projectPath, client) {
+    const commandQueue = getAgentCommandQueue();
+    const pendingCommands = commandQueue.getPendingCommands();
+    const failedCommands = commandQueue.getFailedCommands();
+    if (pendingCommands.length === 0 && failedCommands.length === 0) {
+      console.log("[Daemon] EP1237: No pending agent commands");
+      return;
+    }
+    console.log(`[Daemon] EP1237: Found ${pendingCommands.length} pending and ${failedCommands.length} failed command(s)`);
+    for (const pending of failedCommands) {
+      const cmd = pending.command;
+      const sessionId = cmd.sessionId || "unknown";
+      console.log(`[Daemon] EP1237: Reporting failed command for session ${sessionId} (exceeded max retries)`);
+      try {
+        await client.send({
+          type: "agent_result",
+          commandId: pending.commandId,
+          result: {
+            success: false,
+            status: "error",
+            sessionId,
+            error: `Command failed after ${pending.retryCount} retry attempts during WebSocket reconnection`
+          }
+        });
+        commandQueue.fail(sessionId, "Max retries exceeded");
+      } catch (sendError) {
+        console.error("[Daemon] EP1237: Failed to report max retry failure:", sendError);
+      }
+    }
+    for (const pending of pendingCommands) {
+      const cmd = pending.command;
+      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");
+        continue;
+      }
+      commandQueue.incrementRetryCount(sessionId);
+      console.log(`[Daemon] EP1237: Command for session ${sessionId} ready for retry (attempt ${pending.retryCount + 1}/${commandQueue.getMaxRetries()})`);
+    }
+  }
+  /**
+   * EP1237: Reconcile agent sessions on connect/reconnect.
+   *
+   * Reports active local agent sessions to the server so it can compare with DB state.
+   * Server responds with abort/restart commands to fix any mismatches.
+   */
+  async reconcileAgentSessions(projectId, client) {
+    console.log(`[Daemon] EP1237: Starting agent session reconciliation for project ${projectId}`);
+    try {
+      if (!this.machineUuid) {
+        console.log("[Daemon] EP1237: Cannot reconcile agent sessions - machineUuid not available yet");
+        return;
+      }
+      const agentManager = getAgentManager();
+      const activeSessions = agentManager.getActiveSessionsForReconciliation();
+      console.log(`[Daemon] EP1237: Reporting ${activeSessions.length} active agent session(s)`);
+      const report = {
+        projectId,
+        machineId: this.machineUuid,
+        sessions: activeSessions.map((s) => ({
+          sessionId: s.sessionId,
+          moduleId: s.moduleId,
+          moduleUid: s.moduleUid,
+          status: s.status,
+          agentSessionId: s.agentSessionId,
+          lastActivityAt: s.lastActivityAt.toISOString()
+        }))
+      };
+      await client.send({
+        type: "agent_reconciliation_report",
+        report
+      });
+      console.log("[Daemon] EP1237: Agent session reconciliation report sent - awaiting server commands");
+    } catch (error) {
+      console.error("[Daemon] EP1237: Agent session reconciliation error:", error instanceof Error ? error.message : error);
+      throw error;
+    }
+  }
   /**
    * EP1002: Handle worktree_setup command from server
    * This provides a unified setup flow for both local and cloud environments.