launcher.js

#!/usr/bin/env node
// ========================================
// BLUM LAUNCHER — Local Control Panel
// 17 Feb 2026
//
// One-click management of the Blum system.
// Starts/stops room server + home processes.
// Serves a web UI for status, controls, logs.
//
// Usage: node launcher.js [port]
// Default port: 3100
// ========================================

const http = require('http');
const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');

const NODE = '/opt/homebrew/bin/node';
const LAUNCHER_PORT = parseInt(process.argv[2] || '3100');

// ── Paths ──────────────────────────────
const BLUM_DIR = __dirname;
const CODE_DIR = path.join(BLUM_DIR, 'read-the-architecture-spec-first', 'i-have-read-the-spec');
const ROOM_SERVER_JS = path.join(CODE_DIR, 'shared-room-server-that-hosts-rooms-and-dispatches-transcripts-15feb2026', 'blum-room-server-15feb2026.js');
const HOME_JS = path.join(CODE_DIR, 'home-agent-os-15feb2026', 'home.js');
const CREATE_HOME_JS = path.join(CODE_DIR, 'home-agent-os-15feb2026', 'create-home.js');
const HOMES_DIR = require('path').join(require('os').homedir(), 'blum', 'homes');

// ── State ──────────────────────────────
const ROOM_SERVER_PORT = 3141;
let roomServerProc = null;
let roomServerLog = [];        // ring buffer, last 200 lines

// { name: { proc, port, homeDir, config, log[] } }
const homes = {};

const MAX_LOG_LINES = 200;
const PROBE_PORTS = Array.from({ length: 31 }, (_, i) => 4100 + i);

function pushLog(buf, line) {
  buf.push(line);
  if (buf.length > MAX_LOG_LINES) buf.shift();
}

function extractTs(line) {
  const m = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)/);
  return m ? m[1] : null;
}

function makeBoardroomDiagnosis(kind, label, detail, severity = 'info', ts = null) {
  return { kind, label, detail, severity, ts };
}

function makeHealthDiagnosis(kind, label, detail, severity = 'info', ts = null) {
  return { kind, label, detail, severity, ts };
}

function titleCaseError(code) {
  return String(code || '')
    .replace(/[_:]+/g, ' ')
    .trim()
    .replace(/\b\w/g, c => c.toUpperCase());
}

function diagnoseServiceability(liveStatus, running) {
  const health = liveStatus?.health;
  if (!running) {
    return makeHealthDiagnosis('offline', 'Offline', 'No live home endpoint is answering right now.', 'error', null);
  }
  if (!health) {
    return makeHealthDiagnosis('unknown', 'Unknown', 'Live home status does not expose structured health yet.', 'warn', null);
  }
  if (health.lastErrorType) {
    return makeHealthDiagnosis(
      health.lastErrorType,
      titleCaseError(health.lastErrorType),
      'Most recent cycle ended with an explicit runtime or provider failure.',
      'error',
      health.lastErrorAt || null
    );
  }
  if (health.lastFailureNoticeAt) {
    return makeHealthDiagnosis(
      'failure_notice',
      'Failure Notice Sent',
      'The home is up, but its last visible result was a system failure notice rather than a normal reply.',
      'warn',
      health.lastFailureNoticeAt
    );
  }
  if (health.lastSuccessfulRoomDeliveryAt || health.lastSuccessfulInferenceAt) {
    return makeHealthDiagnosis(
      'healthy',
      'Serviceable',
      'The home has recent successful inference/delivery activity.',
      'ok',
      health.lastSuccessfulRoomDeliveryAt || health.lastSuccessfulInferenceAt
    );
  }
  return makeHealthDiagnosis('idle', 'Idle', 'The home is reachable, but there is no recent success/failure signal yet.', 'warn', null);
}

