@episoda/cli 0.2.176 → 0.2.177

package/dist/daemon/daemon-process.js

@@ -3046,7 +3046,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.176",
+      version: "0.2.177",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -15067,6 +15067,8 @@ var Daemon = class _Daemon {
     // 2 minutes
     // EP1360: Per-session monotonic event seq for daemon→platform stream gap detection.
     this.agentEventSeq = /* @__PURE__ */ new Map();
+    // sessionId -> last seq
+    this.agentHeartbeatLoops = /* @__PURE__ */ new Map();
     this.cliRuntimeVersion = resolveEffectiveCliVersion(packageJson.version);
     this.ipcServer = new IPCServer();
     this.connectionManager = new ConnectionManager();
@@ -15078,6 +15080,12 @@ var Daemon = class _Daemon {
       handleWorktreeSetup: (command, projectPath, worktreeManager) => this.handleWorktreeSetup(command, projectPath, worktreeManager)
     });
   }
+  static {
+    this.AGENT_HEARTBEAT_INTERVAL_MS = 15e3;
+  }
+  static {
+    this.AGENT_HEARTBEAT_REQUEST_TIMEOUT_MS = 12e3;
+  }
   static {
     this.HEALTH_PORT = 9999;
   }
@@ -15097,6 +15105,81 @@ var Daemon = class _Daemon {
     this.agentEventSeq.set(sessionId, next);
     return next;
   }
+  stopAgentHeartbeatLoop(sessionId) {
+    const loop = this.agentHeartbeatLoops.get(sessionId);
+    if (!loop) return;
+    loop.stop();
+    this.agentHeartbeatLoops.delete(sessionId);
+  }
+  async handleServerRequestedAgentStop(sessionId) {
+    try {
+      const agentManager = getAgentControlPlane();
+      await agentManager.stopSession(sessionId);
+      console.log(`[Daemon] EP1430: Stopped session ${sessionId} due to server continue=false`);
+    } catch (error) {
+      console.warn(
+        `[Daemon] EP1430: Failed to stop session ${sessionId} after server continue=false:`,
+        error
+      );
+    }
+  }
+  startAgentHeartbeatLoop(sessionId) {
+    if (this.agentHeartbeatLoops.has(sessionId)) return;
+    let stopped = false;
+    let inFlight = false;
+    let timer = null;
+    const runHeartbeat = async () => {
+      if (stopped || inFlight) return;
+      inFlight = true;
+      const abortController = new AbortController();
+      const requestTimeout = setTimeout(() => {
+        abortController.abort();
+      }, _Daemon.AGENT_HEARTBEAT_REQUEST_TIMEOUT_MS);
+      try {
+        const config = await (0, import_core22.loadConfig)();
+        if (!config?.access_token) return;
+        const apiUrl = config.api_url || "https://episoda.dev";
+        const response = await fetchWithAuth(
+          `${apiUrl}/api/agent-sessions/${sessionId}/heartbeat`,
+          {
+            method: "POST",
+            signal: abortController.signal
+          }
+        );
+        if (!response.ok && response.status !== 409) {
+          return;
+        }
+        const payload = await response.json().catch(() => null);
+        const shouldContinue = response.status === 409 ? false : Boolean(payload?.data?.continue ?? payload?.continue ?? true);
+        if (!shouldContinue) {
+          await this.handleServerRequestedAgentStop(sessionId);
+          this.stopAgentHeartbeatLoop(sessionId);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          console.warn(
+            `[Daemon] EP1430: Heartbeat request timed out for session ${sessionId} after ${_Daemon.AGENT_HEARTBEAT_REQUEST_TIMEOUT_MS}ms`
+          );
+        }
+      } finally {
+        clearTimeout(requestTimeout);
+        inFlight = false;
+      }
+    };
+    timer = setInterval(() => {
+      void runHeartbeat();
+    }, _Daemon.AGENT_HEARTBEAT_INTERVAL_MS);
+    this.agentHeartbeatLoops.set(sessionId, {
+      stop: () => {
+        stopped = true;
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+      }
+    });
+    void runHeartbeat();
+  }
   logReliabilityMetric(metric, fields) {
     console.log(`[Daemon][Metric] ${JSON.stringify({
       metric,
@@ -15500,6 +15583,7 @@ var Daemon = class _Daemon {
             }
           },
           onComplete: async (claudeSessionId, resultMetadata) => {
+            this.stopAgentHeartbeatLoop(sessionId);
             const duration = Date.now() - daemonStreamStart;
             console.log(`[Daemon] EP1191: Stream complete - ${daemonChunkCount} chunks, ${daemonToolUseCount} tool uses forwarded in ${duration}ms`);
             commandQueue.complete(sessionId, commandId);
@@ -15514,6 +15598,7 @@ var Daemon = class _Daemon {
             }
           },
           onError: async (error) => {
+            this.stopAgentHeartbeatLoop(sessionId);
             const duration = Date.now() - daemonStreamStart;
             console.log(`[Daemon] EP1191: Stream error after ${daemonChunkCount} chunks in ${duration}ms - ${error}`);
             commandQueue.complete(sessionId, commandId);
@@ -15533,6 +15618,7 @@ var Daemon = class _Daemon {
           await agentManager.initialize();
           let result;
           if (cmd.action === "start") {
+            this.startAgentHeartbeatLoop(cmd.sessionId);
             const callbacks = createStreamingCallbacks(cmd.sessionId, message.id);
             const agentWorkingDir = await resolveAgentWorkingDirectory({
               command: cmd,
@@ -15573,6 +15659,7 @@ var Daemon = class _Daemon {
               error: startResult.error
             };
           } else if (cmd.action === "message") {
+            this.startAgentHeartbeatLoop(cmd.sessionId);
             const callbacks = createStreamingCallbacks(cmd.sessionId, message.id);
             const sendResult = await agentManager.sendMessage({
               sessionId: cmd.sessionId,
@@ -15597,9 +15684,11 @@ var Daemon = class _Daemon {
               error: sendResult.error
             };
           } else if (cmd.action === "abort") {
+            this.stopAgentHeartbeatLoop(cmd.sessionId);
             await agentManager.abortSession(cmd.sessionId);
             result = { success: true, status: "aborted", sessionId: cmd.sessionId, seq: this.nextAgentSeq(cmd.sessionId) };
           } else if (cmd.action === "stop") {
+            this.stopAgentHeartbeatLoop(cmd.sessionId);
             await agentManager.stopSession(cmd.sessionId);
             result = { success: true, status: "complete", sessionId: cmd.sessionId, seq: this.nextAgentSeq(cmd.sessionId) };
             this.agentEventSeq.delete(cmd.sessionId);
@@ -15611,6 +15700,9 @@ var Daemon = class _Daemon {
               error: `Unknown agent action: ${cmd.action}`
             };
           }
+          if (!result.success && result.sessionId) {
+            this.stopAgentHeartbeatLoop(result.sessionId);
+          }
           await client.send({
             type: "agent_result",
             commandId: message.id,
@@ -15619,6 +15711,7 @@ var Daemon = class _Daemon {
           console.log(`[Daemon] EP912: Agent command ${cmd.action} completed for session ${getAgentCommandSessionId(cmd)}`);
         } catch (error) {
           const sessionId = getAgentCommandSessionId(cmd);
+          this.stopAgentHeartbeatLoop(sessionId);
           const errorMsg = error instanceof Error ? error.message : String(error);
           try {
             await client.send({