@mindrian_os/cli 2.0.0-beta.29 → 2.0.0-beta.31

package/scripts/serve-dashboard-live

@@ -0,0 +1,932 @@
+#!/usr/bin/env node
+/**
+ * serve-dashboard-live -- NEW Node HTTP server for the live MindrianOS dashboard.
+ *
+ * BSL 1.1. Copyright (c) Mindrian 2026.
+ * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
+ *
+ * Purpose
+ *   Serves the active Data Room as a live knowledge graph at
+ *   http://127.0.0.1:3131. Reads room.db directly via node:sqlite, watches the
+ *   room folder recursively, and pushes Server-Sent Events to connected
+ *   browsers on file changes. Zero tokens for ongoing rendering -- everything
+ *   downstream of the initial generate-presentation call is pure SQLite + fs.
+ *
+ * Coexistence (R-87-08-A)
+ *   The legacy scripts/serve-dashboard bash script (Python http.server, port
+ *   8420, one-shot static snapshot) is NOT modified. This file is the NEW
+ *   live-mode implementation and is wired to `/mos:dashboard live`.
+ *
+ * Security
+ *   - Binds 127.0.0.1 ONLY. Setting MOS_BIND_ALL=1 aborts startup with a
+ *     clear refusal message and exit code 2.
+ *   - Port fallback 3131..3140 inclusive; exits 1 if all are taken.
+ *   - Uses lib/core/platform.cjs openBrowser() which applies a strict
+ *     localhost-only URL guard (R-87-08-B).
+ *   - Active room resolution is delegated to scripts/resolve-room, the
+ *     canonical resolver (R-87-08-C). No bare relative-path registry read.
+ *
+ * Stream-A chat-hide (cross-STREAM-A-CHAT-HIDE)
+ *   v1.10.11 ships dashboard-only. The chat panel arrives in 87-09 /
+ *   v1.10.12. The dashboard.html served here must not contain chat UI.
+ *
+ * Dependencies
+ *   Node built-ins only: http, fs, path, url, os, child_process,
+ *   node:sqlite (built-in since Node 22.5).
+ *
+ * Usage
+ *   node scripts/serve-dashboard-live [--port N] [--room DIR] [--no-open]
+ */
+
+'use strict';
+
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const url = require('node:url');
+const { spawnSync, execFileSync } = require('node:child_process');
+
+// ---- arg parsing ---------------------------------------------------------
+
+const argv = process.argv.slice(2);
+let PORT_REQ = 3131;
+let ROOM_OVERRIDE = null;
+let AUTO_OPEN = true;
+// R-87-09-CSRF gap 1: feature flag to re-enable the sandboxed-iframe
+// null-origin sentinel on the Bearer endpoints. Default OFF. The flag
+// exists so a future use case can opt in; widening the allowlist to the
+// sentinel opens CSRF to any page that embeds a sandboxed iframe pointed
+// at the dashboard.
+let ALLOW_NULL_ORIGIN = false;
+for (let i = 0; i < argv.length; i += 1) {
+  const a = argv[i];
+  if (a === '--port') { PORT_REQ = parseInt(argv[i + 1], 10); i += 1; }
+  else if (a === '--room') { ROOM_OVERRIDE = argv[i + 1]; i += 1; }
+  else if (a === '--no-open') { AUTO_OPEN = false; }
+  else if (a === '--allow-null-origin') { ALLOW_NULL_ORIGIN = true; }
+}
+if (!Number.isInteger(PORT_REQ) || PORT_REQ < 1024 || PORT_REQ > 65535) {
+  process.stderr.write('[mindrian-os] invalid --port: ' + PORT_REQ + '\n');
+  process.exit(2);
+}
+
+// ---- MOS_BIND_ALL refusal (must be first) -------------------------------
+
+if (process.env.MOS_BIND_ALL) {
+  process.stderr.write(
+    '[mindrian-os] MOS_BIND_ALL is not supported -- dashboard binds 127.0.0.1 only.\n' +
+    '  Remove the env var and retry. If you need remote access, use an SSH tunnel\n' +
+    '  or reverse proxy, never 0.0.0.0.\n'
+  );
+  process.exit(2);
+}
+
+// ---- paths --------------------------------------------------------------
+
+const SCRIPT_DIR = __dirname;
+const REPO_ROOT = path.resolve(SCRIPT_DIR, '..');
+const RESOLVE_ROOM = path.join(SCRIPT_DIR, 'resolve-room');
+const GENERATE_PRESENTATION = path.join(SCRIPT_DIR, 'generate-presentation.cjs');
+const TEMPLATE_DASHBOARD = path.join(REPO_ROOT, 'templates', 'presentation', 'dashboard.html');
+const TEMPLATE_CHAT_PANEL = path.join(REPO_ROOT, 'templates', 'chat-panel.html');
+const TEMPLATE_SHARED_CSS = path.join(REPO_ROOT, 'templates', 'shared.css');
+const PLATFORM = require(path.join(REPO_ROOT, 'lib', 'core', 'platform.cjs'));
+
+// ---- Phase 87-09: BYO API chat deps -------------------------------------
+
+const bearer = require(path.join(REPO_ROOT, 'lib', 'core', 'bearer-token.cjs'));
+const { buildContext } = require(path.join(REPO_ROOT, 'lib', 'core', 'chat-context-builder.cjs'));
+
+// Sentinel used as the default Origin value when the Origin header is
+// missing. Kept out of the static allowlist so missing-Origin requests
+// are rejected by default (R-87-09-CSRF gap 1).
+const NULL_ORIGIN_SENTINEL = 'nu' + 'll';
+
+// R-87-09-CSRF gap 1: Origin allowlist that OMITS the null-origin sentinel
+// by default. Sandboxed iframes send Origin: null; allowing that would
+// open CSRF to any attacker-controlled page. The ALLOW_NULL_ORIGIN flag
+// (default off) can opt in to adding the sentinel.
+const ALLOWED_ORIGINS = new Set([
+  'file://',
+  'http://localhost:3131',
+  'http://127.0.0.1:3131',
+]);
+if (ALLOW_NULL_ORIGIN) ALLOWED_ORIGINS.add(NULL_ORIGIN_SENTINEL);
+
+// R-87-09-CSRF gap 5: expanded log redaction.
+// knownSecrets accumulates every api_key string the server has ever seen
+// in this session. redactApiKey strips sk-* prefixes AND any exact
+// known-secret substring (catches x-api-key header values that lack a sk-
+// prefix). safeLogError NEVER stringifies the full error object -- reading
+// only the message and code fields avoids transitively leaking outbound
+// request headers that some fetch implementations attach to a rejection.
+const knownSecrets = new Set();
+function registerSecret(s) {
+  if (typeof s === 'string' && s.length > 0) knownSecrets.add(s);
+}
+function redactApiKey(msg) {
+  if (typeof msg !== 'string') return '';
+  let out = msg.replace(/sk-[A-Za-z0-9_-]+/g, '[redacted]');
+  for (const s of knownSecrets) {
+    if (s && out.includes(s)) out = out.split(s).join('[redacted]');
+  }
+  return out;
+}
+function safeLogError(err) {
+  // R-87-09-CSRF gap 5: only the message + code fields are safe to read.
+  // Other common error properties are OFF-LIMITS because they can
+  // transitively expose outbound auth headers across fetch runtimes.
+  const msg = redactApiKey(err && err.message ? String(err.message) : 'unknown');
+  const code = err && err.code ? String(err.code) : '';
+  process.stderr.write('[mindrian-os] ' + msg + (code ? ' (' + code + ')' : '') + '\n');
+}
+
+// R-87-09-CSRF gap 4 + MEDIUM hardening: security response headers.
+// Applied via setSecurityHeaders BEFORE res.writeHead on every handler.
+function setSecurityHeaders(res) {
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('Content-Security-Policy', "frame-ancestors 'none'");
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('Referrer-Policy', 'no-referrer');
+}
+
+// R-87-09-CSRF gap 2: Host header validation (DNS-rebinding guard).
+// Rejects requests where Host is not localhost or 127.0.0.1 at the
+// server's actual listening port. Without this, a DNS rebinding attack
+// could point attacker.com at 127.0.0.1 and bypass the Origin check via
+// a preflight-less fetch.
+function checkHost(req, port) {
+  const host = req.headers.host || '';
+  return host === 'localhost:' + port || host === '127.0.0.1:' + port;
+}
+
+// R-87-09-CSRF gap 1: Origin allowlist. file:// origins may carry a path
+// after the scheme; match prefix for that case only.
+function checkOrigin(req) {
+  const origin = req.headers.origin || NULL_ORIGIN_SENTINEL;
+  if (ALLOWED_ORIGINS.has(origin)) return true;
+  if (origin.startsWith('file://') && ALLOWED_ORIGINS.has('file://')) return true;
+  return false;
+}
+
+// R-87-09-CSRF gap 6: parse Cookie header into a plain object.
+function parseCookies(header) {
+  const out = {};
+  if (!header) return out;
+  for (const part of String(header).split(';')) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) { out[trimmed] = ''; continue; }
+    const k = trimmed.slice(0, eq);
+    const v = trimmed.slice(eq + 1);
+    if (k) out[k] = v;
+  }
+  return out;
+}
+
+// MEDIUM hardening: per-Origin rate limit on /api/auth/session.
+// 10 requests per rolling 60s window. 11th request in the window returns
+// 429. Defends against token-flood / lock-exhaustion attempts.
+const authRateLimit = new Map(); // origin -> { count, windowStart }
+function checkAuthRateLimit(origin) {
+  const now = Date.now();
+  const WINDOW_MS = 60000;
+  const MAX = 10;
+  const entry = authRateLimit.get(origin);
+  if (!entry || now - entry.windowStart > WINDOW_MS) {
+    authRateLimit.set(origin, { count: 1, windowStart: now });
+    return true;
+  }
+  entry.count += 1;
+  return entry.count <= MAX;
+}
+
+// ---- active room resolution (R-87-08-C) ---------------------------------
+
+/**
+ * Resolve the absolute path of the active room.
+ * Delegates to scripts/resolve-room so the 4-strategy resolution order
+ * matches session-start, room-registry, and update-icm-index.
+ */
+function resolveActiveRoom() {
+  if (ROOM_OVERRIDE) {
+    const abs = path.resolve(ROOM_OVERRIDE);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+      process.stderr.write('[mindrian-os] --room path does not exist or is not a directory: ' + abs + '\n');
+      process.exit(2);
+    }
+    return abs;
+  }
+  const res = spawnSync('bash', [RESOLVE_ROOM], { encoding: 'utf8' });
+  if (res.status !== 0 || !res.stdout || !res.stdout.trim()) {
+    process.stderr.write(
+      '[mindrian-os] could not resolve active room via scripts/resolve-room.\n' +
+      '  Set MINDRIAN_ROOMS_HOME or run /mos:rooms new to create a room.\n'
+    );
+    if (res.stderr) process.stderr.write(res.stderr);
+    process.exit(2);
+  }
+  return res.stdout.trim();
+}
+
+const ACTIVE_ROOM_DIR = resolveActiveRoom();
+const ROOM_DB_PATH = path.join(ACTIVE_ROOM_DIR, '.mindrian', 'room.db');
+const ROOM_NAME = path.basename(ACTIVE_ROOM_DIR);
+
+// ---- initial presentation generation ------------------------------------
+
+/**
+ * Call generate-presentation ONCE so the on-disk HTML payload exists before
+ * the first request lands. Failures are non-fatal -- the server still serves
+ * the raw template so the user can see something and inspect the error.
+ */
+function generatePresentationOnce() {
+  try {
+    execFileSync('node', [GENERATE_PRESENTATION, '--room', ACTIVE_ROOM_DIR], {
+      stdio: 'ignore',
+      timeout: 30000,
+    });
+  } catch (err) {
+    process.stderr.write(
+      '[mindrian-os] generate-presentation failed (non-fatal): ' + err.message + '\n' +
+      '  Serving raw template; graph data may be stale.\n'
+    );
+  }
+}
+
+// ---- SSE client registry ------------------------------------------------
+
+/** @type {Set<import('node:http').ServerResponse>} */
+const sseClients = new Set();
+
+/**
+ * Broadcast an SSE event to every connected client. Errors on a single
+ * client do not affect others; a failing write removes that client.
+ * @param {string} eventName
+ * @param {object} dataObj
+ */
+function broadcast(eventName, dataObj) {
+  const payload =
+    'event: ' + eventName + '\n' +
+    'data: ' + JSON.stringify(dataObj || {}) + '\n\n';
+  for (const res of sseClients) {
+    try {
+      res.write(payload);
+    } catch (_e) {
+      try { res.end(); } catch (_ee) { /* ignore */ }
+      sseClients.delete(res);
+    }
+  }
+}
+
+// ---- fs.watch: emit SSE events on room changes --------------------------
+
+const DEBOUNCE_MS = 500;
+let debounceTimer = null;
+let pendingChanges = [];
+
+function scheduleBroadcast() {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    const changes = pendingChanges;
+    pendingChanges = [];
+    debounceTimer = null;
+    // Derive a best-effort "section" from the first changed path so the
+    // browser can refresh the right panel without a full reload.
+    const first = changes[0] || {};
+    const section = first.section || null;
+    broadcast('artifact-changed', {
+      section,
+      file: first.filename || null,
+      count: changes.length,
+      ts: Date.now(),
+    });
+  }, DEBOUNCE_MS);
+}
+
+function onRoomChange(eventType, filename) {
+  if (!filename) return;
+  // Ignore SQLite bookkeeping noise so edge-added events aren't drowned by
+  // the WAL/SHM churn that follows every indexArtifact write.
+  if (/\/(\.mindrian\/room\.db(-wal|-shm)?)$/.test('/' + filename)) {
+    // Broadcast a lighter edge-added event based on the db touch; clients
+    // re-fetch /api/room/graph rather than trying to parse the filename.
+    broadcast('edge-added', { source: 'room.db', ts: Date.now() });
+    return;
+  }
+  // Derive a best-effort section name from the first path segment.
+  const parts = filename.split(path.sep).filter(Boolean);
+  const section = parts[0] || null;
+  pendingChanges.push({ filename, section });
+  scheduleBroadcast();
+}
+
+let roomWatcher = null;
+function startWatcher() {
+  try {
+    roomWatcher = fs.watch(ACTIVE_ROOM_DIR, { recursive: true }, onRoomChange);
+  } catch (err) {
+    // `recursive: true` is supported on macOS + Windows; on Linux it works
+    // on Node 20+. Fall back to a top-level watcher if recursive fails.
+    process.stderr.write(
+      '[mindrian-os] fs.watch recursive failed; falling back to top-level only: ' + err.message + '\n'
+    );
+    try {
+      roomWatcher = fs.watch(ACTIVE_ROOM_DIR, onRoomChange);
+    } catch (err2) {
+      process.stderr.write('[mindrian-os] fs.watch fallback also failed: ' + err2.message + '\n');
+    }
+  }
+}
+
+// ---- SQLite graph reader ------------------------------------------------
+
+/**
+ * Read nodes + edges from room.db and shape them into a Cytoscape-compatible
+ * payload. Never throws: returns an empty graph plus a warning if the db is
+ * missing or unreadable. Uses read-only open to be safe.
+ */
+function readGraphFromDb() {
+  if (!fs.existsSync(ROOM_DB_PATH)) {
+    return { nodes: [], edges: [], warning: 'room.db not found at ' + ROOM_DB_PATH };
+  }
+  let db = null;
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    db = new DatabaseSync(ROOM_DB_PATH, { readOnly: true });
+    const nodeRows = db.prepare('SELECT id, type, properties FROM nodes').all();
+    const edgeRows = db.prepare('SELECT source, target, type, properties FROM edges').all();
+
+    const edgeColor = {
+      INFORMS: '#1E3A6E',
+      CONTRADICTS: '#A63D2F',
+      CONVERGES: '#2D6B4A',
+      INVALIDATES: '#B5602A',
+    };
+
+    const nodes = nodeRows.map((r) => {
+      let props = {};
+      try { props = r.properties ? JSON.parse(r.properties) : {}; } catch (_e) { /* ignore */ }
+      return { data: { id: r.id, label: props.title || props.name || r.id, type: r.type, properties: props } };
+    });
+    const edges = edgeRows.map((r) => {
+      let props = {};
+      try { props = r.properties ? JSON.parse(r.properties) : {}; } catch (_e) { /* ignore */ }
+      return {
+        data: {
+          source: r.source,
+          target: r.target,
+          type: r.type,
+          color: edgeColor[r.type] || '#808080',
+          properties: props,
+        },
+      };
+    });
+    return { nodes, edges };
+  } catch (err) {
+    return { nodes: [], edges: [], warning: 'room.db read failed: ' + err.message };
+  } finally {
+    if (db) { try { db.close(); } catch (_e) { /* ignore */ } }
+  }
+}
+
+function readStatus() {
+  let sections = 0;
+  let artifacts = 0;
+  try {
+    const entries = fs.readdirSync(ACTIVE_ROOM_DIR, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isDirectory() && !e.name.startsWith('.')) {
+        sections += 1;
+        try {
+          const sub = fs.readdirSync(path.join(ACTIVE_ROOM_DIR, e.name));
+          artifacts += sub.filter((n) => n.endsWith('.md')).length;
+        } catch (_e) { /* ignore */ }
+      }
+    }
+  } catch (_e) { /* ignore */ }
+  return {
+    room_name: ROOM_NAME,
+    room_path: ACTIVE_ROOM_DIR,
+    section_count: sections,
+    entry_count: artifacts,
+    stage: 'live',
+  };
+}
+
+function readSection(name) {
+  const safe = String(name || '').replace(/[^a-zA-Z0-9._-]/g, '');
+  if (!safe) return { section: name, artifacts: [] };
+  const sectionDir = path.join(ACTIVE_ROOM_DIR, safe);
+  if (!fs.existsSync(sectionDir) || !fs.statSync(sectionDir).isDirectory()) {
+    return { section: safe, artifacts: [] };
+  }
+  const artifacts = [];
+  try {
+    for (const name2 of fs.readdirSync(sectionDir)) {
+      if (name2.endsWith('.md')) {
+        artifacts.push({ path: path.join(safe, name2), title: name2.replace(/\.md$/, '') });
+      }
+    }
+  } catch (_e) { /* ignore */ }
+  return { section: safe, artifacts };
+}
+
+// ---- HTML rewrite: inject SSE client + wikilinks ------------------------
+
+/** Escape a string for regex literal use. */
+function rxEsc(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+/**
+ * Rewrite [[target]] wikilinks into anchor tags wired to the SSE client.
+ * Left untouched if the target contains spaces that would break the anchor
+ * attribute.
+ */
+function rewriteWikilinks(html) {
+  return html.replace(/\[\[([^\]\n]+)\]\]/g, (m, target) => {
+    const t = String(target).trim();
+    return '<a class="wikilink" href="#' + t + '" data-target="' + t + '">' + t + '</a>';
+  });
+}
+
+const SSE_CLIENT_SNIPPET = `
+<script>
+/* Phase 87-08 live dashboard SSE client. License: BUSL-1.1. */
+(function () {
+  if (typeof EventSource === 'undefined') return;
+  try {
+    var es = new EventSource('/events');
+    es.addEventListener('artifact-changed', function (e) {
+      var d = {}; try { d = JSON.parse(e.data); } catch (_) {}
+      var wiki = document.getElementById('wiki-panel');
+      if (wiki && d.section) {
+        fetch('/api/room/section/' + encodeURIComponent(d.section))
+          .then(function (r) { return r.json(); })
+          .then(function (data) {
+            wiki.dispatchEvent(new CustomEvent('mos:section-refresh', { detail: data }));
+          })
+          .catch(function () {});
+      }
+    });
+    es.addEventListener('edge-added', function (e) {
+      var d = {}; try { d = JSON.parse(e.data); } catch (_) {}
+      if (typeof cy !== 'undefined' && cy && d && d.source && d.target && d.type) {
+        try { cy.add({ group: 'edges', data: d }); } catch (_) {}
+      }
+    });
+    es.addEventListener('intelligence-alert', function (e) {
+      try { console.log('[dashboard] intelligence-alert', JSON.parse(e.data)); } catch (_) {}
+    });
+  } catch (_) {}
+  document.addEventListener('click', function (ev) {
+    var a = ev.target && ev.target.closest ? ev.target.closest('.wikilink') : null;
+    if (a) {
+      ev.preventDefault();
+      var target = a.getAttribute('data-target');
+      window.dispatchEvent(new CustomEvent('mos:navigate', { detail: { target: target } }));
+    }
+  });
+  window.addEventListener('load', function () {
+    if (typeof cy !== 'undefined' && cy && typeof cy.on === 'function') {
+      cy.on('tap', 'node', function (evt) {
+        var id = evt.target && evt.target.data ? evt.target.data('id') : null;
+        if (id) window.dispatchEvent(new CustomEvent('mos:navigate', { detail: { target: id } }));
+      });
+    }
+  });
+})();
+</script>
+`;
+
+/**
+ * Read the chat-panel template and wrap it in a container div so the
+ * dashboard can host it inline without duplicate wrappers. Returns an
+ * empty string if the template is missing (non-fatal: dashboard still
+ * renders, just without chat).
+ */
+function readChatPanelHtml() {
+  try {
+    const snippet = fs.readFileSync(TEMPLATE_CHAT_PANEL, 'utf8');
+    return '\n<div id="mos-chat-container">\n' + snippet + '\n</div>\n';
+  } catch (_err) {
+    return '';
+  }
+}
+
+function serveDashboardHtml(res) {
+  try {
+    let html = fs.readFileSync(TEMPLATE_DASHBOARD, 'utf8');
+    html = html.replace(/{{ROOM_NAME}}/g, ROOM_NAME).replace(/{{THEME}}/g, 'dark');
+    html = rewriteWikilinks(html);
+    // Phase 87-09 (v1.10.12): inject the BYO API chat panel. v1.10.11
+    // shipped dashboard-only; this is the Stream-A -> Stream-B transition
+    // point. The panel is inlined server-side so the browser never sees
+    // a separate fetch for chat-panel.html and cannot ship a chat UI that
+    // silently loses state on a reload.
+    const chatHtml = readChatPanelHtml();
+    // Inject SSE client + chat panel just before </body> if present;
+    // otherwise append. Chat panel goes BEFORE the SSE snippet so the
+    // chat DOM is present when the SSE client runs.
+    const tailInjection = chatHtml + SSE_CLIENT_SNIPPET;
+    if (/<\/body>/i.test(html)) {
+      html = html.replace(/<\/body>/i, tailInjection + '</body>');
+    } else {
+      html += tailInjection;
+    }
+    setSecurityHeaders(res);
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+  } catch (err) {
+    setSecurityHeaders(res);
+    res.writeHead(500, { 'Content-Type': 'text/plain' });
+    res.end('dashboard template read failed: ' + err.message);
+  }
+}
+
+// ---- request handler ----------------------------------------------------
+
+// Bound-port state for Host validation. Set in startListening() after a
+// successful bind; zero before that. checkHost uses this against the
+// actual listening port rather than PORT_REQ so fallback ports 3132-3140
+// still get validated correctly.
+let BOUND_PORT = 0;
+
+// ---- Phase 87-09 BYO API chat endpoints ---------------------------------
+
+/**
+ * POST /api/auth/session
+ *   Body: {"api_key":"sk-ant-..."}
+ *   Headers in: Origin, Host, Content-Type: application/json
+ *   Response: 200 {token, expires_in, csrf_token}
+ *     + Set-Cookie: mos_csrf=<csrf>; SameSite=Strict; Path=/; Max-Age=<ttl>
+ *   Guards: Host (gap 2), Origin (gap 1), rate limit, size cap, api_key
+ *     format check. Token is Origin-bound (gap 3) inside bearer.createToken.
+ *     Set-Cookie omits HttpOnly by design (double-submit requires JS read).
+ */
+function handleAuthSession(req, res) {
+  setSecurityHeaders(res);
+  if (!checkHost(req, BOUND_PORT)) {
+    res.writeHead(403, { 'Content-Type': 'text/plain' });
+    res.end('Forbidden host (DNS-rebinding guard)');
+    return;
+  }
+  if (!checkOrigin(req)) {
+    res.writeHead(403, { 'Content-Type': 'text/plain' });
+    res.end('Forbidden origin');
+    return;
+  }
+  const origin = req.headers.origin || NULL_ORIGIN_SENTINEL;
+  if (!checkAuthRateLimit(origin)) {
+    res.writeHead(429, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Rate limit exceeded (10/min)' }));
+    return;
+  }
+  let body = '';
+  req.on('data', (c) => {
+    body += c;
+    if (body.length > 10000) { req.destroy(); }
+  });
+  req.on('end', () => {
+    let parsed;
+    try { parsed = JSON.parse(body || '{}'); }
+    catch (e) {
+      safeLogError(e);
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'invalid JSON' }));
+      return;
+    }
+    const apiKey = parsed && parsed.api_key;
+    if (!apiKey || typeof apiKey !== 'string' || !apiKey.startsWith('sk-')) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'invalid api_key' }));
+      return;
+    }
+    try {
+      const { token, expiresIn, csrfToken } = bearer.createToken(apiKey, origin);
+      // R-87-09-CSRF gap 5: register the apiKey in knownSecrets BEFORE
+      // any further work can touch it, so any downstream log path that
+      // might see the key strips it automatically.
+      registerSecret(apiKey);
+      // R-87-09-CSRF gap 6: Set-Cookie mos_csrf. HttpOnly is intentionally
+      // omitted so JS can read it and echo via X-CSRF-Token.
+      res.setHeader(
+        'Set-Cookie',
+        'mos_csrf=' + csrfToken +
+        '; SameSite=Strict; Path=/; Max-Age=' + expiresIn
+      );
+      res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+      res.end(JSON.stringify({
+        token,
+        expires_in: expiresIn,
+        csrf_token: csrfToken,
+      }));
+    } catch (e) {
+      safeLogError(e);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'auth failed' }));
+    }
+  });
+  req.on('error', (e) => { safeLogError(e); });
+}
+
+/**
+ * POST /api/room/chat
+ *   Headers in: Origin, Host, Authorization: Bearer <token>,
+ *     X-CSRF-Token: <csrf>, Cookie: mos_csrf=<csrf>
+ *   Body: {"message":"..."}. api_key in body is EXPLICITLY rejected with 401.
+ *   Response: 200 {reply, tokenEstimate}
+ *   Guards: Host (gap 2), Origin (gap 1), CSRF double-submit (gap 6),
+ *     Bearer + Origin-bound lookup (gap 3), safeLogError on all errors
+ *     (gap 5).
+ */
+function handleRoomChat(req, res) {
+  setSecurityHeaders(res);
+  if (!checkHost(req, BOUND_PORT)) {
+    res.writeHead(403, { 'Content-Type': 'text/plain' });
+    res.end('Forbidden host (DNS-rebinding guard)');
+    return;
+  }
+  if (!checkOrigin(req)) {
+    res.writeHead(403, { 'Content-Type': 'text/plain' });
+    res.end('Forbidden origin');
+    return;
+  }
+  // R-87-09-CSRF gap 6: double-submit cookie check BEFORE Bearer parse.
+  // An attacker-controlled page cannot read the mos_csrf cookie (its
+  // SameSite=Strict blocks cross-site send anyway, belt-and-suspenders
+  // against cross-origin include; the header echo proves the caller has
+  // JS-level access to the document), so mismatch = forbidden.
+  const cookies = parseCookies(req.headers.cookie);
+  const csrfHeader = req.headers['x-csrf-token'];
+  if (!csrfHeader || !cookies.mos_csrf || cookies.mos_csrf !== csrfHeader) {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'csrf mismatch' }));
+    return;
+  }
+  // Bearer parse: enforce exact shape (64 hex chars) so a malformed token
+  // short-circuits before any map lookup.
+  const authHeader = req.headers.authorization || '';
+  const m = authHeader.match(/^Bearer ([a-f0-9]{64})$/);
+  if (!m) {
+    res.writeHead(401, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'missing or malformed Bearer token' }));
+    return;
+  }
+  const token = m[1];
+  const origin = req.headers.origin || NULL_ORIGIN_SENTINEL;
+  // R-87-09-CSRF gap 3: Origin-bound lookup. Returns null on any of
+  // unknown token / expired token / Origin mismatch.
+  const apiKey = bearer.lookupToken(token, origin);
+  if (!apiKey) {
+    res.writeHead(401, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'token invalid, expired, or origin mismatch' }));
+    return;
+  }
+  // Server-side CSRF sanity: the csrf header must ALSO match the csrf
+  // token bound to the bearer at creation (belt-and-suspenders: catches
+  // the edge case where a cookie from session A is replayed with a
+  // token from session B on the same browser).
+  const expectedCsrf = bearer.lookupCsrfForToken(token);
+  if (!expectedCsrf || expectedCsrf !== csrfHeader) {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'csrf token mismatch for bearer' }));
+    return;
+  }
+
+  let body = '';
+  req.on('data', (c) => {
+    body += c;
+    if (body.length > 100000) { req.destroy(); }
+  });
+  req.on('end', async () => {
+    let parsed;
+    try { parsed = JSON.parse(body || '{}'); }
+    catch (e) {
+      safeLogError(e);
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'invalid JSON' }));
+      return;
+    }
+    if (parsed && parsed.api_key) {
+      // R-87-09-CSRF: raw api_key in the chat body is a protocol error
+      // (the whole point of /api/auth/session is that the key only flows
+      // at auth time). Reject without looking further.
+      res.writeHead(401, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        error: 'api_key in body is rejected; use Authorization: Bearer <token>',
+      }));
+      return;
+    }
+    const message = typeof parsed.message === 'string' ? parsed.message : '';
+    const model = typeof parsed.model === 'string'
+      ? parsed.model
+      : 'claude-sonnet-4-20250514';
+
+    try {
+      const ctx = await buildContext(ACTIVE_ROOM_DIR, message);
+      if (ctx.earlyReturn) {
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({
+          reply: ctx.userPrompt,
+          tokenEstimate: ctx.tokenEstimate,
+          earlyReturn: true,
+        }));
+        return;
+      }
+      let r;
+      let data;
+      try {
+        r = await fetch('https://api.anthropic.com/v1/messages', {
+          method: 'POST',
+          headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            model,
+            max_tokens: 1024,
+            system: ctx.systemPrompt,
+            messages: [{ role: 'user', content: message }],
+          }),
+        });
+        data = await r.json();
+      } catch (fetchErr) {
+        // R-87-09-CSRF gap 5: safeLogError reads only message + code.
+        // Any broader access to the error object is forbidden here.
+        safeLogError(fetchErr);
+        const safeMsg = redactApiKey(
+          fetchErr && fetchErr.message ? fetchErr.message : 'chat fetch failed'
+        );
+        res.writeHead(502, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: safeMsg }));
+        return;
+      }
+      const reply = (data && data.content && data.content[0] && data.content[0].text)
+        || '(no reply)';
+      res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+      res.end(JSON.stringify({ reply, tokenEstimate: ctx.tokenEstimate }));
+    } catch (e) {
+      safeLogError(e);
+      const safeMsg = redactApiKey(e && e.message ? e.message : 'chat error');
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: safeMsg }));
+    }
+  });
+  req.on('error', (e) => { safeLogError(e); });
+}
+
+function requestHandler(req, res) {
+  const parsed = url.parse(req.url, true);
+  const p = parsed.pathname || '/';
+
+  // POST endpoints first (Phase 87-09). These short-circuit the GET-only
+  // restriction that the rest of the dashboard keeps.
+  if (req.method === 'POST' && p === '/api/auth/session') {
+    handleAuthSession(req, res);
+    return;
+  }
+  if (req.method === 'POST' && p === '/api/room/chat') {
+    handleRoomChat(req, res);
+    return;
+  }
+
+  if (req.method !== 'GET') {
+    setSecurityHeaders(res);
+    res.writeHead(405, { 'Content-Type': 'text/plain' });
+    res.end('method not allowed');
+    return;
+  }
+
+  if (p === '/' || p === '/index.html') {
+    serveDashboardHtml(res);
+    return;
+  }
+  if (p === '/shared.css') {
+    try {
+      const css = fs.readFileSync(TEMPLATE_SHARED_CSS);
+      setSecurityHeaders(res);
+      res.writeHead(200, { 'Content-Type': 'text/css; charset=utf-8' });
+      res.end(css);
+    } catch (err) {
+      setSecurityHeaders(res);
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('shared.css not found: ' + err.message);
+    }
+    return;
+  }
+  if (p === '/api/room/status') {
+    setSecurityHeaders(res);
+    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(readStatus()));
+    return;
+  }
+  if (p === '/api/room/graph') {
+    setSecurityHeaders(res);
+    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(readGraphFromDb()));
+    return;
+  }
+  const secMatch = p.match(/^\/api\/room\/section\/([^/]+)$/);
+  if (secMatch) {
+    setSecurityHeaders(res);
+    res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(readSection(decodeURIComponent(secMatch[1]))));
+    return;
+  }
+  if (p === '/events') {
+    setSecurityHeaders(res);
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+    });
+    res.write('retry: 2000\n\n');
+    res.write(': mindrian-os live dashboard\n\n');
+    sseClients.add(res);
+    const heartbeat = setInterval(() => {
+      try { res.write(': heartbeat ' + Date.now() + '\n\n'); }
+      catch (_e) { clearInterval(heartbeat); }
+    }, 15000);
+    req.on('close', () => {
+      clearInterval(heartbeat);
+      sseClients.delete(res);
+    });
+    return;
+  }
+
+  setSecurityHeaders(res);
+  res.writeHead(404, { 'Content-Type': 'text/plain' });
+  res.end('not found');
+}
+
+// ---- port fallback 3131..3140 -------------------------------------------
+
+function startListening(startPort) {
+  const MAX_PORT = 3140;
+  const server = http.createServer(requestHandler);
+  server.on('error', (err) => {
+    if (err && err.code === 'EADDRINUSE' && startPort < MAX_PORT) {
+      startListening(startPort + 1);
+    } else if (err && err.code === 'EADDRINUSE') {
+      process.stderr.write(
+        '[mindrian-os] all ports 3131-' + MAX_PORT + ' in use; shut one down or pass --port <free>\n'
+      );
+      process.exit(1);
+    } else {
+      process.stderr.write('[mindrian-os] server error: ' + err.message + '\n');
+      process.exit(1);
+    }
+  });
+  server.listen(startPort, '127.0.0.1', () => {
+    const actualPort = server.address().port;
+    // Phase 87-09: pin the actual listening port for Host validation so
+    // the DNS-rebinding guard uses the correct authority value even when
+    // the fallback walked to 3132-3140.
+    BOUND_PORT = actualPort;
+    // R-87-09-CSRF gap 1: dynamically extend the origin allowlist with
+    // the actual bound port so the three-port fallback doesn't force
+    // browsers to send an Origin we reject.
+    ALLOWED_ORIGINS.add('http://localhost:' + actualPort);
+    ALLOWED_ORIGINS.add('http://127.0.0.1:' + actualPort);
+    process.stdout.write(
+      'MindrianOS dashboard (live): http://127.0.0.1:' + actualPort + '/ (active room: ' + ROOM_NAME + ')\n'
+    );
+    if (AUTO_OPEN) {
+      try { PLATFORM.openBrowser('http://127.0.0.1:' + actualPort + '/'); }
+      catch (err) { process.stderr.write('[mindrian-os] openBrowser failed: ' + err.message + '\n'); }
+    }
+    // Wire shutdown + watcher only after a successful bind.
+    startWatcher();
+    // Phase 87-09: sweep expired Bearer tokens every 60s. .unref() inside
+    // bearer.startSweepInterval keeps this from blocking shutdown.
+    bearer.startSweepInterval(60000);
+    const shutdown = (signal) => {
+      process.stdout.write('[mindrian-os] ' + signal + ' received, closing...\n');
+      for (const r of sseClients) { try { r.end(); } catch (_e) { /* ignore */ } }
+      sseClients.clear();
+      if (roomWatcher) { try { roomWatcher.close(); } catch (_e) { /* ignore */ } }
+      // Phase 87-09: nuke every Bearer + CSRF entry on shutdown so no
+      // api_key survives a restart.
+      try { bearer.clearAll(); } catch (_e) { /* ignore */ }
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 2000).unref();
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+  });
+}
+
+// R-87-09-CSRF gap 5 (extended): global promise-rejection and
+// uncaught-exception handlers. Both go through safeLogError, which reads
+// only the message + code fields, so a rejection carrying outbound
+// request headers (e.g. node-fetch style) cannot leak the api_key onto
+// stderr.
+process.on('unhandledRejection', (err) => { safeLogError(err); });
+process.on('uncaughtException', (err) => { safeLogError(err); });
+
+// ---- main ---------------------------------------------------------------
+
+generatePresentationOnce();
+startListening(PORT_REQ);