function diagnoseRoomState(roomName, agentName, roomHealthEntry) {
  if (!roomHealthEntry) {
    return makeHealthDiagnosis('no_room_signal', 'No Room Signal', `No recent ${roomName} dispatch or delivery signal recorded.`, 'warn', null);
  }
  if (roomHealthEntry.lastDispatchErrorType) {
    return makeHealthDiagnosis(
      roomHealthEntry.lastDispatchErrorType,
      titleCaseError(roomHealthEntry.lastDispatchErrorType),
      `Latest ${roomName} dispatch for this agent failed before or during delivery to the home.`,
      'error',
      roomHealthEntry.lastDispatchErrorAt || roomHealthEntry.lastDispatchReceivedAt || null
    );
  }
  if (roomHealthEntry.lastSuppressedReason && (!roomHealthEntry.lastVisibleMessageAt || Date.parse(roomHealthEntry.lastSuppressedAt || 0) >= Date.parse(roomHealthEntry.lastVisibleMessageAt || 0))) {
    return makeHealthDiagnosis(
      roomHealthEntry.lastSuppressedReason,
      titleCaseError(roomHealthEntry.lastSuppressedReason),
      `Latest ${roomName} message was logged but forwarding was intentionally suppressed.`,
      'warn',
      roomHealthEntry.lastSuppressedAt || null
    );
  }
  if (roomHealthEntry.lastVisibleMessageAt) {
    return makeHealthDiagnosis(
      'visible_reply',
      'Visible Reply',
      `A recent message from this agent is visible in ${roomName}.`,
      'ok',
      roomHealthEntry.lastVisibleMessageAt
    );
  }
  if (roomHealthEntry.lastDispatchReceivedAt) {
    return makeHealthDiagnosis(
      'awaiting_reply',
      'Awaiting Reply',
      `A ${roomName} dispatch reached this agent, but no room-visible reply is recorded yet.`,
      'warn',
      roomHealthEntry.lastDispatchReceivedAt
    );
  }
  return makeHealthDiagnosis('no_room_signal', 'No Room Signal', `No recent ${roomName} signal recorded.`, 'warn', null);
}

function analyseBoardroomStatus(log = [], running = false) {
  const lines = [...log].reverse();

  for (const line of lines) {
    const ts = extractTs(line);

    if (line.includes('[exit]')) {
      if (log.some(l => l.includes('EADDRINUSE'))) {
        return makeBoardroomDiagnosis('startup_port_collision', 'Port collision', 'Home failed to stay up because its configured port is already in use.', 'error', ts);
      }
      return makeBoardroomDiagnosis('process_stopped', 'Process stopped', 'Home process exited, so it cannot answer boardroom dispatches.', 'error', ts);
    }

    if (line.includes('process:error room=boardroom error=')) {
      if (line.includes('insufficient_quota') || line.includes('exceeded your current quota')) {
        return makeBoardroomDiagnosis('provider_quota_exhausted', 'Provider quota exhausted', 'The home process is up, but the model account has no remaining credits/quota, so replies cannot be generated.', 'error', ts);
      }
      if (line.includes('openrouter 429')) {
        return makeBoardroomDiagnosis('provider_rate_limited', 'Provider rate limit', 'Model provider is rejecting boardroom calls with 429 rate limits.', 'error', ts);
      }
      if (line.includes('openai 429') || line.includes('Anthropic 529') || line.includes('Overloaded')) {
        return makeBoardroomDiagnosis('provider_overloaded', 'Provider overloaded', 'Model provider is overloaded or rate limiting requests.', 'error', ts);
      }
      if (line.includes('openai 400') && line.includes('context length')) {
        return makeBoardroomDiagnosis('context_overflow', 'Context overflow', 'Boardroom prompt is too large for this model/context window.', 'error', ts);
      }
      if (line.includes('fetch failed')) {
        return makeBoardroomDiagnosis('upstream_fetch_failed', 'Upstream fetch failed', 'The home hit a network or upstream fetch failure while processing boardroom.', 'warn', ts);
      }
      return makeBoardroomDiagnosis('process_error', 'Processing error', line.split('error=')[1] || 'Boardroom processing failed.', 'error', ts);
    }

    if (line.includes('process:output_validator hard_fallback sent to yeshua@boardroom')) {
      return makeBoardroomDiagnosis('hard_fallback_sent', 'Hard fallback sent', 'The home failed to produce a proper reply and sent a system failure notice instead.', 'warn', ts);
    }

    if (line.includes('process:output_validator no_output=true') && line.includes('senderAddress=yeshua@boardroom')) {
      return makeBoardroomDiagnosis('output_protocol_failed', 'Output formatting failed', 'The model replied, but not in a deliverable format, so correction/fallback was required.', 'warn', ts);
    }

    if (line.includes('process:tool_loop_max_iterations')) {
      return makeBoardroomDiagnosis('tool_loop_exhausted', 'Tool loop exhausted', 'The home hit its iteration budget before producing a reply.', 'warn', ts);
    }

    if (line.includes('process:start room=boardroom')) {
      break;
    }
  }

  if (!running) {
    return makeBoardroomDiagnosis('offline', 'Offline', 'Home is not running, so it cannot answer boardroom dispatches.', 'error', null);
  }

  return makeBoardroomDiagnosis('healthy', 'No recent boardroom failure', 'No recent boardroom-specific failure signature found in launcher logs.', 'ok', null);
}

