bosun 0.33.8 → 0.33.9

package/agent-endpoint.mjs

@@ -31,6 +31,7 @@ const DEFAULT_PORT = 18432;
 const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
 const REQUEST_TIMEOUT_MS = 30_000; // 30 seconds
 const ACCESS_DENIED_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
+const BOSUN_ROOT_HINT = __dirname.toLowerCase().replace(/\\/g, '/');
 
 // Valid status transitions when an agent self-reports
 const VALID_TRANSITIONS = {
@@ -175,6 +176,41 @@ function isAlreadyExitedProcessError(err) {
   );
 }
 
+function normalizeCommandLine(commandLine) {
+  return String(commandLine || "").toLowerCase().replace(/\\/g, "/").trim();
+}
+
+function isLikelyBosunCommandLine(commandLine) {
+  const normalized = normalizeCommandLine(commandLine);
+  if (!normalized) return false;
+
+  if (normalized.includes(BOSUN_ROOT_HINT)) return true;
+
+  if (
+    normalized.includes("/bosun/") &&
+    (normalized.includes("monitor.mjs") ||
+      normalized.includes("cli.mjs") ||
+      normalized.includes("agent-endpoint.mjs") ||
+      normalized.includes("ve-orchestrator"))
+  ) {
+    return true;
+  }
+
+  // Dev-mode often launches monitor as node monitor.mjs from bosun root.
+  if (/\bnode(?:\.exe)?\b/.test(normalized) && /\bmonitor\.mjs\b/.test(normalized)) {
+    return true;
+  }
+
+  return false;
+}
+
+function summarizeCommandLine(commandLine, maxLen = 140) {
+  const compact = String(commandLine || "").replace(/\s+/g, " ").trim();
+  if (!compact) return "command line unavailable";
+  if (compact.length <= maxLen) return compact;
+  return compact.slice(0, maxLen) + "...";
+}
+
 // ── AgentEndpoint Class ─────────────────────────────────────────────────────
 
 export class AgentEndpoint {
@@ -311,7 +347,7 @@ export class AgentEndpoint {
       const { execSync, spawnSync } = await import("node:child_process");
       const isWindows = process.platform === "win32";
       let output;
-      let pids = new Set();
+      const pids = new Set();
 
       // PIDs we must NEVER kill — ourselves, our parent (cli.mjs fork host),
       // and any ancestor in the same process tree.  lsof can return these when
@@ -321,13 +357,43 @@ export class AgentEndpoint {
         String(process.ppid),
       ]);
 
+      const readProcessCommandLine = (pid) => {
+        try {
+          if (isWindows) {
+            const query = `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" -ErrorAction SilentlyContinue; if ($p) { $p.CommandLine }`;
+            const result = spawnSync(
+              "powershell",
+              ["-NoProfile", "-Command", query],
+              {
+                encoding: "utf8",
+                timeout: 5000,
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"],
+              },
+            );
+            if (result.error || result.status !== 0) return "";
+            return String(result.stdout || "").trim();
+          }
+
+          const result = spawnSync("ps", ["-p", String(pid), "-o", "args="], {
+            encoding: "utf8",
+            timeout: 5000,
+            stdio: ["ignore", "pipe", "pipe"],
+          });
+          if (result.error || result.status !== 0) return "";
+          return String(result.stdout || "").trim();
+        } catch {
+          return "";
+        }
+      };
+
       if (isWindows) {
         // Windows: netstat -ano | findstr
         output = execSync(`netstat -ano | findstr ":${port}"`, {
           encoding: "utf8",
           timeout: 5000,
         }).trim();
-        const lines = output.split("\n").filter((l) => l.includes("LISTENING"));
+        const lines = output.split("\n").filter((line) => line.includes("LISTENING"));
         for (const line of lines) {
           const parts = line.trim().split(/\s+/);
           const pid = parts[parts.length - 1];
@@ -342,7 +408,7 @@ export class AgentEndpoint {
             encoding: "utf8",
             timeout: 5000,
           }).trim();
-          const pidList = output.split("\n").filter((p) => p.trim());
+          const pidList = output.split("\n").filter((pid) => pid.trim());
           for (const pid of pidList) {
             if (pid && /^\d+$/.test(pid) && !protectedPids.has(pid)) {
               pids.add(pid);
@@ -363,7 +429,23 @@ export class AgentEndpoint {
         }
       }
 
+      const killEligiblePids = new Set();
       for (const pid of pids) {
+        const commandLine = readProcessCommandLine(pid);
+        if (!isLikelyBosunCommandLine(commandLine)) {
+          console.warn(
+            `${TAG} Port ${port} held by non-bosun PID ${pid} (${summarizeCommandLine(commandLine)}); skipping forced kill`,
+          );
+          continue;
+        }
+        killEligiblePids.add(pid);
+      }
+
+      if (killEligiblePids.size === 0) {
+        return;
+      }
+
+      for (const pid of killEligiblePids) {
         console.log(`${TAG} Sending SIGTERM to stale process PID ${pid} on port ${port}`);
         try {
           if (isWindows) {
@@ -421,12 +503,13 @@ export class AgentEndpoint {
           );
         }
       }
+
       // Give the SIGTERM'd processes time to exit gracefully
       await new Promise((r) => setTimeout(r, 2000));
 
       // Escalate: check if any are still alive and SIGKILL them
       if (!isWindows) {
-        for (const pid of pids) {
+        for (const pid of killEligiblePids) {
           try {
             process.kill(Number(pid), 0); // probe — throws if dead
             console.warn(`${TAG} PID ${pid} still alive after SIGTERM — sending SIGKILL`);
@@ -447,7 +530,6 @@ export class AgentEndpoint {
       }
     }
   }
-
   /**
    * Stop the HTTP server.
    * @returns {Promise<void>}

package/maintenance.mjs

@@ -468,6 +468,7 @@ export function cleanupStaleBranches(repoRoot, opts = {}) {
 
 const PID_FILE_NAME = "bosun.pid";
 const MONITOR_MARKER = "bosun/monitor.mjs";
+const PID_START_TIME_TOLERANCE_MS = 90_000;
 
 function parsePidFile(raw) {
   const text = String(raw || "").trim();
@@ -483,24 +484,72 @@ function parsePidFile(raw) {
   return { pid: Number(text), raw: text };
 }
 
-function getProcessCommandLine(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return "";
+function getProcessSnapshot(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
   const processes = getProcesses();
   const entry = processes.find((p) => Number(p.pid) === Number(pid));
-  return entry?.commandLine || "";
+  if (!entry) return null;
+  return {
+    commandLine: entry.commandLine || "",
+    creationDate: entry.creationDate || null,
+  };
 }
 
-function classifyMonitorProcess(pid) {
-  const cmd = getProcessCommandLine(pid);
-  if (!cmd) return "unknown";
-  const normalized = cmd.toLowerCase();
+export function classifyMonitorCommandLine(commandLine) {
+  const normalized = String(commandLine || "").toLowerCase().replace(/\\/g, "/");
+  if (!normalized.trim()) return "unknown";
   if (normalized.includes(MONITOR_MARKER)) return "monitor";
   if (normalized.includes("bosun") && normalized.includes("monitor.mjs")) {
     return "monitor";
   }
+
+  // Dev-mode launches often use a relative script path: `node monitor.mjs`.
+  if (
+    /\bnode(?:\.exe)?\b/.test(normalized) &&
+    /(?:^|[\s"'=])monitor\.mjs(?:$|[\s"'])/.test(normalized)
+  ) {
+    return "monitor";
+  }
+
+  if (
+    normalized.includes("bosun") &&
+    normalized.includes("cli.mjs") &&
+    normalized.includes("monitormonitor")
+  ) {
+    return "monitor";
+  }
+
   return "other";
 }
 
+function isLikelySameProcessFromPidFile(processInfo, pidFileData) {
+  if (!processInfo || !pidFileData?.started_at) return null;
+  const lockStartMs = Date.parse(pidFileData.started_at);
+  const processStartMs = processInfo.creationDate?.getTime?.() || NaN;
+  if (!Number.isFinite(lockStartMs) || !Number.isFinite(processStartMs)) {
+    return null;
+  }
+  return Math.abs(processStartMs - lockStartMs) <= PID_START_TIME_TOLERANCE_MS;
+}
+
+function pidFileLooksLikeMonitor(pidFileData) {
+  if (!pidFileData || !Array.isArray(pidFileData.argv)) return false;
+  return classifyMonitorCommandLine(pidFileData.argv.join(" ")) === "monitor";
+}
+
+function classifyMonitorProcess(pid, pidFileData) {
+  const processInfo = getProcessSnapshot(pid);
+  const commandClass = classifyMonitorCommandLine(processInfo?.commandLine || "");
+  if (commandClass === "monitor") return "monitor";
+
+  // Fallback for cases where OS command-line capture omits argv.
+  const sameProcess = isLikelySameProcessFromPidFile(processInfo, pidFileData);
+  if (sameProcess === true && pidFileLooksLikeMonitor(pidFileData)) {
+    return "monitor";
+  }
+
+  return commandClass;
+}
 /**
  * Acquire a singleton lock by writing our PID file.
  * If a stale monitor is detected (PID file exists but process dead), clean up and take over.
@@ -587,7 +636,7 @@ export function acquireMonitorLock(lockDir) {
           existingPid !== process.pid &&
           isProcessAlive(existingPid)
         ) {
-          const classification = classifyMonitorProcess(existingPid);
+          const classification = classifyMonitorProcess(existingPid, parsed.data);
           if (classification === "monitor") {
             console.error(
               "[maintenance] another bosun is already running (PID " + existingPid + "). Exiting.",

package/monitor.mjs

@@ -800,6 +800,26 @@ let githubReconcile = githubReconcileConfig || {
   mergedLookbackHours: 72,
   trackingLabels: ["tracking"],
 };
+let chdirUnsupportedInRuntime = false;
+
+function isChdirUnsupportedError(err) {
+  if (!err) {
+    return false;
+  }
+  const code = String(err.code || "");
+  const message = String(err.message || "").toLowerCase();
+  return (
+    code === "ERR_WORKER_UNSUPPORTED_OPERATION" ||
+    message.includes("process.chdir() is not supported in workers")
+  );
+}
+
+function normalizePathForCompare(pathValue) {
+  const normalized = String(pathValue || "")
+    .replace(/[\\/]+/g, "/")
+    .replace(/\/+$/, "");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
 
 // ── Ensure CWD is the repo root ─────────────────────────────────────────────
 // The daemon is spawned with cwd=homedir (to avoid deleted worktree paths).
@@ -807,9 +827,13 @@ let githubReconcile = githubReconcileConfig || {
 // trusted git directory, preventing "Not inside a trusted directory" errors.
 // Prefer agentRepoRoot (workspace-aware) over raw repoRoot.
 const effectiveRepoRoot = agentRepoRoot || repoRoot;
-if (!isMainThread) {
+const needsChdir =
+  effectiveRepoRoot &&
+  normalizePathForCompare(process.cwd()) !==
+    normalizePathForCompare(effectiveRepoRoot);
+if (!isMainThread || chdirUnsupportedInRuntime) {
   // Worker threads cannot call process.chdir(); skip to avoid noisy warnings.
-} else if (effectiveRepoRoot && process.cwd() !== effectiveRepoRoot) {
+} else if (needsChdir) {
   try {
     process.chdir(effectiveRepoRoot);
     console.log(`[monitor] changed CWD to repo root: ${effectiveRepoRoot}`);
@@ -818,14 +842,29 @@ if (!isMainThread) {
       console.log(`[monitor] developer repo root: ${repoRoot}`);
     }
   } catch (err) {
-    console.warn(`[monitor] could not chdir to ${effectiveRepoRoot}: ${err.message}`);
-    // Fall back to repoRoot if agentRepoRoot failed
-    if (agentRepoRoot && repoRoot && agentRepoRoot !== repoRoot) {
-      try {
-        process.chdir(repoRoot);
-        console.log(`[monitor] fell back to developer repo root: ${repoRoot}`);
-      } catch (e2) {
-        console.warn(`[monitor] could not chdir to fallback ${repoRoot}: ${e2.message}`);
+    if (isChdirUnsupportedError(err)) {
+      chdirUnsupportedInRuntime = true;
+      console.log("[monitor] runtime does not support process.chdir(); skipping CWD re-anchor.");
+    } else {
+      console.warn(`[monitor] could not chdir to ${effectiveRepoRoot}: ${err.message}`);
+      // Fall back to repoRoot if agentRepoRoot failed
+      if (
+        agentRepoRoot &&
+        repoRoot &&
+        agentRepoRoot !== repoRoot &&
+        normalizePathForCompare(process.cwd()) !== normalizePathForCompare(repoRoot)
+      ) {
+        try {
+          process.chdir(repoRoot);
+          console.log(`[monitor] fell back to developer repo root: ${repoRoot}`);
+        } catch (e2) {
+          if (isChdirUnsupportedError(e2)) {
+            chdirUnsupportedInRuntime = true;
+            console.log("[monitor] runtime does not support process.chdir(); fallback skipped.");
+          } else {
+            console.warn(`[monitor] could not chdir to fallback ${repoRoot}: ${e2.message}`);
+          }
+        }
       }
     }
   }
@@ -13159,8 +13198,21 @@ process.on("uncaughtException", (err) => {
     );
     return;
   }
+  // Always log the exception — even during shutdown — so the crash is traceable.
+  const detail = err?.stack || msg || String(err);
+  try {
+    process.stderr.write("[monitor] uncaughtException: " + detail + "\n");
+  } catch { /* stderr may be torn down */ }
+  try {
+    const crashDir = config?.logDir || resolve(__dirname, "logs");
+    mkdirSync(crashDir, { recursive: true });
+    appendFileSync(
+      resolve(crashDir, "monitor-crash-breadcrumb.log"),
+      `[${new Date().toISOString()}] uncaughtException (shuttingDown=${shuttingDown}): ${detail}\n`,
+    );
+  } catch { /* best effort */ }
   if (shuttingDown) return;
-  console.error("[monitor] uncaughtException: " + (err?.stack || msg));
+  console.error("[monitor] uncaughtException: " + detail);
   handleMonitorFailure("uncaughtException", err).catch((failureErr) => {
     try {
       process.stderr.write(
@@ -13174,6 +13226,16 @@ process.on("uncaughtException", (err) => {
 
 process.on("unhandledRejection", (reason) => {
   const msg = reason?.message || String(reason || "");
+  // Always write breadcrumb — unhandled rejections can cause exit code 1
+  try {
+    const crashDir = config?.logDir || resolve(__dirname, "logs");
+    mkdirSync(crashDir, { recursive: true });
+    const detail = reason instanceof Error ? (reason.stack || msg) : msg;
+    appendFileSync(
+      resolve(crashDir, "monitor-crash-breadcrumb.log"),
+      `[${new Date().toISOString()}] unhandledRejection (shuttingDown=${shuttingDown}): ${detail}\n`,
+    );
+  } catch { /* best effort */ }
   // Always suppress stream noise
   if (isStreamNoise(msg)) {
     console.error(
@@ -13199,14 +13261,26 @@ process.on("unhandledRejection", (reason) => {
 // ── Exit diagnostic: always log the exit code so crashes are traceable ──────
 process.on("exit", (code) => {
   if (code === 0 || code === SELF_RESTART_EXIT_CODE) return;
+  const ts = new Date().toISOString();
+  const line = `[${ts}] process exiting with code ${code} (shuttingDown=${shuttingDown}, uptime=${Math.round(process.uptime())}s)`;
   // Write directly to stderr — console may already be torn down at exit time
   try {
-    process.stderr.write(
-      `[monitor] process exiting with code ${code} (shuttingDown=${shuttingDown})\n`,
-    );
+    process.stderr.write("[monitor] " + line + "\n");
   } catch {
     /* best effort — stderr may be broken */
   }
+  // Persist breadcrumb to disk so the crash is always traceable even when
+  // stderr output is lost (e.g., background daemon, piped output).
+  try {
+    const crashDir = config?.logDir || resolve(__dirname, "logs");
+    mkdirSync(crashDir, { recursive: true });
+    appendFileSync(
+      resolve(crashDir, "monitor-crash-breadcrumb.log"),
+      line + "\n",
+    );
+  } catch {
+    /* best effort */
+  }
 });
 
 if (!isMonitorTestRuntime) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.33.8",
+  "version": "0.33.9",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/task-store.mjs

@@ -54,6 +54,7 @@ const ATOMIC_RENAME_FALLBACK_CODES = new Set(["EPERM", "EACCES", "EBUSY", "EXDEV
 let _store = null; // { _meta: {...}, tasks: { [id]: Task } }
 let _loaded = false;
 let _writeChain = Promise.resolve(); // simple write lock
+let _didLogInitialLoad = false;
 
 export function configureTaskStore(options = {}) {
   const baseDir = options.baseDir ? resolve(options.baseDir) : null;
@@ -74,6 +75,7 @@ export function configureTaskStore(options = {}) {
     _store = null;
     _loaded = false;
     _writeChain = Promise.resolve();
+    _didLogInitialLoad = false;
   }
 
   return storePath;
@@ -222,10 +224,13 @@ export function loadStore() {
         _meta: { ...defaultMeta(), ...(data._meta || {}) },
         tasks: data.tasks || {},
       };
-      console.log(
-        TAG,
-        `Loaded ${Object.keys(_store.tasks).length} tasks from disk`,
-      );
+      if (!_didLogInitialLoad) {
+        _didLogInitialLoad = true;
+        console.log(
+          TAG,
+          `Loaded ${Object.keys(_store.tasks).length} tasks from disk`,
+        );
+      }
     } else {
       _store = { _meta: defaultMeta(), tasks: {} };
       console.log(TAG, "No store file found — initialised empty store");