@polderlabs/bizar 10.7.2 → 10.11.0

package/bizar-dash/src/cli/dashboard-ports.mjs

@@ -1,488 +0,0 @@
-/**
- * src/cli/dashboard-ports.mjs
- *
- * v3.20.7 — Discover every running Bizar dashboard on this machine,
- * classify it as healthy / zombie / orphan / dead, and provide cleanup
- * helpers. Solves the long-standing "why is there a dashboard on
- * port 4321 that I can't reach but won't go away?" problem.
- *
- * We can't trust the port file (it tracks only the most-recent start,
- * written to the last successful boot). Use a combination of:
- *   1. Read the canonical PID from ~/.config/bizar/dashboard.pid
- *   2. Scan all node processes via `ps` for `bizar dash start` /
- *      `@polderlabs/bizar-dash/src/cli.mjs start`
- *   3. For each candidate PID, walk /proc/<pid>/fd → socket inodes →
- *      /proc/net/tcp to find its listening port (Linux only)
- *   4. TCP-probe each candidate port (1.5s timeout, transport-only)
- *   5. HTTP-probe each reachable port's /api/health endpoint
- *
- * Result classification:
- *   - 'healthy' PID alive + /api/health returns ok:true
- *   - 'zombie'  PID alive + port accepts TCP but health probe fails
- *              (request handler deadlock, event loop starved, etc.)
- *   - 'dead'    PID does not exist (orphaned port file)
- *   - 'orphan'  Port responds to health but no PID file knows about it
- *              (started by a different process, port file deleted)
- *
- * Exports:
- *   - findAllDashboards()  → DashboardInstance[]
- *   - killDashboard(pid, signal?) → boolean
- *   - summarize(instances) → friendly multi-line report
- *
- * Cross-platform: the /proc-fd walk is Linux-only. On macOS/Windows
- * we fall back to canonical-PID + port range scan.
- */
-import { execSync, spawn } from 'node:child_process';
-import {
-  existsSync,
-  readFileSync,
-  readlinkSync,
-  readdirSync,
-  writeFileSync,
-  unlinkSync,
-} from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import net from 'node:net';
-
-export const DEFAULT_PORT_START = 4321;
-export const DEFAULT_PORT_END = 4530;
-export const HEALTH_PROBE_TIMEOUT_MS = 1500;
-export const TCP_PROBE_TIMEOUT_MS = 800;
-
-const HOME = homedir();
-const BIZAR_HOME = process.platform === 'win32'
-  ? join(process.env.APPDATA || HOME, 'bizar')
-  : join(HOME, '.config', 'bizar');
-export const PID_FILE = join(BIZAR_HOME, 'dashboard.pid');
-export const PORT_FILE = join(BIZAR_HOME, 'dashboard.port');
-
-/**
- * @typedef {Object} DashboardInstance
- * @property {number|null} pid          PID of the node process (null if unknown)
- * @property {number|null} port         TCP port the dashboard listens on
- * @property {'healthy'|'zombie'|'dead'|'orphan'|'unknown'} state
- * @property {boolean}     portReachable  TCP probe succeeded
- * @property {boolean}     healthOk        /api/health returned ok:true
- * @property {string}      cmdline         Full process command line (or note)
- * @property {'pid-file'|'ps-scan'|'port-scan'} source  How we found it
- * @property {boolean}     isCanonical     Matches the PID file
- */
-
-export function readCanonical() {
-  let pid = null;
-  let port = null;
-  try {
-    const v = parseInt(readFileSync(PID_FILE, 'utf8').trim(), 10);
-    if (Number.isFinite(v) && v > 0) pid = v;
-  } catch { /* ignore */ }
-  try {
-    const v = parseInt(readFileSync(PORT_FILE, 'utf8').trim(), 10);
-    if (Number.isFinite(v) && v > 0 && v <= 65535) port = v;
-  } catch { /* ignore */ }
-  return { pid, port };
-}
-
-/** True if a PID is alive (signal 0 trick). */
-export function pidAlive(pid) {
-  if (!pid || !Number.isFinite(pid)) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** TCP connect probe — auth-free, transport-only. */
-export function tcpProbe(port, timeoutMs = TCP_PROBE_TIMEOUT_MS) {
-  return new Promise((resolve) => {
-    const sock = net.createConnection({ port, host: '127.0.0.1' });
-    let settled = false;
-    const finish = (ok) => {
-      if (settled) return;
-      settled = true;
-      try { sock.destroy(); } catch { /* ignore */ }
-      resolve(ok);
-    };
-    sock.setTimeout(timeoutMs);
-    sock.once('connect', () => finish(true));
-    sock.once('error', () => finish(false));
-    sock.once('timeout', () => finish(false));
-  });
-}
-
-/** HTTP probe — returns true only if /api/health returns ok:true. */
-export async function httpHealth(port, timeoutMs = HEALTH_PROBE_TIMEOUT_MS) {
-  try {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
-    const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: ctrl.signal });
-    clearTimeout(timer);
-    if (!res.ok) return false;
-    let json = null;
-    try { json = await res.json(); } catch { return false; }
-    return json && json.ok === true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Find the listening TCP port for a PID by walking /proc/<pid>/fd and
- * matching socket inodes against /proc/net/tcp. Linux-only.
- * Returns null on other platforms or if the PID has no listening socket.
- */
-export function pidListeningPort(pid) {
-  if (process.platform !== 'linux') return null;
-  try {
-    const fdDir = `/proc/${pid}/fd`;
-    if (!existsSync(fdDir)) return null;
-    const inodes = new Set();
-    for (const fd of readdirSync(fdDir)) {
-      try {
-        const target = readlinkSync(join(fdDir, fd));
-        const m = target.match(/socket:\[(\d+)\]/);
-        if (m) inodes.add(m[1]);
-      } catch { /* stale fd — ignore */ }
-    }
-    if (inodes.size === 0) return null;
-    const tcp = readFileSync('/proc/net/tcp', 'utf8');
-    // 127.0.0.1 in little-endian hex = 0100007F
-    // 0.0.0.0     in little-endian hex = 00000000
-    const LOCAL_IPS = new Set(['0100007F', '00000000']);
-    for (const line of tcp.split('\n').slice(1)) {
-      const cols = line.trim().split(/\s+/);
-      if (cols.length < 10) continue;
-      const local = cols[1];
-      if (!local.includes(':')) continue;
-      const [ipHex, portHex] = local.split(':');
-      if (!LOCAL_IPS.has(ipHex)) continue;
-      const port = parseInt(portHex, 16);
-      const inode = cols[9];
-      if (inodes.has(inode)) return port;
-    }
-  } catch { /* ignore */ }
-  return null;
-}
-
-/**
- * `ps`-based fallback to find every node process whose argv mentions
- * the Bizar dashboard CLI. Returns a list of { pid, cmdline }.
- *
- * v3.20.14 — tightened the pattern + added an explicit cmdline
- * re-verification step that the caller MUST do before trusting the
- * match. The previous version matched anything containing the substring
- * "bizar dash" or "@polderlabs/bizar-dash/src/cli.mjs" — which is fine
- * for finding real dashboards but breaks when:
- *   - The PID is recycled to a different process between ps-scan and
- *     `pidAlive(pid)` (Linux recycles PIDs in milliseconds).
- *   - A previous run wrote a stale `dashboard.pid` file referencing a
- *     PID that's now owned by an unrelated process (chrome-headless-shell
- *     renderer, ssh session, etc.).
- *   - The cmdline contains a path that no longer exists on disk
- *     (e.g. /home/drb0rk/.local/npm/bin/bizar after a clean npm install).
- *
- * The fix: only record a ps-scan match if the cmdline actually looks
- * like a node-launched Bizar dashboard CLI. The `cmdlineLooksLikeDashboard`
- * helper does the structural check (node binary + cli.mjs OR a known
- * `bizar` bin path + `dash start`). Then the caller's `pidAlive`
- * step re-reads /proc/<pid>/cmdline and calls the same helper to
- * confirm the PID hasn't been recycled.
- *
- * Skips our own process (the runner) so the CLI doesn't see itself.
- */
-export function psScanDashboards() {
-  const out = new Map(); // pid → cmdline
-  if (process.platform === 'win32') {
-    // tasklist | findstr — too platform-specific for now; users on
-    // Windows who hit this can restart their machine. The canonical
-    // PID file path still works on Windows.
-    return out;
-  }
-  try {
-    const result = execSync(
-      // Match `bizar dash` or `@polderlabs/bizar-dash/src/cli.mjs`. The
-      // pipe through grep -v grep is still needed to suppress grep's
-      // own argv from matching the regex.
-      `ps -eo pid=,args= 2>/dev/null | grep -E '(bizar[ ]+dash|@polderlabs/bizar-dash/src/cli\\.mjs)' | grep -v grep || true`,
-      { encoding: 'utf8', timeout: 5000 },
-    );
-    for (const line of result.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      // Format: "<pid> <args...>" — pid is the first whitespace-delimited token.
-      const m = trimmed.match(/^(\d+)\s+(.+)$/);
-      if (!m) continue;
-      const pid = parseInt(m[1], 10);
-      if (!Number.isFinite(pid)) continue;
-      if (pid === process.pid) continue; // skip our own process
-      const cmdline = m[2].trim();
-      // Structural check: only keep matches that look like a real
-      // dashboard launch. Anything else is a false positive (PID
-      // recycled, or a process whose argv happens to contain the
-      // words "bizar dash" — e.g. a stale node process or a shell
-      // command that includes the words in a comment).
-      if (!cmdlineLooksLikeDashboard(cmdline)) continue;
-      out.set(pid, cmdline);
-    }
-  } catch {
-    // ps not available — fall back to canonical only
-  }
-  return out;
-}
-
-/**
- * Structural check: does this cmdline look like a Bizar dashboard
- * launch? We accept:
- *   - `node <anything>/@polderlabs/bizar-dash/src/cli.mjs [start|tui|...]`
- *   - `<path>/bizar dash <subcommand>` where `<path>` is a real-looking
- *     filesystem path (contains `/` or starts with `.`).
- *
- * Reject anything that doesn't match those patterns (e.g. a `bash -c`
- * shell command whose body mentions `bizar dash` in a comment).
- *
- * Implementation note: we anchor the `bizar` bin to a path-like prefix
- * by requiring it to be preceded by either the start of the cmdline,
- * a `/`, or a `\`. This rejects strings like
- * `bash -c "echo I want to run bizar dash start"` where `bizar dash
- * start` is mid-string inside a quoted argument — the `bizar` is
- * preceded by a space, not by a path separator.
- */
-export function cmdlineLooksLikeDashboard(cmdline) {
-  if (!cmdline || typeof cmdline !== 'string') return false;
-  // Direct CLI invocation: @polderlabs/bizar-dash/src/cli.mjs <verb>
-  if (/\/@polderlabs\/bizar-dash\/src\/cli\.mjs\b/.test(cmdline)) return true;
-  // Wrapped via the `bizar` bin: <path>/bizar dash <subcommand>.
-  // - The `bizar` token must be preceded by a path separator (so it's
-  //   a binary path, not an arbitrary word in a comment).
-  // - The `dash` and subcommand must be whitespace-delimited argv.
-  if (/(?:^|[\/\\])\S*bizar\s+dash\s+(?:start|tui|stop|status|cleanup)\b/.test(cmdline)) return true;
-  return false;
-}
-
-/**
- * Re-read /proc/<pid>/cmdline and verify the cmdline still looks like
- * a dashboard launch. Linux recycles PIDs aggressively — between
- * `psScanDashboards` returning a PID and `pidAlive(pid)` succeeding,
- * the PID may have been reassigned to an unrelated process. We catch
- * that by reading /proc/<pid>/cmdline fresh and re-applying the
- * structural check. Returns the cmdline string on success, null on
- * failure (PID dead, /proc unreadable, or cmdline no longer matches).
- */
-export function verifyCmdlineAtProbeTime(pid) {
-  if (!pid) return null;
-  try {
-    const cmdline = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ').trim();
-    if (cmdlineLooksLikeDashboard(cmdline)) return cmdline;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Discover every Bizar dashboard process on this machine.
- *
- * @param {Object} opts
- * @param {number} [opts.portStart=4321]   Start of port scan range
- * @param {number} [opts.portEnd=4530]     End of port scan range
- * @param {boolean} [opts.scanPorts=true]  If true, probe ports in [start, end] for orphans
- * @returns {Promise<DashboardInstance[]>}
- */
-export async function findAllDashboards({
-  portStart = DEFAULT_PORT_START,
-  portEnd = DEFAULT_PORT_END,
-  scanPorts = true,
-} = {}) {
-  const canonical = readCanonical();
-  /** @type {Map<number, DashboardInstance>} */
-  const byPid = new Map();
-
-  // 1. Canonical PID — even if dead, record it so the user can clean up.
-  if (canonical.pid) {
-    const alive = pidAlive(canonical.pid);
-    let cmdline = '';
-    try { cmdline = readFileSync(`/proc/${canonical.pid}/cmdline`, 'utf8').replace(/\0/g, ' ').trim(); } catch {}
-    if (!cmdline) cmdline = '(no /proc entry — process likely exited)';
-    // v3.20.14 — only treat the canonical PID as canonical if the
-    // current cmdline still looks like a dashboard launch. A recycled
-    // PID (now owned by chrome, ssh, etc.) should NOT count as the
-    // canonical dashboard — the PID file is stale.
-    const cmdlineMatches = cmdlineLooksLikeDashboard(cmdline);
-    byPid.set(canonical.pid, {
-      pid: canonical.pid,
-      port: canonical.port,
-      // If PID is alive but cmdline is no longer a dashboard, the PID
-      // has been recycled. Mark as 'dead' so cleanup clears the
-      // stale PID file. Same if PID is genuinely dead.
-      state: alive && cmdlineMatches ? 'unknown' : 'dead',
-      portReachable: false,
-      healthOk: false,
-      cmdline,
-      // Only canonical if PID file path AND cmdline both look real.
-      // This prevents the "Found 1 dashboard: [healthy] pid 938619
-      // from ps-scan" trap where the PID file's PID has been recycled
-      // to an unrelated process.
-      isCanonical: cmdlineMatches,
-      source: 'pid-file',
-    });
-  }
-
-  // 2. ps scan — find every node process running the dashboard CLI.
-  const psResults = psScanDashboards();
-  for (const [pid, cmdline] of psResults) {
-    if (byPid.has(pid)) {
-      // Already known — backfill cmdline if it was empty.
-      const existing = byPid.get(pid);
-      if (!existing.cmdline || existing.cmdline.startsWith('(')) {
-        existing.cmdline = cmdline;
-      }
-      continue;
-    }
-    byPid.set(pid, {
-      pid,
-      port: null,
-      state: 'unknown',
-      portReachable: false,
-      healthOk: false,
-      cmdline,
-      source: 'ps-scan',
-      isCanonical: false,
-    });
-  }
-
-  // 3. Probe each PID's listening port + health.
-  for (const inst of byPid.values()) {
-    if (!pidAlive(inst.pid)) {
-      inst.state = 'dead';
-      continue;
-    }
-    // v3.20.14 — re-read /proc/<pid>/cmdline fresh and re-verify it
-    // still looks like a dashboard launch. Linux recycles PIDs
-    // aggressively; a PID that matched ps-scan a moment ago may
-    // now belong to an unrelated process (chrome-headless-shell
-    // renderer, ssh session, etc.). If the cmdline no longer matches
-    // the dashboard pattern, the PID is recycled — mark it dead.
-    if (inst.source === 'ps-scan') {
-      const fresh = verifyCmdlineAtProbeTime(inst.pid);
-      if (fresh === null) {
-        inst.state = 'dead';
-        continue;
-      }
-      // Update cmdline in case it changed (the argv we saw at scan time
-      // might have been a stale /proc snapshot — extremely rare but
-      // possible during a process exec).
-      if (fresh !== inst.cmdline) inst.cmdline = fresh;
-    }
-    // Resolve port: prefer /proc fd walk; fall back to canonical port for PID file match.
-    if (!inst.port) {
-      const discovered = pidListeningPort(inst.pid);
-      if (discovered) inst.port = discovered;
-    }
-    if (!inst.port) continue; // can't probe without a port
-    inst.portReachable = await tcpProbe(inst.port);
-    if (!inst.portReachable) continue;
-    inst.healthOk = await httpHealth(inst.port);
-    inst.state = inst.healthOk ? 'healthy' : 'zombie';
-  }
-
-  // 4. Port-range scan for orphans — ports that respond to health but
-  //    no PID claimed them.
-  if (scanPorts) {
-    const claimed = new Set(
-      Array.from(byPid.values()).filter(i => i.port).map(i => i.port),
-    );
-    for (let p = portStart; p <= portEnd; p++) {
-      if (claimed.has(p)) continue;
-      const reachable = await tcpProbe(p);
-      if (!reachable) continue;
-      const healthOk = await httpHealth(p);
-      if (!healthOk) continue;
-      // We found a port responding to /api/health that no PID claimed.
-      // This is an orphan — typically started by a different user or
-      // after the port file was deleted.
-      byPid.set(-p, {
-        pid: null,
-        port: p,
-        state: 'orphan',
-        portReachable: true,
-        healthOk: true,
-        cmdline: '(unknown — no PID claimed this port)',
-        source: 'port-scan',
-        isCanonical: false,
-      });
-    }
-  }
-
-  return Array.from(byPid.values()).sort((a, b) => {
-    // Canonical first, then by port, then by pid
-    if (a.isCanonical !== b.isCanonical) return a.isCanonical ? -1 : 1;
-    if (a.port !== b.port) return (a.port || 0) - (b.port || 0);
-    return (a.pid || 0) - (b.pid || 0);
-  });
-}
-
-/**
- * Send a signal to a PID. Returns true if the signal was delivered.
- * `signal` defaults to 'SIGTERM' (graceful). Use 'SIGKILL' for stuck procs.
- */
-export function killDashboard(pid, signal = 'SIGTERM') {
-  if (!pid) return false;
-  try {
-    process.kill(pid, signal);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Clear the canonical PID/port files (only if the PID is dead or matches).
- */
-export function clearCanonicalFiles(onlyIfPid = null) {
-  if (onlyIfPid !== null) {
-    const canonical = readCanonical();
-    if (canonical.pid !== onlyIfPid) return false;
-  }
-  try { unlinkSync(PID_FILE); } catch { /* ignore */ }
-  try { unlinkSync(PORT_FILE); } catch { /* ignore */ }
-  return true;
-}
-
-/**
- * Wait for a PID to exit (poll). Returns true if it exited within
- * `timeoutMs`, false otherwise.
- */
-export async function waitForExit(pid, timeoutMs = 5000, intervalMs = 200) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (!pidAlive(pid)) return true;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  return !pidAlive(pid);
-}
-
-/**
- * Render a friendly multi-line summary of dashboard instances for the CLI.
- */
-export function summarize(instances) {
-  if (!instances.length) {
-    return 'No dashboards detected.';
-  }
-  const lines = [];
-  lines.push(`Found ${instances.length} dashboard${instances.length === 1 ? '' : 's'}:`);
-  lines.push('');
-  for (const inst of instances) {
-    const tag = inst.isCanonical ? '★ canonical' : '  ';
-    const stateTag = `[${inst.state.padEnd(8)}]`;
-    const portStr = inst.port ? `:${inst.port}` : '(no port)';
-    const pidStr = inst.pid ? `pid ${inst.pid}` : 'pid ?';
-    lines.push(`  ${tag} ${stateTag} ${pidStr.padEnd(12)} ${portStr.padEnd(10)} ${inst.source}`);
-    if (inst.cmdline) {
-      const cl = inst.cmdline.length > 100 ? inst.cmdline.slice(0, 97) + '...' : inst.cmdline;
-      lines.push(`             ${cl}`);
-    }
-  }
-  return lines.join('\n');
-}