chatroom-cli 1.49.1 → 1.50.0

package/dist/index.js

@@ -30140,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);
     }
@@ -82749,6 +82750,24 @@ class TempFileOutputStore {
       totalBytes: this.state.totalBytes
     };
   }
+  async getLastNLines(maxLines) {
+    let source;
+    try {
+      source = await readFile8(this.state.filePath, "utf-8");
+    } catch {
+      source = this.state.inMemory;
+    }
+    const lines = source.split(`
+`);
+    const slice = lines.length > maxLines ? lines.slice(-maxLines) : lines;
+    const content = slice.join(`
+`);
+    return {
+      content,
+      totalBytes: Buffer.byteLength(content, "utf-8"),
+      lineCount: slice.length
+    };
+  }
   async getFullOutput() {
     try {
       return await readFile8(this.state.filePath, "utf-8");
@@ -82777,39 +82796,96 @@ async function cleanOrphanTempFiles() {
     await rm(TEMP_DIR, { recursive: true, force: true });
   } catch {}
 }
-var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE;
+var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
   TEMP_DIR = join17(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
+// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+function isRunLogObserved(runId) {
+  return observedRunIds.has(runId);
+}
+function consumePendingFullSync(runId) {
+  if (!pendingFullSyncRunIds.has(runId))
+    return false;
+  pendingFullSyncRunIds.delete(runId);
+  return true;
+}
+function startLogObserverPoll(ctx) {
+  let stopped = false;
+  const poll4 = async () => {
+    if (stopped)
+      return;
+    try {
+      const runs = await ctx.deps.backend.query(api.commands.listRunsWithLogObservers, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId
+      });
+      observedRunIds.clear();
+      pendingFullSyncRunIds.clear();
+      for (const run3 of runs) {
+        observedRunIds.add(run3._id);
+        if (run3.pendingFullOutputSync) {
+          pendingFullSyncRunIds.add(run3._id);
+        }
+      }
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Log-observer poll failed: ${getErrorMessage(err)}`);
+    }
+  };
+  poll4();
+  const handle = setInterval(() => {
+    poll4();
+  }, OUTPUT_FLUSH_INTERVAL_MS);
+  handle.unref?.();
+  return {
+    stop: () => {
+      stopped = true;
+      clearInterval(handle);
+      observedRunIds.clear();
+      pendingFullSyncRunIds.clear();
+    }
+  };
+}
+var observedRunIds, pendingFullSyncRunIds;
+var init_log_observer_sync = __esm(() => {
+  init_api3();
+  init_convex_error();
+  init_state2();
+  observedRunIds = new Set;
+  pendingFullSyncRunIds = new Set;
+});
+
 // src/commands/machine/daemon-start/handlers/process/spawner.ts
 import { spawn as spawn4 } from "node:child_process";
-async function flushTail(ctx, tracked) {
-  const tail = tracked.store.getTail();
+async function flushTailV2(ctx, tracked) {
+  if (!isRunLogObserved(tracked.runId))
+    return;
+  const tail = await tracked.store.getLastNLines(MAX_TAIL_LINES_V2);
   if (tail.content.length === 0)
     return;
   const compressed = encodeOutput(tail.content);
   try {
-    await ctx.deps.backend.mutation(api.commands.updateRunTail, {
+    await ctx.deps.backend.mutation(api.commands.updateRunTailV2, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
       runId: tracked.runId,
       tailOutput: {
         compression: compressed.compression,
         content: compressed.content,
-        byteLength: tail.content.length,
+        byteLength: tail.totalBytes,
         totalBytesWritten: tail.totalBytes,
-        updatedAt: Date.now()
+        updatedAt: Date.now(),
+        lineCount: tail.lineCount
       }
     });
   } catch (err) {
     console.warn(`[${formatTimestamp()}] ⚠️ Failed to flush tail for run ${tracked.runId}: ${getErrorMessage(err)}`);
   }
 }
-async function flushFinalChunks(ctx, tracked, runId) {
-  await flushTail(ctx, tracked);
+async function appendFullOutputChunks(ctx, tracked, runId) {
   let fullOutput;
   try {
     fullOutput = await tracked.store.getFullOutput();
@@ -82833,11 +82909,31 @@ async function flushFinalChunks(ctx, tracked, runId) {
       });
       chunkIndex++;
     } catch (err) {
-      console.error(`[${formatTimestamp()}] ❌ Failed to flush final chunk ${chunkIndex} for run ${tracked.runId}: ${getErrorMessage(err)}`);
+      console.error(`[${formatTimestamp()}] ❌ Failed to flush chunk ${chunkIndex} for run ${tracked.runId}: ${getErrorMessage(err)}`);
       return;
     }
   }
 }
+async function flushFinalChunks(ctx, tracked, runId) {
+  await flushTailV2(ctx, tracked);
+  if (consumePendingFullSync(tracked.runId)) {
+    await appendFullOutputChunks(ctx, tracked, runId);
+  }
+}
+async function syncFullOutputOnRequest(ctx, tracked, runId) {
+  if (!consumePendingFullSync(tracked.runId))
+    return;
+  await appendFullOutputChunks(ctx, tracked, runId);
+  try {
+    await ctx.deps.backend.mutation(api.commands.clearPendingFullOutputSync, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to clear pending full sync for ${tracked.runId}: ${getErrorMessage(err)}`);
+  }
+}
 async function spawnCommandProcess(ctx, event, commandKey) {
   const { workingDir, commandName, script, runId } = event;
   const runIdStr = runId.toString();
@@ -82859,7 +82955,8 @@ async function spawnCommandProcess(ctx, event, commandKey) {
     store,
     startedAt: Date.now(),
     flushTimer: setInterval(() => {
-      flushTail(ctx, tracked).catch(() => {});
+      flushTailV2(ctx, tracked).catch(() => {});
+      syncFullOutputOnRequest(ctx, tracked, runId).catch(() => {});
     }, OUTPUT_FLUSH_INTERVAL_MS),
     softTimeoutTimer: null,
     terminationIntent: null
@@ -82926,7 +83023,7 @@ async function spawnCommandProcess(ctx, event, commandKey) {
     }
   };
   child.on("exit", (code2, signal) => {
-    console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
+    console.log(`[${formatTimestamp()}] \uD83D\uDCCB Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     finalize(code2, signal).catch(() => {});
   });
   child.on("error", async (err) => {
@@ -82945,6 +83042,7 @@ var init_spawner = __esm(() => {
   init_manager();
   init_killer();
   init_output_store();
+  init_log_observer_sync();
 });
 
 // src/commands/machine/daemon-start/handlers/command-runner.ts
@@ -83327,6 +83425,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)
@@ -83449,16 +83557,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;
   }
@@ -83621,31 +83737,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);
@@ -83655,6 +83778,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) {
@@ -83740,12 +83939,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, {
@@ -83865,9 +84058,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;
           }
@@ -83878,9 +84069,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;
             }
@@ -83918,6 +84107,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();
@@ -85184,6 +85374,7 @@ async function startCommandLoop(ctx) {
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
   let observedSyncSubscriptionHandle = null;
+  let logObserverPollHandle = null;
   let pendingPromptSubscriptionHandle = null;
   let pendingHarnessSessionSubscriptionHandle = null;
   let commandSubscriptionHandle = null;
@@ -85209,6 +85400,8 @@ async function startCommandLoop(ctx) {
       fileTreeSubscriptionHandle.stop();
     if (observedSyncSubscriptionHandle)
       observedSyncSubscriptionHandle.stop();
+    if (logObserverPollHandle)
+      logObserverPollHandle.stop();
     if (pendingPromptSubscriptionHandle)
       pendingPromptSubscriptionHandle.stop();
     if (pendingHarnessSessionSubscriptionHandle)
@@ -85237,6 +85430,7 @@ async function startCommandLoop(ctx) {
   if (ctx.observedSyncEnabled) {
     observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
   }
+  logObserverPollHandle = startLogObserverPoll(ctx);
   if (featureFlags.directHarnessWorkers) {
     const sessionRepository = new ConvexSessionRepository({
       backend: ctx.deps.backend,
@@ -85325,6 +85519,7 @@ var init_command_loop = __esm(() => {
   init_command_runner();
   init_manager();
   init_init2();
+  init_log_observer_sync();
   init_observed_sync();
   init_api3();
   init_client2();
@@ -86504,4 +86699,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1017D812F7A83DCE64756E2164756E21
+//# debugId=3E031CCB2CBFFA9464756E2164756E21