chatroom-cli 1.43.1 → 1.43.3

package/dist/index.js

@@ -69493,6 +69493,7 @@ var init_errorCodes = __esm(() => {
     COMMAND_NOT_RUNNING: "COMMAND_NOT_RUNNING",
     TOO_MANY_COMMANDS: "TOO_MANY_COMMANDS",
     INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION",
+    INVALID_RUN_STATE_TRANSITION: "INVALID_RUN_STATE_TRANSITION",
     OUTPUT_CHUNK_TOO_LARGE: "OUTPUT_CHUNK_TOO_LARGE",
     NOT_FOUND: "NOT_FOUND",
     INVALID_BOT_TOKEN: "INVALID_BOT_TOKEN",
@@ -69573,6 +69574,7 @@ var init_errorCodes = __esm(() => {
     BACKEND_ERROR_CODES.INVALID_STDIN_FORMAT,
     BACKEND_ERROR_CODES.INVALID_BOT_TOKEN,
     BACKEND_ERROR_CODES.INVALID_STATE_TRANSITION,
+    BACKEND_ERROR_CODES.INVALID_RUN_STATE_TRANSITION,
     BACKEND_ERROR_CODES.TASK_INVALID_TRANSITION,
     BACKEND_ERROR_CODES.TASK_MISSING_REQUIRED_FIELD,
     BACKEND_ERROR_CODES.TASK_VALIDATION_FAILED,
@@ -75936,31 +75938,248 @@ var init_file_tree_subscription = __esm(() => {
   init_convex_error();
 });
 
-// src/commands/machine/daemon-start/handlers/command-runner.ts
-import { spawn as spawn4 } from "node:child_process";
-import { access as access3 } from "node:fs/promises";
-function evictStalePendingStops() {
-  const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
-  for (const [runId, ts] of pendingStops) {
-    if (ts < evictBefore)
-      pendingStops.delete(runId);
+// src/commands/machine/daemon-start/handlers/orphan-tracker.ts
+import { createHash as createHash6 } from "node:crypto";
+import {
+  appendFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync5,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join15 } from "node:path";
+function getUrlHash2() {
+  const url2 = getConvexUrl();
+  return createHash6("sha256").update(url2).digest("hex").substring(0, 8);
+}
+function getChildPidsFilePath() {
+  const dir = join15(homedir6(), ".chatroom");
+  return join15(dir, `daemon-children-${getUrlHash2()}.pids`);
+}
+function ensureChatroomDir3() {
+  const dir = join15(homedir6(), ".chatroom");
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true, mode: 448 });
   }
 }
-function buildCommandKey(machineId, workingDir, commandName) {
-  return `${machineId}|${workingDir}|${commandName}`;
+function readPids() {
+  const filePath = getChildPidsFilePath();
+  if (!existsSync3(filePath))
+    return [];
+  try {
+    return readFileSync5(filePath, "utf-8").split(`
+`).map((line) => parseInt(line.trim(), 10)).filter((n) => Number.isFinite(n) && n > 0);
+  } catch {
+    return [];
+  }
 }
-async function reportRunFailed(ctx, runId, reason) {
+function trackChildPid(pid) {
   try {
-    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      runId,
-      status: "failed"
+    ensureChatroomDir3();
+    appendFileSync(getChildPidsFilePath(), `${pid}
+`, "utf-8");
+  } catch (err) {
+    console.warn(`[orphan-tracker] Failed to track child PID ${pid}: ${err}`);
+  }
+}
+function untrackChildPid(pid) {
+  try {
+    const filePath = getChildPidsFilePath();
+    if (!existsSync3(filePath))
+      return;
+    const remaining = readFileSync5(filePath, "utf-8").split(`
+`).filter((line) => {
+      const n = parseInt(line.trim(), 10);
+      return Number.isFinite(n) && n > 0 && n !== pid;
     });
+    const tmpPath = `${filePath}.tmp`;
+    writeFileSync3(tmpPath, remaining.join(`
+`) + (remaining.length > 0 ? `
+` : ""), "utf-8");
+    renameSync(tmpPath, filePath);
   } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to report run failure (${reason}): ${getErrorMessage(err)}`);
+    console.warn(`[orphan-tracker] Failed to untrack child PID ${pid}: ${err}`);
   }
 }
+function clearTrackedPids() {
+  try {
+    const filePath = getChildPidsFilePath();
+    if (existsSync3(filePath)) {
+      unlinkSync2(filePath);
+    }
+  } catch {}
+}
+async function reapOrphanedProcessGroups() {
+  const pids = readPids();
+  let reaped = 0;
+  const checked = pids.length;
+  for (const pgid of pids) {
+    if (process.platform === "win32")
+      continue;
+    try {
+      process.kill(-pgid, 0);
+    } catch {
+      continue;
+    }
+    try {
+      process.kill(-pgid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    const deadline = Date.now() + 500;
+    let alive = true;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 50));
+      try {
+        process.kill(-pgid, 0);
+      } catch {
+        alive = false;
+        break;
+      }
+    }
+    if (alive) {
+      try {
+        process.kill(-pgid, "SIGKILL");
+      } catch {}
+    }
+    console.log(`[orphan-tracker] Reaped orphan process group ${pgid}`);
+    reaped++;
+  }
+  clearTrackedPids();
+  return { reaped, checked };
+}
+var CHATROOM_DIR5;
+var init_orphan_tracker = __esm(() => {
+  init_client2();
+  CHATROOM_DIR5 = join15(homedir6(), ".chatroom");
+});
+
+// src/commands/machine/daemon-start/handlers/process/state.ts
+function deriveTerminalStatus(code2, signal, terminationIntent) {
+  if (terminationIntent !== null)
+    return terminationIntent;
+  if (code2 === 0)
+    return "completed";
+  if (signal !== null)
+    return "stopped";
+  return "failed";
+}
+var TERMINAL_STATES, PENDING_STOP_TTL_MS = 60000, SIGTERM_GRACE_PERIOD_MS = 5000, SOFT_TIMEOUT_MS, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE;
+var init_state2 = __esm(() => {
+  TERMINAL_STATES = new Set(["completed", "failed", "stopped", "killed"]);
+  SOFT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+  MAX_BUFFER_SIZE = 100 * 1024;
+});
+
+// src/commands/machine/daemon-start/handlers/process/manager.ts
+class ProcessManager {
+  runningProcesses = new Map;
+  runningProcessesByCommand = new Map;
+  pendingStops = new Map;
+  has(runId) {
+    return this.runningProcesses.has(runId);
+  }
+  get(runId) {
+    return this.runningProcesses.get(runId);
+  }
+  getByCommand(commandKey) {
+    const runId = this.runningProcessesByCommand.get(commandKey);
+    if (runId === undefined)
+      return;
+    return this.runningProcesses.get(runId);
+  }
+  getAll() {
+    return [...this.runningProcesses.entries()];
+  }
+  get size() {
+    return this.runningProcesses.size;
+  }
+  register(runId, commandKey, process2) {
+    this.runningProcesses.set(runId, process2);
+    this.runningProcessesByCommand.set(commandKey, runId);
+  }
+  unregister(runId, commandKey) {
+    this.runningProcesses.delete(runId);
+    if (this.runningProcessesByCommand.get(commandKey) === runId) {
+      this.runningProcessesByCommand.delete(commandKey);
+    }
+  }
+  markPendingStop(runId) {
+    this.pendingStops.set(runId, Date.now());
+  }
+  hasPendingStop(runId) {
+    return this.pendingStops.has(runId);
+  }
+  consumePendingStop(runId) {
+    const has5 = this.pendingStops.has(runId);
+    if (has5)
+      this.pendingStops.delete(runId);
+    return has5;
+  }
+  evictStalePendingStops() {
+    const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
+    for (const [runId, ts] of this.pendingStops) {
+      if (ts < evictBefore)
+        this.pendingStops.delete(runId);
+    }
+  }
+  clear() {
+    this.runningProcesses.clear();
+    this.runningProcessesByCommand.clear();
+    this.pendingStops.clear();
+  }
+  waitForExit(runId, ms) {
+    return new Promise((resolve5) => {
+      const interval = 100;
+      let elapsed3 = 0;
+      const timer = setInterval(() => {
+        if (!this.runningProcesses.has(runId)) {
+          clearInterval(timer);
+          resolve5(true);
+          return;
+        }
+        elapsed3 += interval;
+        if (elapsed3 >= ms) {
+          clearInterval(timer);
+          resolve5(false);
+        }
+      }, interval);
+    });
+  }
+}
+var processManager;
+var init_manager = __esm(() => {
+  init_state2();
+  processManager = new ProcessManager;
+});
+
+// src/commands/machine/daemon-start/handlers/process/killer.ts
+function killProcess(child, signal) {
+  if (child.pid == null)
+    return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {}
+}
+async function killTrackedProcess(tracked) {
+  killProcess(tracked.process, "SIGTERM");
+  const exited = await processManager.waitForExit(tracked.runId, SIGTERM_GRACE_PERIOD_MS);
+  if (!exited) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${tracked.runId}`);
+    killProcess(tracked.process, "SIGKILL");
+    await processManager.waitForExit(tracked.runId, 1000);
+  }
+}
+var init_killer = __esm(() => {
+  init_state2();
+  init_manager();
+});
+
+// src/commands/machine/daemon-start/handlers/process/spawner.ts
+import { spawn as spawn4 } from "node:child_process";
 async function flushOutput(ctx, tracked) {
   if (tracked.outputBuffer.length === 0)
     return;
@@ -75986,91 +76205,14 @@ function appendToBuffer(ctx, tracked, data) {
     flushOutput(ctx, tracked).catch(() => {});
   }
 }
-function killProcess(child, signal) {
-  try {
-    child.kill(signal);
-  } catch {}
-}
-function waitForExit(runIdStr, ms) {
-  return new Promise((resolve5) => {
-    const interval = 100;
-    let elapsed3 = 0;
-    const timer = setInterval(() => {
-      if (!runningProcesses.has(runIdStr)) {
-        clearInterval(timer);
-        resolve5(true);
-        return;
-      }
-      elapsed3 += interval;
-      if (elapsed3 >= ms) {
-        clearInterval(timer);
-        resolve5(false);
-      }
-    }, interval);
-  });
-}
-async function killTrackedProcess(tracked) {
-  killProcess(tracked.process, "SIGTERM");
-  const exited = await waitForExit(tracked.runId, SIGTERM_GRACE_PERIOD_MS);
-  if (!exited) {
-    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${tracked.runId}`);
-    killProcess(tracked.process, "SIGKILL");
-    await waitForExit(tracked.runId, 1000);
-  }
-}
-async function onCommandRun(ctx, event) {
+function spawnCommandProcess(ctx, event, commandKey) {
   const { workingDir, commandName, script, runId } = event;
   const runIdStr = runId.toString();
-  const commandKey = buildCommandKey(ctx.machineId, workingDir, commandName);
-  if (runningProcesses.has(runIdStr)) {
-    console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
-    return;
-  }
-  if (pendingStops.has(runIdStr)) {
-    pendingStops.delete(runIdStr);
-    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
-    try {
-      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId,
-        runId,
-        status: "stopped"
-      });
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
-    }
-    return;
-  }
-  const priorRunId = runningProcessesByCommand.get(commandKey);
-  if (priorRunId) {
-    const priorTracked = runningProcesses.get(priorRunId);
-    if (priorTracked) {
-      console.log(`[${formatTimestamp()}] \uD83D\uDD04 Replacing prior run ${priorRunId} with ${runIdStr} for ${commandName}`);
-      clearInterval(priorTracked.flushTimer);
-      if (priorTracked.softTimeoutTimer)
-        clearTimeout(priorTracked.softTimeoutTimer);
-      await killTrackedProcess(priorTracked);
-      runningProcesses.delete(priorRunId);
-      runningProcessesByCommand.delete(commandKey);
-    }
-  }
-  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
-  if (!workingDir.startsWith("/")) {
-    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
-    await reportRunFailed(ctx, runId, "Working directory is not an absolute path");
-    return;
-  }
-  try {
-    await access3(workingDir);
-  } catch {
-    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir not found: ${workingDir}`);
-    await reportRunFailed(ctx, runId, "Working directory not found");
-    return;
-  }
   const child = spawn4("sh", ["-c", script], {
     cwd: workingDir,
     env: { ...process.env },
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
   });
   const tracked = {
     process: child,
@@ -76081,16 +76223,20 @@ async function onCommandRun(ctx, event) {
     flushTimer: setInterval(() => {
       flushOutput(ctx, tracked).catch(() => {});
     }, OUTPUT_FLUSH_INTERVAL_MS),
-    softTimeoutTimer: null
+    softTimeoutTimer: null,
+    terminationIntent: null
   };
   tracked.flushTimer.unref?.();
-  runningProcesses.set(runIdStr, tracked);
-  runningProcessesByCommand.set(commandKey, runIdStr);
+  processManager.register(runIdStr, commandKey, tracked);
+  if (child.pid != null) {
+    trackChildPid(child.pid);
+  }
   const softTimeoutTimer = setTimeout(async () => {
     console.log(`[${formatTimestamp()}] ⏰ Command soft timeout (24h): ${commandName} (runId: ${runIdStr})`);
-    const currentTracked = runningProcesses.get(runIdStr);
+    const currentTracked = processManager.get(runIdStr);
     if (!currentTracked)
       return;
+    currentTracked.terminationIntent = "killed";
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76104,7 +76250,7 @@ async function onCommandRun(ctx, event) {
     }
     killProcess(child, "SIGTERM");
     setTimeout(() => {
-      if (!runningProcesses.has(runIdStr))
+      if (!processManager.has(runIdStr))
         return;
       console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
       killProcess(child, "SIGKILL");
@@ -76112,17 +76258,6 @@ async function onCommandRun(ctx, event) {
   }, SOFT_TIMEOUT_MS);
   softTimeoutTimer.unref?.();
   tracked.softTimeoutTimer = softTimeoutTimer;
-  try {
-    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      runId,
-      status: "running",
-      pid: child.pid
-    });
-  } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status to running: ${getErrorMessage(err)}`);
-  }
   child.stdout?.on("data", (data) => {
     appendToBuffer(ctx, tracked, data.toString());
   });
@@ -76132,14 +76267,14 @@ async function onCommandRun(ctx, event) {
   child.on("exit", async (code2, signal) => {
     console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     await flushOutput(ctx, tracked).catch(() => {});
+    if (tracked.process.pid != null) {
+      untrackChildPid(tracked.process.pid);
+    }
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    runningProcesses.delete(runIdStr);
-    if (runningProcessesByCommand.get(commandKey) === runIdStr) {
-      runningProcessesByCommand.delete(commandKey);
-    }
-    const status3 = code2 === 0 ? "completed" : signal ? "stopped" : "failed";
+    processManager.unregister(runIdStr, commandKey);
+    const status3 = deriveTerminalStatus(code2, signal, tracked.terminationIntent);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76154,13 +76289,13 @@ async function onCommandRun(ctx, event) {
   });
   child.on("error", async (err) => {
     console.error(`[${formatTimestamp()}] ❌ Command spawn failed: ${commandName}: ${err.message}`);
+    if (tracked.process.pid != null) {
+      untrackChildPid(tracked.process.pid);
+    }
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    runningProcesses.delete(runIdStr);
-    if (runningProcessesByCommand.get(commandKey) === runIdStr) {
-      runningProcessesByCommand.delete(commandKey);
-    }
+    processManager.unregister(runIdStr, commandKey);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76172,13 +76307,111 @@ async function onCommandRun(ctx, event) {
       console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status on error: ${getErrorMessage(updateErr)}`);
     }
   });
+  return tracked;
+}
+var init_spawner = __esm(() => {
+  init_api3();
+  init_convex_error();
+  init_orphan_tracker();
+  init_state2();
+  init_manager();
+  init_killer();
+});
+
+// src/commands/machine/daemon-start/handlers/command-runner.ts
+import { access as access3 } from "node:fs/promises";
+function buildCommandKey(machineId, workingDir, commandName) {
+  return `${machineId}|${workingDir}|${commandName}`;
+}
+async function reportRunFailed(ctx, runId, reason) {
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId,
+      status: "failed"
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to report run failure (${reason}): ${getErrorMessage(err)}`);
+  }
+}
+async function onCommandRun(ctx, event) {
+  const { workingDir, commandName, script, runId } = event;
+  const runIdStr = runId.toString();
+  const commandKey = buildCommandKey(ctx.machineId, workingDir, commandName);
+  if (processManager.has(runIdStr)) {
+    console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
+    return;
+  }
+  if (processManager.consumePendingStop(runIdStr)) {
+    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId,
+        status: "stopped"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
+    }
+    return;
+  }
+  try {
+    const currentRun = await ctx.deps.backend.query(api.commands.getRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId
+    });
+    if (currentRun && TERMINAL_STATES.has(currentRun.status)) {
+      console.log(`[${formatTimestamp()}] ⏭️ Skipping command run — row already ${currentRun.status}: ${commandName} (${runIdStr})`);
+      return;
+    }
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to check run status before spawn: ${getErrorMessage(err)}`);
+  }
+  const priorTracked = processManager.getByCommand(commandKey);
+  if (priorTracked) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Replacing prior run ${priorTracked.runId} with ${runIdStr} for ${commandName}`);
+    priorTracked.terminationIntent = "killed";
+    clearInterval(priorTracked.flushTimer);
+    if (priorTracked.softTimeoutTimer)
+      clearTimeout(priorTracked.softTimeoutTimer);
+    await killTrackedProcess(priorTracked);
+    processManager.unregister(priorTracked.runId, commandKey);
+  }
+  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
+  if (!workingDir.startsWith("/")) {
+    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
+    await reportRunFailed(ctx, runId, "Working directory is not an absolute path");
+    return;
+  }
+  try {
+    await access3(workingDir);
+  } catch {
+    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir not found: ${workingDir}`);
+    await reportRunFailed(ctx, runId, "Working directory not found");
+    return;
+  }
+  const tracked = spawnCommandProcess(ctx, event, commandKey);
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId,
+      status: "running",
+      pid: tracked.process.pid
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status to running: ${getErrorMessage(err)}`);
+  }
 }
 async function onCommandStop(ctx, event) {
   const runIdStr = event.runId.toString();
-  const tracked = runningProcesses.get(runIdStr);
+  const tracked = processManager.get(runIdStr);
   if (!tracked) {
     console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr} — marking as stopped`);
