chatroom-cli 1.49.0 → 1.49.2

package/dist/index.js

@@ -27494,9 +27494,6 @@ class CursorSdkStreamAdapter {
       case "status":
         process.stdout.write(`${this.logPrefix} status: ${message.status}]
 `);
-        if (TERMINAL_STATUS.has(message.status)) {
-          this.emitAgentEnd();
-        }
         break;
       case "thinking":
         process.stdout.write(`${this.logPrefix} thinking] ${message.text}
@@ -27512,6 +27509,9 @@ class CursorSdkStreamAdapter {
         break;
     }
   }
+  flushPendingOutput() {
+    this.flushText();
+  }
   finish() {
     this.flushText();
     this.emitAgentEnd();
@@ -27553,10 +27553,6 @@ class CursorSdkStreamAdapter {
       cb();
   }
 }
-var TERMINAL_STATUS;
-var init_cursor_sdk_stream_adapter = __esm(() => {
-  TERMINAL_STATUS = new Set(["FINISHED", "ERROR", "CANCELLED"]);
-});
 
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-agent-service.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -27634,7 +27630,6 @@ var init_cursor_sdk_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_detection_result();
   init_cursor_models();
-  init_cursor_sdk_stream_adapter();
   CursorSdkAgentService = class CursorSdkAgentService extends BaseCLIAgentService {
     id = "cursor-sdk";
     displayName = "Cursor (SDK)";
@@ -27790,6 +27785,10 @@ ${options.prompt}` : options.prompt;
               for (const cb of outputCallbacks)
                 cb();
             });
+            adapter.onAgentEnd(() => {
+              for (const cb of agentEndCallbacks)
+                cb();
+            });
             for await (const message of run3.stream()) {
               if (session.aborted)
                 break;
@@ -27801,15 +27800,14 @@ ${options.prompt}` : options.prompt;
               break;
             }
             const result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
-            adapter.finish();
+            adapter.flushPendingOutput();
             if (result.status === "error") {
               exitCode = 2;
               process.stderr.write(`${logPrefix} run-error] run ${result.id} failed
 `);
               break;
             }
-            for (const cb of agentEndCallbacks)
-              cb();
+            adapter.finish();
             const resumePrompt = await waitForResumeOrAbort(session);
             if (resumePrompt === null || session.aborted) {
               if (session.aborted) {
@@ -27857,7 +27855,6 @@ ${options.prompt}` : options.prompt;
 // src/infrastructure/services/remote-agents/cursor-sdk/index.ts
 var init_cursor_sdk = __esm(() => {
   init_cursor_sdk_agent_service();
-  init_cursor_sdk_stream_adapter();
 });
 
 // ../../node_modules/.pnpm/@opencode-ai+sdk@1.15.11/node_modules/@opencode-ai/sdk/dist/gen/types.gen.js
@@ -30143,6 +30140,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         } catch (err) {
           console.warn(`[opencode-sdk] session.abort for pid=${pid} sessionId=${meta.sessionId} failed (continuing with SIGTERM):`, err instanceof Error ? err.message : err);
         }
+        this.sessionStore.remove(meta.sessionId);
       }
       await super.stop(pid);
     }
@@ -83330,6 +83328,16 @@ var init_crash_loop_tracker = __esm(() => {
   ];
 });
 
