@bulletproof-sh/ctrl-daemon 0.0.0

package/bin/ctrl-daemon.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const entry = join(__dirname, "..", "dist", "index.js");
+
+// Check for bun in PATH
+try {
+	execFileSync("bun", ["--version"], { stdio: "ignore" });
+} catch {
+	console.error(
+		"ctrl-daemon requires Bun to run.\n\nInstall Bun: https://bun.sh\n  curl -fsSL https://bun.sh/install | bash",
+	);
+	process.exit(1);
+}
+
+// Forward all CLI args to the daemon entry point
+const args = ["run", entry, ...process.argv.slice(2)];
+
+try {
+	execFileSync("bun", args, { stdio: "inherit" });
+} catch (err) {
+	// execFileSync throws on non-zero exit — just propagate the code
+	process.exit(err.status ?? 1);
+}

package/dist/index.js

@@ -0,0 +1,671 @@
+// @bun
+// src/index.ts
+import * as path3 from "path";
+
+// src/projectScanner.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// ../shared/src/transcript/constants.ts
+var FILE_WATCHER_POLL_INTERVAL_MS = 2000;
+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 BASH_COMMAND_DISPLAY_MAX_LENGTH = 30;
+var TASK_DESCRIPTION_DISPLAY_MAX_LENGTH = 40;
+
+// src/sessionWatcher.ts
+import * as fs from "fs";
+// ../shared/src/transcript/timerManager.ts
+function clearAgentActivity(agent, agentId, permissionTimers, broadcast) {
+  if (!agent)
+    return;
+  agent.activeToolIds.clear();
+  agent.activeToolStatuses.clear();
+  agent.activeToolNames.clear();
+  agent.activeSubagentToolIds.clear();
+  agent.activeSubagentToolNames.clear();
+  agent.isWaiting = false;
+  agent.permissionSent = false;
+  cancelPermissionTimer(agentId, permissionTimers);
+  broadcast({ type: "agentToolsClear", id: agentId });
+  broadcast({ type: "agentStatus", id: agentId, status: "active" });
+}
+function cancelWaitingTimer(agentId, waitingTimers) {
+  const timer = waitingTimers.get(agentId);
+  if (timer) {
+    clearTimeout(timer);
+    waitingTimers.delete(agentId);
+  }
+}
+function startWaitingTimer(agentId, delayMs, agents, waitingTimers, broadcast) {
+  cancelWaitingTimer(agentId, waitingTimers);
+  const timer = setTimeout(() => {
+    waitingTimers.delete(agentId);
+    const agent = agents.get(agentId);
+    if (agent) {
+      agent.isWaiting = true;
+    }
+    broadcast({
+      type: "agentStatus",
+      id: agentId,
+      status: "waiting"
+    });
+  }, delayMs);
+  waitingTimers.set(agentId, timer);
+}
+function cancelPermissionTimer(agentId, permissionTimers) {
+  const timer = permissionTimers.get(agentId);
+  if (timer) {
+    clearTimeout(timer);
+    permissionTimers.delete(agentId);
+  }
+}
+function startPermissionTimer(agentId, agents, permissionTimers, permissionExemptTools, broadcast) {
+  cancelPermissionTimer(agentId, permissionTimers);
+  const timer = setTimeout(() => {
+    permissionTimers.delete(agentId);
+    const agent = agents.get(agentId);
+    if (!agent)
+      return;
+    let hasNonExempt = false;
+    for (const toolId of agent.activeToolIds) {
+      const toolName = agent.activeToolNames.get(toolId);
+      if (!permissionExemptTools.has(toolName || "")) {
+        hasNonExempt = true;
+        break;
+      }
+    }
+    const stuckSubagentParentToolIds = [];
+    for (const [parentToolId, subToolNames] of agent.activeSubagentToolNames) {
+      for (const [, toolName] of subToolNames) {
+        if (!permissionExemptTools.has(toolName)) {
+          stuckSubagentParentToolIds.push(parentToolId);
+          hasNonExempt = true;
+          break;
+        }
+      }
+    }
+    if (hasNonExempt) {
+      agent.permissionSent = true;
+      console.log(`[ctrl] Agent ${agentId}: possible permission wait detected`);
+      broadcast({
+        type: "agentToolPermission",
+        id: agentId
+      });
+      for (const parentToolId of stuckSubagentParentToolIds) {
+        broadcast({
+          type: "subagentToolPermission",
+          id: agentId,
+          parentToolId
+        });
+      }
+    }
+  }, PERMISSION_TIMER_DELAY_MS);
+  permissionTimers.set(agentId, timer);
+}
+// ../shared/src/transcript/transcriptParser.ts
+import * as path from "path";
+var PERMISSION_EXEMPT_TOOLS = new Set(["Task", "AskUserQuestion"]);
+function formatToolStatus(toolName, input) {
+  const base = (p) => typeof p === "string" ? path.basename(p) : "";
+  switch (toolName) {
+    case "Read":
+      return `Reading ${base(input.file_path)}`;
+    case "Edit":
+      return `Editing ${base(input.file_path)}`;
+    case "Write":
+      return `Writing ${base(input.file_path)}`;
+    case "Bash": {
+      const cmd = input.command || "";
+      return `Running: ${cmd.length > BASH_COMMAND_DISPLAY_MAX_LENGTH ? cmd.slice(0, BASH_COMMAND_DISPLAY_MAX_LENGTH) + "\u2026" : cmd}`;
+    }
+    case "Glob":
+      return "Searching files";
+    case "Grep":
+      return "Searching code";
+    case "WebFetch":
+      return "Fetching web content";
+    case "WebSearch":
+      return "Searching the web";
+    case "Task": {
+      const desc = typeof input.description === "string" ? input.description : "";
+      return desc ? `Subtask: ${desc.length > TASK_DESCRIPTION_DISPLAY_MAX_LENGTH ? desc.slice(0, TASK_DESCRIPTION_DISPLAY_MAX_LENGTH) + "\u2026" : desc}` : "Running subtask";
+    }
+    case "AskUserQuestion":
+      return "Waiting for your answer";
+    case "EnterPlanMode":
+      return "Planning";
+    case "NotebookEdit":
+      return `Editing notebook`;
+    default:
+      return `Using ${toolName}`;
+  }
+}
+function processTranscriptLine(agentId, line, agents, waitingTimers, permissionTimers, broadcast) {
+  const agent = agents.get(agentId);
+  if (!agent)
+    return;
+  try {
+    const record = JSON.parse(line);
+    if (record.type === "assistant" && Array.isArray(record.message?.content)) {
+      const blocks = record.message.content;
+      const hasToolUse = blocks.some((b) => b.type === "tool_use");
+      if (hasToolUse) {
+        cancelWaitingTimer(agentId, waitingTimers);
+        agent.isWaiting = false;
+        agent.hadToolsInTurn = true;
+        broadcast({ type: "agentStatus", id: agentId, status: "active" });
+        let hasNonExemptTool = false;
+        for (const block of blocks) {
+          if (block.type === "tool_use" && block.id) {
+            const toolName = block.name || "";
+            const status = formatToolStatus(toolName, block.input || {});
+            console.log(`[ctrl] Agent ${agentId} tool start: ${block.id} ${status}`);
+            agent.activeToolIds.add(block.id);
+            agent.activeToolStatuses.set(block.id, status);
+            agent.activeToolNames.set(block.id, toolName);
+            if (!PERMISSION_EXEMPT_TOOLS.has(toolName)) {
+              hasNonExemptTool = true;
+            }
+            broadcast({
+              type: "agentToolStart",
+              id: agentId,
+              toolId: block.id,
+              status
+            });
+          }
+        }
+        if (hasNonExemptTool) {
+          startPermissionTimer(agentId, agents, permissionTimers, PERMISSION_EXEMPT_TOOLS, broadcast);
+        }
+      } else if (blocks.some((b) => b.type === "text") && !agent.hadToolsInTurn) {
+        startWaitingTimer(agentId, TEXT_IDLE_DELAY_MS, agents, waitingTimers, broadcast);
+      }
+    } else if (record.type === "progress") {
+      processProgressRecord(agentId, record, agents, waitingTimers, permissionTimers, broadcast);
+    } else if (record.type === "user") {
+      const content = record.message?.content;
+      if (Array.isArray(content)) {
+        const blocks = content;
+        const hasToolResult = blocks.some((b) => b.type === "tool_result");
+        if (hasToolResult) {
+          for (const block of blocks) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              console.log(`[ctrl] Agent ${agentId} tool done: ${block.tool_use_id}`);
+              const completedToolId = block.tool_use_id;
+              if (agent.activeToolNames.get(completedToolId) === "Task") {
+                agent.activeSubagentToolIds.delete(completedToolId);
+                agent.activeSubagentToolNames.delete(completedToolId);
+                broadcast({
+                  type: "subagentClear",
+                  id: agentId,
+                  parentToolId: completedToolId
+                });
+              }
+              agent.activeToolIds.delete(completedToolId);
+              agent.activeToolStatuses.delete(completedToolId);
+              agent.activeToolNames.delete(completedToolId);
+              const toolId = completedToolId;
+              setTimeout(() => {
+                broadcast({
+                  type: "agentToolDone",
+                  id: agentId,
+                  toolId
+                });
+              }, TOOL_DONE_DELAY_MS);
+            }
+          }
+          if (agent.activeToolIds.size === 0) {
+            agent.hadToolsInTurn = false;
+          }
+        } else {
+          cancelWaitingTimer(agentId, waitingTimers);
+          clearAgentActivity(agent, agentId, permissionTimers, broadcast);
+          agent.hadToolsInTurn = false;
+        }
+      } else if (typeof content === "string" && content.trim()) {
+        cancelWaitingTimer(agentId, waitingTimers);
+        clearAgentActivity(agent, agentId, permissionTimers, broadcast);
+        agent.hadToolsInTurn = false;
+      }
+    } else if (record.type === "system" && record.subtype === "turn_duration") {
+      cancelWaitingTimer(agentId, waitingTimers);
+      cancelPermissionTimer(agentId, permissionTimers);
+      if (agent.activeToolIds.size > 0) {
+        agent.activeToolIds.clear();
+        agent.activeToolStatuses.clear();
+        agent.activeToolNames.clear();
+        agent.activeSubagentToolIds.clear();
+        agent.activeSubagentToolNames.clear();
+        broadcast({ type: "agentToolsClear", id: agentId });
+      }
+      agent.isWaiting = true;
+      agent.permissionSent = false;
+      agent.hadToolsInTurn = false;
+      broadcast({
+        type: "agentStatus",
+        id: agentId,
+        status: "waiting"
+      });
+    }
+  } catch {}
+}
+function processProgressRecord(agentId, record, agents, waitingTimers, permissionTimers, broadcast) {
+  const agent = agents.get(agentId);
+  if (!agent)
+    return;
+  const parentToolId = record.parentToolUseID;
+  if (!parentToolId)
+    return;
+  const data = record.data;
+  if (!data)
+    return;
+  const dataType = data.type;
+  if (dataType === "bash_progress" || dataType === "mcp_progress") {
+    if (agent.activeToolIds.has(parentToolId)) {
+      startPermissionTimer(agentId, agents, permissionTimers, PERMISSION_EXEMPT_TOOLS, broadcast);
+    }
+    return;
+  }
+  if (agent.activeToolNames.get(parentToolId) !== "Task")
+    return;
+  const msg = data.message;
+  if (!msg)
+    return;
+  const msgType = msg.type;
+  const innerMsg = msg.message;
+  const content = innerMsg?.content;
+  if (!Array.isArray(content))
+    return;
+  if (msgType === "assistant") {
+    let hasNonExemptSubTool = false;
+    for (const block of content) {
+      if (block.type === "tool_use" && block.id) {
+        const toolName = block.name || "";
+        const status = formatToolStatus(toolName, block.input || {});
+        console.log(`[ctrl] Agent ${agentId} subagent tool start: ${block.id} ${status} (parent: ${parentToolId})`);
+        let subTools = agent.activeSubagentToolIds.get(parentToolId);
+        if (!subTools) {
+          subTools = new Set;
+          agent.activeSubagentToolIds.set(parentToolId, subTools);
+        }
+        subTools.add(block.id);
+        let subNames = agent.activeSubagentToolNames.get(parentToolId);
+        if (!subNames) {
+          subNames = new Map;
+          agent.activeSubagentToolNames.set(parentToolId, subNames);
+        }
+        subNames.set(block.id, toolName);
+        if (!PERMISSION_EXEMPT_TOOLS.has(toolName)) {
+          hasNonExemptSubTool = true;
+        }
+        broadcast({
+          type: "subagentToolStart",
+          id: agentId,
+          parentToolId,
+          toolId: block.id,
+          status
+        });
+      }
+    }
+    if (hasNonExemptSubTool) {
+      startPermissionTimer(agentId, agents, permissionTimers, PERMISSION_EXEMPT_TOOLS, broadcast);
+    }
+  } else if (msgType === "user") {
+    for (const block of content) {
+      if (block.type === "tool_result" && block.tool_use_id) {
+        console.log(`[ctrl] Agent ${agentId} subagent tool done: ${block.tool_use_id} (parent: ${parentToolId})`);
+        const subTools = agent.activeSubagentToolIds.get(parentToolId);
+        if (subTools) {
+          subTools.delete(block.tool_use_id);
+        }
+        const subNames = agent.activeSubagentToolNames.get(parentToolId);
+        if (subNames) {
+          subNames.delete(block.tool_use_id);
+        }
+        const toolId = block.tool_use_id;
+        setTimeout(() => {
+          broadcast({
+            type: "subagentToolDone",
+            id: agentId,
+            parentToolId,
+            toolId
+          });
+        }, 300);
+      }
+    }
+    let stillHasNonExempt = false;
+    for (const [, subNames] of agent.activeSubagentToolNames) {
+      for (const [, toolName] of subNames) {
+        if (!PERMISSION_EXEMPT_TOOLS.has(toolName)) {
+          stillHasNonExempt = true;
+          break;
+        }
+      }
+      if (stillHasNonExempt)
+        break;
+    }
+    if (stillHasNonExempt) {
+      startPermissionTimer(agentId, agents, permissionTimers, PERMISSION_EXEMPT_TOOLS, broadcast);
+    }
+  }
+}
+// src/sessionWatcher.ts
+function startSessionWatcher(agentId, filePath, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast) {
+  try {
+    const watcher = fs.watch(filePath, () => {
+      readNewLines(agentId, agents, waitingTimers, permissionTimers, broadcast);
+    });
+    fileWatchers.set(agentId, watcher);
+  } catch (e) {
+    console.log(`[ctrl-daemon] fs.watch failed for agent ${agentId}: ${e}`);
+  }
+  const interval = setInterval(() => {
+    if (!agents.has(agentId)) {
+      clearInterval(interval);
+      return;
+    }
+    readNewLines(agentId, agents, waitingTimers, permissionTimers, broadcast);
+  }, FILE_WATCHER_POLL_INTERVAL_MS);
+  pollingTimers.set(agentId, interval);
+}
+function readNewLines(agentId, agents, waitingTimers, permissionTimers, broadcast) {
+  const agent = agents.get(agentId);
+  if (!agent)
+    return;
+  try {
+    const stat = fs.statSync(agent.jsonlFile);
+    if (stat.size <= agent.fileOffset)
+      return;
+    const buf = Buffer.alloc(stat.size - agent.fileOffset);
+    const fd = fs.openSync(agent.jsonlFile, "r");
+    fs.readSync(fd, buf, 0, buf.length, agent.fileOffset);
+    fs.closeSync(fd);
+    agent.fileOffset = stat.size;
+    const text = agent.lineBuffer + buf.toString("utf-8");
+    const lines = text.split(`
+`);
+    agent.lineBuffer = lines.pop() || "";
+    const hasLines = lines.some((l) => l.trim());
+    if (hasLines) {
+      agent.lastActivityAt = Date.now();
+      cancelWaitingTimer(agentId, waitingTimers);
+      cancelPermissionTimer(agentId, permissionTimers);
+      if (agent.permissionSent) {
+        agent.permissionSent = false;
+        broadcast({ type: "agentToolPermissionClear", id: agentId });
+      }
+    }
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      processTranscriptLine(agentId, line, agents, waitingTimers, permissionTimers, broadcast);
+    }
+  } catch (e) {
+    console.log(`[ctrl-daemon] Read error for agent ${agentId}: ${e}`);
+  }
+}
+function stopSessionWatcher(agentId, fileWatchers, pollingTimers, waitingTimers, permissionTimers) {
+  fileWatchers.get(agentId)?.close();
+  fileWatchers.delete(agentId);
+  const pt = pollingTimers.get(agentId);
+  if (pt)
+    clearInterval(pt);
+  pollingTimers.delete(agentId);
+  cancelWaitingTimer(agentId, waitingTimers);
+  cancelPermissionTimer(agentId, permissionTimers);
+}
+
+// src/projectScanner.ts
+function resolveProjectHash(projectDir) {
+  return projectDir.replace(/[:\\/.]/g, "-");
+}
+function resolveProjectDir(projectDir, claudeHome) {
+  const home = claudeHome || path2.join(process.env.HOME || "~", ".claude");
+  const projectsDir = path2.join(home, "projects");
+  const exactHash = resolveProjectHash(projectDir);
+  const exactPath = path2.join(projectsDir, exactHash);
+  if (fs2.existsSync(exactPath))
+    return exactPath;
+  const macHash = projectDir.replace(/[:\\/._ ]/g, "-");
+  const macPath = path2.join(projectsDir, macHash);
+  if (fs2.existsSync(macPath))
+    return macPath;
+  return exactPath;
+}
+function collectJsonlFiles(dir) {
+  try {
+    const results = [];
+    for (const f of fs2.readdirSync(dir)) {
+      if (!f.endsWith(".jsonl"))
+        continue;
+      const filePath = path2.join(dir, f);
+      try {
+        const stat = fs2.statSync(filePath);
+        results.push({ filePath, mtimeMs: stat.mtimeMs });
+      } catch {}
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function collectAllJsonlFiles(projectsRoot) {
+  const files = [];
+  let subdirs;
+  try {
+    subdirs = fs2.readdirSync(projectsRoot);
+  } catch {
+    return [];
+  }
+  for (const subdir of subdirs) {
+    const fullPath = path2.join(projectsRoot, subdir);
+    try {
+      const stat = fs2.statSync(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...collectJsonlFiles(fullPath));
+      }
+    } catch {}
+  }
+  return files;
+}
+function startProjectScanner(rootDir, scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, broadcast) {
+  const knownJsonlFiles = new Set;
+  let nextAgentId = 1;
+  function scan() {
+    const now = Date.now();
+    const fileInfos = scanAll ? collectAllJsonlFiles(rootDir) : collectJsonlFiles(rootDir);
+    for (const { filePath, mtimeMs } of fileInfos) {
+      if (knownJsonlFiles.has(filePath))
+        continue;
+      knownJsonlFiles.add(filePath);
+      if (now - mtimeMs > AGENT_IDLE_TIMEOUT_MS)
+        continue;
+      const id = nextAgentId++;
+      const agentProjectDir = path2.dirname(filePath);
+      const agent = {
+        id,
+        projectDir: agentProjectDir,
+        jsonlFile: filePath,
+        fileOffset: 0,
+        lineBuffer: "",
+        activeToolIds: new Set,
+        activeToolStatuses: new Map,
+        activeToolNames: new Map,
+        activeSubagentToolIds: new Map,
+        activeSubagentToolNames: new Map,
+        isWaiting: false,
+        permissionSent: false,
+        hadToolsInTurn: false,
+        lastActivityAt: mtimeMs
+      };
+      agents.set(id, agent);
+      console.log(`[ctrl-daemon] 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 removed = !fs2.existsSync(agent.jsonlFile);
+      if (removed || idle) {
+        const reason = removed ? "JSONL removed" : "idle timeout";
+        console.log(`[ctrl-daemon] Agent ${agentId}: ${reason}, closing`);
+        stopSessionWatcher(agentId, fileWatchers, pollingTimers, waitingTimers, permissionTimers);
+        agents.delete(agentId);
+        knownJsonlFiles.delete(agent.jsonlFile);
+        broadcast({ type: "agentClosed", id: agentId });
+      }
+    }
+  }
+  const timer = setInterval(scan, PROJECT_SCAN_INTERVAL_MS);
+  scan();
+  return {
+    stop: () => clearInterval(timer)
+  };
+}
+
+// src/server.ts
+function createServer({ port, host, agents }) {
+  const clients = new Set;
+  function broadcast(msg) {
+    const json = JSON.stringify(msg);
+    for (const ws of clients) {
+      try {
+        ws.send(json);
+      } 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
+          });
+        }
+        ws.send(JSON.stringify({ type: "existingAgents", agents: existingAgents }));
+      },
+      message(_ws, _message) {},
+      close(ws) {
+        clients.delete(ws);
+        console.log(`[ctrl-daemon] WebSocket client disconnected (${clients.size} total)`);
+      }
+    }
+  });
+  console.log(`[ctrl-daemon] Listening on ws://${server.hostname}:${server.port}/ws`);
+  return {
+    broadcast,
+    stop: () => server.stop()
+  };
+}
+
+// src/index.ts
+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
+
+Without --project-dir, watches ALL projects in ~/.claude/projects/.
+With --project-dir, watches only that specific project.`);
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let projectDir;
+  let port = 3001;
+  let host = "0.0.0.0";
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--help" || args[i] === "-h") {
+      printUsage();
+      process.exit(0);
+    } else if (args[i] === "--project-dir" && args[i + 1]) {
+      projectDir = args[++i];
+    } else if (args[i] === "--port" && args[i + 1]) {
+      port = Number.parseInt(args[++i], 10);
+    } else if (args[i] === "--host" && args[i + 1]) {
+      host = args[++i];
+    }
+  }
+  return { projectDir, port, host };
+}
+function resolveProjectsRoot(claudeHome) {
+  const home = claudeHome || path3.join(process.env.HOME || "~", ".claude");
+  return path3.join(home, "projects");
+}
+function main() {
+  const { projectDir, port, host } = parseArgs();
+  const claudeHome = process.env.CLAUDE_HOME;
+  let scanDirs;
+  if (projectDir) {
+    const dir = resolveProjectDir(projectDir, claudeHome);
+    scanDirs = [dir];
+    console.log(`[ctrl-daemon] Project dir: ${projectDir}`);
+    console.log(`[ctrl-daemon] Session dir: ${dir}`);
+  } else {
+    const projectsRoot = resolveProjectsRoot(claudeHome);
+    console.log(`[ctrl-daemon] Watching all projects in: ${projectsRoot}`);
+    scanDirs = [projectsRoot];
+  }
+  const agents = new Map;
+  const fileWatchers = new Map;
+  const pollingTimers = new Map;
+  const waitingTimers = new Map;
+  const permissionTimers = new Map;
+  const server = createServer({ port, host, agents });
+  const scanAll = !projectDir;
+  const scanner = startProjectScanner(scanDirs[0], scanAll, agents, fileWatchers, pollingTimers, waitingTimers, permissionTimers, server.broadcast);
+  process.on("SIGINT", () => {
+    console.log(`
+[ctrl-daemon] Shutting down...`);
+    scanner.stop();
+    server.stop();
+    for (const watcher of fileWatchers.values())
+      watcher.close();
+    for (const timer of pollingTimers.values())
+      clearInterval(timer);
+    for (const timer of waitingTimers.values())
+      clearTimeout(timer);
+    for (const timer of permissionTimers.values())
+      clearTimeout(timer);
+    process.exit(0);
+  });
+}
+main();

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@bulletproof-sh/ctrl-daemon",
+	"version": "0.0.0",
+	"description": "WebSocket daemon for ctrl — watches Claude Code sessions and broadcasts agent state",
+	"type": "module",
+	"license": "MIT",
+	"bin": {
+		"ctrl-daemon": "bin/ctrl-daemon.js"
+	},
+	"files": [
+		"bin/",
+		"dist/"
+	],
+	"scripts": {
+		"dev": "bun --watch src/index.ts",
+		"start": "bun src/index.ts",
+		"build": "bun build src/index.ts --outdir dist --target bun",
+		"check": "biome check .",
+		"prepublishOnly": "bun run build"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@types/bun": "latest",
+		"typescript": "~5.9.3"
+	}
+}