async function probeHomes() {
  const found = {};
  await Promise.all(PROBE_PORTS.map(async (port) => {
    try {
      const res = await fetch(`http://localhost:${port}/status`);
      if (!res.ok) return;
      const data = await res.json();
      if (data?.name) found[data.name] = { port, liveStatus: data };
    } catch {}
  }));
  return found;
}

function hasLiveProc(info) {
  return !!(info && info.proc && info.proc.exitCode === null && !info.proc.killed);
}

async function probeRoomServer() {
  try {
    const res = await fetch(`http://localhost:${ROOM_SERVER_PORT}/api/state`);
    return res.ok;
  } catch {
    return false;
  }
}

// ── Process Management ─────────────────

function startRoomServer() {
  if (roomServerProc) return { ok: false, error: 'Already running' };

  const proc = spawn(NODE, [ROOM_SERVER_JS], {
    cwd: path.dirname(ROOM_SERVER_JS),
    env: { ...process.env, PATH: '/opt/homebrew/bin:' + (process.env.PATH || '') },
    stdio: ['ignore', 'pipe', 'pipe'],
  });

  roomServerLog = [];
  proc.stdout.on('data', d => d.toString().split('\n').filter(Boolean).forEach(l => pushLog(roomServerLog, `[out] ${l}`)));
  proc.stderr.on('data', d => d.toString().split('\n').filter(Boolean).forEach(l => pushLog(roomServerLog, `[err] ${l}`)));
  proc.on('exit', (code, signal) => {
    pushLog(roomServerLog, `[exit] code=${code} signal=${signal}`);
    roomServerProc = null;
  });

  roomServerProc = proc;
  return { ok: true, pid: proc.pid };
}

function stopRoomServer() {
  if (!roomServerProc) return { ok: false, error: 'Not running' };
  roomServerProc.kill('SIGTERM');
  roomServerProc = null;
  return { ok: true };
}

function discoverHomes() {
  // Scan HOMES_DIR for existing home directories
  if (!fs.existsSync(HOMES_DIR)) return [];
  const found = [];
  for (const entry of fs.readdirSync(HOMES_DIR, { withFileTypes: true })) {
    if (!entry.isDirectory()) continue;
    const configPath = path.join(HOMES_DIR, entry.name, 'config.json');
    if (fs.existsSync(configPath)) {
      try {
        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
        found.push({
          name: config.name || entry.name,
          homeDir: path.join(HOMES_DIR, entry.name),
          model: config.model || 'unknown',
          hasApiKey: !!(config.apiKey || config.apiKeyEnv || fs.existsSync(path.join(HOMES_DIR, entry.name, 'config.local.json'))),
        });
      } catch {}
    }
  }
  return found;
}

function startHome(name, port) {
  if (homes[name]?.proc) return { ok: false, error: `${name} already running` };

  const homeDir = path.join(HOMES_DIR, name);
  if (!fs.existsSync(path.join(homeDir, 'config.json'))) {
    return { ok: false, error: `No config.json in ${homeDir}` };
  }

  const config = JSON.parse(fs.readFileSync(path.join(homeDir, 'config.json'), 'utf8'));

  const proc = spawn(NODE, [HOME_JS, homeDir, String(port)], {
    cwd: path.dirname(HOME_JS),
    env: { ...process.env, PATH: '/opt/homebrew/bin:' + (process.env.PATH || '') },
    stdio: ['ignore', 'pipe', 'pipe'],
  });

  const log = [];
  proc.stdout.on('data', d => d.toString().split('\n').filter(Boolean).forEach(l => pushLog(log, `[out] ${l}`)));
  proc.stderr.on('data', d => d.toString().split('\n').filter(Boolean).forEach(l => pushLog(log, `[err] ${l}`)));
  proc.on('exit', (code, signal) => {
    pushLog(log, `[exit] code=${code} signal=${signal}`);
    if (homes[name]) homes[name].proc = null;
  });

  homes[name] = { proc, port, homeDir, config, log };
  return { ok: true, pid: proc.pid, port };
}

function stopHome(name) {
  if (!homes[name]?.proc) return { ok: false, error: `${name} not running` };
  homes[name].proc.kill('SIGTERM');
  homes[name].proc = null;
  return { ok: true };
}

