@bulletproof-sh/ctrl-daemon 0.0.7 → 0.0.9

package/README.md

@@ -26,6 +26,7 @@ npx @bulletproof-sh/ctrl-daemon --port 3001 --host 127.0.0.1
 | `--port <number>` | `3001` | Port to listen on |
 | `--host <address>` | `0.0.0.0` | Host/address to bind to |
 | `--project-dir <path>` | — | Watch a single project; omit to watch all projects |
+| `--idle-timeout <minutes>` | `15` | Agent idle timeout in minutes |
 | `--help`, `-h` | — | Print usage |
 
 Without `--project-dir`, the daemon scans `~/.claude/projects/` and watches every session it finds there.

package/dist/index.js

@@ -4319,7 +4319,7 @@ var PROJECT_SCAN_INTERVAL_MS = 1000;
 var TOOL_DONE_DELAY_MS = 300;
 var PERMISSION_TIMER_DELAY_MS = 7000;
 var TEXT_IDLE_DELAY_MS = 5000;
-var AGENT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+var AGENT_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
 var BASH_COMMAND_DISPLAY_MAX_LENGTH = 30;
 var TASK_DESCRIPTION_DISPLAY_MAX_LENGTH = 40;
 
@@ -4660,6 +4660,186 @@ function processProgressRecord(agentId, record, agents, waitingTimers, permissio
     }
   }
 }
