chatroom-cli 1.38.5 → 1.38.7

package/dist/index.js

@@ -75146,33 +75146,59 @@ async function getCommitStatusChecks(cwd, ref) {
   if (!repoSlug)
     return null;
   try {
-    const [checkRunsResult, statusResult] = await Promise.all([
+    const [checkRunsResult, legacyStatusesResult] = await Promise.all([
       runCommand(`gh api repos/${repoSlug}/commits/${encodeURIComponent(ref)}/check-runs --jq '{check_runs: [.check_runs[] | {name: .name, status: .status, conclusion: .conclusion}], total_count: .total_count}'`, cwd),
-      runCommand(`gh api repos/${repoSlug}/commits/${encodeURIComponent(ref)}/status --jq '.state'`, cwd)
+      runCommand(`gh api repos/${repoSlug}/commits/${encodeURIComponent(ref)}/statuses --jq '[group_by(.context)[] | max_by(.created_at) | {context: .context, state: .state, target_url: .target_url}]'`, cwd)
     ]);
-    if ("error" in checkRunsResult || "error" in statusResult)
+    if ("error" in checkRunsResult || "error" in legacyStatusesResult)
       return null;
     const checkRunsData = JSON.parse(checkRunsResult.stdout.trim());
-    const combinedState = statusResult.stdout.trim() || "pending";
-    let state = combinedState;
-    if (checkRunsData.total_count > 0) {
-      const conclusions = checkRunsData.check_runs.map((cr) => cr.conclusion);
-      if (conclusions.some((c) => c === "failure" || c === "timed_out")) {
-        state = "failure";
-      } else if (conclusions.every((c) => c === "success" || c === "skipped" || c === "neutral")) {
-        state = "success";
-      } else if (checkRunsData.check_runs.some((cr) => cr.status !== "completed")) {
-        state = "pending";
+    const legacyStatuses = JSON.parse(legacyStatusesResult.stdout.trim());
+    const modernEntries = checkRunsData.check_runs.map((cr) => ({
+      name: cr.name,
+      status: cr.status,
+      conclusion: cr.conclusion,
+      source: "check-run"
+    }));
+    const legacyEntries = legacyStatuses.map((s) => {
+      let status3;
+      let conclusion;
+      switch (s.state) {
+        case "success":
+          status3 = "completed";
+          conclusion = "success";
+          break;
+        case "failure":
+        case "error":
+          status3 = "completed";
+          conclusion = "failure";
+          break;
+        default:
+          status3 = "in_progress";
+          conclusion = null;
       }
+      return {
+        name: s.context,
+        status: status3,
+        conclusion,
+        source: "status",
+        url: s.target_url ?? null
+      };
+    });
+    const merged = [...modernEntries, ...legacyEntries];
+    const FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "error"]);
+    let state;
+    if (merged.some((e) => e.conclusion !== null && FAILURE_CONCLUSIONS.has(e.conclusion))) {
+      state = "failure";
+    } else if (merged.some((e) => e.status !== "completed")) {
+      state = "pending";
+    } else {
+      state = "success";
     }
     return {
       state,
-      checkRuns: checkRunsData.check_runs.map((cr) => ({
-        name: cr.name,
-        status: cr.status,
-        conclusion: cr.conclusion
-      })),
-      totalCount: checkRunsData.total_count
+      checkRuns: merged,
+      totalCount: merged.length
     };
   } catch {
     return null;
@@ -75858,6 +75884,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 +75924,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 +75979,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 +76008,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 +76071,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 +76093,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 +76111,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 +76131,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 +76157,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 +79334,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=A3C30103B208BB9B64756E2164756E21
+//# debugId=5B0DF926AD89205364756E2164756E21
 //# sourceMappingURL=index.js.map