+// src/infrastructure/deps/process.ts
+function isProcessAlive(kill, pid) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/infrastructure/machine/stop-reason.ts
 function resolveStopReason(code2, signal) {
   if (signal !== null)
@@ -83452,16 +83460,24 @@ class AgentProcessManager {
   async ensureRunning(opts) {
     const key = agentKey2(opts.chatroomId, opts.role);
     const slot = this.getOrCreateSlot(key);
-    if (slot.state === "running") {
-      return { success: true, pid: slot.pid };
-    }
-    if (slot.state === "spawning" && slot.pendingOperation) {
-      return slot.pendingOperation;
+    if (slot.state === "running" && slot.pid && !isProcessAlive(this.deps.processes.kill, slot.pid)) {
+      slot.state = "idle";
+      slot.pid = undefined;
+      slot.harness = undefined;
+      slot.harnessSessionId = undefined;
+      slot.model = undefined;
+      slot.workingDir = undefined;
+      slot.startedAt = undefined;
+      slot.pendingOperation = undefined;
     }
-    if (slot.state === "stopping" && slot.pendingOperation) {
-      await slot.pendingOperation;
+    if (slot.pendingOperation) {
+      if (slot.state === "stopping") {
+        await slot.pendingOperation;
+      } else {
+        return slot.pendingOperation;
+      }
     }
-    const operation = this.doEnsureRunning(key, slot, opts);
+    const operation = this.executeEnsureRunning(key, slot, opts);
     slot.pendingOperation = operation;
     return operation;
   }
@@ -83624,31 +83640,38 @@ class AgentProcessManager {
     } catch (err) {
       console.warn(`[AgentProcessManager] ⚠️ Failed to load persisted agent entries: ${err.message}`);
     }
-    let recovered = 0;
+    let killed = 0;
     let cleaned = 0;
     for (const { chatroomId, role, entry } of entries2) {
-      const key = agentKey2(chatroomId, role);
-      let alive = false;
-      try {
-        this.deps.processes.kill(entry.pid, 0);
-        alive = true;
-      } catch {
-        alive = false;
-      }
-      if (alive) {
-        this.slots.set(key, {
-          state: "running",
+      if (isProcessAlive(this.deps.processes.kill, entry.pid)) {
+        await this.stopPersistedProcess(entry.pid, entry.harness);
+        const exitArgs = {
+          sessionId: this.deps.sessionId,
+          machineId: this.deps.machineId,
+          chatroomId,
+          role,
           pid: entry.pid,
-          harness: entry.harness,
-          wantResume: true
+          stopReason: "daemon.shutdown",
+          exitCode: undefined,
+          signal: undefined,
+          agentHarness: entry.harness
+        };
+        this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
+          console.log(`   ⚠️  Failed to record agent exit on recovery: ${err.message}`);
+          this.queueExitRetry({ role, args: exitArgs });
         });
-        recovered++;
+        try {
+          await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+        } catch {}
+        killed++;
       } else {
-        this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+        try {
+          await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+        } catch {}
         cleaned++;
       }
     }
-    console.log(`[AgentProcessManager] Recovery: ${recovered} alive, ${cleaned} cleaned up`);
+    console.log(`[AgentProcessManager] Recovery: ${killed} killed, ${cleaned} cleaned up`);
   }
   getOrCreateSlot(key) {
     let slot = this.slots.get(key);
@@ -83658,6 +83681,82 @@ class AgentProcessManager {
     }
     return slot;
   }
+  async stopPersistedProcess(pid, harness) {
+    const service = this.deps.agentServices.get(harness);
+    if (service) {
+      try {
+        await service.stop(pid);
+        service.untrack(pid);
+      } catch {}
+    } else {
+      try {
+        this.deps.processes.kill(-pid, "SIGTERM");
+      } catch {}
+      for (const svc of this.deps.agentServices.values()) {
+        svc.untrack(pid);
+      }
+    }
+    untrackChildPid(pid);
+  }
+  async killExistingBeforeSpawn(chatroomId, role) {
+    const key = agentKey2(chatroomId, role);
+    const slot = this.slots.get(key);
+    if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === "running" || slot.state === "spawning")) {
+      const pid2 = slot.pid;
+      slot.state = "stopping";
+      await this.doStop(key, slot, pid2, { chatroomId, role, reason: "daemon.respawn" });
+    }
+    let entries2 = [];
+    try {
+      entries2 = await this.deps.persistence.listAgentEntries(this.deps.machineId);
+    } catch {
+      return;
+    }
+    const persisted = entries2.find((e) => e.chatroomId === chatroomId && e.role.toLowerCase() === role.toLowerCase());
+    if (!persisted) {
+      return;
+    }
+    const { pid, harness } = persisted.entry;
+    if (!isProcessAlive(this.deps.processes.kill, pid)) {
+      try {
+        await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+      } catch {}
+      return;
+    }
+    const currentSlot = this.slots.get(key);
+    if (currentSlot?.pid === pid && currentSlot.state !== "idle") {
+      return;
+    }
+    await this.stopPersistedProcess(pid, harness);
+    const exitArgs = {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId,
+      role,
+      pid,
+      stopReason: "daemon.respawn",
+      exitCode: undefined,
+      signal: undefined,
+      agentHarness: harness
+    };
+    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
+      console.log(`   ⚠️  Failed to record agent exit before respawn: ${err.message}`);
+      this.queueExitRetry({ role, args: exitArgs });
+    });
+    try {
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+    } catch {}
+  }
+  async executeEnsureRunning(key, slot, opts) {
+    try {
+      await this.killExistingBeforeSpawn(opts.chatroomId, opts.role);
+      return await this.doEnsureRunning(key, slot, opts);
+    } finally {
+      if (slot.pendingOperation) {
+        slot.pendingOperation = undefined;
+      }
+    }
+  }
   queueExitRetry(item) {
     this.exitRetryQueue.push(item);
     if (this.exitRetryTimer === null) {
@@ -83743,12 +83842,6 @@ class AgentProcessManager {
         slot.pendingOperation = undefined;
         return { success: false, error: `Working directory does not exist: ${opts.workingDir}` };
       }
-      if (slot.pid) {
-        try {
-          this.deps.processes.kill(-slot.pid, "SIGTERM");
-        } catch {}
-        slot.pid = undefined;
-      }
       let initPromptResult;
       try {
         initPromptResult = await this.deps.backend.query(api.messages.getInitPrompt, {
@@ -83868,9 +83961,7 @@ class AgentProcessManager {
         let dead = false;
         for (let i2 = 0;i2 < 20; i2++) {
           await this.deps.clock.delay(500);
-          try {
-            this.deps.processes.kill(pid, 0);
-          } catch {
+          if (!isProcessAlive(this.deps.processes.kill, pid)) {
             dead = true;
             break;
           }
@@ -83881,9 +83972,7 @@ class AgentProcessManager {
           } catch {}
           for (let i2 = 0;i2 < 10; i2++) {
             await this.deps.clock.delay(500);
-            try {
-              this.deps.processes.kill(pid, 0);
-            } catch {
+            if (!isProcessAlive(this.deps.processes.kill, pid)) {
               dead = true;
               break;
             }
@@ -83921,6 +84010,7 @@ class AgentProcessManager {
 }
 var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
 var init_agent_process_manager = __esm(() => {
+  init_orphan_tracker();
   init_api3();
   init_types();
   init_generator();
@@ -86507,4 +86597,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=2DBCEF13548BACBB64756E2164756E21
+//# debugId=4BF4F3B3AF6C84CB64756E2164756E21