+// src/tui/constants.ts
+var KATAKANA_START = 65382;
+var KATAKANA_END = 65437;
+var KATAKANA_CHARS = [];
+for (let i = KATAKANA_START;i <= KATAKANA_END; i++) {
+  KATAKANA_CHARS.push(String.fromCharCode(i));
+}
+var EXTRA_CHARS = "0123456789$+-*/%=#@&<>~^".split("");
+var RAIN_CHARS = [...KATAKANA_CHARS, ...EXTRA_CHARS];
+var TRAIL_GRADIENT = [
+  231,
+  159,
+  123,
+  49,
+  48,
+  46,
+  40,
+  34,
+  28,
+  22,
+  23,
+  29,
+  24,
+  18,
+  17
+];
+var LAYERS = {
+  back: {
+    speedMin: 0.15,
+    speedMax: 0.3,
+    trailMin: 8,
+    trailMax: 16,
+    spawnRate: 0.01,
+    mutationInterval: 12,
+    brightnessOffset: 4
+  },
+  mid: {
+    speedMin: 0.3,
+    speedMax: 0.6,
+    trailMin: 10,
+    trailMax: 25,
+    spawnRate: 0.02,
+    mutationInterval: 8,
+    brightnessOffset: 2
+  },
+  front: {
+    speedMin: 0.6,
+    speedMax: 1.2,
+    trailMin: 6,
+    trailMax: 14,
+    spawnRate: 0.015,
+    mutationInterval: 5,
+    brightnessOffset: 0
+  }
+};
+var LIGHTNING_CHANCE = 0.002;
+var LIGHTNING_SPEED_MIN = 2;
+var LIGHTNING_SPEED_MAX = 4;
+var LIGHTNING_TRAIL_LEN = 4;
+var TARGET_FPS = 8;
+var FRAME_INTERVAL_MS = Math.round(1000 / TARGET_FPS);
+var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
+var PANEL_MAX_WIDTH = 80;
+var PANEL_MAX_HEIGHT = 24;
+var PANEL_MARGIN_X = 5;
+var PANEL_MARGIN_Y = 3;
+var PANEL_MIN_WIDTH = 40;
+var PANEL_MIN_HEIGHT = 12;
+var PANEL_HEADER_HEIGHT = 8;
+var LOG_RING_SIZE = 200;
+var BORDER_GLOW_SPEED = 0.05;
+var BOX = {
+  topLeft: "\u2554",
+  topRight: "\u2557",
+  bottomLeft: "\u255A",
+  bottomRight: "\u255D",
+  horizontal: "\u2550",
+  vertical: "\u2551",
+  teeLeft: "\u2560",
+  teeRight: "\u2563"
+};
+var FG256_TABLE = [];
+for (let i = 0;i < 256; i++) {
+  FG256_TABLE.push(`\x1B[38;5;${i}m`);
+}
+var fg256 = (n) => FG256_TABLE[n];
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var BRIGHT_GREEN_FG = "\x1B[92m";
+var CYAN_FG = "\x1B[36m";
+var YELLOW_FG = "\x1B[33m";
+var RED_FG = "\x1B[31m";
+var ORANGE_FG = "\x1B[38;5;208m";
+
+// src/tui/logSink.ts
+var logBuffer = [];
+var tuiActive = false;
+var originalConsoleLog = console.log;
+var originalConsoleError = console.error;
+function timestamp() {
+  const d = new Date;
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+function pushEntry(message, color) {
+  logBuffer.push({ timestamp: timestamp(), message, color });
+  if (logBuffer.length > LOG_RING_SIZE) {
+    logBuffer.shift();
+  }
+}
+function getLogEntries() {
+  return logBuffer;
+}
+function daemonLog(message, color) {
+  if (tuiActive) {
+    pushEntry(message, color || fg256(250));
+  } else {
+    originalConsoleError(`[ctrl-daemon] ${message}`);
+  }
+}
+function onBroadcast(msg) {
+  if (!tuiActive)
+    return;
+  if (typeof msg !== "object" || msg === null)
+    return;
+  const m = msg;
+  const type = m.type;
+  const id = m.id;
+  switch (type) {
+    case "agentCreated":
+      pushEntry(`Agent ${id}: session started`, BRIGHT_GREEN_FG);
+      break;
+    case "agentClosed":
+      pushEntry(`Agent ${id}: session closed`, fg256(240));
+      break;
+    case "agentToolStart": {
+      const toolName = m.toolName || "tool";
+      pushEntry(`Agent ${id}: ${toolName}`, CYAN_FG);
+      break;
+    }
+    case "agentToolDone": {
+      const toolName = m.toolName || "tool";
+      pushEntry(`Agent ${id}: ${toolName} done`, fg256(34));
+      break;
+    }
+    case "agentStatus": {
+      const status = m.status;
+      if (status === "waiting") {
+        pushEntry(`Agent ${id}: turn complete`, YELLOW_FG);
+      } else if (status === "permission") {
+        pushEntry(`Agent ${id}: waiting for permission`, ORANGE_FG);
+      }
+      break;
+    }
+    case "agentToolPermissionClear":
+      break;
+    default:
+      pushEntry(`[broadcast] ${type}`, fg256(240));
+      break;
+  }
+}
+function captureConsole() {
+  tuiActive = true;
+  originalConsoleLog = console.log;
+  originalConsoleError = console.error;
+  console.log = (...args) => {
+    const msg = args.map((a) => String(a)).join(" ");
+    pushEntry(msg, fg256(250));
+  };
+  console.error = (...args) => {
+    const msg = args.map((a) => String(a)).join(" ");
+    pushEntry(msg, RED_FG);
+  };
+}
+function restoreConsole() {
+  tuiActive = false;
+  console.log = originalConsoleLog;
+  console.error = originalConsoleError;
+}
+
 // src/sessionWatcher.ts
 function startSessionWatcher(agentId, filePath, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast) {
   try {
@@ -4668,7 +4848,7 @@ function startSessionWatcher(agentId, filePath, agents, fileWatchers, pollingTim
     });
     fileWatchers.set(agentId, watcher);
   } catch (e) {
-    console.log(`[ctrl-daemon] fs.watch failed for agent ${agentId}: ${e}`);
+    daemonLog(`fs.watch failed for agent ${agentId}: ${e}`);
   }
   const interval = setInterval(() => {
     if (!agents.has(agentId)) {
@@ -4712,7 +4892,7 @@ function readNewLines(agentId, agents, waitingTimers, permissionTimers, broadcas
       processTranscriptLine(agentId, line, agents, waitingTimers, permissionTimers, broadcast);
     }
   } catch (e) {
-    console.log(`[ctrl-daemon] Read error for agent ${agentId}: ${e}`);
+    daemonLog(`Read error for agent ${agentId}: ${e}`);
   }
 }
 function stopSessionWatcher(agentId, fileWatchers, pollingTimers, waitingTimers, permissionTimers) {
@@ -4779,7 +4959,7 @@ function collectAllJsonlFiles(projectsRoot) {
   }
   return files;
 }
-function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast) {
+function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast, idleTimeoutMs) {
   const knownJsonlFiles = new Set;
   let nextAgentId = 1;
   function scan() {
@@ -4788,9 +4968,9 @@ function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTime
     for (const { filePath, mtimeMs } of fileInfos) {
       if (knownJsonlFiles.has(filePath))
         continue;
-      knownJsonlFiles.add(filePath);
-      if (now - mtimeMs > AGENT_IDLE_TIMEOUT_MS)
+      if (now - mtimeMs > idleTimeoutMs)
         continue;
+      knownJsonlFiles.add(filePath);
       const id = nextAgentId++;
       const agentProjectDir = path2.dirname(filePath);
       const agent = {
@@ -4810,18 +4990,18 @@ function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTime
         lastActivityAt: mtimeMs
       };
       agents.set(id, agent);
-      console.log(`[ctrl-daemon] Agent ${id}: watching ${path2.basename(filePath)}`);
+      daemonLog(`Agent ${id}: watching ${path2.basename(filePath)}`);
       broadcast({ type: "agentCreated", id });
       startSessionWatcher(id, filePath, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast);
       readNewLines(id, agents, waitingTimers, permissionTimers, broadcast);
     }
     for (const [agentId, agent] of agents) {
       const lastActivity = agent.lastActivityAt || 0;
-      const idle = now - lastActivity > AGENT_IDLE_TIMEOUT_MS;
+      const idle = now - lastActivity > idleTimeoutMs;
       const removed = !fs2.existsSync(agent.jsonlFile);
       if (removed || idle) {
         const reason = removed ? "JSONL removed" : "idle timeout";
-        console.log(`[ctrl-daemon] Agent ${agentId}: ${reason}, closing`);
+        daemonLog(`Agent ${agentId}: ${reason}, closing`);
         stopSessionWatcher(agentId, fileWatchers, pollingTimers, waitingTimers, permissionTimers);
         agents.delete(agentId);
         knownJsonlFiles.delete(agent.jsonlFile);
@@ -4837,6 +5017,7 @@ function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTime
 }
 
 // src/server.ts
+var PORT_RETRY_LIMIT = 10;
 function createServer({ port, host, agents }) {
   const clients = new Set;
   function broadcast(msg) {
@@ -4847,60 +5028,595 @@ function createServer({ port, host, agents }) {
       } catch {}
     }
   }
-  const server = Bun.serve({
-    port,
-    hostname: host,
-    fetch(req, server2) {
-      const url = new URL(req.url);
-      if (url.pathname === "/ws") {
-        if (server2.upgrade(req))
-          return;
-        return new Response("WebSocket upgrade failed", { status: 400 });
-      }
-      if (url.pathname === "/health") {
-        return Response.json({
-          status: "ok",
-          agents: agents.size
-        });
-      }
-      return new Response("Not found", { status: 404 });
-    },
-    websocket: {
-      open(ws) {
-        clients.add(ws);
-        console.log(`[ctrl-daemon] WebSocket client connected (${clients.size} total)`);
-        const existingAgents = [];
-        for (const [, agent] of agents) {
-          const activeTools = [];
-          for (const toolId of agent.activeToolIds) {
-            activeTools.push({
-              toolId,
-              status: agent.activeToolStatuses.get(toolId) || ""
-            });
-          }
-          existingAgents.push({
-            id: agent.id,
-            isWaiting: agent.isWaiting,
-            permissionSent: agent.permissionSent,
-            activeTools
+  function makeServerConfig(listenPort) {
+    return {
+      port: listenPort,
+      hostname: host,
+      fetch(req, server2) {
+        const url = new URL(req.url);
+        if (url.pathname === "/ws") {
+          if (server2.upgrade(req))
+            return;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        if (url.pathname === "/health") {
+          return Response.json({
+            status: "ok",
+            agents: agents.size
           });
         }
-        ws.send(JSON.stringify({ type: "existingAgents", agents: existingAgents }));
+        return new Response("Not found", { status: 404 });
       },
-      message(_ws, _message) {},
-      close(ws) {
-        clients.delete(ws);
-        console.log(`[ctrl-daemon] WebSocket client disconnected (${clients.size} total)`);
+      websocket: {
+        open(ws) {
+          clients.add(ws);
+          daemonLog(`Client connected (${clients.size} total)`);
+          const existingAgents = [];
+          for (const [, agent] of agents) {
+            const activeTools = [];
+            for (const toolId of agent.activeToolIds) {
+              activeTools.push({
+                toolId,
+                status: agent.activeToolStatuses.get(toolId) || ""
+              });
+            }
+            existingAgents.push({
+              id: agent.id,
+              isWaiting: agent.isWaiting,
+              permissionSent: agent.permissionSent,
+              activeTools
+            });
+          }
+          ws.send(JSON.stringify({
+            type: "existingAgents",
+            agents: existingAgents
+          }));
+        },
+        message(_ws, _message) {},
+        close(ws) {
+          clients.delete(ws);
+          daemonLog(`Client disconnected (${clients.size} total)`);
+        }
+      }
+    };
+  }
+  function tryServe(startPort) {
+    let boundPort = startPort;
+    for (let attempt = 0;attempt < PORT_RETRY_LIMIT; attempt++) {
+      try {
+        return Bun.serve(makeServerConfig(boundPort));
+      } catch (err) {
+        const isAddrInUse = err instanceof Error && (err.message.includes("EADDRINUSE") || err.message.includes("address already in use"));
+        if (!isAddrInUse || attempt === PORT_RETRY_LIMIT - 1)
+          throw err;
+        boundPort++;
       }
     }
-  });
-  console.log(`[ctrl-daemon] Listening on ws://${server.hostname}:${server.port}/ws`);
+    throw new Error(`No available port after ${PORT_RETRY_LIMIT} attempts`);
+  }
+  const server = tryServe(port);
+  if (server.port !== port) {
+    daemonLog(`Port ${port} in use, using ${server.port} instead`);
+  }
+  daemonLog(`Listening on ws://${server.hostname}:${server.port}/ws`);
   return {
     broadcast,
+    clientCount: () => clients.size,
+    port: server.port,
     stop: () => server.stop()
   };
 }
 
+// src/tui/terminal.ts
+var ALT_SCREEN_ON = "\x1B[?1049h";
+var ALT_SCREEN_OFF = "\x1B[?1049l";
+var CURSOR_HIDE = "\x1B[?25l";
+var CURSOR_SHOW = "\x1B[?25h";
+var CLEAR_SCREEN = "\x1B[2J";
+var RESET_ATTRS = "\x1B[0m";
+var resizeCallback = null;
+function onSigwinch() {
+  resizeCallback?.();
+}
+function getTerminalSize() {
+  return {
+    rows: process.stdout.rows || 24,
+    cols: process.stdout.columns || 80
+  };
+}
+function enterAltScreen() {
+  process.stdout.write(ALT_SCREEN_ON + CURSOR_HIDE + CLEAR_SCREEN);
+}
+function clearScreen() {
+  process.stdout.write(CLEAR_SCREEN);
+}
+function exitAltScreen() {
+  process.stdout.write(RESET_ATTRS + CURSOR_SHOW + ALT_SCREEN_OFF);
+}
+function onResize(callback) {
+  resizeCallback = callback;
+  process.on("SIGWINCH", onSigwinch);
+}
+function offResize() {
+  resizeCallback = null;
+  process.removeListener("SIGWINCH", onSigwinch);
+}
+function moveTo(row, col) {
+  return `\x1B[${row};${col}H`;
+}
+
+// src/tui/renderer.ts
+function createFrameBuffer(rows, cols) {
+  const cells = [];
+  for (let r = 0;r < rows; r++) {
+    const row = [];
+    for (let c = 0;c < cols; c++) {
+      row.push({ char: " ", fg: "", bold: false, dim: false });
+    }
+    cells.push(row);
+  }
+  return { cells, rows, cols };
+}
+function clearBuffer(buf) {
+  for (let r = 0;r < buf.rows; r++) {
+    const row = buf.cells[r];
+    for (let c = 0;c < buf.cols; c++) {
+      const cell = row[c];
+      cell.char = " ";
+      cell.fg = "";
+      cell.bold = false;
+      cell.dim = false;
+    }
+  }
+}
+function setCell(buf, row, col, char, fg, bold, dim) {
+  if (row >= 0 && row < buf.rows && col >= 0 && col < buf.cols) {
+    const cell = buf.cells[row][col];
+    cell.char = char;
+    cell.fg = fg;
+    cell.bold = bold;
+    cell.dim = dim;
+  }
+}
+function flushDiff(current, previous) {
+  let out = "";
+  let lastFg = "\x00";
+  let lastBold = false;
+  let lastDim = false;
+  for (let r = 0;r < current.rows; r++) {
+    const curRow = current.cells[r];
+    const prevRow = previous?.cells[r];
+    let runStart = -1;
+    for (let c = 0;c <= current.cols; c++) {
+      let changed = false;
+      if (c < current.cols) {
+        const cur = curRow[c];
+        if (prevRow) {
+          const prev = prevRow[c];
+          if (cur.char === " " && cur.fg === "" && prev.char === " " && prev.fg === "") {
+            if (runStart !== -1) {
+              out += flushRun(curRow, r, runStart, c, lastFg, lastBold, lastDim);
+              const last = curRow[c - 1];
+              lastFg = last.fg;
+              lastBold = last.bold;
+              lastDim = last.dim;
+              runStart = -1;
+            }
+            continue;
+          }
+          changed = cur.char !== prev.char || cur.fg !== prev.fg || cur.bold !== prev.bold || cur.dim !== prev.dim;
+        } else {
+          changed = cur.char !== " " || cur.fg !== "";
+        }
+      }
+      if (changed) {
+        if (runStart === -1)
+          runStart = c;
+      } else if (runStart !== -1) {
+        out += flushRun(curRow, r, runStart, c, lastFg, lastBold, lastDim);
+        const last = curRow[c - 1];
+        lastFg = last.fg;
+        lastBold = last.bold;
+        lastDim = last.dim;
+        runStart = -1;
+      }
+    }
+  }
+  if (out.length > 0) {
+    out += RESET;
+    process.stdout.write(out);
+  }
+}
+function flushRun(row, r, start, end, lastFg, lastBold, lastDim) {
+  let s = moveTo(r + 1, start + 1);
+  let fg = lastFg;
+  let bold = lastBold;
+  let dim = lastDim;
+  for (let i = start;i < end; i++) {
+    const cell = row[i];
+    if (cell.fg !== fg || cell.bold !== bold || cell.dim !== dim) {
+      s += RESET;
+      if (cell.fg)
+        s += cell.fg;
+      if (cell.bold)
+        s += BOLD;
+      if (cell.dim)
+        s += DIM;
+      fg = cell.fg;
+      bold = cell.bold;
+      dim = cell.dim;
+    }
+    s += cell.char;
+  }
+  return s;
+}
+
+// src/tui/panel.ts
+var glowPosition = 0;
+var GLOW_BRIGHT = fg256(46);
+var GLOW_MEDIUM = fg256(34);
+var GLOW_DIM = fg256(22);
+function computePanelGeometry(termRows, termCols) {
+  const maxW = Math.min(PANEL_MAX_WIDTH, termCols - PANEL_MARGIN_X * 2);
+  const maxH = Math.min(PANEL_MAX_HEIGHT, termRows - PANEL_MARGIN_Y * 2);
+  if (maxW < PANEL_MIN_WIDTH || maxH < PANEL_MIN_HEIGHT) {
+    return { x: 0, y: 0, width: 0, height: 0, logLines: 0, visible: false };
+  }
+  const width = maxW;
+  const height = maxH;
+  const x = Math.floor((termCols - width) / 2);
+  const y = Math.floor((termRows - height) / 2);
+  const logLines = height - PANEL_HEADER_HEIGHT - 1;
+  return {
+    x,
+    y,
+    width,
+    height,
+    logLines: Math.max(0, logLines),
+    visible: true
+  };
+}
+function borderColor(borderIdx, perimeterLen) {
+  const dist = Math.abs(borderIdx - glowPosition);
+  const wrappedDist = Math.min(dist, perimeterLen - dist);
+  if (wrappedDist < 3)
+    return GLOW_BRIGHT;
+  if (wrappedDist < 6)
+    return GLOW_MEDIUM;
+  return GLOW_DIM;
+}
+function writeString(buf, row, col, str, fg, bold, dim) {
+  for (let i = 0;i < str.length; i++) {
+    setCell(buf, row, col + i, str[i], fg, bold, dim);
+  }
+}
+function renderPanel(buf, panel, logs, agentCount, clientCount, version2, wsUrl) {
+  if (!panel.visible)
+    return;
+  const { x, y, width, height } = panel;
+  const innerWidth = width - 2;
+  const perimeter = 2 * (width + height) - 4;
+  glowPosition = (glowPosition + BORDER_GLOW_SPEED) % perimeter;
+  let borderIdx = 0;
+  setCell(buf, y, x, BOX.topLeft, borderColor(borderIdx++, perimeter), false, false);
+  for (let c = 1;c < width - 1; c++) {
+    setCell(buf, y, x + c, BOX.horizontal, borderColor(borderIdx++, perimeter), false, false);
+  }
+  setCell(buf, y, x + width - 1, BOX.topRight, borderColor(borderIdx++, perimeter), false, false);
+  for (let r = 1;r < height - 1; r++) {
+    setCell(buf, y + r, x + width - 1, BOX.vertical, borderColor(borderIdx++, perimeter), false, false);
+  }
+  setCell(buf, y + height - 1, x + width - 1, BOX.bottomRight, borderColor(borderIdx++, perimeter), false, false);
+  for (let c = width - 2;c > 0; c--) {
+    setCell(buf, y + height - 1, x + c, BOX.horizontal, borderColor(borderIdx++, perimeter), false, false);
+  }
+  setCell(buf, y + height - 1, x, BOX.bottomLeft, borderColor(borderIdx++, perimeter), false, false);
+  for (let r = height - 2;r > 0; r--) {
+    setCell(buf, y + r, x, BOX.vertical, borderColor(borderIdx++, perimeter), false, false);
+  }
+  for (let r = 1;r < height - 1; r++) {
+    for (let c = 1;c < width - 1; c++) {
+      setCell(buf, y + r, x + c, " ", "", false, false);
+    }
+  }
+  const logoStartRow = y + 1;
+  for (let i = 0;i < LOGO_LINES.length && i < height - 2; i++) {
+    const line = LOGO_LINES[i];
+    const maxChars = Math.min(line.length, innerWidth - 1);
+    for (let c = 0;c < maxChars; c++) {
+      setCell(buf, logoStartRow + i, x + 2 + c, line[c], BRIGHT_GREEN_FG, true, false);
+    }
+  }
+  if (LOGO_LINES.length >= 3) {
+    const infoStr = `${version2 ? `v${version2}` : ""} \xB7 ${wsUrl}`;
+    const maxInfoLen = innerWidth - (LOGO_LINES[2]?.length || 0) - 3;
+    if (maxInfoLen > 10) {
+      const trimmed = infoStr.slice(0, maxInfoLen);
+      const infoCol = x + width - 2 - trimmed.length;
+      writeString(buf, logoStartRow + 2, infoCol, trimmed, CYAN_FG, false, true);
+    }
+  }
+  if (LOGO_LINES.length >= 5) {
+    const countStr = `${agentCount} agent${agentCount !== 1 ? "s" : ""} \xB7 ${clientCount} client${clientCount !== 1 ? "s" : ""}`;
+    const statusStr = `\u2713 ${countStr}`;
+    const maxCountLen = innerWidth - (LOGO_LINES[4]?.length || 0) - 3;
+    if (maxCountLen > 10) {
+      const trimmed = statusStr.slice(0, maxCountLen);
+      const countCol = x + width - 2 - trimmed.length;
+      writeString(buf, logoStartRow + 4, countCol, trimmed, BRIGHT_GREEN_FG, false, false);
+    }
+  }
+  const sepRow = y + LOGO_LINES.length + 1;
+  if (sepRow < y + height - 1) {
+    const sepBorderIdx = Math.floor(glowPosition) % perimeter;
+    setCell(buf, sepRow, x, BOX.teeLeft, borderColor(sepBorderIdx, perimeter), false, false);
+    for (let c = 1;c < width - 1; c++) {
+      setCell(buf, sepRow, x + c, BOX.horizontal, borderColor((sepBorderIdx + c) % perimeter, perimeter), false, false);
+    }
+    setCell(buf, sepRow, x + width - 1, BOX.teeRight, borderColor((sepBorderIdx + width - 1) % perimeter, perimeter), false, false);
+  }
+  const logStartRow = sepRow + 1;
+  const visibleLogs = logs.slice(-panel.logLines);
+  for (let i = 0;i < visibleLogs.length; i++) {
+    const row = logStartRow + i;
+    if (row >= y + height - 1)
+      break;
+    const entry = visibleLogs[i];
+    writeString(buf, row, x + 2, entry.timestamp, CYAN_FG, false, true);
+    const msgCol = x + 2 + entry.timestamp.length + 1;
+    const maxMsgLen = innerWidth - entry.timestamp.length - 3;
+    const msg = entry.message.slice(0, Math.max(0, maxMsgLen));
+    writeString(buf, row, msgCol, msg, entry.color, false, false);
+  }
+}
+
+// src/tui/rain.ts
+var ACTIVE_LAYERS = ["mid", "front"];
+var MAX_DROPS_PER_COLUMN = 3;
+var RAIN_CHAR_COUNT = RAIN_CHARS.length;
+function randomChar() {
+  return RAIN_CHARS[Math.random() * RAIN_CHAR_COUNT | 0];
+}
+function createRainLayers(cols) {
+  return ACTIVE_LAYERS.map((name) => {
+    const columns = [];
+    for (let c = 0;c < cols; c++) {
+      columns.push({ drops: [] });
+    }
+    return { name, columns };
+  });
+}
+function resizeRainLayers(layers, cols) {
+  for (const layer of layers) {
+    while (layer.columns.length < cols) {
+      layer.columns.push({ drops: [] });
+    }
+    if (layer.columns.length > cols) {
+      layer.columns.length = cols;
+    }
+  }
+}
+function spawnDrop(layerName, rows) {
+  const cfg = LAYERS[layerName];
+  const trailLen = cfg.trailMin + (Math.random() * (cfg.trailMax - cfg.trailMin + 1) | 0);
+  const chars = [];
+  for (let i = 0;i < trailLen; i++) {
+    chars.push(randomChar());
+  }
+  return {
+    y: -(Math.random() * rows * 0.3 | 0),
+    speed: cfg.speedMin + Math.random() * (cfg.speedMax - cfg.speedMin),
+    trailLen,
+    chars,
+    frameCount: 0,
+    isLightning: false
+  };
+}
+function spawnLightning() {
+  const chars = [];
+  for (let i = 0;i < LIGHTNING_TRAIL_LEN; i++) {
+    chars.push(randomChar());
+  }
+  return {
+    y: -(Math.random() * 3 | 0),
+    speed: LIGHTNING_SPEED_MIN + Math.random() * (LIGHTNING_SPEED_MAX - LIGHTNING_SPEED_MIN),
+    trailLen: LIGHTNING_TRAIL_LEN,
+    chars,
+    frameCount: 0,
+    isLightning: true
+  };
+}
+function tickRain(layers, rows) {
+  for (const layer of layers) {
+    const cfg = LAYERS[layer.name];
+    const isFront = layer.name === "front";
+    for (let col = 0;col < layer.columns.length; col++) {
+      const column = layer.columns[col];
+      const drops = column.drops;
+      if (drops.length < MAX_DROPS_PER_COLUMN && Math.random() < cfg.spawnRate) {
+        drops.push(spawnDrop(layer.name, rows));
+      }
+      if (isFront && drops.length < MAX_DROPS_PER_COLUMN && Math.random() < LIGHTNING_CHANCE) {
+        drops.push(spawnLightning());
+      }
+      let write = 0;
+      for (let d = 0;d < drops.length; d++) {
+        const drop = drops[d];
+        drop.y += drop.speed;
+        drop.frameCount++;
+        if (drop.y - drop.trailLen > rows)
+          continue;
+        const mutInterval = drop.isLightning ? 3 : cfg.mutationInterval;
+        if (drop.frameCount % mutInterval === 0 && drop.chars.length > 1) {
+          const idx = 1 + (Math.random() * (drop.chars.length - 1) | 0);
+          drop.chars[idx] = randomChar();
+        }
+        drop.chars[0] = randomChar();
+        drops[write++] = drop;
+      }
+      drops.length = write;
+    }
+  }
+}
+var GRADIENT_STRINGS = [];
+for (let offset = 0;offset <= 4; offset++) {
+  const arr = [];
+  for (let g = 0;g < TRAIL_GRADIENT.length; g++) {
+    const idx = Math.min(TRAIL_GRADIENT.length - 1, Math.max(0, g + offset));
+    arr.push(fg256(TRAIL_GRADIENT[idx]));
+  }
+  GRADIENT_STRINGS.push(arr);
+}
+var LIGHTNING_HEAD = fg256(231);
+var LIGHTNING_NEAR = fg256(159);
+var LIGHTNING_TAIL = fg256(49);
+function renderRain(layers, buf, panel) {
+  const bufRows = buf.rows;
+  const bufCols = buf.cols;
+  const panelVisible = panel?.visible ?? false;
+  const panelX = panel?.x ?? 0;
+  const panelY = panel?.y ?? 0;
+  const panelX2 = panelX + (panel?.width ?? 0);
+  const panelY2 = panelY + (panel?.height ?? 0);
+  const gradLen = TRAIL_GRADIENT.length - 1;
+  for (const layer of layers) {
+    const brightnessOffset = LAYERS[layer.name].brightnessOffset;
+    const gradStrs = GRADIENT_STRINGS[brightnessOffset];
+    const colCount = Math.min(layer.columns.length, bufCols);
+    for (let col = 0;col < colCount; col++) {
+      if (panelVisible && col >= panelX && col < panelX2) {
+        const drops = layer.columns[col].drops;
+        for (let d = 0;d < drops.length; d++) {
+          const drop = drops[d];
+          const headRow = drop.y | 0;
+          const trailLen = drop.trailLen;
+          for (let i = 0;i < trailLen; i++) {
+            const row = headRow - i;
+            if (row < 0 || row >= bufRows)
+              continue;
+            if (row >= panelY && row < panelY2)
+              continue;
+            let color;
+            if (drop.isLightning) {
+              color = i === 0 ? LIGHTNING_HEAD : i === 1 ? LIGHTNING_NEAR : LIGHTNING_TAIL;
+            } else {
+              const gradIdx = trailLen > 1 ? i * gradLen / (trailLen - 1) | 0 : 0;
+              color = gradStrs[Math.min(gradIdx, gradLen)];
+            }
+            const bold = i === 0 || drop.isLightning;
+            const dim = !drop.isLightning && i > trailLen * 0.7;
+            setCell(buf, row, col, drop.chars[i], color, bold, dim);
+          }
+        }
+      } else {
+        const drops = layer.columns[col].drops;
+        for (let d = 0;d < drops.length; d++) {
+          const drop = drops[d];
+          const headRow = drop.y | 0;
+          const trailLen = drop.trailLen;
+          for (let i = 0;i < trailLen; i++) {
+            const row = headRow - i;
+            if (row < 0 || row >= bufRows)
+              continue;
+            let color;
+            if (drop.isLightning) {
+              color = i === 0 ? LIGHTNING_HEAD : i === 1 ? LIGHTNING_NEAR : LIGHTNING_TAIL;
+            } else {
+              const gradIdx = trailLen > 1 ? i * gradLen / (trailLen - 1) | 0 : 0;
+              color = gradStrs[Math.min(gradIdx, gradLen)];
+            }
+            const bold = i === 0 || drop.isLightning;
+            const dim = !drop.isLightning && i > trailLen * 0.7;
+            setCell(buf, row, col, drop.chars[i], color, bold, dim);
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/tui/index.ts
+var running = false;
+var renderTimer = null;
+var bufA = null;
+var bufB = null;
+var currentIsA = true;
+var hasPrevious = false;
+var rainLayers = [];
+var panel = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  logLines: 0,
+  visible: false
+};
+var tuiOptions = null;
+function handleResize() {
+  const { rows, cols } = getTerminalSize();
+  clearScreen();
+  bufA = createFrameBuffer(rows, cols);
+  bufB = createFrameBuffer(rows, cols);
+  currentIsA = true;
+  hasPrevious = false;
+  resizeRainLayers(rainLayers, cols);
+  panel = computePanelGeometry(rows, cols);
+}
+function scheduleFrame() {
+  if (!running)
+    return;
+  renderTimer = setTimeout(renderFrame, FRAME_INTERVAL_MS);
+}
+function renderFrame() {
+  if (!running || !bufA || !bufB || !tuiOptions)
+    return;
+  const current = currentIsA ? bufA : bufB;
+  const previous = currentIsA ? bufB : bufA;
+  tickRain(rainLayers, current.rows);
+  clearBuffer(current);
+  renderRain(rainLayers, current, panel);
+  const wsUrl = `ws://${tuiOptions.host}:${tuiOptions.port}`;
+  renderPanel(current, panel, getLogEntries(), tuiOptions.agentCount(), tuiOptions.clientCount(), tuiOptions.version, wsUrl);
+  flushDiff(current, hasPrevious ? previous : null);
+  currentIsA = !currentIsA;
+  hasPrevious = true;
+  scheduleFrame();
+}
+function startTui(options) {
+  if (running)
+    return;
+  running = true;
+  tuiOptions = options;
+  enterAltScreen();
+  const { rows, cols } = getTerminalSize();
+  bufA = createFrameBuffer(rows, cols);
+  bufB = createFrameBuffer(rows, cols);
+  currentIsA = true;
+  hasPrevious = false;
+  rainLayers = createRainLayers(cols);
+  panel = computePanelGeometry(rows, cols);
+  captureConsole();
+  onResize(handleResize);
+  scheduleFrame();
+  daemonLog("TUI started");
+}
+function stopTui() {
+  if (!running)
+    return;
+  running = false;
+  if (renderTimer) {
+    clearTimeout(renderTimer);
+    renderTimer = null;
+  }
+  offResize();
+  restoreConsole();
+  exitAltScreen();
+  bufA = null;
+  bufB = null;
+  hasPrevious = false;
+  tuiOptions = null;
+}
+
 // src/updater.ts
 var PACKAGE_NAME = "@bulletproof-sh/ctrl-daemon";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
@@ -4965,10 +5681,12 @@ function printUsage() {
   console.log(`Usage: ctrl-daemon [options]
 
 Options:
-  --port <number>      Port to listen on (default: 3001)
-  --host <address>     Host/address to bind to (default: 0.0.0.0)
-  --project-dir <path> Watch a single project directory
-  --help, -h           Show this help message
+  --port <number>         Port to listen on (default: 3001)
+  --host <address>        Host/address to bind to (default: 0.0.0.0)
+  --project-dir <path>    Watch a single project directory
+  --idle-timeout <minutes> Agent idle timeout in minutes (default: 15)
+  --no-tui                Disable Matrix rain TUI
+  --help, -h              Show this help message
 
 Without --project-dir, watches ALL projects in ~/.claude/projects/.
 With --project-dir, watches only that specific project.`);
@@ -4978,6 +5696,8 @@ function parseArgs() {
   let projectDir;
   let port = 3001;
   let host = "0.0.0.0";
+  let idleTimeoutMs = 15 * 60 * 1000;
+  let noTui = false;
   for (let i = 0;i < args.length; i++) {
     if (args[i] === "--help" || args[i] === "-h") {
       printUsage();
@@ -4988,9 +5708,13 @@ function parseArgs() {
       port = Number.parseInt(args[++i], 10);
     } else if (args[i] === "--host" && args[i + 1]) {
       host = args[++i];
+    } else if (args[i] === "--idle-timeout" && args[i + 1]) {
+      idleTimeoutMs = Number.parseInt(args[++i], 10) * 60 * 1000;
+    } else if (args[i] === "--no-tui") {
+      noTui = true;
     }
   }
-  return { projectDir, port, host };
+  return { projectDir, port, host, idleTimeoutMs, noTui };
 }
 function resolveProjectsRoot(claudeHome) {
   const home = claudeHome || path3.join(process.env.HOME || "~", ".claude");
@@ -5006,19 +5730,22 @@ async function main() {
   ]);
   stopSpinner();
   process.on("uncaughtException", async (err) => {
+    stopTui();
     console.error("[ctrl-daemon] Uncaught exception:", err);
     trackException(err, { ...systemInfo, crash_type: "uncaughtException" });
     await shutdownAnalytics();
     process.exit(1);
   });
   process.on("unhandledRejection", async (reason) => {
+    stopTui();
     const err = reason instanceof Error ? reason : new Error(String(reason));
     console.error("[ctrl-daemon] Unhandled rejection:", err);
     trackException(err, { ...systemInfo, crash_type: "unhandledRejection" });
     await shutdownAnalytics();
     process.exit(1);
   });
-  const { projectDir, port, host } = parseArgs();
+  const { projectDir, port, host, idleTimeoutMs, noTui } = parseArgs();
+  const useTui = !noTui && process.stdout.isTTY;
   const claudeHome = process.env.CLAUDE_HOME;
   let scanDirs;
   if (projectDir) {
@@ -5034,18 +5761,41 @@ async function main() {
   const waitingTimers = new Map;
   const permissionTimers = new Map;
   const server = createServer({ port, host, agents });
-  printReady(port, version2, updateMsg);
+  const boundPort = server.port;
+  printReady(boundPort, version2, updateMsg);
+  const rawBroadcast = server.broadcast;
+  const broadcast = (msg) => {
+    rawBroadcast(msg);
+    onBroadcast(msg);
+  };
+  if (useTui) {
+    startTui({
+      version: version2,
+      port: boundPort,
+      host,
+      agentCount: () => agents.size,
+      clientCount: () => server.clientCount()
+    });
+  }
   trackEvent("daemon_started", {
     version: version2 ?? "unknown",
-    port,
+    port: boundPort,
     host,
     mode: projectDir ? "single" : "all",
     ...systemInfo,
     ...analyticsConfig
   });
   const scanAll = !projectDir;
-  const scanner = startProjectScanner(scanDirs[0], scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, server.broadcast);
+  const scanner = startProjectScanner(scanDirs[0], scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast, idleTimeoutMs);
+  const updateCheckTimer = setInterval(async () => {
+    const msg = await checkForUpdate();
+    if (msg) {
+      daemonLog(`Update available! ${msg.replace(/\n\s*/g, " ")}`, "\x1B[33m");
+    }
+  }, UPDATE_CHECK_INTERVAL_MS);
   async function shutdown() {
+    stopTui();
+    clearInterval(updateCheckTimer);
     console.log(`
 [ctrl-daemon] Shutting down...`);
     scanner.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bulletproof-sh/ctrl-daemon",
-	"version": "0.0.7",
+	"version": "0.0.9",
 	"description": "WebSocket daemon for ctrl — watches Claude Code sessions and broadcasts agent state",
 	"type": "module",
 	"license": "BUSL-1.1",