claude-code-controller 0.1.0 → 0.2.0

package/dist/api/index.cjs

@@ -0,0 +1,1588 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  ActionTracker: () => ActionTracker,
+  createApi: () => createApi
+});
+module.exports = __toCommonJS(api_exports);
+var import_hono2 = require("hono");
+var import_cors = require("hono/cors");
+
+// src/api/action-tracker.ts
+var ActionTracker = class {
+  approvals = /* @__PURE__ */ new Map();
+  idles = /* @__PURE__ */ new Map();
+  agentTypes = /* @__PURE__ */ new Map();
+  listeners = [];
+  currentController = null;
+  attach(controller) {
+    this.detach();
+    this.currentController = controller;
+    const onPlan = (agent, parsed) => {
+      this.approvals.set(parsed.requestId, {
+        type: "plan",
+        agent,
+        requestId: parsed.requestId,
+        timestamp: parsed.timestamp,
+        planContent: parsed.planContent,
+        action: `POST /agents/${agent}/approve-plan`
+      });
+    };
+    const onPermission = (agent, parsed) => {
+      this.approvals.set(parsed.requestId, {
+        type: "permission",
+        agent,
+        requestId: parsed.requestId,
+        timestamp: parsed.timestamp,
+        toolName: parsed.toolName,
+        description: parsed.description,
+        action: `POST /agents/${agent}/approve-permission`
+      });
+    };
+    const onIdle = (agent) => {
+      this.idles.set(agent, {
+        name: agent,
+        type: this.agentTypes.get(agent) ?? "unknown",
+        idleSince: (/* @__PURE__ */ new Date()).toISOString(),
+        action: `POST /agents/${agent}/messages`
+      });
+    };
+    const onMessage = (agent) => {
+      this.idles.delete(agent);
+    };
+    const onSpawned = (agent) => {
+      this.idles.delete(agent);
+    };
+    const onExited = (agent) => {
+      this.idles.delete(agent);
+      for (const [id, approval] of this.approvals) {
+        if (approval.agent === agent) {
+          this.approvals.delete(id);
+        }
+      }
+    };
+    controller.on("plan:approval_request", onPlan);
+    controller.on("permission:request", onPermission);
+    controller.on("idle", onIdle);
+    controller.on("message", onMessage);
+    controller.on("agent:spawned", onSpawned);
+    controller.on("agent:exited", onExited);
+    this.listeners = [
+      { event: "plan:approval_request", fn: onPlan },
+      { event: "permission:request", fn: onPermission },
+      { event: "idle", fn: onIdle },
+      { event: "message", fn: onMessage },
+      { event: "agent:spawned", fn: onSpawned },
+      { event: "agent:exited", fn: onExited }
+    ];
+  }
+  /** Remove all event listeners from the current controller. */
+  detach() {
+    if (this.currentController) {
+      for (const { event, fn } of this.listeners) {
+        this.currentController.removeListener(event, fn);
+      }
+    }
+    this.listeners = [];
+    this.currentController = null;
+  }
+  /** Track agent type so idle entries have the right type. */
+  registerAgentType(name, type) {
+    this.agentTypes.set(name, type);
+  }
+  resolveApproval(requestId) {
+    this.approvals.delete(requestId);
+  }
+  getPendingApprovals() {
+    return Array.from(this.approvals.values());
+  }
+  getIdleAgents() {
+    return Array.from(this.idles.values());
+  }
+  /** Clear all tracked state AND detach from the controller. */
+  clear() {
+    this.detach();
+    this.approvals.clear();
+    this.idles.clear();
+    this.agentTypes.clear();
+  }
+};
+
+// src/api/routes.ts
+var import_hono = require("hono");
+
+// src/controller.ts
+var import_node_events = require("events");
+var import_node_child_process3 = require("child_process");
+var import_node_crypto2 = require("crypto");
+
+// src/team-manager.ts
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_crypto = require("crypto");
+
+// src/paths.ts
+var import_node_os = require("os");
+var import_node_path = require("path");
+var CLAUDE_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".claude");
+function teamsDir() {
+  return (0, import_node_path.join)(CLAUDE_DIR, "teams");
+}
+function teamDir(teamName) {
+  return (0, import_node_path.join)(teamsDir(), teamName);
+}
+function teamConfigPath(teamName) {
+  return (0, import_node_path.join)(teamDir(teamName), "config.json");
+}
+function inboxesDir(teamName) {
+  return (0, import_node_path.join)(teamDir(teamName), "inboxes");
+}
+function inboxPath(teamName, agentName) {
+  return (0, import_node_path.join)(inboxesDir(teamName), `${agentName}.json`);
+}
+function tasksBaseDir() {
+  return (0, import_node_path.join)(CLAUDE_DIR, "tasks");
+}
+function tasksDir(teamName) {
+  return (0, import_node_path.join)(tasksBaseDir(), teamName);
+}
+function taskPath(teamName, taskId) {
+  return (0, import_node_path.join)(tasksDir(teamName), `${taskId}.json`);
+}
+
+// src/team-manager.ts
+var TeamManager = class {
+  teamName;
+  sessionId;
+  log;
+  constructor(teamName, logger) {
+    this.teamName = teamName;
+    this.sessionId = (0, import_node_crypto.randomUUID)();
+    this.log = logger;
+  }
+  /**
+   * Create the team directory structure and config.json.
+   * The controller registers itself as the lead member.
+   */
+  async create(opts) {
+    const dir = teamDir(this.teamName);
+    const inboxDir = inboxesDir(this.teamName);
+    const taskDir = tasksDir(this.teamName);
+    await (0, import_promises.mkdir)(dir, { recursive: true });
+    await (0, import_promises.mkdir)(inboxDir, { recursive: true });
+    await (0, import_promises.mkdir)(taskDir, { recursive: true });
+    const leadName = "controller";
+    const leadAgentId = `${leadName}@${this.teamName}`;
+    const config = {
+      name: this.teamName,
+      description: opts?.description,
+      createdAt: Date.now(),
+      leadAgentId,
+      leadSessionId: this.sessionId,
+      members: [
+        {
+          agentId: leadAgentId,
+          name: leadName,
+          agentType: "controller",
+          joinedAt: Date.now(),
+          tmuxPaneId: "",
+          cwd: opts?.cwd || process.cwd(),
+          subscriptions: []
+        }
+      ]
+    };
+    await this.writeConfig(config);
+    this.log.info(`Team "${this.teamName}" created`);
+    return config;
+  }
+  /**
+   * Add a member to the team config.
+   */
+  async addMember(member) {
+    const config = await this.getConfig();
+    config.members = config.members.filter((m) => m.name !== member.name);
+    config.members.push(member);
+    await this.writeConfig(config);
+    this.log.debug(`Added member "${member.name}" to team`);
+  }
+  /**
+   * Remove a member from the team config.
+   */
+  async removeMember(name) {
+    const config = await this.getConfig();
+    config.members = config.members.filter((m) => m.name !== name);
+    await this.writeConfig(config);
+    this.log.debug(`Removed member "${name}" from team`);
+  }
+  /**
+   * Read the current team config.
+   */
+  async getConfig() {
+    const path = teamConfigPath(this.teamName);
+    if (!(0, import_node_fs.existsSync)(path)) {
+      throw new Error(
+        `Team "${this.teamName}" does not exist (no config.json)`
+      );
+    }
+    const raw = await (0, import_promises.readFile)(path, "utf-8");
+    return JSON.parse(raw);
+  }
+  /**
+   * Check if the team already exists on disk.
+   */
+  exists() {
+    return (0, import_node_fs.existsSync)(teamConfigPath(this.teamName));
+  }
+  /**
+   * Destroy the team: remove all team directories and task directories.
+   */
+  async destroy() {
+    const dir = teamDir(this.teamName);
+    const taskDir = tasksDir(this.teamName);
+    if ((0, import_node_fs.existsSync)(dir)) {
+      await (0, import_promises.rm)(dir, { recursive: true, force: true });
+    }
+    if ((0, import_node_fs.existsSync)(taskDir)) {
+      await (0, import_promises.rm)(taskDir, { recursive: true, force: true });
+    }
+    this.log.info(`Team "${this.teamName}" destroyed`);
+  }
+  async writeConfig(config) {
+    const path = teamConfigPath(this.teamName);
+    await (0, import_promises.writeFile)(path, JSON.stringify(config, null, 2), "utf-8");
+  }
+};
+
+// src/task-manager.ts
+var import_promises2 = require("fs/promises");
+var import_node_fs2 = require("fs");
+var TaskManager = class {
+  constructor(teamName, log) {
+    this.teamName = teamName;
+    this.log = log;
+  }
+  nextId = 1;
+  /**
+   * Initialize the task directory. Call after team creation.
+   * Also scans for existing tasks to set the next ID correctly.
+   */
+  async init() {
+    const dir = tasksDir(this.teamName);
+    await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const existing = await this.list();
+    if (existing.length > 0) {
+      const maxId = Math.max(...existing.map((t) => parseInt(t.id, 10)));
+      this.nextId = maxId + 1;
+    }
+  }
+  /**
+   * Create a new task. Returns the assigned task ID.
+   */
+  async create(task) {
+    const id = String(this.nextId++);
+    const full = {
+      id,
+      subject: task.subject,
+      description: task.description,
+      activeForm: task.activeForm,
+      owner: task.owner,
+      status: task.status || "pending",
+      blocks: task.blocks || [],
+      blockedBy: task.blockedBy || [],
+      metadata: task.metadata
+    };
+    await this.writeTask(full);
+    this.log.debug(`Created task #${id}: ${task.subject}`);
+    return id;
+  }
+  /**
+   * Get a task by ID.
+   */
+  async get(taskId) {
+    const path = taskPath(this.teamName, taskId);
+    if (!(0, import_node_fs2.existsSync)(path)) {
+      throw new Error(`Task #${taskId} not found`);
+    }
+    const raw = await (0, import_promises2.readFile)(path, "utf-8");
+    return JSON.parse(raw);
+  }
+  /**
+   * Update a task. Merges the provided fields.
+   */
+  async update(taskId, updates) {
+    const task = await this.get(taskId);
+    Object.assign(task, updates);
+    await this.writeTask(task);
+    this.log.debug(`Updated task #${taskId}: status=${task.status}`);
+    return task;
+  }
+  /**
+   * Add blocking relationships.
+   */
+  async addBlocks(taskId, blockedTaskIds) {
+    const task = await this.get(taskId);
+    const toAdd = blockedTaskIds.filter((id) => !task.blocks.includes(id));
+    task.blocks.push(...toAdd);
+    await this.writeTask(task);
+    for (const blockedId of toAdd) {
+      const blocked = await this.get(blockedId);
+      if (!blocked.blockedBy.includes(taskId)) {
+        blocked.blockedBy.push(taskId);
+        await this.writeTask(blocked);
+      }
+    }
+  }
+  /**
+   * List all tasks.
+   */
+  async list() {
+    const dir = tasksDir(this.teamName);
+    if (!(0, import_node_fs2.existsSync)(dir)) return [];
+    const files = await (0, import_promises2.readdir)(dir);
+    const tasks = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const raw = await (0, import_promises2.readFile)(taskPath(this.teamName, file.replace(".json", "")), "utf-8");
+      tasks.push(JSON.parse(raw));
+    }
+    return tasks.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+  }
+  /**
+   * Delete a task file.
+   */
+  async delete(taskId) {
+    const path = taskPath(this.teamName, taskId);
+    if ((0, import_node_fs2.existsSync)(path)) {
+      await (0, import_promises2.rm)(path);
+      this.log.debug(`Deleted task #${taskId}`);
+    }
+  }
+  /**
+   * Wait for a task to reach a target status.
+   */
+  async waitFor(taskId, targetStatus = "completed", opts) {
+    const timeout = opts?.timeout ?? 3e5;
+    const interval = opts?.pollInterval ?? 1e3;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const task = await this.get(taskId);
+      if (task.status === targetStatus) return task;
+      await sleep(interval);
+    }
+    throw new Error(
+      `Timeout waiting for task #${taskId} to reach "${targetStatus}"`
+    );
+  }
+  async writeTask(task) {
+    const path = taskPath(this.teamName, task.id);
+    await (0, import_promises2.writeFile)(path, JSON.stringify(task, null, 4), "utf-8");
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/process-manager.ts
+var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
+var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  log;
+  constructor(logger) {
+    this.log = logger;
+  }
+  /**
+   * Spawn a new claude CLI process in teammate mode.
+   * Uses a Python PTY wrapper to provide the terminal the TUI needs.
+   */
+  spawn(opts) {
+    let binary = opts.claudeBinary || "claude";
+    if (!binary.startsWith("/")) {
+      try {
+        binary = (0, import_node_child_process2.execSync)(`which ${binary}`, { encoding: "utf-8" }).trim();
+      } catch {
+      }
+    }
+    const claudeArgs = [
+      "--teammate-mode",
+      opts.teammateMode || "auto",
+      "--agent-id",
+      opts.agentId,
+      "--agent-name",
+      opts.agentName,
+      "--team-name",
+      opts.teamName
+    ];
+    if (opts.agentType) {
+      claudeArgs.push("--agent-type", opts.agentType);
+    }
+    if (opts.color) {
+      claudeArgs.push("--agent-color", opts.color);
+    }
+    if (opts.parentSessionId) {
+      claudeArgs.push("--parent-session-id", opts.parentSessionId);
+    }
+    if (opts.model) {
+      claudeArgs.push("--model", opts.model);
+    }
+    if (opts.permissions) {
+      for (const perm of opts.permissions) {
+        claudeArgs.push("--allowedTools", perm);
+      }
+    }
+    this.log.info(
+      `Spawning agent "${opts.agentName}": ${binary} ${claudeArgs.join(" ")}`
+    );
+    const cmdJson = JSON.stringify([binary, ...claudeArgs]);
+    const pythonScript = `
+import pty, os, sys, json, signal, select
+
+cmd = json.loads(sys.argv[1])
+pid, fd = pty.fork()
+if pid == 0:
+    os.execvp(cmd[0], cmd)
+else:
+    signal.signal(signal.SIGTERM, lambda *a: (os.kill(pid, signal.SIGTERM), sys.exit(0)))
+    signal.signal(signal.SIGINT, lambda *a: (os.kill(pid, signal.SIGTERM), sys.exit(0)))
+    try:
+        while True:
+            r, _, _ = select.select([fd, 0], [], [], 1.0)
+            if fd in r:
+                try:
+                    data = os.read(fd, 4096)
+                    if not data:
+                        break
+                    os.write(1, data)
+                except OSError:
+                    break
+            if 0 in r:
+                try:
+                    data = os.read(0, 4096)
+                    if not data:
+                        break
+                    os.write(fd, data)
+                except OSError:
+                    break
+    except:
+        pass
+    finally:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except:
+            pass
+        _, status = os.waitpid(pid, 0)
+        sys.exit(os.WEXITSTATUS(status) if os.WIFEXITED(status) else 1)
+`;
+    const proc = (0, import_node_child_process.spawn)("python3", ["-c", pythonScript, cmdJson], {
+      cwd: opts.cwd || process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
+        ...opts.env
+      }
+    });
+    this.processes.set(opts.agentName, proc);
+    proc.on("exit", (code, signal) => {
+      this.log.info(
+        `Agent "${opts.agentName}" exited (code=${code}, signal=${signal})`
+      );
+      this.processes.delete(opts.agentName);
+    });
+    proc.on("error", (err) => {
+      this.log.error(`Agent "${opts.agentName}" process error: ${err.message}`);
+      this.processes.delete(opts.agentName);
+    });
+    return proc;
+  }
+  /**
+   * Register a callback for when an agent process exits.
+   */
+  onExit(name, callback) {
+    const proc = this.processes.get(name);
+    if (proc) proc.on("exit", (code) => callback(code));
+  }
+  /**
+   * Get the process for a named agent.
+   */
+  get(name) {
+    return this.processes.get(name);
+  }
+  /**
+   * Check if an agent process is still running.
+   */
+  isRunning(name) {
+    const proc = this.processes.get(name);
+    return proc !== void 0 && proc.exitCode === null && !proc.killed;
+  }
+  /**
+   * Get the PID of a running agent.
+   */
+  getPid(name) {
+    return this.processes.get(name)?.pid;
+  }
+  /**
+   * Kill a specific agent process.
+   */
+  async kill(name, signal = "SIGTERM") {
+    const proc = this.processes.get(name);
+    if (!proc) return;
+    proc.kill(signal);
+    await Promise.race([
+      new Promise((resolve) => proc.on("exit", () => resolve())),
+      new Promise(
+        (resolve) => setTimeout(() => {
+          if (this.processes.has(name)) {
+            this.log.warn(`Force-killing agent "${name}" with SIGKILL`);
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+          }
+          resolve();
+        }, 5e3)
+      )
+    ]);
+    this.processes.delete(name);
+  }
+  /**
+   * Kill all agent processes.
+   */
+  async killAll() {
+    const names = [...this.processes.keys()];
+    await Promise.all(names.map((name) => this.kill(name)));
+  }
+  /**
+   * Get all running agent names.
+   */
+  runningAgents() {
+    return [...this.processes.keys()].filter((n) => this.isRunning(n));
+  }
+};
+
+// src/inbox.ts
+var import_promises3 = require("fs/promises");
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var import_proper_lockfile = require("proper-lockfile");
+var LOCK_OPTIONS = {
+  retries: { retries: 5, minTimeout: 50, maxTimeout: 500 },
+  stale: 1e4
+};
+async function ensureDir(filePath) {
+  const dir = (0, import_node_path2.dirname)(filePath);
+  if (!(0, import_node_fs3.existsSync)(dir)) {
+    await (0, import_promises3.mkdir)(dir, { recursive: true });
+  }
+}
+async function ensureFile(filePath) {
+  await ensureDir(filePath);
+  if (!(0, import_node_fs3.existsSync)(filePath)) {
+    await (0, import_promises3.writeFile)(filePath, "[]", "utf-8");
+  }
+}
+async function writeInbox(teamName, agentName, message, logger) {
+  const path = inboxPath(teamName, agentName);
+  await ensureFile(path);
+  let release;
+  try {
+    release = await (0, import_proper_lockfile.lock)(path, LOCK_OPTIONS);
+    const raw = await (0, import_promises3.readFile)(path, "utf-8");
+    const messages = JSON.parse(raw || "[]");
+    messages.push({ ...message, read: false });
+    await (0, import_promises3.writeFile)(path, JSON.stringify(messages, null, 2), "utf-8");
+    logger?.debug(`Wrote message to inbox ${agentName}`, message.from);
+  } finally {
+    if (release) await release();
+  }
+}
+async function readUnread(teamName, agentName) {
+  const path = inboxPath(teamName, agentName);
+  if (!(0, import_node_fs3.existsSync)(path)) return [];
+  let release;
+  try {
+    release = await (0, import_proper_lockfile.lock)(path, LOCK_OPTIONS);
+    const raw = await (0, import_promises3.readFile)(path, "utf-8");
+    const messages = JSON.parse(raw || "[]");
+    const unread = messages.filter((m) => !m.read);
+    if (unread.length === 0) return [];
+    for (const m of messages) {
+      m.read = true;
+    }
+    await (0, import_promises3.writeFile)(path, JSON.stringify(messages, null, 2), "utf-8");
+    return unread;
+  } finally {
+    if (release) await release();
+  }
+}
+function parseMessage(msg) {
+  try {
+    const parsed = JSON.parse(msg.text);
+    if (parsed && typeof parsed === "object" && "type" in parsed) {
+      return parsed;
+    }
+  } catch {
+  }
+  return { type: "plain_text", text: msg.text };
+}
+
+// src/inbox-poller.ts
+var InboxPoller = class {
+  teamName;
+  agentName;
+  interval;
+  timer = null;
+  log;
+  handlers = [];
+  constructor(teamName, agentName, logger, opts) {
+    this.teamName = teamName;
+    this.agentName = agentName;
+    this.log = logger;
+    this.interval = opts?.pollInterval ?? 500;
+  }
+  /**
+   * Register a handler for new messages.
+   */
+  onMessages(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+   * Start polling.
+   */
+  start() {
+    if (this.timer) return;
+    this.log.debug(
+      `Starting inbox poller for "${this.agentName}" (interval=${this.interval}ms)`
+    );
+    this.timer = setInterval(() => this.poll(), this.interval);
+  }
+  /**
+   * Stop polling.
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+      this.log.debug(`Stopped inbox poller for "${this.agentName}"`);
+    }
+  }
+  /**
+   * Poll once for new messages.
+   */
+  async poll() {
+    try {
+      const unread = await readUnread(this.teamName, this.agentName);
+      if (unread.length === 0) return [];
+      const events = unread.map((raw) => ({
+        raw,
+        parsed: parseMessage(raw)
+      }));
+      for (const handler of this.handlers) {
+        try {
+          handler(events);
+        } catch (err) {
+          this.log.error("Inbox handler error:", String(err));
+        }
+      }
+      return events;
+    } catch (err) {
+      this.log.error("Inbox poll error:", String(err));
+      return [];
+    }
+  }
+};
+
+// src/agent-handle.ts
+var AgentHandle = class {
+  name;
+  pid;
+  controller;
+  constructor(controller, name, pid) {
+    this.controller = controller;
+    this.name = name;
+    this.pid = pid;
+  }
+  /**
+   * Send a message to this agent.
+   */
+  async send(message, summary) {
+    return this.controller.send(this.name, message, summary);
+  }
+  /**
+   * Wait for a response from this agent.
+   * Returns the text of the first unread plain-text message.
+   */
+  async receive(opts) {
+    const messages = await this.controller.receive(this.name, opts);
+    const texts = messages.map((m) => m.text);
+    return texts.join("\n");
+  }
+  /**
+   * Send a message and wait for the response. Convenience method.
+   */
+  async ask(question, opts) {
+    await this.send(question);
+    return this.receive(opts);
+  }
+  /**
+   * Check if the agent process is still running.
+   */
+  get isRunning() {
+    return this.controller.isAgentRunning(this.name);
+  }
+  /**
+   * Request the agent to shut down gracefully.
+   */
+  async shutdown() {
+    return this.controller.sendShutdownRequest(this.name);
+  }
+  /**
+   * Force-kill the agent process.
+   */
+  async kill() {
+    return this.controller.killAgent(this.name);
+  }
+  /**
+   * Async iterator for agent events (messages from this agent).
+   * Polls the controller's inbox for messages from this agent.
+   */
+  async *events(opts) {
+    const interval = opts?.pollInterval ?? 500;
+    const timeout = opts?.timeout ?? 0;
+    const deadline = timeout > 0 ? Date.now() + timeout : Infinity;
+    while (Date.now() < deadline) {
+      try {
+        const messages = await this.controller.receive(this.name, {
+          timeout: interval,
+          pollInterval: interval
+        });
+        for (const msg of messages) {
+          yield msg;
+        }
+      } catch {
+      }
+      if (!this.isRunning) return;
+    }
+  }
+};
+
+// src/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+function createLogger(level = "info") {
+  const threshold = LEVELS[level];
+  const noop = () => {
+  };
+  const make = (lvl, fn) => (msg, ...args) => {
+    if (LEVELS[lvl] >= threshold) {
+      fn(`[claude-ctrl:${lvl}]`, msg, ...args);
+    }
+  };
+  return {
+    debug: threshold <= LEVELS.debug ? make("debug", console.debug) : noop,
+    info: threshold <= LEVELS.info ? make("info", console.info) : noop,
+    warn: threshold <= LEVELS.warn ? make("warn", console.warn) : noop,
+    error: threshold <= LEVELS.error ? make("error", console.error) : noop
+  };
+}
+
+// src/controller.ts
+var AGENT_COLORS = [
+  "#00FF00",
+  "#00BFFF",
+  "#FF6347",
+  "#FFD700",
+  "#DA70D6",
+  "#40E0D0",
+  "#FF69B4",
+  "#7B68EE"
+];
+var ClaudeCodeController = class extends import_node_events.EventEmitter {
+  teamName;
+  team;
+  tasks;
+  processes;
+  poller;
+  log;
+  cwd;
+  claudeBinary;
+  defaultEnv;
+  colorIndex = 0;
+  initialized = false;
+  constructor(opts) {
+    super();
+    this.teamName = opts?.teamName || `ctrl-${(0, import_node_crypto2.randomUUID)().slice(0, 8)}`;
+    this.cwd = opts?.cwd || process.cwd();
+    this.claudeBinary = opts?.claudeBinary || "claude";
+    this.defaultEnv = opts?.env || {};
+    this.log = opts?.logger || createLogger(opts?.logLevel ?? "info");
+    this.team = new TeamManager(this.teamName, this.log);
+    this.tasks = new TaskManager(this.teamName, this.log);
+    this.processes = new ProcessManager(this.log);
+    this.poller = new InboxPoller(
+      this.teamName,
+      "controller",
+      this.log
+    );
+    this.poller.onMessages((events) => this.handlePollEvents(events));
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────
+  /**
+   * Initialize the controller: create the team and start polling.
+   * Must be called before any other operations.
+   */
+  async init() {
+    if (this.initialized) return this;
+    await this.team.create({ cwd: this.cwd });
+    await this.tasks.init();
+    this.poller.start();
+    this.initialized = true;
+    this.log.info(
+      `Controller initialized (team="${this.teamName}")`
+    );
+    return this;
+  }
+  /**
+   * Graceful shutdown:
+   * 1. Send shutdown requests to all agents
+   * 2. Wait briefly for acknowledgment
+   * 3. Kill remaining processes
+   * 4. Clean up team files
+   */
+  async shutdown() {
+    this.log.info("Shutting down controller...");
+    const running = this.processes.runningAgents();
+    const shutdownPromises = [];
+    for (const name of running) {
+      try {
+        await this.sendShutdownRequest(name);
+        shutdownPromises.push(
+          new Promise((resolve) => {
+            const proc = this.processes.get(name);
+            if (!proc) return resolve();
+            const timer = setTimeout(() => resolve(), 1e4);
+            proc.on("exit", () => {
+              clearTimeout(timer);
+              resolve();
+            });
+          })
+        );
+      } catch {
+      }
+    }
+    if (shutdownPromises.length > 0) {
+      await Promise.all(shutdownPromises);
+    }
+    await this.processes.killAll();
+    this.poller.stop();
+    await this.team.destroy();
+    this.initialized = false;
+    this.log.info("Controller shut down");
+  }
+  // ─── Agent Management ────────────────────────────────────────────────
+  /**
+   * Spawn a new Claude Code agent.
+   */
+  async spawnAgent(opts) {
+    this.ensureInitialized();
+    const agentId = `${opts.name}@${this.teamName}`;
+    const color = AGENT_COLORS[this.colorIndex++ % AGENT_COLORS.length];
+    const cwd = opts.cwd || this.cwd;
+    const member = {
+      agentId,
+      name: opts.name,
+      agentType: opts.type || "general-purpose",
+      model: opts.model,
+      joinedAt: Date.now(),
+      tmuxPaneId: "",
+      cwd,
+      subscriptions: []
+    };
+    await this.team.addMember(member);
+    const env = Object.keys(this.defaultEnv).length > 0 || opts.env ? { ...this.defaultEnv, ...opts.env } : void 0;
+    const proc = this.processes.spawn({
+      teamName: this.teamName,
+      agentName: opts.name,
+      agentId,
+      agentType: opts.type || "general-purpose",
+      model: opts.model,
+      cwd,
+      parentSessionId: this.team.sessionId,
+      color,
+      claudeBinary: this.claudeBinary,
+      permissions: opts.permissions,
+      env
+    });
+    this.emit("agent:spawned", opts.name, proc.pid ?? 0);
+    this.processes.onExit(opts.name, (code) => {
+      this.emit("agent:exited", opts.name, code ?? null);
+    });
+    return new AgentHandle(this, opts.name, proc.pid);
+  }
+  // ─── Messaging ───────────────────────────────────────────────────────
+  /**
+   * Send a message to a specific agent.
+   */
+  async send(agentName, message, summary) {
+    this.ensureInitialized();
+    await writeInbox(
+      this.teamName,
+      agentName,
+      {
+        from: "controller",
+        text: message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        summary
+      },
+      this.log
+    );
+  }
+  /**
+   * Send a structured shutdown request to an agent.
+   */
+  async sendShutdownRequest(agentName) {
+    const requestId = `shutdown-${Date.now()}@${agentName}`;
+    const msg = JSON.stringify({
+      type: "shutdown_request",
+      requestId,
+      from: "controller",
+      reason: "Controller shutdown requested",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.send(agentName, msg);
+  }
+  /**
+   * Broadcast a message to all registered agents (except controller).
+   */
+  async broadcast(message, summary) {
+    this.ensureInitialized();
+    const config = await this.team.getConfig();
+    const agents = config.members.filter((m) => m.name !== "controller");
+    await Promise.all(
+      agents.map((a) => this.send(a.name, message, summary))
+    );
+  }
+  /**
+   * Wait for messages from a specific agent.
+   * Polls the controller's inbox for messages from the given agent.
+   *
+   * Returns when:
+   * - A non-idle message is received (SendMessage from agent), OR
+   * - An idle_notification is received (agent finished its turn),
+   *   in which case the idle message is returned.
+   */
+  async receive(agentName, opts) {
+    const timeout = opts?.timeout ?? 6e4;
+    const interval = opts?.pollInterval ?? 500;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const unread = await readUnread(this.teamName, "controller");
+      const fromAgent = unread.filter((m) => m.from === agentName);
+      if (fromAgent.length > 0) {
+        const PROTOCOL_TYPES = /* @__PURE__ */ new Set([
+          "shutdown_approved",
+          "plan_approval_response",
+          "permission_response"
+        ]);
+        const meaningful = fromAgent.filter((m) => {
+          const parsed = parseMessage(m);
+          return parsed.type !== "idle_notification" && !PROTOCOL_TYPES.has(parsed.type);
+        });
+        if (meaningful.length > 0) {
+          return opts?.all ? meaningful : [meaningful[0]];
+        }
+        const idles = fromAgent.filter((m) => {
+          const parsed = parseMessage(m);
+          return parsed.type === "idle_notification";
+        });
+        if (idles.length > 0) {
+          return opts?.all ? idles : [idles[0]];
+        }
+      }
+      await sleep2(interval);
+    }
+    throw new Error(
+      `Timeout (${timeout}ms) waiting for message from "${agentName}"`
+    );
+  }
+  /**
+   * Wait for any message from any agent.
+   */
+  async receiveAny(opts) {
+    const timeout = opts?.timeout ?? 6e4;
+    const interval = opts?.pollInterval ?? 500;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const unread = await readUnread(this.teamName, "controller");
+      const meaningful = unread.filter((m) => {
+        const parsed = parseMessage(m);
+        return parsed.type !== "idle_notification";
+      });
+      if (meaningful.length > 0) {
+        return meaningful[0];
+      }
+      await sleep2(interval);
+    }
+    throw new Error(`Timeout (${timeout}ms) waiting for any message`);
+  }
+  // ─── Tasks ───────────────────────────────────────────────────────────
+  /**
+   * Create a task and optionally notify the assigned agent.
+   */
+  async createTask(task) {
+    this.ensureInitialized();
+    const taskId = await this.tasks.create(task);
+    if (task.owner) {
+      const fullTask = await this.tasks.get(taskId);
+      const assignmentMsg = JSON.stringify({
+        type: "task_assignment",
+        taskId,
+        subject: fullTask.subject,
+        description: fullTask.description,
+        assignedBy: "controller",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await this.send(task.owner, assignmentMsg);
+    }
+    return taskId;
+  }
+  /**
+   * Assign a task to an agent.
+   */
+  async assignTask(taskId, agentName) {
+    const task = await this.tasks.update(taskId, { owner: agentName });
+    const msg = JSON.stringify({
+      type: "task_assignment",
+      taskId,
+      subject: task.subject,
+      description: task.description,
+      assignedBy: "controller",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.send(agentName, msg);
+  }
+  // ─── Protocol Responses ───────────────────────────────────────────
+  /**
+   * Approve or reject a teammate's plan.
+   * Send this in response to a `plan:approval_request` event.
+   */
+  async sendPlanApproval(agentName, requestId, approve, feedback) {
+    const msg = JSON.stringify({
+      type: "plan_approval_response",
+      requestId,
+      from: "controller",
+      approved: approve,
+      feedback,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.send(agentName, msg);
+  }
+  /**
+   * Approve or reject a teammate's permission/tool-use request.
+   * Send this in response to a `permission:request` event.
+   */
+  async sendPermissionResponse(agentName, requestId, approve) {
+    const msg = JSON.stringify({
+      type: "permission_response",
+      requestId,
+      from: "controller",
+      approved: approve,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.send(agentName, msg);
+  }
+  /**
+   * Wait for a task to be completed.
+   */
+  async waitForTask(taskId, timeout) {
+    return this.tasks.waitFor(taskId, "completed", { timeout });
+  }
+  // ─── Utilities ───────────────────────────────────────────────────────
+  /**
+   * Check if an agent process is still running.
+   */
+  isAgentRunning(name) {
+    return this.processes.isRunning(name);
+  }
+  /**
+   * Kill a specific agent.
+   */
+  async killAgent(name) {
+    await this.processes.kill(name);
+    await this.team.removeMember(name);
+  }
+  /**
+   * Get the installed Claude Code version.
+   */
+  getClaudeVersion() {
+    try {
+      const version = (0, import_node_child_process3.execSync)(`${this.claudeBinary} --version`, {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      return version;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Verify that the required CLI flags exist in the installed version.
+   */
+  verifyCompatibility() {
+    const version = this.getClaudeVersion();
+    return { compatible: version !== null, version };
+  }
+  // ─── Internal ────────────────────────────────────────────────────────
+  handlePollEvents(events) {
+    for (const event of events) {
+      const { raw, parsed } = event;
+      switch (parsed.type) {
+        case "idle_notification":
+          this.emit("idle", raw.from);
+          break;
+        case "shutdown_approved":
+          this.log.info(
+            `Shutdown approved by "${raw.from}" (requestId=${parsed.requestId})`
+          );
+          this.emit("shutdown:approved", raw.from, parsed);
+          break;
+        case "plan_approval_request":
+          this.log.info(
+            `Plan approval request from "${raw.from}" (requestId=${parsed.requestId})`
+          );
+          this.emit("plan:approval_request", raw.from, parsed);
+          break;
+        case "permission_request":
+          this.log.info(
+            `Permission request from "${raw.from}": ${parsed.toolName} (requestId=${parsed.requestId})`
+          );
+          this.emit("permission:request", raw.from, parsed);
+          break;
+        case "plain_text":
+          this.emit("message", raw.from, raw);
+          break;
+        default:
+          this.emit("message", raw.from, raw);
+      }
+    }
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error(
+        "Controller not initialized. Call init() first."
+      );
+    }
+  }
+};
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/api/routes.ts
+var SAFE_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+var SAFE_TASK_ID_RE = /^[0-9]{1,10}$/;
+function validateName(value, field) {
+  if (!SAFE_NAME_RE.test(value)) {
+    throw new ValidationError(
+      `${field} must be 1-64 alphanumeric characters, hyphens, or underscores`
+    );
+  }
+}
+function validateTaskId(value) {
+  if (!SAFE_TASK_ID_RE.test(value)) {
+    throw new ValidationError("task id must be a numeric string (1-10 digits)");
+  }
+}
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function isNotFoundError(err) {
+  return err instanceof Error && /not found/i.test(err.message);
+}
+function getController(state) {
+  if (!state.controller) {
+    throw new Error(
+      "No active session. Call POST /session/init first."
+    );
+  }
+  return state.controller;
+}
+function buildRoutes(state) {
+  const api = new import_hono.Hono();
+  api.get("/health", (c) => {
+    return c.json({
+      status: "ok",
+      uptime: Date.now() - state.startTime,
+      session: state.controller !== null
+    });
+  });
+  api.get("/session", (c) => {
+    if (!state.controller) {
+      return c.json({ initialized: false, teamName: "" });
+    }
+    return c.json({
+      initialized: true,
+      teamName: state.controller.teamName
+    });
+  });
+  api.post("/session/init", async (c) => {
+    if (state.initLock) {
+      return c.json({ error: "Session init already in progress" }, 409);
+    }
+    state.initLock = true;
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      if (body.teamName) validateName(body.teamName, "teamName");
+      const oldController = state.controller;
+      if (oldController) {
+        state.tracker.clear();
+        state.controller = null;
+        if (state.owned) {
+          await oldController.shutdown();
+        }
+      }
+      const controller = new ClaudeCodeController({
+        teamName: body.teamName,
+        cwd: body.cwd,
+        claudeBinary: body.claudeBinary,
+        env: body.env,
+        logLevel: body.logLevel ?? "info"
+      });
+      try {
+        await controller.init();
+      } catch (err) {
+        try {
+          await controller.shutdown();
+        } catch {
+        }
+        throw err;
+      }
+      state.controller = controller;
+      state.owned = true;
+      state.tracker.attach(controller);
+      return c.json({
+        initialized: true,
+        teamName: controller.teamName
+      }, 201);
+    } finally {
+      state.initLock = false;
+    }
+  });
+  api.post("/session/shutdown", async (c) => {
+    if (state.initLock) {
+      return c.json({ error: "Session operation in progress" }, 409);
+    }
+    state.initLock = true;
+    try {
+      const ctrl = getController(state);
+      const wasOwned = state.owned;
+      state.tracker.clear();
+      state.controller = null;
+      state.owned = false;
+      if (wasOwned) {
+        await ctrl.shutdown();
+      }
+      return c.json({ ok: true });
+    } finally {
+      state.initLock = false;
+    }
+  });
+  api.get("/actions", async (c) => {
+    const ctrl = getController(state);
+    const approvals = state.tracker.getPendingApprovals();
+    const idleAgents = state.tracker.getIdleAgents();
+    const tasks = await ctrl.tasks.list();
+    const unassignedTasks = tasks.filter((t) => !t.owner && t.status !== "completed").map((t) => ({
+      id: t.id,
+      subject: t.subject,
+      description: t.description,
+      status: t.status,
+      action: `POST /tasks/${t.id}/assign`
+    }));
+    const pending = approvals.length + unassignedTasks.length + idleAgents.length;
+    return c.json({ pending, approvals, unassignedTasks, idleAgents });
+  });
+  api.get("/actions/approvals", (_c) => {
+    getController(state);
+    return _c.json(state.tracker.getPendingApprovals());
+  });
+  api.get("/actions/tasks", async (c) => {
+    const ctrl = getController(state);
+    const tasks = await ctrl.tasks.list();
+    const unassigned = tasks.filter((t) => !t.owner && t.status !== "completed").map((t) => ({
+      id: t.id,
+      subject: t.subject,
+      description: t.description,
+      status: t.status,
+      action: `POST /tasks/${t.id}/assign`
+    }));
+    return c.json(unassigned);
+  });
+  api.get("/actions/idle-agents", (_c) => {
+    getController(state);
+    return _c.json(state.tracker.getIdleAgents());
+  });
+  api.get("/agents", async (c) => {
+    const ctrl = getController(state);
+    const config = await ctrl.team.getConfig();
+    const agents = config.members.filter((m) => m.name !== "controller").map((m) => ({
+      name: m.name,
+      type: m.agentType,
+      model: m.model,
+      running: ctrl.isAgentRunning(m.name)
+    }));
+    return c.json(agents);
+  });
+  api.post("/agents", async (c) => {
+    const ctrl = getController(state);
+    const body = await c.req.json();
+    if (!body.name) {
+      return c.json({ error: "name is required" }, 400);
+    }
+    validateName(body.name, "name");
+    const agentType = body.type || "general-purpose";
+    state.tracker.registerAgentType(body.name, agentType);
+    const handle = await ctrl.spawnAgent({
+      name: body.name,
+      type: body.type,
+      model: body.model,
+      cwd: body.cwd,
+      permissions: body.permissions,
+      env: body.env
+    });
+    return c.json(
+      {
+        name: handle.name,
+        pid: handle.pid,
+        running: handle.isRunning
+      },
+      201
+    );
+  });
+  api.get("/agents/:name", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    const config = await ctrl.team.getConfig();
+    const member = config.members.find((m) => m.name === name);
+    if (!member) {
+      return c.json({ error: `Agent "${name}" not found` }, 404);
+    }
+    return c.json({
+      name: member.name,
+      type: member.agentType,
+      model: member.model,
+      running: ctrl.isAgentRunning(name)
+    });
+  });
+  api.post("/agents/:name/messages", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    const body = await c.req.json();
+    if (!body.message) {
+      return c.json({ error: "message is required" }, 400);
+    }
+    await ctrl.send(name, body.message, body.summary);
+    return c.json({ ok: true });
+  });
+  api.post("/agents/:name/kill", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    await ctrl.killAgent(name);
+    return c.json({ ok: true });
+  });
+  api.post("/agents/:name/shutdown", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    await ctrl.sendShutdownRequest(name);
+    return c.json({ ok: true });
+  });
+  api.post("/agents/:name/approve-plan", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    const body = await c.req.json();
+    if (!body.requestId) {
+      return c.json({ error: "requestId is required" }, 400);
+    }
+    await ctrl.sendPlanApproval(
+      name,
+      body.requestId,
+      body.approve ?? true,
+      body.feedback
+    );
+    state.tracker.resolveApproval(body.requestId);
+    return c.json({ ok: true });
+  });
+  api.post("/agents/:name/approve-permission", async (c) => {
+    const ctrl = getController(state);
+    const name = c.req.param("name");
+    validateName(name, "name");
+    const body = await c.req.json();
+    if (!body.requestId) {
+      return c.json({ error: "requestId is required" }, 400);
+    }
+    await ctrl.sendPermissionResponse(
+      name,
+      body.requestId,
+      body.approve ?? true
+    );
+    state.tracker.resolveApproval(body.requestId);
+    return c.json({ ok: true });
+  });
+  api.post("/broadcast", async (c) => {
+    const ctrl = getController(state);
+    const body = await c.req.json();
+    if (!body.message) {
+      return c.json({ error: "message is required" }, 400);
+    }
+    await ctrl.broadcast(body.message, body.summary);
+    return c.json({ ok: true });
+  });
+  api.get("/tasks", async (c) => {
+    const ctrl = getController(state);
+    const tasks = await ctrl.tasks.list();
+    return c.json(tasks);
+  });
+  api.post("/tasks", async (c) => {
+    const ctrl = getController(state);
+    const body = await c.req.json();
+    if (!body.subject || !body.description) {
+      return c.json({ error: "subject and description are required" }, 400);
+    }
+    if (body.owner) validateName(body.owner, "owner");
+    const taskId = await ctrl.createTask(body);
+    const task = await ctrl.tasks.get(taskId);
+    return c.json(task, 201);
+  });
+  api.get("/tasks/:id", async (c) => {
+    const ctrl = getController(state);
+    const id = c.req.param("id");
+    validateTaskId(id);
+    try {
+      const task = await ctrl.tasks.get(id);
+      return c.json(task);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return c.json({ error: `Task "${id}" not found` }, 404);
+      }
+      throw err;
+    }
+  });
+  api.patch("/tasks/:id", async (c) => {
+    const ctrl = getController(state);
+    const id = c.req.param("id");
+    validateTaskId(id);
+    const body = await c.req.json();
+    try {
+      const task = await ctrl.tasks.update(id, body);
+      return c.json(task);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return c.json({ error: `Task "${id}" not found` }, 404);
+      }
+      throw err;
+    }
+  });
+  api.delete("/tasks/:id", async (c) => {
+    const ctrl = getController(state);
+    const id = c.req.param("id");
+    validateTaskId(id);
+    try {
+      await ctrl.tasks.get(id);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return c.json({ error: `Task "${id}" not found` }, 404);
+      }
+      throw err;
+    }
+    await ctrl.tasks.delete(id);
+    return c.json({ ok: true });
+  });
+  api.post("/tasks/:id/assign", async (c) => {
+    const ctrl = getController(state);
+    const id = c.req.param("id");
+    validateTaskId(id);
+    const body = await c.req.json();
+    if (!body.agent) {
+      return c.json({ error: "agent is required" }, 400);
+    }
+    validateName(body.agent, "agent");
+    try {
+      await ctrl.tasks.get(id);
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return c.json({ error: `Task "${id}" not found` }, 404);
+      }
+      throw err;
+    }
+    await ctrl.assignTask(id, body.agent);
+    return c.json({ ok: true });
+  });
+  return api;
+}
+
+// src/api/index.ts
+function createApi(controller, options) {
+  const tracker = new ActionTracker();
+  if (controller) {
+    tracker.attach(controller);
+  }
+  const state = {
+    controller: controller ?? null,
+    tracker,
+    owned: false,
+    // externally-provided controllers are not owned by the API
+    initLock: false,
+    startTime: Date.now()
+  };
+  const app = new import_hono2.Hono();
+  const basePath = options?.basePath ?? "/";
+  if (options?.cors !== false) {
+    app.use("*", (0, import_cors.cors)());
+  }
+  const routes = buildRoutes(state);
+  app.route(basePath, routes);
+  app.onError((err, c) => {
+    const message = err instanceof Error ? err.message : "Internal server error";
+    const status = err.name === "ValidationError" ? 400 : 500;
+    return c.json({ error: message }, status);
+  });
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionTracker,
+  createApi
+});
+//# sourceMappingURL=index.cjs.map