async function registerEndpoints() {
  // Tell room server where each running home lives, but only from verified
  // live /status identity, not remembered launcher port state.
  const results = [];
  const probedHomes = await probeHomes();
  for (const discovered of discoverHomes()) {
    const name = discovered.name;
    const info = homes[name];
    const live = probedHomes[name];
    if (!live) {
      try {
        const body = JSON.stringify({ name, endpoint: null });
        const res = await fetch(`http://localhost:${ROOM_SERVER_PORT}/api/directory/update-endpoint`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body,
        });
        results.push({
          name,
          ok: false,
          cleared: res.ok,
          error: 'No live /status match found; stale endpoint cleared',
        });
      } catch (e) {
        results.push({ name, ok: false, error: `No live /status match found; failed to clear stale endpoint: ${e.message}` });
      }
      continue;
    }
    try {
      if (info) info.port = live.port;
      const body = JSON.stringify({ name, endpoint: `http://localhost:${live.port}` });
      const res = await fetch(`http://localhost:${ROOM_SERVER_PORT}/api/directory/update-endpoint`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body,
      });
      results.push({ name, ok: res.ok, port: live.port });
    } catch (e) {
      results.push({ name, ok: false, error: e.message });
    }
  }
  return results;
}

async function getStatus() {
  const discovered = discoverHomes();
  const homeStatus = {};
  const probedHomes = await probeHomes();
  const roomServerRunning = roomServerProc ? true : await probeRoomServer();
  let roomHealth = {};
  if (roomServerRunning) {
    try {
      const res = await fetch(`http://localhost:${ROOM_SERVER_PORT}/api/room-health`);
      if (res.ok) roomHealth = await res.json();
    } catch {}
  }

  for (const h of discovered) {
    const launcherInfo = homes[h.name];
    const running = hasLiveProc(launcherInfo) || !!probedHomes[h.name];
    const port = probedHomes[h.name]?.port || launcherInfo?.port || h.port || null;
    const liveStatus = probedHomes[h.name]?.liveStatus || null;
    const boardroomHealth = roomHealth.boardroom?.[h.name] || null;
    const cochairsHealth = roomHealth.cochairs?.[h.name] || null;
    homeStatus[h.name] = {
      name: h.name,
      model: h.model,
      homeDir: h.homeDir,
      hasApiKey: h.hasApiKey,
      running,
      pid: hasLiveProc(launcherInfo) ? launcherInfo.proc.pid : null,
      port,
      queueDepth: liveStatus?.queueDepth ?? null,
      processing: liveStatus?.processing ?? null,
      rooms: liveStatus?.rooms ?? null,
      health: liveStatus?.health ?? null,
      serviceability: diagnoseServiceability(liveStatus, running),
      boardroom: analyseBoardroomStatus(launcherInfo?.log || [], running),
      boardroomRoomState: diagnoseRoomState('boardroom', h.name, boardroomHealth),
      cochairsRoomState: diagnoseRoomState('cochairs', h.name, cochairsHealth),
    };
  }

  return {
    roomServer: {
      running: roomServerRunning,
      pid: roomServerProc?.pid || null,
      port: ROOM_SERVER_PORT,
    },
    homes: homeStatus,
    roomHealth,
    homesDir: HOMES_DIR,
    launcherPort: LAUNCHER_PORT,
  };
}

// ── Default port assignment ────────────
function assignPort(name) {
  const portMap = { alpha: 4110, beta: 4111, gamma: 4112 };
  if (portMap[name]) return portMap[name];
  // Read from config.json if available — prevents port collisions on restart
  const configPath = path.join(HOMES_DIR, name, 'config.json');
  if (fs.existsSync(configPath)) {
    try {
      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
      if (config.port) return config.port;
    } catch {}
  }
  // Fall back to auto-assign from 4113+
  const usedPorts = new Set(Object.values(homes).map(h => h.port));
  let p = 4113;
  while (usedPorts.has(p)) p++;
  return p;
}

// ── HTTP API + UI ──────────────────────

