chatroom-cli 1.38.5 → 1.38.6

package/dist/index.js

@@ -75858,6 +75858,9 @@ function evictStalePendingStops() {
       pendingStops.delete(runId);
   }
 }
+function buildCommandKey(machineId, workingDir, commandName) {
+  return `${machineId}|${workingDir}|${commandName}`;
+}
 async function reportRunFailed(ctx, runId, reason) {
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -75895,9 +75898,42 @@ 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) {
   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;
@@ -75917,6 +75953,19 @@ async function onCommandRun(ctx, event) {
     }
     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}`);
@@ -75933,49 +75982,48 @@ async function onCommandRun(ctx, event) {
   const child = spawn4("sh", ["-c", script], {
     cwd: workingDir,
     env: { ...process.env },
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true
+    stdio: ["ignore", "pipe", "pipe"]
   });
-  const timeoutTimer = setTimeout(() => {
-    console.log(`[${formatTimestamp()}] ⏰ Command timed out after ${DEFAULT_COMMAND_TIMEOUT_MS / 60000} minutes: ${commandName} (runId: ${runIdStr})`);
-    const pid = child.pid;
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGTERM");
-      } catch {
-        child.kill("SIGTERM");
-      }
-    } else {
-      child.kill("SIGTERM");
-    }
-    setTimeout(() => {
-      if (!runningProcesses.has(runIdStr))
-        return;
-      console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
-      if (pid) {
-        try {
-          process.kill(-pid, "SIGKILL");
-        } catch {
-          child.kill("SIGKILL");
-        }
-      } else {
-        child.kill("SIGKILL");
-      }
-    }, SIGTERM_GRACE_PERIOD_MS);
-  }, DEFAULT_COMMAND_TIMEOUT_MS);
-  timeoutTimer.unref?.();
   const tracked = {
     process: child,
     runId: runIdStr,
+    commandKey,
     outputBuffer: "",
     chunkIndex: 0,
     flushTimer: setInterval(() => {
       flushOutput(ctx, tracked).catch(() => {});
     }, OUTPUT_FLUSH_INTERVAL_MS),
-    timeoutTimer
+    softTimeoutTimer: null
   };
   tracked.flushTimer.unref?.();
   runningProcesses.set(runIdStr, tracked);
+  runningProcessesByCommand.set(commandKey, runIdStr);
+  const softTimeoutTimer = setTimeout(async () => {
+    console.log(`[${formatTimestamp()}] ⏰ Command soft timeout (24h): ${commandName} (runId: ${runIdStr})`);
+    const currentTracked = runningProcesses.get(runIdStr);
+    if (!currentTracked)
+      return;
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId,
+        status: "killed",
+        terminationReason: "timeout-24h"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as killed (timeout): ${getErrorMessage(err)}`);
+    }
+    killProcess(child, "SIGTERM");
+    setTimeout(() => {
+      if (!runningProcesses.has(runIdStr))
+        return;
+      console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
+      killProcess(child, "SIGKILL");
+    }, SIGTERM_GRACE_PERIOD_MS);
+  }, SOFT_TIMEOUT_MS);
+  softTimeoutTimer.unref?.();
+  tracked.softTimeoutTimer = softTimeoutTimer;
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
       sessionId: ctx.sessionId,
@@ -75997,9 +76045,12 @@ async function onCommandRun(ctx, event) {
     console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     await flushOutput(ctx, tracked).catch(() => {});
     clearInterval(tracked.flushTimer);
-    if (tracked.timeoutTimer)
-      clearTimeout(tracked.timeoutTimer);
+    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";
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -76016,9 +76067,12 @@ async function onCommandRun(ctx, event) {
   child.on("error", async (err) => {
     console.error(`[${formatTimestamp()}] ❌ Command spawn failed: ${commandName}: ${err.message}`);
     clearInterval(tracked.flushTimer);
-    if (tracked.timeoutTimer)
-      clearTimeout(tracked.timeoutTimer);
+    if (tracked.softTimeoutTimer)
+      clearTimeout(tracked.softTimeoutTimer);
     runningProcesses.delete(runIdStr);
+    if (runningProcessesByCommand.get(commandKey) === runIdStr) {
+      runningProcessesByCommand.delete(commandKey);
+    }
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76031,36 +76085,6 @@ async function onCommandRun(ctx, event) {
     }
   });
 }
-function killProcess(child, signal) {
-  const pid = child.pid;
-  if (pid) {
-    try {
-      process.kill(-pid, signal);
-      return;
-    } catch {}
-  }
-  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 onCommandStop(ctx, event) {
   const runIdStr = event.runId.toString();
   const tracked = runningProcesses.get(runIdStr);
@@ -76081,19 +76105,16 @@ async function onCommandStop(ctx, event) {
     return;
   }
   console.log(`[${formatTimestamp()}] \uD83D\uDED1 Stopping command run: ${runIdStr}`);
-  if (tracked.timeoutTimer) {
-    clearTimeout(tracked.timeoutTimer);
-    tracked.timeoutTimer = null;
+  if (tracked.softTimeoutTimer) {
+    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");
-    const exitedAfterSigkill = await waitForExit(runIdStr, 1000);
-    if (!exitedAfterSigkill) {
-      console.error(`[${formatTimestamp()}] ❌ Failed to stop process for run: ${runIdStr} — process did not exit after SIGKILL`);
-    }
+    await waitForExit(runIdStr, 1000);
   }
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -76110,49 +76131,47 @@ async function shutdownAllCommands(ctx) {
   if (runningProcesses.size === 0)
     return;
   console.log(`[${formatTimestamp()}] Shutting down ${runningProcesses.size} running command(s)...`);
-  for (const [, tracked] of runningProcesses) {
+  const trackedEntries = [...runningProcesses.entries()];
+  for (const [, tracked] of trackedEntries) {
     clearInterval(tracked.flushTimer);
-    if (tracked.timeoutTimer)
-      clearTimeout(tracked.timeoutTimer);
+    if (tracked.softTimeoutTimer)
+      clearTimeout(tracked.softTimeoutTimer);
     await flushOutput(ctx, tracked).catch(() => {});
-    const pid = tracked.process.pid;
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGTERM");
-      } catch {
-        tracked.process.kill("SIGTERM");
-      }
-    } else {
-      tracked.process.kill("SIGTERM");
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId: tracked.runId,
+        status: "killed",
+        terminationReason: "daemon-shutdown"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as killed on shutdown: ${getErrorMessage(err)}`);
     }
+    killProcess(tracked.process, "SIGTERM");
   }
   await new Promise((resolve5) => {
     const t = setTimeout(resolve5, 3000);
     t.unref?.();
   });
-  for (const [, tracked] of runningProcesses) {
-    const pid = tracked.process.pid;
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGKILL");
-      } catch {}
-    } else {
-      try {
-        tracked.process.kill("SIGKILL");
-      } catch {}
+  for (const [, tracked] of trackedEntries) {
+    if (runningProcesses.has(tracked.runId)) {
+      killProcess(tracked.process, "SIGKILL");
     }
   }
   runningProcesses.clear();
+  runningProcessesByCommand.clear();
   console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, DEFAULT_COMMAND_TIMEOUT_MS, SIGTERM_GRACE_PERIOD_MS = 5000;
+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;
-  DEFAULT_COMMAND_TIMEOUT_MS = 30 * 60 * 1000;
+  SOFT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/handlers/ping.ts
@@ -79289,5 +79308,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=A3C30103B208BB9B64756E2164756E21
+//# debugId=1884CBA22481288264756E2164756E21
 //# sourceMappingURL=index.js.map