mixdog 0.7.1

package/src/status/server.mjs

@@ -0,0 +1,413 @@
+/**
+ * Status HTTP server (forked child process).
+ *
+ * A tiny loopback-only HTTP server that exposes GET /bridge/status for
+ * statusline consumers. Lives in its OWN process (forked by server.mjs
+ * at boot) so bursty MCP tool activity in the parent can't starve the
+ * statusline's short 1-second curl timeout.
+ *
+ * Binds to an ephemeral port on 127.0.0.1 and advertises the port via
+ * ~/.claude/mixdog-status.json so bin/statusline.sh can discover it
+ * without hard-coded port numbers.
+ *
+ * Can be used two ways:
+ *   1. Imported: `startStatusServer({ dataDir, advertisePath, log })` —
+ *      kept as a named export for tests / ad-hoc in-process hosting.
+ *   2. Spawned directly via `fork('src/status/server.mjs')` — config is
+ *      read from MIXDOG_STATUS_DATA_DIR / MIXDOG_STATUS_ADVERTISE_PATH
+ *      env vars. The parent kills this process at shutdown.
+ */
+
+import http from 'http';
+import { unlinkSync, mkdirSync, existsSync } from 'fs';
+import { readdir as readdirAsync, readFile as readFileAsync, unlink as unlinkAsync } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+import { buildBridgeStatus, buildBridgeStatusCompact, renderBridgeStatusText } from './aggregator.mjs';
+import { writeJsonAtomicSync } from '../shared/atomic-file.mjs';
+
+const OWNER_SESSION_ID = process.env.MIXDOG_OWNER_SESSION_ID || null;
+const OWNER_LEAD_PID = (() => {
+  const pid = Number(process.env.MIXDOG_OWNER_LEAD_PID);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+})();
+const OWNER_HOST_PID = (() => {
+  const pid = Number(process.env.MIXDOG_OWNER_HOST_PID);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+})();
+
+// Stale-session sweep. saveSession() never unlinks closed sessions, so the
+// sessions/ directory grows without bound for the lifetime of the install.
+// The aggregator scan cost is O(N) per statusline poll; once N reaches the
+// hundreds, the scan saturates a CPU core. Closed sessions older than 30 min
+// have no consumer (active filter uses .hb heartbeats; recent-completed
+// window is 30 min) so removing them is safe.
+const SESSION_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+const SESSION_STALE_MS = 30 * 60 * 1000;
+
+// Shared sweep helper. Both stale-session and stale-advert sweepers share
+// the same shape: readdir the directory, fan out per-file work via
+// Promise.all (parallel scan keeps a large dir from blocking the first
+// status response after boot), swallow per-file errors so one corrupt
+// file does not abort the batch, count removals, log only when >0.
+// `perFile` returns 1 when a file was removed, 0 otherwise.
+async function sweepDir(dir, perFile, log, message) {
+  if (!existsSync(dir)) return;
+  let names;
+  try { names = await readdirAsync(dir); } catch { return; }
+  const results = await Promise.all(names.map((f) => perFile(f)));
+  const removed = results.reduce((a, b) => a + b, 0);
+  if (removed > 0) log(`[status-server] sweep: removed ${removed} ${message}`);
+}
+
+async function sweepStaleSessions(sessionsDir, log) {
+  const now = Date.now();
+  await sweepDir(sessionsDir, async (f) => {
+    if (!f.endsWith('.json')) return 0;
+    const full = join(sessionsDir, f);
+    try {
+      const j = JSON.parse(await readFileAsync(full, 'utf-8'));
+      // Anchor stale-age on the terminal updatedAt (or closedAt), not
+      // createdAt: a long-lived bridge session that closed just before a
+      // sweep would otherwise be removed inside the aggregator's 30 min
+      // recent-completed window.
+      const terminalAt = Number.isFinite(j.updatedAt) ? j.updatedAt
+        : (Number.isFinite(j.closedAt) ? j.closedAt : null);
+      if (j.closed === true && terminalAt !== null && (now - terminalAt) > SESSION_STALE_MS) {
+        await unlinkAsync(full);
+        try { await unlinkAsync(full.replace(/\.json$/, '.hb')); } catch {}
+        return 1;
+      }
+    } catch { /* skip corrupt */ }
+    return 0;
+  }, log, 'stale closed sessions');
+}
+
+// Advert directory sweep. Each forked status-server writes its own
+// {session_id}.json into mixdog-status/. Crashes / SIGKILL / abrupt
+// supervisor restarts can leave files behind whose pid is no longer
+// alive. statusline.sh greps every advert each tick for cc_session_id
+// pairing, so accumulation linearly slows every refresh. Invariant: a
+// live owner is the only writer of its advert, so a pid whose process
+// is gone proves the advert is dead. process.kill(pid, 0) returns ESRCH
+// for non-existent pids on POSIX and Windows alike.
+async function sweepStaleAdverts(advertisePath, log) {
+  const dir = dirname(advertisePath);
+  await sweepDir(dir, async (f) => {
+    const full = join(dir, f);
+    if (full === advertisePath) return 0;
+    // .cc-<sessionId>.path mapping files: orphan when the referenced
+    // advert is gone. Invariant: mapping body is the advert path, so a
+    // missing target proves the mapping is stale and safe to remove.
+    if (f.startsWith('.cc-') && f.endsWith('.path')) {
+      try {
+        const target = (await readFileAsync(full, 'utf-8')).trim();
+        if (target && !existsSync(target)) { await unlinkAsync(full); return 1; }
+      } catch { /* skip */ }
+      return 0;
+    }
+    if (!f.endsWith('.json')) return 0;
+    try {
+      const j = JSON.parse(await readFileAsync(full, 'utf-8'));
+      const pid = Number(j.pid);
+      if (!Number.isFinite(pid) || pid <= 0) return 0;
+      try { process.kill(pid, 0); return 0; }
+      catch (e) {
+        if (e.code === 'ESRCH') { await unlinkAsync(full); return 1; }
+      }
+    } catch { /* skip corrupt */ }
+    return 0;
+  }, log, 'dead advert/mapping files');
+}
+
+function writeAdvertisement(path, record) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeJsonAtomicSync(path, record, { lock: true });
+}
+
+function sanitizeCcId(ccId) {
+  return String(ccId).replace(/[^a-zA-Z0-9-]/g, '-');
+}
+
+function perCcAdvertPath(beaconPath, ccId) {
+  const dir = dirname(beaconPath);
+  const base = basename(beaconPath, '.json');
+  return join(dir, `${base}-cc-${sanitizeCcId(ccId)}.json`);
+}
+
+function beaconRecord(record) {
+  if (!record || typeof record !== 'object') return record;
+  const { cc_session_id: _drop, ...rest } = record;
+  return rest;
+}
+
+function claimAdvertPath(claim) {
+  if (typeof claim === 'string' && claim) return claim;
+  const p = claim?.path;
+  return typeof p === 'string' && p ? p : null;
+}
+
+function claimClientHostPid(claim) {
+  const pid = Number(claim?.clientHostPid);
+  return Number.isFinite(pid) && pid > 0 ? pid : 0;
+}
+
+const recapState = { state: 'idle', running: false, startedAt: null, lastCompletedAt: null, updatedAt: null, errorMessage: null };
+
+function normalizeTimestamp(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function updateRecapState(next = {}) {
+  if (typeof next.state === 'string') recapState.state = next.state;
+  recapState.running = next.running === true;
+  recapState.startedAt = normalizeTimestamp(next.startedAt);
+  recapState.lastCompletedAt = normalizeTimestamp(next.lastCompletedAt);
+  recapState.updatedAt = normalizeTimestamp(next.updatedAt);
+  recapState.errorMessage = typeof next.errorMessage === 'string' ? next.errorMessage : null;
+}
+
+function readRecapState() {
+  return { ...recapState };
+}
+
+export async function startStatusServer({ dataDir, advertisePath, log = () => {}, getRecapState = readRecapState, ownerSessionId = OWNER_SESSION_ID }) {
+  // Multi-terminal claim: advertisePath is a permanent unclaimed BEACON
+  // (never cc_session_id). Each CC POSTs /register-cc-session and gets a
+  // dedicated advert file with cc_session_id set; statusline matches or
+  // claims via the beacon per bin/statusline-lib.mjs.
+  const claimedCcById = new Map(); // ccId -> { path, clientHostPid }
+  const recordRef = { current: null };  // populated after listen() so advert helper can re-emit
+  function rewriteAdvert() {
+    if (!recordRef.current) return;
+    const beacon = beaconRecord(recordRef.current);
+    try { writeAdvertisement(advertisePath, beacon); }
+    catch (e) { log(`[status-server] advert rewrite failed: ${e.message}`); }
+    for (const [ccId, claim] of claimedCcById) {
+      const perPath = claimAdvertPath(claim);
+      const clientHostPid = claimClientHostPid(claim);
+      if (!perPath) continue;
+      try {
+        writeAdvertisement(perPath, {
+          ...beacon,
+          cc_session_id: ccId,
+          ...(clientHostPid > 0 ? { clientHostPid } : {}),
+        });
+      } catch (e) {
+        log(`[status-server] per-cc advert rewrite failed (${ccId}): ${e.message}`);
+      }
+    }
+  }
+  const server = http.createServer(async (req, res) => {
+    // Loopback-only: reject non-localhost peers (belt-and-braces —
+    // binding to 127.0.0.1 should already exclude them).
+    const remote = req.socket?.remoteAddress || '';
+    const isLoopback = remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+    if (!isLoopback) {
+      res.writeHead(403, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: 'forbidden' }));
+      return;
+    }
+
+    try {
+      const url = new URL(req.url || '/', 'http://localhost');
+      if (req.method === 'GET' && url.pathname === '/bridge/status') {
+        const fmt = url.searchParams.get('format');
+        const wantText = fmt === 'text'
+          || (req.headers['accept'] || '').includes('text/plain');
+        const wantCompact = fmt === 'statusline-json';
+        const filterClientHostPid = Number(url.searchParams.get('clientHostPid')) || undefined;
+        const payload = wantCompact
+          ? await buildBridgeStatusCompact(dataDir, { ownerSessionId, clientHostPid: filterClientHostPid, ownerHostPid: OWNER_HOST_PID })
+          : await buildBridgeStatus(dataDir, { recap: getRecapState(), ownerSessionId, clientHostPid: filterClientHostPid, ownerHostPid: OWNER_HOST_PID });
+        if (wantText) {
+          res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+          res.end(renderBridgeStatusText(payload));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(payload));
+        }
+        return;
+      }
+      if (req.method === 'POST' && url.pathname === '/register-cc-session') {
+        let body = '';
+        // Cap the accumulated body at 16 KiB. The expected payload is a
+        // tiny JSON object ({cc_session_id, client_host_pid}); anything
+        // larger is either malformed or a memory-exhaustion attempt
+        // against the loopback endpoint. Aborting closes the socket and
+        // skips the JSON.parse pass.
+        const MAX_BODY_BYTES = 16 * 1024;
+        let bodyOverflow = false;
+        req.on('data', d => {
+          if (bodyOverflow) return;
+          body += d;
+          if (body.length > MAX_BODY_BYTES) {
+            bodyOverflow = true;
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'payload too large' }));
+            req.destroy();
+          }
+        });
+        req.on('end', () => {
+          if (bodyOverflow) return;
+          let parsed = null;
+          try { parsed = JSON.parse(body); } catch { /* fall through */ }
+          const ccId = String(parsed?.cc_session_id ?? '').trim();
+          if (!ccId) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'cc_session_id required' }));
+            return;
+          }
+          const rawClientHostPid = Number(parsed?.client_host_pid ?? parsed?.clientHostPid ?? 0);
+          const clientHostPid = Number.isFinite(rawClientHostPid) && rawClientHostPid > 0 ? rawClientHostPid : 0;
+          const perPath = perCcAdvertPath(advertisePath, ccId);
+          const existing = claimedCcById.get(ccId);
+          const existingPath = claimAdvertPath(existing);
+          const existingHostPid = claimClientHostPid(existing);
+          if (existingPath && existingPath !== perPath) {
+            res.writeHead(409, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, claimed: ccId, ownerHostPid: OWNER_HOST_PID, clientHostPid: existingHostPid || null }));
+            return;
+          }
+          claimedCcById.set(ccId, { path: perPath, clientHostPid });
+          rewriteAdvert();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, claimed: ccId, ownerHostPid: OWNER_HOST_PID, clientHostPid: clientHostPid || null }));
+        });
+        return;
+      }
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('not found');
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(e?.message || e) }));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.removeListener('error', reject);
+      resolve();
+    });
+  });
+
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : 0;
+
+  const record = {
+    pid: process.pid,
+    port,
+    startedAt: Date.now(),
+    ...ownerSessionId ? { ownerSessionId } : {},
+    ...OWNER_LEAD_PID ? { ownerLeadPid: OWNER_LEAD_PID } : {},
+    ...OWNER_HOST_PID ? { ownerHostPid: OWNER_HOST_PID } : {},
+  };
+  recordRef.current = record;  // expose to /register-cc-session handler for in-place cc_session_id append
+  try { writeAdvertisement(advertisePath, beaconRecord(record)); }
+  catch (e) { log(`[status-server] advertise write failed: ${e.message}`); }
+
+  log(`[status-server] listening on 127.0.0.1:${port} (advertise=${advertisePath})`);
+
+  // Self-heal: external cleanup (antivirus, indexer, user tools) can unlink
+  // the advert file while the child stays alive. Statusline then logs
+  // NOBRIDGE despite a healthy server. Re-write the advert every 30s if
+  // missing so any external removal recovers within one tick.
+  const advertHeal = setInterval(() => {
+    if (!recordRef.current) return;
+    const beacon = beaconRecord(recordRef.current);
+    if (!existsSync(advertisePath)) {
+      try {
+        writeAdvertisement(advertisePath, beacon);
+        log(`[status-server] advert restored at ${advertisePath}`);
+      } catch (e) {
+        log(`[status-server] advert restore failed: ${e.message}`);
+      }
+    }
+    for (const [ccId, claim] of claimedCcById) {
+      const perPath = claimAdvertPath(claim);
+      const clientHostPid = claimClientHostPid(claim);
+      if (!perPath) continue;
+      if (!existsSync(perPath)) {
+        try {
+          writeAdvertisement(perPath, {
+            ...beacon,
+            cc_session_id: ccId,
+            ...(clientHostPid > 0 ? { clientHostPid } : {}),
+          });
+          log(`[status-server] per-cc advert restored at ${perPath}`);
+        } catch (e) {
+          log(`[status-server] per-cc advert restore failed (${ccId}): ${e.message}`);
+        }
+      }
+    }
+  }, 30000);
+  advertHeal.unref?.();
+
+  sweepStaleAdverts(advertisePath, log);
+  const advertSweep = setInterval(() => sweepStaleAdverts(advertisePath, log), SESSION_SWEEP_INTERVAL_MS);
+  advertSweep.unref?.();
+
+  const sessionsDir = join(dataDir, 'sessions');
+  sweepStaleSessions(sessionsDir, log);
+  const sessionSweep = setInterval(() => sweepStaleSessions(sessionsDir, log), SESSION_SWEEP_INTERVAL_MS);
+  sessionSweep.unref?.();
+
+  return {
+    port,
+    rewriteAdvert,
+    close: () => new Promise((resolve) => {
+      clearInterval(advertHeal);
+      clearInterval(advertSweep);
+      clearInterval(sessionSweep);
+      try { unlinkSync(advertisePath); } catch {}
+      for (const claim of claimedCcById.values()) {
+        const perPath = claimAdvertPath(claim);
+        if (!perPath) continue;
+        try { unlinkSync(perPath); } catch {}
+      }
+      server.close(() => resolve());
+    }),
+  };
+}
+
+// ── Child-process entry point ─────────────────────────────────────────
+// When invoked directly (`node src/status/server.mjs`), read config
+// from env and boot. Parent signals shutdown by disconnecting IPC or
+// sending SIGTERM; either way we tear down the server and exit.
+const isMain = import.meta.url === pathToFileURL(process.argv[1] || '').href;
+if (isMain) {
+  const dataDir = process.env.MIXDOG_STATUS_DATA_DIR;
+  const advertisePath = process.env.MIXDOG_STATUS_ADVERTISE_PATH;
+  if (!dataDir || !advertisePath) {
+    process.stderr.write('[status-server] missing MIXDOG_STATUS_DATA_DIR or MIXDOG_STATUS_ADVERTISE_PATH\n');
+    process.exit(2);
+  }
+  const log = (m) => process.stdout.write(m + '\n');
+  let handle = null;
+  let shuttingDown = false;
+  process.on('message', (msg) => {
+    if (msg?.type === 'recap_status') {
+      updateRecapState(msg.recap);
+      try { handle?.rewriteAdvert?.(); } catch {}
+    }
+  });
+  const shutdown = async (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`[status-server] shutdown (${reason})`);
+    try { if (handle) await handle.close(); } catch {}
+    process.exit(0);
+  };
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('disconnect', () => shutdown('parent-disconnect'));
+  try {
+    handle = await startStatusServer({ dataDir, advertisePath, log, ownerSessionId: OWNER_SESSION_ID });
+  } catch (e) {
+    process.stderr.write(`[status-server] failed to start: ${e && (e.stack || e.message) || e}\n`);
+    process.exit(1);
+  }
+}