const server = http.createServer(async (req, res) => {
  const url = new URL(req.url, `http://localhost:${LAUNCHER_PORT}`);
  const p = url.pathname;

  // ── API routes ──
  if (p === '/api/status') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(await getStatus()));
  }

  if (p === '/api/start-room-server' && req.method === 'POST') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(startRoomServer()));
  }

  if (p === '/api/stop-room-server' && req.method === 'POST') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(stopRoomServer()));
  }

  if (p === '/api/start-home' && req.method === 'POST') {
    const body = await readBody(req);
    const { name, port } = JSON.parse(body);
    const actualPort = port || assignPort(name);
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(startHome(name, actualPort)));
  }

  if (p === '/api/stop-home' && req.method === 'POST') {
    const body = await readBody(req);
    const { name } = JSON.parse(body);
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(stopHome(name)));
  }

  if (p === '/api/start-all' && req.method === 'POST') {
    const results = {};
    // Start room server first
    results.roomServer = startRoomServer();
    // Wait a beat for room server to bind
    await new Promise(r => setTimeout(r, 1000));
    // Start all discovered homes
    for (const h of discoverHomes()) {
      const port = assignPort(h.name);
      results[h.name] = startHome(h.name, port);
    }
    // Wait for homes to bind, then register endpoints
    await new Promise(r => setTimeout(r, 1500));
    results.endpoints = await registerEndpoints();
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(results));
  }

  if (p === '/api/stop-all' && req.method === 'POST') {
    const results = {};
    for (const name of Object.keys(homes)) {
      results[name] = stopHome(name);
    }
    results.roomServer = stopRoomServer();
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(results));
  }

  if (p === '/api/register-endpoints' && req.method === 'POST') {
    const results = await registerEndpoints();
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(results));
  }

  if (p === '/api/logs') {
    const name = url.searchParams.get('name');
    let lines;
    if (name === 'room-server') {
      lines = roomServerLog;
    } else if (homes[name]) {
      lines = homes[name].log || [];
    } else {
      res.writeHead(404, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Unknown service' }));
    }
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify({ name, lines }));
  }

  // ── Config API ──
  if (p.startsWith('/api/config/') && req.method === 'GET') {
    const name = p.slice('/api/config/'.length);
    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid name' }));
    }
    const cfgPath = path.join(HOMES_DIR, name, 'config.json');
    if (!fs.existsSync(cfgPath)) {
      res.writeHead(404, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Not found' }));
    }
    const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
    // Redact API key value but preserve presence indicator
    const safe = { ...cfg };
    if (safe.apiKey) safe.apiKey = '***';
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(safe));
  }

  if (p.startsWith('/api/config/') && req.method === 'POST') {
    const name = p.slice('/api/config/'.length);
    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid name' }));
    }
    const cfgPath = path.join(HOMES_DIR, name, 'config.json');
    if (!fs.existsSync(cfgPath)) {
      res.writeHead(404, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Not found' }));
    }
    const body = await readBody(req);
    let updates;
    try { updates = JSON.parse(body); } catch (e) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid JSON' }));
    }
    const existing = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
    // Don't let masked placeholder overwrite the real key
    if (updates.apiKey === '***') delete updates.apiKey;
    const merged = { ...existing, ...updates };
    // Preserve immutables
    merged.name = existing.name;
    merged.uid = existing.uid;
    fs.writeFileSync(cfgPath, JSON.stringify(merged, null, 2));
    // Restart so changes take effect
    stopHome(name);
    await new Promise(r => setTimeout(r, 500));
    startHome(name, merged.port || existing.port);
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify({ ok: true, restarted: true, name }));
  }

  // ── Cron API ──
  if (p.startsWith('/api/cron/') && req.method === 'GET') {
    const name = p.slice('/api/cron/'.length);
    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid name' }));
    }
    const cronPath = path.join(HOMES_DIR, name, 'cron.json');
    if (!fs.existsSync(cronPath)) {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify([]));
    }
    const jobs = JSON.parse(fs.readFileSync(cronPath, 'utf8'));
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify(jobs));
  }

  if (p.startsWith('/api/cron/') && req.method === 'POST') {
    const name = p.slice('/api/cron/'.length);
    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid name' }));
    }
    const cronPath = path.join(HOMES_DIR, name, 'cron.json');
    const body = await readBody(req);
    let jobs;
    try { jobs = JSON.parse(body); } catch (e) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Invalid JSON' }));
    }
    if (!Array.isArray(jobs)) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: 'Expected array of cron jobs' }));
    }
    fs.writeFileSync(cronPath, JSON.stringify(jobs, null, 2));
    res.writeHead(200, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify({ ok: true, jobs: jobs.length, name }));
  }

  // ── Serve UI ──
  if (p === '/' || p === '/index.html') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    return res.end(DASHBOARD_HTML);
  }

  res.writeHead(404);
  res.end('Not found');
});

function readBody(req) {
  return new Promise((resolve) => {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => resolve(body));
  });
}