-    pendingStops.set(runIdStr, Date.now());
+    processManager.markPendingStop(runIdStr);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76197,13 +76430,8 @@ async function onCommandStop(ctx, event) {
     clearTimeout(tracked.softTimeoutTimer);
     tracked.softTimeoutTimer = null;
   }
-  killProcess(tracked.process, "SIGTERM");
-  const exitedAfterSigterm = await waitForExit(runIdStr, SIGTERM_GRACE_PERIOD_MS);
-  if (!exitedAfterSigterm) {
-    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${runIdStr}`);
-    killProcess(tracked.process, "SIGKILL");
-    await waitForExit(runIdStr, 1000);
-  }
+  tracked.terminationIntent = "stopped";
+  await killTrackedProcess(tracked);
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
       sessionId: ctx.sessionId,
@@ -76216,15 +76444,14 @@ async function onCommandStop(ctx, event) {
   }
 }
 async function shutdownAllCommands(ctx) {
-  if (runningProcesses.size === 0)
+  if (processManager.size === 0)
     return;
-  console.log(`[${formatTimestamp()}] Shutting down ${runningProcesses.size} running command(s)...`);
-  const trackedEntries = [...runningProcesses.entries()];
+  console.log(`[${formatTimestamp()}] Shutting down ${processManager.size} running command(s)...`);
+  const trackedEntries = processManager.getAll();
   for (const [, tracked] of trackedEntries) {
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    await flushOutput(ctx, tracked).catch(() => {});
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76243,23 +76470,22 @@ async function shutdownAllCommands(ctx) {
     t.unref?.();
   });
   for (const [, tracked] of trackedEntries) {
-    if (runningProcesses.has(tracked.runId)) {
+    if (processManager.has(tracked.runId)) {
       killProcess(tracked.process, "SIGKILL");
     }
   }
-  runningProcesses.clear();
-  runningProcessesByCommand.clear();
+  processManager.clear();
+  clearTrackedPids();
   console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, runningProcessesByCommand, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, SOFT_TIMEOUT_MS, SIGTERM_GRACE_PERIOD_MS = 5000;
 var init_command_runner = __esm(() => {
   init_api3();
   init_convex_error();
-  runningProcesses = new Map;
-  runningProcessesByCommand = new Map;
-  pendingStops = new Map;
-  MAX_BUFFER_SIZE = 100 * 1024;
-  SOFT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+  init_orphan_tracker();
+  init_state2();
+  init_manager();
+  init_spawner();
+  init_killer();
 });
 
 // src/commands/machine/daemon-start/handlers/ping.ts
@@ -77228,21 +77454,25 @@ async function recoverState(ctx) {
     console.log(`   ⚠️  Failed to clear stale PIDs: ${getErrorMessage(e)}`);
   }
   try {
-    const runResult = await ctx.deps.backend.mutation(api.commands.clearStaleCommandRuns, {
+    const runResult = await ctx.deps.backend.mutation(api.commands.reapOrphansForDaemonRestart, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     });
-    if (runResult.clearedCount > 0) {
-      console.log(`   \uD83E\uDDF9 Cleared ${runResult.clearedCount} stale command run(s) from backend`);
+    if (runResult.reapedCount > 0) {
+      console.log(`   \uD83E\uDDF9 Reaped ${runResult.reapedCount} command run(s) from previous daemon run (marked as daemon-restart)`);
     }
   } catch (e) {
-    console.log(`   ⚠️  Failed to clear stale command runs: ${getErrorMessage(e)}`);
+    console.warn(`   ⚠️  Failed to reap orphan command runs: ${getErrorMessage(e)}`);
   }
 }
 async function initDaemon() {
   if (!acquireLock()) {
     process.exit(1);
   }
+  const { reaped } = await reapOrphanedProcessGroups();
+  if (reaped > 0) {
+    console.log(`[${formatTimestamp()}] Reaped ${reaped} orphaned process group(s) from previous daemon run`);
+  }
   const convexUrl = getConvexUrl();
   const sessionId = await validateAuthentication(convexUrl);
   const client4 = await getConvexClient();
@@ -77330,6 +77560,7 @@ var init_init2 = __esm(() => {
   init_error_formatting();
   init_version();
   init_pid();
+  init_orphan_tracker();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
@@ -78075,7 +78306,7 @@ function evictStaleDedupEntries(tracker) {
     if (ts < evictBefore)
       tracker.commandStopIds.delete(id3);
   }
-  evictStalePendingStops();
+  processManager.evictStalePendingStops();
 }
 async function dispatchCommandEvent(ctx, event, tracker) {
   const eventId = event._id.toString();
@@ -78331,6 +78562,7 @@ var init_command_loop = __esm(() => {
   init_file_tree_subscription();
   init_git_subscription();
   init_command_runner();
+  init_manager();
   init_init2();
   init_observed_sync();
   init_api3();
@@ -79446,5 +79678,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1151E4B582DED8E964756E2164756E21
+//# debugId=A50E5218AF2CBB4A64756E2164756E21
 //# sourceMappingURL=index.js.map