// ── Dashboard HTML ─────────────────────
const DASHBOARD_HTML = `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Blum Launcher</title>
<style>
  * { margin: 0; padding: 0; box-sizing: border-box; }
  body {
    font-family: -apple-system, BlinkMacSystemFont, 'SF Pro', system-ui, sans-serif;
    background: #0a0a0c;
    color: #e0e0e0;
    min-height: 100vh;
  }
  header {
    padding: 24px 32px;
    border-bottom: 1px solid #1a1a2e;
    display: flex;
    align-items: center;
    justify-content: space-between;
  }
  header h1 {
    font-size: 20px;
    font-weight: 600;
    color: #fff;
    letter-spacing: 0.5px;
  }
  header h1 span { color: #6366f1; }
  .header-actions { display: flex; gap: 10px; }
  .btn {
    padding: 8px 16px;
    border: 1px solid #2a2a3e;
    border-radius: 8px;
    background: #12121a;
    color: #ccc;
    font-size: 13px;
    cursor: pointer;
    transition: all 0.15s;
  }
  .btn:hover { background: #1a1a2e; color: #fff; }
  .btn-start { border-color: #22543d; color: #68d391; }
  .btn-start:hover { background: #1a3a2a; }
  .btn-stop { border-color: #5a2020; color: #fc8181; }
  .btn-stop:hover { background: #3a1a1a; }
  .btn-primary { border-color: #4338ca; color: #a5b4fc; background: #1e1b4b; }
  .btn-primary:hover { background: #2e2a5b; }

  main { padding: 24px 32px; }

  /* ── Room Server Card ── */
  .section-label {
    font-size: 11px;
    text-transform: uppercase;
    letter-spacing: 1.5px;
    color: #666;
    margin-bottom: 12px;
  }
  .service-card {
    background: #12121a;
    border: 1px solid #1a1a2e;
    border-radius: 12px;
    padding: 20px;
    margin-bottom: 24px;
  }
  .service-header {
    display: flex;
    align-items: center;
    justify-content: space-between;
    margin-bottom: 12px;
  }
  .service-name {
    display: flex;
    align-items: center;
    gap: 10px;
    font-size: 15px;
    font-weight: 500;
  }
  .status-dot {
    width: 10px; height: 10px;
    border-radius: 50%;
    background: #4a4a5a;
  }
  .status-dot.running { background: #48bb78; box-shadow: 0 0 8px rgba(72,187,120,0.4); }
  .status-dot.stopped { background: #e53e3e; }
  .service-meta {
    font-size: 12px;
    color: #666;
    display: flex;
    gap: 16px;
  }
  .service-meta span { display: flex; align-items: center; gap: 4px; }

  /* ── Homes Grid ── */
  .homes-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
    gap: 16px;
    margin-bottom: 24px;
  }
  .home-card {
    background: #12121a;
    border: 1px solid #1a1a2e;
    border-radius: 12px;
    padding: 20px;
  }
  .home-card.boardroom-ok { border-color: #214d35; }
  .home-card.boardroom-warn { border-color: #6b5318; }
  .home-card.boardroom-error { border-color: #6b1d1d; }
  .home-card .model-tag {
    font-size: 11px;
    padding: 3px 8px;
    border-radius: 4px;
    background: #1a1a2e;
    color: #8b8ba0;
    font-family: 'SF Mono', monospace;
  }
  .model-tag.haiku { color: #68d391; background: #1a2e1a; }
  .model-tag.sonnet { color: #63b3ed; background: #1a1a2e; }
  .model-tag.opus { color: #d6bcfa; background: #2a1a3e; }
  .diag-row {
    margin-top: 14px;
    padding-top: 14px;
    border-top: 1px solid #1a1a2e;
    display: grid;
    gap: 8px;
  }
  .diag-stack {
    display: grid;
    gap: 12px;
  }
  .diag-block {
    display: grid;
    gap: 8px;
  }
  .diag-head {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 12px;
  }
  .diag-label {
    font-size: 11px;
    text-transform: uppercase;
    letter-spacing: 1.2px;
    color: #7d8597;
  }
  .diag-badge {
    font-size: 11px;
    padding: 4px 8px;
    border-radius: 999px;
    font-weight: 600;
  }
  .diag-badge.ok { color: #7ee0a1; background: #183524; }
  .diag-badge.warn { color: #f3d17a; background: #3a2c10; }
  .diag-badge.error { color: #ff9b9b; background: #431919; }
  .diag-detail {
    font-size: 12px;
    color: #b6bcc9;
    line-height: 1.45;
    min-height: 34px;
  }
  .diag-meta {
    font-size: 11px;
    color: #7d8597;
    display: flex;
    gap: 12px;
    flex-wrap: wrap;
  }

  /* ── Log Panel ── */
  .log-panel {
    background: #0d0d12;
    border: 1px solid #1a1a2e;
    border-radius: 12px;
    margin-top: 24px;
    overflow: hidden;
  }
  .log-tabs {
    display: flex;
    border-bottom: 1px solid #1a1a2e;
    padding: 0 12px;
    overflow-x: auto;
  }
  .log-tab {
    padding: 10px 16px;
    font-size: 12px;
    color: #666;
    cursor: pointer;
    border-bottom: 2px solid transparent;
    white-space: nowrap;
  }
  .log-tab:hover { color: #aaa; }
  .log-tab.active { color: #a5b4fc; border-bottom-color: #6366f1; }
  .log-content {
    height: 280px;
    overflow-y: auto;
    padding: 12px 16px;
    font-family: 'SF Mono', 'Fira Code', monospace;
    font-size: 12px;
    line-height: 1.6;
    color: #8b8ba0;
  }
  .log-content .log-err { color: #fc8181; }
  .log-content .log-exit { color: #fbd38d; }
</style>
</head>
<body>

<header>
  <h1><span>blum</span> launcher</h1>
  <div class="header-actions">
    <button class="btn btn-start" onclick="startAll()">Start All</button>
    <button class="btn btn-stop" onclick="stopAll()">Stop All</button>
    <button class="btn" onclick="registerEndpoints()">Register Endpoints</button>
  </div>
</header>

<main>
  <!-- Room Server -->
  <div class="section-label">Room Server</div>
  <div class="service-card" id="room-server-card">
    <div class="service-header">
      <div class="service-name">
        <div class="status-dot" id="rs-dot"></div>
        <span>Room Server</span>
      </div>
      <div>
        <button class="btn btn-start" onclick="startRoomServer()">Start</button>
        <button class="btn btn-stop" onclick="stopRoomServer()">Stop</button>
      </div>
    </div>
    <div class="service-meta">
      <span>Port: <strong>3141</strong></span>
      <span id="rs-pid"></span>
    </div>
  </div>

  <!-- Homes -->
  <div class="section-label">Agent Homes</div>
  <div class="homes-grid" id="homes-grid"></div>

  <!-- Logs -->
  <div class="section-label">Logs</div>
  <div class="log-panel">
    <div class="log-tabs" id="log-tabs"></div>
    <div class="log-content" id="log-content"></div>
  </div>
</main>

<script>
const API = '';
let currentLogTab = 'room-server';
let autoScroll = true;

function modelClass(model) {
  if (!model) return '';
  if (model.includes('haiku')) return 'haiku';
  if (model.includes('sonnet')) return 'sonnet';
  if (model.includes('opus')) return 'opus';
  return '';
}

function modelShort(model) {
  if (!model) return 'unknown';
  // "claude-haiku-4-5" → "haiku 4.5"
  const m = model.match(/(haiku|sonnet|opus)[- ]?(\\d+)?[- ]?(\\d+)?/i);
  if (m) {
    const ver = m[2] && m[3] ? m[2] + '.' + m[3] : (m[2] || '');
    return m[1].toLowerCase() + (ver ? ' ' + ver : '');
  }
  return model.replace('claude-', '');
}

function severityClass(severity) {
  return severity === 'error' ? 'error' : (severity === 'warn' ? 'warn' : 'ok');
}

function relativeTs(ts) {
  if (!ts) return 'No recent event';
  const ms = Date.now() - Date.parse(ts);
  if (!Number.isFinite(ms)) return ts;
  const mins = Math.round(ms / 60000);
  if (mins < 1) return 'just now';
  if (mins < 60) return mins + 'm ago';
  const hrs = Math.round(mins / 60);
  if (hrs < 48) return hrs + 'h ago';
  const days = Math.round(hrs / 24);
  return days + 'd ago';
}

async function fetchJSON(url, opts) {
  const res = await fetch(API + url, opts);
  return res.json();
}

async function refresh() {
  try {
    const status = await fetchJSON('/api/status');
    renderRoomServer(status.roomServer);
    renderHomes(status.homes);
    renderLogTabs(status);
    await refreshLog();
  } catch (e) {
    console.error('Refresh failed:', e);
  }
}

function renderRoomServer(rs) {
  const dot = document.getElementById('rs-dot');
  dot.className = 'status-dot ' + (rs.running ? 'running' : 'stopped');
  document.getElementById('rs-pid').textContent = rs.running ? 'PID: ' + rs.pid : 'Stopped';
}

function renderHomes(homesMap) {
  const grid = document.getElementById('homes-grid');
  const names = Object.keys(homesMap).sort();
  grid.innerHTML = names.map(name => {
    const h = homesMap[name];
    const service = h.serviceability || { label: 'Unknown', detail: 'No serviceability diagnosis available.', severity: 'warn' };
    const boardroom = h.boardroomRoomState || h.boardroom || { label: 'Unknown', detail: 'No boardroom diagnosis available.', severity: 'warn' };
    const cochairs = h.cochairsRoomState || { label: 'Unknown', detail: 'No cochairs diagnosis available.', severity: 'warn' };
    const cardClass = 'home-card boardroom-' + severityClass(service.severity);
    return \`
      <div class="\${cardClass}">
        <div class="service-header">
          <div class="service-name">
            <div class="status-dot \${h.running ? 'running' : 'stopped'}"></div>
            <span>\${h.name}</span>
            <span class="model-tag \${modelClass(h.model)}">\${modelShort(h.model)}</span>
          </div>
          <div>
            <button class="btn btn-start" onclick="startHome('\${h.name}')">Start</button>
            <button class="btn btn-stop" onclick="stopHome('\${h.name}')">Stop</button>
          </div>
        </div>
        <div class="service-meta">
          <span>Port: <strong>\${h.port || '—'}</strong></span>
          <span>\${h.running ? 'PID: ' + h.pid : 'Stopped'}</span>
          <span>\${h.hasApiKey ? 'Key: yes' : 'Key: none'}</span>
        </div>
        <div class="diag-row">
          <div class="diag-stack">
            <div class="diag-block">
              <div class="diag-head">
                <div class="diag-label">Serviceability</div>
                <div class="diag-badge \${severityClass(service.severity)}">\${service.label}</div>
              </div>
              <div class="diag-detail">\${service.detail}</div>
            </div>
            <div class="diag-block">
              <div class="diag-head">
                <div class="diag-label">Boardroom</div>
                <div class="diag-badge \${severityClass(boardroom.severity)}">\${boardroom.label}</div>
              </div>
              <div class="diag-detail">\${boardroom.detail}</div>
            </div>
            <div class="diag-block">
              <div class="diag-head">
                <div class="diag-label">Cochairs</div>
                <div class="diag-badge \${severityClass(cochairs.severity)}">\${cochairs.label}</div>
              </div>
              <div class="diag-detail">\${cochairs.detail}</div>
            </div>
          </div>
          <div class="diag-meta">
            <span>Queue: \${h.queueDepth == null ? '—' : h.queueDepth}</span>
            <span>\${h.processing === true ? 'Processing now' : (h.processing === false ? 'Idle' : 'Processing: —')}</span>
            <span>Service: \${relativeTs(service.ts)}</span>
            <span>Boardroom: \${relativeTs(boardroom.ts)}</span>
            <span>Cochairs: \${relativeTs(cochairs.ts)}</span>
          </div>
        </div>
      </div>\`;
  }).join('');
}

function renderLogTabs(status) {
  const tabs = document.getElementById('log-tabs');
  const services = ['room-server', ...Object.keys(status.homes).sort()];
  tabs.innerHTML = services.map(s =>
    \`<div class="log-tab \${s === currentLogTab ? 'active' : ''}" onclick="switchLog('\${s}')">\${s}</div>\`
  ).join('');
}

function switchLog(name) {
  currentLogTab = name;
  document.querySelectorAll('.log-tab').forEach(t =>
    t.classList.toggle('active', t.textContent === name));
  refreshLog();
}

async function refreshLog() {
  try {
    const data = await fetchJSON('/api/logs?name=' + currentLogTab);
    const el = document.getElementById('log-content');
    el.innerHTML = (data.lines || []).map(l => {
      let cls = '';
      if (l.startsWith('[err]')) cls = 'log-err';
      if (l.startsWith('[exit]')) cls = 'log-exit';
      return \`<div class="\${cls}">\${escHtml(l)}</div>\`;
    }).join('');
    if (autoScroll) el.scrollTop = el.scrollHeight;
  } catch {}
}

function escHtml(s) {
  return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
}

// ── Actions ──
async function startRoomServer() { await fetchJSON('/api/start-room-server', { method: 'POST' }); refresh(); }
async function stopRoomServer() { await fetchJSON('/api/stop-room-server', { method: 'POST' }); refresh(); }
async function startHome(name) {
  await fetchJSON('/api/start-home', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name }) });
  refresh();
}
async function stopHome(name) {
  await fetchJSON('/api/stop-home', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name }) });
  refresh();
}
async function startAll() { await fetchJSON('/api/start-all', { method: 'POST' }); refresh(); }
async function stopAll() { await fetchJSON('/api/stop-all', { method: 'POST' }); refresh(); }
async function registerEndpoints() { await fetchJSON('/api/register-endpoints', { method: 'POST' }); refresh(); }

// ── Poll ──
refresh();
setInterval(refresh, 3000);
setInterval(refreshLog, 2000);
</script>
</body>
</html>`;

server.listen(LAUNCHER_PORT, () => {
  console.log(`\n  BLUM LAUNCHER`);
  console.log(`  ═════════════`);
  console.log(`  UI:    http://localhost:${LAUNCHER_PORT}`);
  console.log(`  Homes: ${HOMES_DIR}`);
  console.log(`  Ready.\n`);
});