@burdenoff/vibe-agent 2.1.1 → 2.3.0

package/dist/cli.js

@@ -1,19 +1,39 @@
 #!/usr/bin/env bun
 // @bun
 import {
-  ServiceRegistry,
+  ServiceRegistry
+} from "./index-atjhkm74.js";
+import {
+  ServiceManager,
   checkDependencies,
   installDependencies
-} from "./index-t06ktmx9.js";
+} from "./index-s7ff1fj1.js";
+import {
+  logger
+} from "./index-88ym10cs.js";
+import {
+  blank,
+  colors,
+  fail,
+  formatStatus,
+  formatTable,
+  header,
+  icons,
+  info,
+  kv,
+  printAgentDetails,
+  success,
+  timeAgo,
+  warn
+} from "./index-xmeskdnb.js";
 import {
   __commonJS,
   __require,
   __toESM
 } from "./index-g8dczzvv.js";
 import {
-  PluginManager,
-  logger
-} from "./plugin-system-bg1pzjj9.js";
+  PluginManager
+} from "./plugin-system-7r9mb1tb.js";
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
@@ -2125,548 +2145,29 @@ var {
 } = import__.default;
 
 // src/cli.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join3 } from "path";
 
 // src/cli/commands/start.cmd.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-
-// src/cli/utils/api-client.ts
-var DEFAULT_AGENT_URL = "http://localhost:3005";
-var _apiKeyCache = new Map;
-function getAgentUrl(opts) {
-  return opts?.agentUrl || process.env.AGENT_URL || DEFAULT_AGENT_URL;
-}
-async function resolveApiKey(agentUrl) {
-  if (process.env.AGENT_API_KEY)
-    return process.env.AGENT_API_KEY;
-  if (_apiKeyCache.has(agentUrl))
-    return _apiKeyCache.get(agentUrl);
-  try {
-    const res = await fetch(`${agentUrl}/api/agent/api-key`);
-    if (res.ok) {
-      const data = await res.json();
-      if (data.apiKey) {
-        _apiKeyCache.set(agentUrl, data.apiKey);
-        return data.apiKey;
-      }
-    }
-  } catch {}
-  return;
-}
-async function agentFetch(agentUrl, path, options = {}) {
-  const apiKey = await resolveApiKey(agentUrl);
-  const headers = {
-    ...options.body ? { "Content-Type": "application/json" } : {},
-    ...apiKey ? { "x-agent-api-key": apiKey } : {},
-    ...options.headers ?? {}
-  };
-  const res = await fetch(`${agentUrl}${path}`, { ...options, headers });
-  const data = await res.json().catch(() => ({}));
-  return { ok: res.ok, status: res.status, data };
-}
-async function apiGet(agentUrl, path) {
-  const { ok, status, data } = await agentFetch(agentUrl, path);
-  if (!ok) {
-    const errorMsg = data?.error || data?.message || `Agent returned ${status}`;
-    throw new Error(String(errorMsg));
-  }
-  return data;
-}
-async function apiPost(agentUrl, path, body) {
-  const { ok, status, data } = await agentFetch(agentUrl, path, {
-    method: "POST",
-    body: body != null ? JSON.stringify(body) : undefined
-  });
-  if (!ok) {
-    const errorMsg = data?.error || data?.message || `Agent returned ${status}`;
-    throw new Error(String(errorMsg));
-  }
-  return data;
-}
-async function apiPut(agentUrl, path, body) {
-  const { ok, status, data } = await agentFetch(agentUrl, path, {
-    method: "PUT",
-    body: body != null ? JSON.stringify(body) : undefined
-  });
-  if (!ok) {
-    const errorMsg = data?.error || data?.message || `Agent returned ${status}`;
-    throw new Error(String(errorMsg));
-  }
-  return data;
-}
-async function apiDelete(agentUrl, path) {
-  const { ok, status, data } = await agentFetch(agentUrl, path, {
-    method: "DELETE"
-  });
-  if (!ok) {
-    const errorMsg = data?.error || data?.message || `Agent returned ${status}`;
-    throw new Error(String(errorMsg));
-  }
-  return data;
-}
-// src/cli/utils/format.ts
-var colors = {
-  bold: (text) => `\x1B[1m${text}\x1B[22m`,
-  dim: (text) => `\x1B[2m${text}\x1B[22m`,
-  italic: (text) => `\x1B[3m${text}\x1B[23m`,
-  underline: (text) => `\x1B[4m${text}\x1B[24m`,
-  red: (text) => `\x1B[31m${text}\x1B[39m`,
-  green: (text) => `\x1B[32m${text}\x1B[39m`,
-  yellow: (text) => `\x1B[33m${text}\x1B[39m`,
-  blue: (text) => `\x1B[34m${text}\x1B[39m`,
-  magenta: (text) => `\x1B[35m${text}\x1B[39m`,
-  cyan: (text) => `\x1B[36m${text}\x1B[39m`,
-  white: (text) => `\x1B[37m${text}\x1B[39m`,
-  gray: (text) => `\x1B[90m${text}\x1B[39m`,
-  brightRed: (text) => `\x1B[91m${text}\x1B[39m`,
-  brightGreen: (text) => `\x1B[92m${text}\x1B[39m`,
-  brightYellow: (text) => `\x1B[93m${text}\x1B[39m`,
-  brightBlue: (text) => `\x1B[94m${text}\x1B[39m`,
-  reset: "\x1B[0m"
-};
-var icons = {
-  success: colors.green("\u2713"),
-  error: colors.red("\u2717"),
-  warning: colors.yellow("\u26A0"),
-  info: colors.blue("\u25CF"),
-  running: colors.green("\u25CF"),
-  stopped: colors.red("\u25CB"),
-  pending: colors.yellow("\u25CC"),
-  arrow: colors.gray("\u2192"),
-  bullet: colors.gray("\u2022"),
-  check: colors.green("\u2714")
-};
-function fail(msg) {
-  console.error(`${colors.red("Error:")} ${msg}`);
-  process.exit(1);
-}
-function success(msg) {
-  console.log(`  ${icons.success} ${msg}`);
-}
-function warn(msg) {
-  console.log(`  ${icons.warning} ${msg}`);
-}
-function info(msg) {
-  console.log(`  ${icons.info} ${msg}`);
-}
-function header(title) {
-  console.log(`
-  ${colors.bold(`\u2500\u2500 ${title} \u2500\u2500`)}
-`);
-}
-function kv(key, value) {
-  const display = value === null || value === undefined ? colors.gray("(none)") : String(value);
-  console.log(`  ${colors.bold(key.padEnd(14))} ${display}`);
-}
-function blank() {
-  console.log();
-}
-function formatTable(rows) {
-  if (rows.length === 0) {
-    console.log("  (none)");
-    return;
-  }
-  console.table(rows);
-}
-function timeAgo(dateStr) {
-  const diff = Date.now() - new Date(dateStr).getTime();
-  const s = Math.floor(diff / 1000);
-  if (s < 0)
-    return "just now";
-  if (s < 60)
-    return `${s}s ago`;
-  const m = Math.floor(s / 60);
-  if (m < 60)
-    return `${m}m ago`;
-  const h = Math.floor(m / 60);
-  if (h < 24)
-    return `${h}h ago`;
-  const d = Math.floor(h / 24);
-  if (d < 30)
-    return `${d}d ago`;
-  return `${Math.floor(d / 30)}mo ago`;
-}
-function formatDuration(seconds) {
-  if (seconds < 60)
-    return `${Math.floor(seconds)}s`;
-  const m = Math.floor(seconds / 60);
-  const s = Math.floor(seconds % 60);
-  if (m < 60)
-    return `${m}m ${s}s`;
-  const h = Math.floor(m / 60);
-  const rm = m % 60;
-  return `${h}h ${rm}m`;
-}
-function formatBytes(bytes) {
-  if (bytes < 1024)
-    return `${bytes} B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024)
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function formatStatus(status) {
-  switch (status) {
-    case "running":
-    case "active":
-    case "healthy":
-    case "success":
-    case "completed":
-      return colors.green(status);
-    case "stopped":
-    case "inactive":
-    case "terminated":
-    case "failed":
-      return colors.red(status);
-    case "starting":
-    case "stopping":
-    case "pending":
-    case "warning":
-      return colors.yellow(status);
-    case "error":
-      return colors.red(status);
-    default:
-      return status;
-  }
-}
-function formatNotificationType(type) {
-  switch (type) {
-    case "error":
-      return colors.red("\u25CF");
-    case "warning":
-      return colors.yellow("\u25CF");
-    case "success":
-      return colors.green("\u25CF");
-    case "info":
-    default:
-      return colors.blue("\u25CF");
-  }
-}
-function shortId(id, len = 10) {
-  if (id.length <= len)
-    return id;
-  return id.substring(0, len) + "...";
-}
-async function printAgentDetails(agentUrl, maxWaitMs = 15000) {
-  const startTime = Date.now();
-  let healthy = false;
-  while (Date.now() - startTime < maxWaitMs) {
-    try {
-      const res = await fetch(`${agentUrl}/health`);
-      if (res.ok) {
-        healthy = true;
-        break;
-      }
-    } catch {}
-    await new Promise((r) => setTimeout(r, 500));
-  }
-  if (!healthy) {
-    console.log(`
-  ${icons.warning}  Agent not yet responding at ${agentUrl}. Check ${colors.bold("vibe logs")} for details.
-`);
-    return;
-  }
-  let apiKey = "(unavailable)";
-  try {
-    const res = await fetch(`${agentUrl}/api/agent/api-key`);
-    if (res.ok) {
-      const data = await res.json();
-      apiKey = data.apiKey;
-    }
-  } catch {}
-  let tunnelUrl = "(not running)";
-  let tunnelWaiting = false;
-  try {
-    const res = await fetch(`${agentUrl}/api/agent/tunnel`);
-    if (res.ok) {
-      const data = await res.json();
-      if (data.tunnelUrl) {
-        tunnelUrl = data.tunnelUrl;
-      } else if (data.status !== "inactive") {
-        tunnelWaiting = true;
-      }
-    }
-  } catch {}
-  if (tunnelWaiting || tunnelUrl === "(not running)") {
-    const tunnelWaitMs = 20000;
-    const tunnelStart = Date.now();
-    while (Date.now() - tunnelStart < tunnelWaitMs) {
-      try {
-        const res = await fetch(`${agentUrl}/api/agent/tunnel`);
-        if (res.ok) {
-          const data = await res.json();
-          if (data.tunnelUrl) {
-            tunnelUrl = data.tunnelUrl;
-            break;
-          }
-        }
-      } catch {}
-      await new Promise((r) => setTimeout(r, 1000));
-    }
-  }
-  header("Agent Connection Details");
-  kv("Agent URL:", agentUrl);
-  kv("API Key:", apiKey);
-  kv("Tunnel URL:", tunnelUrl === "(not running)" ? colors.yellow(tunnelUrl) : colors.green(tunnelUrl));
-  blank();
-  console.log("  Copy the API Key and Tunnel URL into the VibeControls UI agent configuration.");
-  if (tunnelUrl === "(not running)") {
-    console.log(`  Start a tunnel manually: ${colors.bold(`vibe tunnel agent --start --agent-url ${agentUrl}`)}`);
-  }
-  blank();
-}
-// src/services/service-manager.ts
-import { spawn } from "child_process";
-import { promisify } from "util";
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  openSync,
-  closeSync
-} from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import { join } from "path";
 import { homedir } from "os";
-import { exec } from "child_process";
-var execAsync = promisify(exec);
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname(__filename2);
 
-class ServiceManager {
-  registryPath;
-  logsDir;
-  constructor() {
-    const configDir = join(homedir(), ".vibecontrols");
-    this.registryPath = join(configDir, "agents.json");
-    this.logsDir = join(configDir, "logs");
-    mkdirSync(configDir, { recursive: true });
-    mkdirSync(this.logsDir, { recursive: true });
-  }
-  async startDaemon(config) {
-    const existing = await this.findProcessByName(config.name);
-    if (existing && existing.status === "running") {
-      console.log(`\u26A0\uFE0F  Agent '${config.name}' is already running on port ${existing.port}`);
-      return;
-    }
-    const logFile = join(this.logsDir, `${config.name}.log`);
-    const logFd = openSync(logFile, "a");
-    const indexPath = join(__dirname2, "..", "index.js");
-    const child = spawn("bun", ["run", indexPath], {
-      detached: true,
-      stdio: ["ignore", logFd, logFd],
-      env: {
-        ...process.env,
-        PORT: config.port.toString(),
-        DB_PATH: config.dbPath,
-        NODE_ENV: "production"
-      }
-    });
-    closeSync(logFd);
-    child.unref();
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-    const isRunning = await this.isProcessRunning(child.pid);
-    if (!isRunning) {
-      throw new Error(`Failed to start agent '${config.name}'`);
-    }
-    await this.saveProcessInfo(config.name, child.pid, config);
-    console.log(`\uD83D\uDE80 Agent '${config.name}' started (PID: ${child.pid}, Port: ${config.port})`);
-  }
-  async stop(name) {
-    const agentProcess = await this.findProcessByName(name);
-    if (!agentProcess || agentProcess.status !== "running") {
-      console.log(`\u26A0\uFE0F  Agent '${name}' is not running`);
-      return;
-    }
-    try {
-      process.kill(agentProcess.pid, "SIGTERM");
-      await new Promise((resolve) => setTimeout(resolve, 3000));
-      const stillRunning = await this.isProcessRunning(agentProcess.pid);
-      if (stillRunning) {
-        process.kill(agentProcess.pid, "SIGKILL");
-      }
-      await this.updateProcessStatus(name, "stopped");
-      console.log(`\u2705 Agent '${name}' stopped`);
-    } catch (err) {
-      throw new Error(`Failed to stop agent '${name}': ${err}`, { cause: err });
-    }
-  }
-  async restart(name, config) {
-    const existing = await this.findProcessByName(name);
-    if (existing && existing.status === "running") {
-      await this.stop(name);
-    }
-    await this.startDaemon(config);
-    console.log(`\uD83D\uDD04 Agent '${name}' restarted`);
-  }
-  async kill(name) {
-    const agentProcess = await this.findProcessByName(name);
-    if (!agentProcess || agentProcess.status !== "running") {
-      console.log(`\u26A0\uFE0F  Agent '${name}' is not running`);
-      return;
-    }
-    await this.killProcessTree(agentProcess.pid);
-    await this.updateProcessStatus(name, "stopped");
-    console.log(`\uD83D\uDC80 Agent '${name}' killed`);
-  }
-  async getStatus(name) {
-    return this.findProcessByName(name);
-  }
-  async getStatusAll() {
-    const registry = this.loadRegistry();
-    const processes = [];
-    for (const processInfo of registry) {
-      const isRunning = await this.isProcessRunning(processInfo.pid);
-      processes.push({
-        ...processInfo,
-        status: isRunning ? "running" : "stopped"
-      });
-    }
-    return processes;
-  }
-  async listInstances() {
-    return this.getStatusAll();
-  }
-  async showLogs(name, options) {
-    const logFile = join(this.logsDir, `${name}.log`);
-    if (!existsSync(logFile)) {
-      console.log(`No logs found for agent '${name}'`);
-      return;
-    }
-    if (options.follow) {
-      const tail = spawn("tail", [
-        "-f",
-        "-n",
-        options.tail.toString(),
-        logFile
-      ]);
-      tail.stdout?.on("data", (data) => process.stdout.write(data));
-      tail.stderr?.on("data", (data) => process.stderr.write(data));
-      process.on("SIGINT", () => {
-        tail.kill();
-        process.exit(0);
-      });
-    } else {
-      try {
-        const { stdout } = await execAsync(`tail -n ${options.tail} "${logFile}"`);
-        console.log(stdout);
-      } catch (err) {
-        console.error("Failed to read logs:", err);
-      }
-    }
-  }
-  async checkHealth(name) {
-    const proc = await this.findProcessByName(name);
-    if (!proc || proc.status !== "running") {
-      return { healthy: false, details: { error: "Process not running" } };
-    }
+// src/services/port-utils.ts
+function isPortAvailable(port, host = "0.0.0.0") {
+  return new Promise((resolve) => {
     try {
-      const response = await fetch(`http://localhost:${proc.port}/health`);
-      const data = await response.json();
-      return { healthy: response.ok, details: data };
-    } catch (err) {
-      return {
-        healthy: false,
-        details: {
-          error: "Health check failed",
-          message: err.message
+      const server = Bun.listen({
+        hostname: host,
+        port,
+        socket: {
+          data() {}
         }
-      };
-    }
-  }
-  async setConfig(key, value) {
-    const configFile = join(homedir(), ".vibecontrols", "config.json");
-    let config = {};
-    if (existsSync(configFile)) {
-      config = JSON.parse(readFileSync(configFile, "utf8"));
-    }
-    config[key] = value;
-    writeFileSync(configFile, JSON.stringify(config, null, 2));
-  }
-  async getConfig(key) {
-    const configFile = join(homedir(), ".vibecontrols", "config.json");
-    if (!existsSync(configFile))
-      return key ? undefined : {};
-    const config = JSON.parse(readFileSync(configFile, "utf8"));
-    return key ? config[key] : config;
-  }
-  loadRegistry() {
-    if (!existsSync(this.registryPath))
-      return [];
-    try {
-      return JSON.parse(readFileSync(this.registryPath, "utf8"));
-    } catch {
-      return [];
-    }
-  }
-  saveRegistry(processes) {
-    writeFileSync(this.registryPath, JSON.stringify(processes, null, 2));
-  }
-  async saveProcessInfo(name, pid, config) {
-    const registry = this.loadRegistry();
-    const filtered = registry.filter((p) => p.name !== name);
-    filtered.push({
-      name,
-      pid,
-      port: config.port,
-      config,
-      startTime: new Date().toISOString(),
-      status: "running"
-    });
-    this.saveRegistry(filtered);
-  }
-  async updateProcessStatus(name, status) {
-    const registry = this.loadRegistry();
-    const proc = registry.find((p) => p.name === name);
-    if (proc) {
-      proc.status = status;
-      this.saveRegistry(registry);
-    }
-  }
-  async findProcessByName(name) {
-    const registry = this.loadRegistry();
-    const proc = registry.find((p) => p.name === name);
-    if (!proc)
-      return null;
-    const isRunning = await this.isProcessRunning(proc.pid);
-    proc.status = isRunning ? "running" : "stopped";
-    return proc;
-  }
-  async isProcessRunning(pid) {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async killProcessTree(pid) {
-    try {
-      process.kill(-pid, "SIGKILL");
+      });
+      server.stop(true);
+      resolve(true);
     } catch {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {}
+      resolve(false);
     }
-  }
-}
-
-// src/services/port-utils.ts
-import { createServer } from "net";
-function isPortAvailable(port, host = "0.0.0.0") {
-  return new Promise((resolve) => {
-    const server = createServer();
-    server.once("error", () => resolve(false));
-    server.once("listening", () => {
-      server.close(() => resolve(true));
-    });
-    server.listen(port, host);
   });
 }
 async function findFreePortFrom(startPort, host = "0.0.0.0") {
@@ -2682,12 +2183,12 @@ async function findFreePortFrom(startPort, host = "0.0.0.0") {
 
 // src/cli/commands/start.cmd.ts
 function register(program2) {
-  program2.command("start").description("Start a VibeControls agent instance").option("-p, --port <port>", "Port to listen on", "3005").option("-n, --name <name>", "Agent instance name", "default").option("-d, --daemon", "Run as a background daemon", false).option("--db-path <path>", "Path to the SQLite database", "./vibecontrols-agent.db").option("--host <host>", "Host to bind to", "0.0.0.0").action(async (opts) => {
+  program2.command("start").description("Start a VibeControls agent instance").option("-p, --port <port>", "Port to listen on", "3005").option("-n, --name <name>", "Agent instance name", "default").option("-f, --foreground", "Run in foreground mode (default: daemon)", false).option("--db-path <path>", "Path to the SQLite database", "./vibecontrols-agent.db").option("--host <host>", "Host to bind to", "0.0.0.0").action(async (opts) => {
     try {
       const serviceManager = new ServiceManager;
       const dbPath = opts.dbPath;
-      const configDir = join2(homedir2(), ".vibecontrols");
-      const firstRun = !existsSync2(dbPath) && !existsSync2(join2(configDir, "agents.json"));
+      const configDir = join(homedir(), ".vibecontrols");
+      const firstRun = !existsSync(dbPath) && !existsSync(join(configDir, "agents.json"));
       if (firstRun) {
         info("First run detected \u2014 running setup...");
         blank();
@@ -2720,47 +2221,49 @@ function register(program2) {
       }
       const host = opts.host;
       const agentUrl = `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`;
-      if (opts.daemon) {
-        header("Starting agent in daemon mode");
-        kv("Name", opts.name);
-        kv("Port", String(port));
-        kv("Host", host);
-        kv("Database", dbPath);
-        blank();
-        await serviceManager.startDaemon({
-          port,
-          name: opts.name,
-          daemon: true,
-          dbPath,
-          host
-        });
-        await printAgentDetails(agentUrl);
-      } else {
+      if (opts.foreground) {
         header("Starting agent in foreground");
         kv("Name", opts.name);
         kv("Port", String(port));
         kv("Host", host);
         kv("Database", dbPath);
         blank();
-        const { createApp } = await import("./app-31chs2a1.js");
+        const { createApp } = await import("./app-sm6n9xst.js");
         const appInstance = await createApp({
           port,
           host,
           dbPath
         });
         await appInstance.start();
+        await printAgentDetails(agentUrl);
         const shutdown = async () => {
           await appInstance.stop();
           process.exit(0);
         };
         process.on("SIGTERM", shutdown);
         process.on("SIGINT", shutdown);
+      } else {
+        header("Starting agent in daemon mode");
+        kv("Name", opts.name);
+        kv("Port", String(port));
+        kv("Host", host);
+        kv("Database", dbPath);
+        blank();
+        await serviceManager.startDaemon({
+          port,
+          name: opts.name,
+          daemon: true,
+          dbPath,
+          host
+        });
+        await printAgentDetails(agentUrl);
       }
     } catch (err) {
       fail(`Failed to start agent: ${err instanceof Error ? err.message : err}`);
     }
   });
 }
+
 // src/cli/commands/stop.cmd.ts
 function register2(program2) {
   program2.command("stop").description("Stop a running VibeControls agent instance").option("-n, --name <name>", "Agent instance name", "default").option("--all", "Stop all running agent instances", false).action(async (opts) => {
@@ -2797,6 +2300,7 @@ function register2(program2) {
     }
   });
 }
+
 // src/cli/commands/restart.cmd.ts
 function register3(program2) {
   program2.command("restart").description("Restart a running VibeControls agent instance").option("-n, --name <name>", "Agent instance name", "default").option("-p, --port <port>", "Port to listen on", "3005").option("--db-path <path>", "Path to the SQLite database", "./vibecontrols-agent.db").action(async (opts) => {
@@ -2838,54 +2342,49 @@ function register3(program2) {
     }
   });
 }
-// src/cli/commands/status.cmd.ts
+
+// src/cli/commands/kill.cmd.ts
 function register4(program2) {
-  program2.command("status").description("Show status of VibeControls agent instance(s)").option("-n, --name <name>", "Agent instance name").action(async (opts) => {
+  program2.command("kill").description("Force kill a VibeControls agent instance").option("-n, --name <name>", "Agent instance name", "default").option("--all", "Kill all agent instances", false).action(async (opts) => {
     try {
       const serviceManager = new ServiceManager;
-      if (opts.name) {
-        header(`Agent Status: ${opts.name}`);
+      if (opts.all) {
+        header("Force killing all agent instances");
         blank();
-        const instance = await serviceManager.getStatus(opts.name);
-        if (!instance) {
-          fail(`Agent instance ${colors.bold(opts.name)} not found.`);
+        const instances = await serviceManager.listInstances();
+        if (!instances || instances.length === 0) {
+          info(`${icons.info} No agent instances found.`);
           return;
         }
-        kv("Name", instance.name);
-        kv("Status", formatStatus(instance.status));
-        kv("PID", instance.pid ? String(instance.pid) : colors.dim("n/a"));
-        kv("Port", instance.port ? String(instance.port) : colors.dim("n/a"));
-        kv("Host", instance.config?.host || colors.dim("n/a"));
-        kv("Database", instance.config?.dbPath || colors.dim("n/a"));
-        if (instance.startTime) {
-          kv("Started", timeAgo(instance.startTime));
+        let killed = 0;
+        for (const instance of instances) {
+          try {
+            await serviceManager.kill(instance.name);
+            success(`${icons.success} Killed ${colors.bold(instance.name)} (PID: ${instance.pid || "unknown"})`);
+            killed++;
+          } catch {
+            warn(`${icons.warning} Could not kill ${colors.bold(instance.name)}`);
+          }
         }
         blank();
+        success(`${icons.success} Killed ${killed}/${instances.length} instance(s).`);
       } else {
-        header("Agent Instances");
+        header(`Force killing agent: ${opts.name}`);
         blank();
-        const instances = await serviceManager.listInstances();
-        if (!instances || instances.length === 0) {
-          info(`${icons.info} No agent instances found.`);
-          info(`Run ${colors.bold("vibe start")} to start an agent.`);
+        const instance = await serviceManager.getStatus(opts.name);
+        if (!instance) {
+          fail(`Agent instance ${colors.bold(opts.name)} not found.`);
           return;
         }
-        const rows = instances.map((inst) => ({
-          Name: inst.name,
-          Status: formatStatus(inst.status),
-          PID: inst.pid || "-",
-          Port: inst.port || "-",
-          Started: inst.startTime ? timeAgo(inst.startTime) : "-"
-        }));
-        formatTable(rows);
-        blank();
-        info(`${icons.info} ${instances.length} instance(s) found. Use ${colors.bold("vibe status -n <name>")} for details.`);
+        await serviceManager.kill(opts.name);
+        success(`${icons.success} Agent ${colors.bold(opts.name)} killed (PID: ${instance.pid || "unknown"}).`);
       }
     } catch (err) {
-      fail(`Failed to get status: ${err.message}`);
+      fail(`Failed to kill agent: ${err.message}`);
     }
   });
 }
+
 // src/cli/commands/list.cmd.ts
 function register5(program2) {
   program2.command("list").alias("ls").description("List all VibeControls agent instances").action(async () => {
@@ -2918,49 +2417,9 @@ function register5(program2) {
     }
   });
 }
-// src/cli/commands/kill.cmd.ts
-function register6(program2) {
-  program2.command("kill").description("Force kill a VibeControls agent instance").option("-n, --name <name>", "Agent instance name", "default").option("--all", "Kill all agent instances", false).action(async (opts) => {
-    try {
-      const serviceManager = new ServiceManager;
-      if (opts.all) {
-        header("Force killing all agent instances");
-        blank();
-        const instances = await serviceManager.listInstances();
-        if (!instances || instances.length === 0) {
-          info(`${icons.info} No agent instances found.`);
-          return;
-        }
-        let killed = 0;
-        for (const instance of instances) {
-          try {
-            await serviceManager.kill(instance.name);
-            success(`${icons.success} Killed ${colors.bold(instance.name)} (PID: ${instance.pid || "unknown"})`);
-            killed++;
-          } catch {
-            warn(`${icons.warning} Could not kill ${colors.bold(instance.name)}`);
-          }
-        }
-        blank();
-        success(`${icons.success} Killed ${killed}/${instances.length} instance(s).`);
-      } else {
-        header(`Force killing agent: ${opts.name}`);
-        blank();
-        const instance = await serviceManager.getStatus(opts.name);
-        if (!instance) {
-          fail(`Agent instance ${colors.bold(opts.name)} not found.`);
-          return;
-        }
-        await serviceManager.kill(opts.name);
-        success(`${icons.success} Agent ${colors.bold(opts.name)} killed (PID: ${instance.pid || "unknown"}).`);
-      }
-    } catch (err) {
-      fail(`Failed to kill agent: ${err.message}`);
-    }
-  });
-}
+
 // src/cli/commands/logs.cmd.ts
-function register7(program2) {
+function register6(program2) {
   program2.command("logs").description("View logs for a VibeControls agent instance").option("-n, --name <name>", "Agent instance name", "default").option("-f, --follow", "Follow log output", false).option("--tail <lines>", "Number of lines to show from the end", "100").action(async (opts) => {
     try {
       const serviceManager = new ServiceManager;
@@ -2989,134 +2448,13 @@ function register7(program2) {
     }
   });
 }
-// src/cli/commands/key.cmd.ts
-var DEFAULT_AGENT_URL2 = "http://localhost:3005";
-function register8(program2) {
-  program2.command("key").description("Get the API key for a running VibeControls agent").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL2).action(async (opts) => {
+
+// src/cli/commands/setup.cmd.ts
+function register7(program2) {
+  program2.command("setup").description("Install or verify system dependencies (tmux, ttyd, cloudflared)").option("--check", "Only check without installing", false).action(async (options) => {
     try {
-      const agentUrl = getAgentUrl(opts);
-      header("Agent API Key");
-      blank();
-      const data = await apiGet(agentUrl, "/api/agent/api-key");
-      kv("API Key", colors.bold(data.apiKey));
-      blank();
-    } catch (err) {
-      fail(`Failed to get API key: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/health.cmd.ts
-var DEFAULT_AGENT_URL3 = "http://localhost:3005";
-function register9(program2) {
-  program2.command("health").description("Check health of a VibeControls agent instance").option("-n, --name <name>", "Agent instance name").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL3).action(async (opts) => {
-    try {
-      header("Agent Health");
-      blank();
-      if (opts.name) {
-        const serviceManager = new ServiceManager;
-        const result = await serviceManager.checkHealth(opts.name);
-        if (!result.healthy) {
-          fail(`Agent instance ${colors.bold(opts.name)} is not responding.`);
-          return;
-        }
-        const details = result.details;
-        kv("Instance", opts.name);
-        kv("Status", formatStatus(details.status ?? "healthy"));
-        if (details.uptime !== undefined) {
-          kv("Uptime", `${details.uptime}s`);
-        }
-        if (details.checks) {
-          blank();
-          info(`${icons.info} Health checks:`);
-          for (const [name, check] of Object.entries(details.checks)) {
-            const icon = check.status === "healthy" ? icons.success : icons.error;
-            kv(`  ${icon} ${name}`, formatStatus(check.status));
-          }
-        }
-      } else {
-        const agentUrl = getAgentUrl(opts);
-        const data = await apiGet(agentUrl, "/health");
-        kv("URL", agentUrl);
-        kv("Status", formatStatus(data.status));
-        if (data.version) {
-          kv("Version", data.version);
-        }
-        if (data.uptime !== undefined) {
-          kv("Uptime", `${data.uptime}s`);
-        }
-        if (data.timestamp) {
-          kv("Timestamp", data.timestamp);
-        }
-        if (data.checks) {
-          blank();
-          info(`${icons.info} Health checks:`);
-          for (const [name, check] of Object.entries(data.checks)) {
-            const icon = check.status === "healthy" ? icons.success : icons.error;
-            kv(`  ${icon} ${name}`, formatStatus(check.status));
-          }
-        }
-      }
-      blank();
-      success(`${icons.success} Agent is healthy.`);
-    } catch (err) {
-      fail(`Health check failed: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/info.cmd.ts
-import { platform, arch, release, hostname, cpus, totalmem } from "os";
-var DEFAULT_AGENT_URL4 = "http://localhost:3005";
-function register10(program2) {
-  program2.command("info").description("Show local and remote VibeControls agent information").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL4).action(async (opts) => {
-    try {
-      header("VibeControls Agent Info");
-      blank();
-      info(`${icons.info} Local System`);
-      kv("Hostname", hostname());
-      kv("Platform", `${platform()} ${arch()}`);
-      kv("OS Release", release());
-      kv("CPUs", String(cpus().length));
-      kv("Total Memory", formatBytes(totalmem()));
-      kv("Node.js", process.version);
-      if (process.versions.bun) {
-        kv("Bun", process.versions.bun);
-      }
-      blank();
-      const agentUrl = getAgentUrl(opts);
-      try {
-        const data = await apiGet(agentUrl, "/api/agent/version");
-        info(`${icons.info} Remote Agent`);
-        kv("URL", agentUrl);
-        kv("Version", colors.bold(data.version));
-        if (data.build) {
-          kv("Build", data.build);
-        }
-        if (data.commit) {
-          kv("Commit", data.commit);
-        }
-        if (data.nodeVersion) {
-          kv("Node.js (remote)", data.nodeVersion);
-        }
-        if (data.bunVersion) {
-          kv("Bun (remote)", data.bunVersion);
-        }
-      } catch {
-        info(`${icons.info} Remote Agent`);
-        kv("URL", agentUrl);
-        kv("Status", colors.dim("not reachable"));
-      }
-      blank();
-    } catch (err) {
-      fail(`Failed to get info: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/setup.cmd.ts
-function register11(program2) {
-  program2.command("setup").description("Install or verify system dependencies (tmux, ttyd, cloudflared)").option("--check", "Only check without installing", false).action(async (options) => {
-    try {
-      header("VibeControls Agent Setup");
-      info("Checking dependencies...");
+      header("VibeControls Agent Setup");
+      info("Checking dependencies...");
       blank();
       const deps = checkDependencies();
       const missing = [];
@@ -3154,17 +2492,17 @@ function register11(program2) {
     }
   });
 }
+
 // src/cli/commands/update.cmd.ts
-import { execSync } from "child_process";
 var PACKAGE_NAME = "vibecontrols-agent";
-function register12(program2) {
+function register8(program2) {
   program2.command("update").description("Check for and install VibeControls agent updates").option("--check", "Only check for updates without installing", false).action(async (opts) => {
     try {
       header("VibeControls Agent Update");
       blank();
       let currentVersion;
       try {
-        const pkg = await import("./package-hb6db316.js", {
+        const pkg = await import("./package-04nkt49b.js", {
           with: { type: "json" }
         });
         currentVersion = pkg.default.version || pkg.version;
@@ -3175,9 +2513,10 @@ function register12(program2) {
       blank();
       let latestVersion;
       try {
-        latestVersion = execSync(`npm view ${PACKAGE_NAME} version`, {
-          encoding: "utf-8"
-        }).trim();
+        const result = Bun.spawnSync(["npm", "view", PACKAGE_NAME, "version"], { stdout: "pipe", stderr: "pipe" });
+        if (result.exitCode !== 0)
+          throw new Error("npm view failed");
+        latestVersion = result.stdout.toString().trim();
       } catch {
         fail(`Could not check for updates. Ensure you have internet connectivity and npm is available.`);
         return;
@@ -3197,10 +2536,9 @@ function register12(program2) {
       info(`${icons.info} Updating to ${colors.bold(latestVersion)}...`);
       blank();
       try {
-        execSync(`npm install -g ${PACKAGE_NAME}@${latestVersion}`, {
-          encoding: "utf-8",
-          stdio: "inherit"
-        });
+        const installResult = Bun.spawnSync(["npm", "install", "-g", `${PACKAGE_NAME}@${latestVersion}`], { stdout: "inherit", stderr: "inherit" });
+        if (installResult.exitCode !== 0)
+          throw new Error("install failed");
       } catch {
         fail(`Failed to install update. Try running with sudo: ${colors.bold(`sudo npm install -g ${PACKAGE_NAME}@${latestVersion}`)}`);
         return;
@@ -3213,1221 +2551,17 @@ function register12(program2) {
     }
   });
 }
-// src/cli/commands/system.cmd.ts
-var DEFAULT_AGENT_URL5 = "http://localhost:3005";
-function register13(program2) {
-  program2.command("system").description("Show system information for a running VibeControls agent").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL5).action(async (opts) => {
-    try {
-      const agentUrl = getAgentUrl(opts);
-      header("Agent System Information");
-      blank();
-      const data = await apiGet(agentUrl, "/api/agent/system");
-      info(`${icons.info} Agent`);
-      kv("Version", colors.bold(data.agentVersion));
-      if (data.bunVersion) {
-        kv("Bun", data.bunVersion);
-      }
-      if (data.environment) {
-        kv("Environment", data.environment);
-      }
-      kv("Uptime", formatDuration(data.uptime));
-      blank();
-      info(`${icons.info} Platform`);
-      kv("OS", `${data.platform} ${data.arch}`);
-      kv("Hostname", data.hostname);
-      kv("Release", data.release);
-      blank();
-      info(`${icons.info} Resources`);
-      kv("CPUs", String(data.cpus));
-      kv("Total Memory", formatBytes(data.totalMemory));
-      kv("Free Memory", formatBytes(data.freeMemory));
-      blank();
-      info(`${icons.info} Paths`);
-      kv("Home", data.homeDir);
-      kv("CWD", data.cwd);
-      blank();
-    } catch (err) {
-      fail(`Failed to get system info: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/url.cmd.ts
-var DEFAULT_AGENT_URL6 = "http://localhost:3005";
-function register14(program2) {
-  program2.command("url").description("Show the active URL for a running VibeControls agent").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL6).action(async (opts) => {
-    try {
-      const agentUrl = getAgentUrl(opts);
-      header("Agent URL");
-      blank();
-      const data = await apiGet(agentUrl, "/api/agent/url");
-      kv("Active URL", colors.bold(data.url));
-      kv("Local URL", data.localUrl);
-      if (data.tunnelUrl) {
-        kv("Tunnel URL", colors.cyan(data.tunnelUrl));
-      }
-      kv("Mode", data.isTunnel ? `${icons.running} Tunnel active` : `${icons.info} Local only`);
-      blank();
-      if (data.isTunnel) {
-        info(`${icons.info} Agent is accessible via tunnel at ${colors.bold(data.tunnelUrl)}`);
-      } else {
-        info(`${icons.info} Agent is running locally at ${colors.bold(data.localUrl)}`);
-      }
-    } catch (err) {
-      fail(`Failed to get URL: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/config.cmd.ts
-var DEFAULT_AGENT_URL7 = "http://localhost:3005";
-function register15(program2) {
-  program2.command("config").description("Manage VibeControls agent configuration").option("--set <key=value>", "Set a configuration value").option("--get <key>", "Get a configuration value").option("--delete <key>", "Delete a configuration value").option("--list", "List all configuration values", false).option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL7).action(async (opts) => {
-    try {
-      const agentUrl = getAgentUrl(opts);
-      if (opts.set) {
-        const eqIndex = opts.set.indexOf("=");
-        if (eqIndex === -1) {
-          fail(`Invalid format. Use ${colors.bold("--set key=value")}`);
-          return;
-        }
-        const key = opts.set.slice(0, eqIndex).trim();
-        const value = opts.set.slice(eqIndex + 1).trim();
-        if (!key) {
-          fail("Configuration key cannot be empty.");
-          return;
-        }
-        try {
-          await apiPut(agentUrl, `/api/config/${encodeURIComponent(key)}`, {
-            value
-          });
-        } catch {
-          await apiPost(agentUrl, "/api/config/", { key, value });
-        }
-        success(`${icons.success} Set ${colors.bold(key)} = ${colors.cyan(value)}`);
-      } else if (opts.get) {
-        header("Configuration");
-        blank();
-        const data = await apiGet(agentUrl, `/api/config/${encodeURIComponent(opts.get)}`);
-        kv(data.key, colors.bold(data.value));
-        blank();
-      } else if (opts.delete) {
-        await apiDelete(agentUrl, `/api/config/${encodeURIComponent(opts.delete)}`);
-        success(`${icons.success} Deleted configuration key: ${colors.bold(opts.delete)}`);
-      } else if (opts.list) {
-        header("Agent Configuration");
-        blank();
-        const data = await apiGet(agentUrl, "/api/config/");
-        if (!data.configs || data.configs.length === 0) {
-          info(`${icons.info} No configuration entries found.`);
-          return;
-        }
-        const rows = data.configs.map((c) => ({
-          Key: c.key,
-          Value: c.value
-        }));
-        formatTable(rows);
-        blank();
-        info(`${icons.info} ${data.configs.length} configuration(s) found.`);
-      } else {
-        info(`${icons.info} Usage:`);
-        info(`  ${colors.bold("vibe config --list")}              List all config values`);
-        info(`  ${colors.bold("vibe config --get <key>")}         Get a config value`);
-        info(`  ${colors.bold("vibe config --set <key=value>")}   Set a config value`);
-        info(`  ${colors.bold("vibe config --delete <key>")}      Delete a config value`);
-      }
-    } catch (err) {
-      fail(`Config operation failed: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/gateway-auth.cmd.ts
-var DEFAULT_AGENT_URL8 = "http://localhost:3005";
-function register16(program2) {
-  const gatewayAuth = program2.command("gateway-auth").description("Manage gateway authentication for VibeControls agent");
-  gatewayAuth.command("configure").description("Configure gateway authentication credentials").requiredOption("--global-url <url>", "Global gateway URL").requiredOption("--workspace-url <url>", "Workspace gateway URL").requiredOption("--client-id <id>", "OAuth client ID").requiredOption("--client-secret <secret>", "OAuth client secret").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL8).action(async (opts) => {
-    try {
-      const agentUrl = getAgentUrl(opts);
-      header("Configure Gateway Authentication");
-      blank();
-      info(`${icons.info} Sending gateway auth configuration...`);
-      blank();
-      const data = await apiPost(agentUrl, "/api/agent/gateway-auth", {
-        globalUrl: opts.globalUrl,
-        workspaceUrl: opts.workspaceUrl,
-        clientId: opts.clientId,
-        clientSecret: opts.clientSecret
-      });
-      if (data.success) {
-        success(`${icons.success} Gateway authentication configured successfully.`);
-        blank();
-        kv("Global URL", opts.globalUrl);
-        kv("Workspace URL", opts.workspaceUrl);
-        kv("Client ID", opts.clientId);
-        kv("Client Secret", colors.dim("********"));
-      } else {
-        fail(data.message || "Failed to configure gateway authentication.");
-      }
-      blank();
-    } catch (err) {
-      fail(`Failed to configure gateway auth: ${err.message}`);
-    }
-  });
-  gatewayAuth.command("status").description("Check gateway authentication status").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL8).action(async (opts) => {
-    try {
-      const agentUrl = getAgentUrl(opts);
-      header("Gateway Authentication Status");
-      blank();
-      const data = await apiGet(agentUrl, "/api/agent/gateway-auth");
-      kv("Configured", data.configured ? `${icons.success} ${colors.green("Yes")}` : `${icons.error} ${colors.red("No")}`);
-      if (data.configured) {
-        kv("Global URL", data.globalUrl || colors.dim("n/a"));
-        kv("Workspace URL", data.workspaceUrl || colors.dim("n/a"));
-        kv("Client ID", data.clientId || colors.dim("n/a"));
-        kv("Authenticated", data.authenticated ? `${icons.success} ${colors.green("Yes")}` : `${icons.error} ${colors.red("No")}`);
-        if (data.tokenExpiresAt) {
-          kv("Token Expires", data.tokenExpiresAt);
-        }
-      } else {
-        blank();
-        info(`${icons.info} Run ${colors.bold("vibe gateway-auth configure")} to set up gateway authentication.`);
-      }
-      blank();
-    } catch (err) {
-      fail(`Failed to get gateway auth status: ${err.message}`);
-    }
-  });
-}
-// src/cli/commands/session.cmd.ts
-var DEFAULT_AGENT_URL9 = "http://localhost:3005";
-function register17(program2) {
-  const cmd = program2.command("session").description("Manage terminal sessions");
-  cmd.command("list").description("List all sessions").option("--system", "Show system sessions instead of user sessions").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const endpoint = options.system ? "/api/sessions?system=true" : "/api/sessions";
-      const sessions = await apiGet(url, endpoint);
-      if (!sessions || sessions.length === 0) {
-        info("No sessions found.");
-        return;
-      }
-      header("Sessions");
-      formatTable(sessions.map((s) => ({
-        ID: shortId(s.id),
-        Name: s.name || "-",
-        Status: formatStatus(s.status),
-        Port: s.port ?? "-",
-        Project: s.project || s.projectId || "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("create").description("Create a new session").requiredOption("--name <name>", "Session name").option("--project <id>", "Project ID", "default").option("--command <cmd>", "Initial command to run").option("--cwd <dir>", "Working directory").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {
-        name: options.name,
-        project: options.project
-      };
-      if (options.command)
-        body.command = options.command;
-      if (options.cwd)
-        body.cwd = options.cwd;
-      const result = await apiPost(url, "/api/sessions/create", body);
-      success(`Session created: ${shortId(result.id || result.sessionId)}`);
-      kv("Name", options.name);
-      kv("Project", options.project);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("kill").description("Kill a session").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/sessions/${options.id}`);
-      success(`Session ${shortId(options.id)} killed.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("exec").description("Execute a command in a session").requiredOption("-i, --id <id>", "Session ID").requiredOption("-c, --command <cmd>", "Command to execute").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, `/api/sessions/${options.id}/command`, { command: options.command });
-      success("Command executed.");
-      if (result?.output) {
-        blank();
-        console.log(result.output);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("capture").description("Capture session terminal output").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiGet(url, `/api/sessions/${options.id}/capture`);
-      if (result?.content || result?.output) {
-        console.log(result.content || result.output);
-      } else {
-        info("No capture data available.");
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("keys").description("Send keys to a session").requiredOption("-i, --id <id>", "Session ID").requiredOption("-k, --keys <keys>", "Keys to send").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, `/api/sessions/${options.id}/keys`, {
-        keys: options.keys
-      });
-      success("Keys sent.");
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("interrupt").description("Send interrupt signal to a session").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, `/api/sessions/${options.id}/interrupt`, {});
-      success(`Session ${shortId(options.id)} interrupted.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("rename").description("Rename a session").requiredOption("-i, --id <id>", "Session ID").requiredOption("--name <name>", "New session name").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPut(url, `/api/sessions/${options.id}/rename`, {
-        name: options.name
-      });
-      success(`Session ${shortId(options.id)} renamed to "${options.name}".`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("toggle-mouse").description("Toggle mouse support in a session").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, `/api/sessions/${options.id}/toggle-mouse`, {});
-      success(`Mouse support ${result?.mouseEnabled ? "enabled" : "toggled"} for session ${shortId(options.id)}.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("terminal-start").description("Start terminal for a session").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, `/api/sessions/${options.id}/terminal`, {});
-      success(`Terminal started for session ${shortId(options.id)}.`);
-      if (result?.port)
-        kv("Port", result.port);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("terminal-stop").description("Stop terminal for a session").requiredOption("-i, --id <id>", "Session ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, `/api/sessions/${options.id}/terminal/stop`, {});
-      success(`Terminal stopped for session ${shortId(options.id)}.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("health-check").description("Run health check on all sessions").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL9).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/sessions/health-check", {});
-      success("Health check completed.");
-      if (result?.healthy !== undefined)
-        kv("Healthy", result.healthy);
-      if (result?.checked !== undefined)
-        kv("Checked", result.checked);
-      if (result?.fixed !== undefined)
-        kv("Fixed", result.fixed);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/tunnel.cmd.ts
-var DEFAULT_AGENT_URL10 = "http://localhost:3005";
-function register18(program2) {
-  const cmd = program2.command("tunnel").description("Manage tunnels for exposing local ports");
-  cmd.command("list").description("List all tunnels").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const tunnels = await apiGet(url, "/api/tunnels");
-      if (!tunnels || tunnels.length === 0) {
-        info("No tunnels found.");
-        return;
-      }
-      header("Tunnels");
-      formatTable(tunnels.map((t) => ({
-        ID: shortId(t.id),
-        Port: t.port ?? "-",
-        "Public URL": t.publicUrl || t.url || "-",
-        Status: formatStatus(t.status),
-        PID: t.pid ?? "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("start").description("Start a new tunnel").requiredOption("-p, --port <port>", "Local port to expose").option("-s, --subdomain <subdomain>", "Preferred subdomain").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {
-        port: parseInt(options.port, 10)
-      };
-      if (options.subdomain)
-        body.subdomain = options.subdomain;
-      const result = await apiPost(url, "/api/tunnels/start", body);
-      success("Tunnel started.");
-      if (result?.id)
-        kv("ID", shortId(result.id));
-      if (result?.publicUrl || result?.url)
-        kv("Public URL", result.publicUrl || result.url);
-      kv("Port", options.port);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("stop").description("Stop a tunnel").requiredOption("-i, --id <id>", "Tunnel ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, `/api/tunnels/${options.id}/stop`, {});
-      success(`Tunnel ${shortId(options.id)} stopped.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("delete").description("Delete a tunnel").requiredOption("-i, --id <id>", "Tunnel ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/tunnels/${options.id}`);
-      success(`Tunnel ${shortId(options.id)} deleted.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("status").description("Show tunnel status summary").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiGet(url, "/api/tunnels/status");
-      header("Tunnel Status");
-      kv("Total", result?.total ?? 0);
-      kv("Active", result?.active ?? 0);
-      kv("Inactive", result?.inactive ?? 0);
-      kv("Errored", result?.errored ?? 0);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("agent").description("Manage agent tunnel").option("--start", "Start the agent tunnel").option("--stop", "Stop the agent tunnel").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL10).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      if (options.start) {
-        const result = await apiPost(url, "/api/agent/tunnel", {
-          action: "start"
-        });
-        success("Agent tunnel started.");
-        if (result?.publicUrl || result?.url)
-          kv("Public URL", result.publicUrl || result.url);
-      } else if (options.stop) {
-        const result = await apiPost(url, "/api/agent/tunnel", {
-          action: "stop"
-        });
-        success("Agent tunnel stopped.");
-      } else {
-        const result = await apiGet(url, "/api/agent/tunnel");
-        header("Agent Tunnel");
-        kv("Status", formatStatus(result?.status || "unknown"));
-        if (result?.publicUrl || result?.url)
-          kv("Public URL", result.publicUrl || result.url);
-        if (result?.port)
-          kv("Port", result.port);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/task.cmd.ts
-var DEFAULT_AGENT_URL11 = "http://localhost:3005";
-function register19(program2) {
-  const cmd = program2.command("task").description("Manage background tasks");
-  cmd.command("list").description("List tasks").option("--status <status>", "Filter by status").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL11).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const query = options.status ? `/api/tasks/?status=${encodeURIComponent(options.status)}` : "/api/tasks/";
-      const data = await apiGet(url, query);
-      const tasks = data.tasks || [];
-      if (!tasks || tasks.length === 0) {
-        info("No tasks found.");
-        return;
-      }
-      header("Tasks");
-      formatTable(tasks.map((t) => ({
-        ID: shortId(t.id),
-        Type: t.type || "-",
-        Status: formatStatus(t.status),
-        Created: t.createdAt ? timeAgo(t.createdAt) : "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("run").description("Run a new task").requiredOption("-c, --command <cmd>", "Command to run").option("--cwd <dir>", "Working directory").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL11).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const payload = { command: options.command };
-      if (options.cwd)
-        payload.cwd = options.cwd;
-      const body = {
-        type: "command",
-        payload: JSON.stringify(payload)
-      };
-      const result = await apiPost(url, "/api/tasks/", body);
-      success(`Task created: ${shortId(result?.id || result?.taskId)}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("cancel").description("Cancel a running task").requiredOption("-i, --id <id>", "Task ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL11).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPut(url, `/api/tasks/${options.id}/cancel`, {});
-      success(`Task ${shortId(options.id)} cancelled.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/git.cmd.ts
-var DEFAULT_AGENT_URL12 = "http://localhost:3005";
-function register20(program2) {
-  const cmd = program2.command("git").description("Manage git repositories");
-  cmd.command("list").description("List discovered git repositories").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL12).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const data = await apiGet(url, "/api/git");
-      const repos = data.repositories || [];
-      if (!repos || repos.length === 0) {
-        info("No git repositories found.");
-        return;
-      }
-      header("Git Repositories");
-      formatTable(repos.map((r) => ({
-        ID: shortId(r.id),
-        Name: r.name || "-",
-        Path: r.path || "-",
-        Type: r.type || r.projectType || "-",
-        Submodule: r.isSubmodule ? "Yes" : "No",
-        Scanned: r.scannedAt ? timeAgo(r.scannedAt) : "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("scan").description("Scan a directory for git repositories").requiredOption("--dir <directory>", "Directory to scan").option("--depth <depth>", "Scan depth", "3").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL12).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/git/scan", {
-        directory: options.dir,
-        depth: parseInt(options.depth, 10)
-      });
-      success("Git scan completed.");
-      if (result?.found !== undefined)
-        kv("Repositories found", result.found);
-      if (result?.repositories)
-        kv("Repositories found", result.repositories.length);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("update").description("Update a git repository entry").requiredOption("-i, --id <id>", "Repository ID").option("--vite-port <port>", "Vite dev server port").option("--project-type <type>", "Project type").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL12).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {};
-      if (options.vitePort)
-        body.vitePort = parseInt(options.vitePort, 10);
-      if (options.projectType)
-        body.projectType = options.projectType;
-      await apiPut(url, `/api/git/${options.id}`, body);
-      success(`Repository ${shortId(options.id)} updated.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("delete").description("Delete a git repository entry").requiredOption("-i, --id <id>", "Repository ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL12).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/git/${options.id}`);
-      success(`Repository ${shortId(options.id)} deleted.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("fix-hierarchy").description("Fix repository parent-child hierarchy").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL12).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/git/fix-hierarchy", {});
-      success("Hierarchy fix completed.");
-      if (result?.fixed !== undefined)
-        kv("Fixed", result.fixed);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/file.cmd.ts
-var DEFAULT_AGENT_URL13 = "http://localhost:3005";
-function register21(program2) {
-  const cmd = program2.command("file").description("File system operations via agent");
-  cmd.command("read").description("Read a file").requiredOption("--path <path>", "File path to read").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/files/read", {
-        path: options.path
-      });
-      if (result?.content !== undefined) {
-        console.log(result.content);
-      } else {
-        info("File is empty or has no content.");
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("write").description("Write content to a file").requiredOption("--path <path>", "File path to write").requiredOption("--content <content>", "Content to write").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, "/api/files/write", {
-        path: options.path,
-        content: options.content
-      });
-      success(`File written: ${options.path}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("list").description("List files in a directory").requiredOption("--path <path>", "Directory path").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/files/list", {
-        path: options.path
-      });
-      const files = result?.files || result;
-      if (!files || Array.isArray(files) && files.length === 0) {
-        info("Directory is empty.");
-        return;
-      }
-      header(`Files in ${options.path}`);
-      formatTable((Array.isArray(files) ? files : []).map((f) => ({
-        Name: f.name || f.filename || "-",
-        Type: f.type || (f.isDirectory ? "directory" : "file"),
-        Size: f.size !== undefined ? formatBytes(f.size) : "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("exists").description("Check if a file exists").requiredOption("--path <path>", "File path to check").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/files/exists", {
-        path: options.path
-      });
-      if (result?.exists) {
-        success(`File exists: ${options.path}`);
-      } else {
-        info(`File does not exist: ${options.path}`);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("delete").description("Delete a file").requiredOption("--path <path>", "File path to delete").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, "/api/files/delete", {
-        path: options.path
-      });
-      success(`File deleted: ${options.path}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("readme").description("Read the README file from a directory").requiredOption("--path <path>", "Directory path").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL13).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/files/readme", {
-        path: options.path
-      });
-      if (result?.content) {
-        console.log(result.content);
-      } else {
-        info("No README found in the specified directory.");
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/bookmark.cmd.ts
-var DEFAULT_AGENT_URL14 = "http://localhost:3005";
-function register22(program2) {
-  const cmd = program2.command("bookmark").description("Manage command bookmarks");
-  cmd.command("list").description("List bookmarks").option("--project <id>", "Filter by project ID").option("--category <cat>", "Filter by category").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL14).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const params = new URLSearchParams;
-      if (options.project)
-        params.set("project", options.project);
-      if (options.category)
-        params.set("category", options.category);
-      const query = params.toString();
-      const endpoint = query ? `/api/bookmarks?${query}` : "/api/bookmarks";
-      const data = await apiGet(url, endpoint);
-      const bookmarks = data.bookmarks || [];
-      if (!bookmarks || bookmarks.length === 0) {
-        info("No bookmarks found.");
-        return;
-      }
-      header("Bookmarks");
-      formatTable(bookmarks.map((b) => ({
-        ID: shortId(b.id),
-        Command: b.command || "-",
-        Description: b.description || "-",
-        Category: b.category || "-",
-        Project: b.project || b.projectId || "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("create").description("Create a new bookmark").requiredOption("-c, --command <cmd>", "Command to bookmark").option("--description <desc>", "Bookmark description").option("--category <cat>", "Category").option("--project <id>", "Project ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL14).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = { command: options.command };
-      if (options.description)
-        body.description = options.description;
-      if (options.category)
-        body.category = options.category;
-      if (options.project)
-        body.project = options.project;
-      const result = await apiPost(url, "/api/bookmarks", body);
-      success(`Bookmark created: ${shortId(result?.id)}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("update").description("Update a bookmark").requiredOption("-i, --id <id>", "Bookmark ID").option("-c, --command <cmd>", "New command").option("--description <desc>", "New description").option("--category <cat>", "New category").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL14).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {};
-      if (options.command)
-        body.command = options.command;
-      if (options.description)
-        body.description = options.description;
-      if (options.category)
-        body.category = options.category;
-      if (Object.keys(body).length === 0) {
-        fail("No fields to update. Provide at least one of --command, --description, or --category.");
-        return;
-      }
-      await apiPut(url, `/api/bookmarks/${options.id}`, body);
-      success(`Bookmark ${shortId(options.id)} updated.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("delete").description("Delete a bookmark").requiredOption("-i, --id <id>", "Bookmark ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL14).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/bookmarks/${options.id}`);
-      success(`Bookmark ${shortId(options.id)} deleted.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("execute").description("Execute a bookmarked command").requiredOption("-i, --id <id>", "Bookmark ID").option("--session <sessionId>", "Session ID to execute in").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL14).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {};
-      if (options.session)
-        body.sessionId = options.session;
-      const result = await apiPost(url, `/api/bookmarks/${options.id}/execute`, body);
-      success(`Bookmark ${shortId(options.id)} executed.`);
-      if (result?.output) {
-        console.log(result.output);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/notify.cmd.ts
-var DEFAULT_AGENT_URL15 = "http://localhost:3005";
-function register23(program2) {
-  const cmd = program2.command("notify").description("Manage notifications");
-  cmd.command("list").description("List notifications").option("--unread", "Show only unread notifications").option("--project <id>", "Filter by project ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const params = new URLSearchParams;
-      if (options.unread)
-        params.set("unread", "true");
-      if (options.project)
-        params.set("project", options.project);
-      const query = params.toString();
-      const endpoint = query ? `/api/notifications?${query}` : "/api/notifications";
-      const data = await apiGet(url, endpoint);
-      const notifications = data.notifications || [];
-      if (!notifications || notifications.length === 0) {
-        info("No notifications found.");
-        return;
-      }
-      header("Notifications");
-      blank();
-      for (const n of notifications) {
-        const icon = formatNotificationType(n.type);
-        const time = n.createdAt ? colors.dim(timeAgo(n.createdAt)) : "";
-        const title = colors.bold(n.title || "Untitled");
-        const id = colors.dim(`[${shortId(n.id)}]`);
-        console.log(`  ${icon} ${title} ${id} ${time}`);
-        if (n.message) {
-          console.log(`    ${n.message}`);
-        }
-        blank();
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("create").description("Create a notification").requiredOption("--title <title>", "Notification title").requiredOption("--message <msg>", "Notification message").option("--type <type>", "Notification type", "info").option("--project <id>", "Project ID").option("--session <name>", "Session name").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {
-        title: options.title,
-        message: options.message,
-        type: options.type
-      };
-      if (options.project)
-        body.project = options.project;
-      if (options.session)
-        body.session = options.session;
-      const result = await apiPost(url, "/api/notifications", body);
-      success(`Notification created: ${shortId(result?.id)}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("delete").description("Delete a notification").requiredOption("-i, --id <id>", "Notification ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/notifications/${options.id}`);
-      success(`Notification ${shortId(options.id)} deleted.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("read-all").description("Mark all notifications as read").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPut(url, "/api/notifications/read-all", {});
-      success("All notifications marked as read.");
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("clear-old").description("Clear old notifications").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, "/api/notifications/clear/old");
-      success("Old notifications cleared.");
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("webhook").description("Send a webhook notification to a session").requiredOption("--session <sessionId>", "Target session ID").option("--title <title>", "Notification title").option("--message <msg>", "Notification message").option("--type <type>", "Notification type", "info").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL15).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const body = {};
-      if (options.title)
-        body.title = options.title;
-      if (options.message)
-        body.message = options.message;
-      if (options.type)
-        body.type = options.type;
-      await apiPost(url, `/api/notifications/webhook/${options.session}`, body);
-      success(`Webhook notification sent to session ${shortId(options.session)}.`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/project.cmd.ts
-var DEFAULT_AGENT_URL16 = "http://localhost:3005";
-function register24(program2) {
-  const cmd = program2.command("project").description("Manage projects");
-  cmd.command("list").description("List all projects").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL16).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const data = await apiGet(url, "/api/projects");
-      const projects = data.projects || [];
-      if (!projects || projects.length === 0) {
-        info("No projects found.");
-        return;
-      }
-      header("Projects");
-      formatTable(projects.map((p) => ({
-        ID: shortId(p.id),
-        Name: p.name || "-",
-        Path: p.path || "-",
-        Type: p.type || p.projectType || "-",
-        Framework: p.framework || "-",
-        "Git Branch": p.gitBranch || p.branch || "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("scan").description("Scan a directory for projects").requiredOption("--dir <directory>", "Directory to scan").option("--depth <depth>", "Scan depth", "3").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL16).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/projects/scan", {
-        directory: options.dir,
-        depth: parseInt(options.depth, 10)
-      });
-      success("Project scan completed.");
-      if (result?.found !== undefined)
-        kv("Projects found", result.found);
-      if (result?.projects)
-        kv("Projects found", result.projects.length);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("scan-remote").description("Scan remote workspace for projects").requiredOption("--workspace-id <id>", "Workspace ID").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL16).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiPost(url, "/api/projects/scan-remote", {
-        workspaceId: options.workspaceId
-      });
-      success("Remote project scan completed.");
-      if (result?.found !== undefined)
-        kv("Projects found", result.found);
-      if (result?.projects)
-        kv("Projects found", result.projects.length);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/plugin.cmd.ts
-var DEFAULT_AGENT_URL17 = "http://localhost:3005";
-function register25(program2) {
-  const cmd = program2.command("plugin").description("Manage plugins");
-  cmd.command("list").description("List installed plugins").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL17).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      let plugins;
-      try {
-        const data = await apiGet(url, "/api/plugins");
-        plugins = data.plugins || [];
-      } catch {
-        warn("Agent not reachable. Attempting local plugin registry...");
-        try {
-          const { PluginManager: PluginManager2 } = await import("./plugin-system-bg1pzjj9.js");
-          const pm = new PluginManager2;
-          plugins = pm.getPluginDetails() || [];
-        } catch {
-          fail("Could not list plugins from agent or local registry.");
-          return;
-        }
-      }
-      if (!plugins || plugins.length === 0) {
-        info("No plugins installed.");
-        return;
-      }
-      header("Installed Plugins");
-      formatTable(plugins.map((p) => ({
-        Name: p.name || p.package || "-",
-        Version: p.version || "-",
-        Status: p.status || p.enabled ? "enabled" : "disabled",
-        Description: p.description || "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("install").description("Install a plugin").argument("<package>", "NPM package name to install").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL17).action(async (packageName, options) => {
-    try {
-      const url = getAgentUrl(options);
-      try {
-        const result = await apiPost(url, "/api/plugins/install", {
-          package: packageName
-        });
-        success(`Plugin "${packageName}" installed.`);
-        if (result?.version)
-          kv("Version", result.version);
-      } catch {
-        warn("Agent not reachable. Attempting local install...");
-        try {
-          const { PluginManager: PluginManager2 } = await import("./plugin-system-bg1pzjj9.js");
-          const pm = new PluginManager2;
-          await pm.install(packageName);
-          success(`Plugin "${packageName}" installed locally.`);
-        } catch (localErr) {
-          fail(`Could not install plugin via agent or locally: ${localErr.message}`);
-        }
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("remove").description("Remove a plugin").argument("<package>", "NPM package name to remove").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL17).action(async (packageName, options) => {
-    try {
-      const url = getAgentUrl(options);
-      try {
-        await apiPost(url, "/api/plugins/remove", {
-          package: packageName
-        });
-        success(`Plugin "${packageName}" removed.`);
-      } catch {
-        warn("Agent not reachable. Attempting local removal...");
-        try {
-          const { PluginManager: PluginManager2 } = await import("./plugin-system-bg1pzjj9.js");
-          const pm = new PluginManager2;
-          await pm.remove(packageName);
-          success(`Plugin "${packageName}" removed locally.`);
-        } catch (localErr) {
-          fail(`Could not remove plugin via agent or locally: ${localErr.message}`);
-        }
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("reload").description("Reload all plugins").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL17).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiPost(url, "/api/plugins/reload", {});
-      success("Plugins reloaded.");
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("available").description("Show available plugins").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL17).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const availData = await apiGet(url, "/api/plugins/available");
-      const plugins = availData.plugins || [];
-      if (!plugins || plugins.length === 0) {
-        info("No available plugins found.");
-        return;
-      }
-      header("Available Plugins");
-      formatTable(plugins.map((p) => ({
-        Name: p.name || p.package || "-",
-        Version: p.version || p.latestVersion || "-",
-        Description: p.description || "-"
-      })));
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/state.cmd.ts
-var DEFAULT_AGENT_URL18 = "http://localhost:3005";
-function register26(program2) {
-  const cmd = program2.command("state").description("Manage plugin key-value state");
-  cmd.command("list").description("List all state entries for a plugin").argument("<plugin>", "Plugin name").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL18).action(async (plugin, options) => {
-    try {
-      const url = getAgentUrl(options);
-      const entries = await apiGet(url, `/api/plugin-state/${encodeURIComponent(plugin)}`);
-      if (!entries || typeof entries === "object" && Object.keys(entries).length === 0) {
-        info(`No state entries for plugin "${plugin}".`);
-        return;
-      }
-      header(`State: ${plugin}`);
-      blank();
-      if (Array.isArray(entries)) {
-        for (const entry of entries) {
-          kv(entry.key, JSON.stringify(entry.value));
-        }
-      } else if (typeof entries === "object") {
-        for (const [key, value] of Object.entries(entries)) {
-          kv(key, JSON.stringify(value));
-        }
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("get").description("Get a state value").argument("<plugin>", "Plugin name").argument("<key>", "State key").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL18).action(async (plugin, key, options) => {
-    try {
-      const url = getAgentUrl(options);
-      const result = await apiGet(url, `/api/plugin-state/${encodeURIComponent(plugin)}/${encodeURIComponent(key)}`);
-      if (result?.value !== undefined) {
-        header(`${plugin} / ${key}`);
-        console.log(typeof result.value === "string" ? result.value : JSON.stringify(result.value, null, 2));
-      } else {
-        info(`No value found for key "${key}" in plugin "${plugin}".`);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("set").description("Set a state value").argument("<plugin>", "Plugin name").argument("<key>", "State key").argument("<value>", "Value to set").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL18).action(async (plugin, key, value, options) => {
-    try {
-      const url = getAgentUrl(options);
-      let parsedValue = value;
-      try {
-        parsedValue = JSON.parse(value);
-      } catch {}
-      await apiPut(url, `/api/plugin-state/${encodeURIComponent(plugin)}/${encodeURIComponent(key)}`, { value: parsedValue });
-      success(`State set: ${plugin}/${key}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("unset").description("Remove a state value").argument("<plugin>", "Plugin name").argument("<key>", "State key").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL18).action(async (plugin, key, options) => {
-    try {
-      const url = getAgentUrl(options);
-      await apiDelete(url, `/api/plugin-state/${encodeURIComponent(plugin)}/${encodeURIComponent(key)}`);
-      success(`State removed: ${plugin}/${key}`);
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-}
-// src/cli/commands/log.cmd.ts
-var DEFAULT_AGENT_URL19 = "http://localhost:3005";
-function register27(program2) {
-  const cmd = program2.command("log").description("View and stream logs");
-  cmd.command("list").description("List recent log entries").option("--level <level>", "Minimum log level", "info").option("--limit <n>", "Number of entries to show", "50").option("--source <source>", "Filter by source").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL19).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const params = new URLSearchParams;
-      params.set("level", options.level);
-      params.set("limit", options.limit);
-      if (options.source)
-        params.set("source", options.source);
-      const logs = await apiGet(url, `/api/logs?${params.toString()}`);
-      if (!logs || logs.length === 0) {
-        info("No log entries found.");
-        return;
-      }
-      header("Logs");
-      blank();
-      for (const entry of logs) {
-        const level = formatLogLevel(entry.level);
-        const time = entry.timestamp ? colors.dim(timeAgo(entry.timestamp)) : "";
-        const source = entry.source ? colors.cyan(`[${entry.source}]`) : "";
-        const message = entry.message || "";
-        console.log(`  ${level} ${source} ${message} ${time}`);
-      }
-    } catch (err) {
-      fail(err.message);
-    }
-  });
-  cmd.command("stream").description("Stream logs in real-time (SSE)").option("--level <level>", "Minimum log level", "info").option("--agent-url <url>", "Agent URL", DEFAULT_AGENT_URL19).action(async (options) => {
-    try {
-      const url = getAgentUrl(options);
-      const params = new URLSearchParams;
-      params.set("level", options.level);
-      const streamUrl = `${url}/api/logs/stream?${params.toString()}`;
-      info(`Streaming logs from ${url} (level: ${options.level})...`);
-      info(`Press Ctrl+C to stop.
-`);
-      const response = await fetch(streamUrl, {
-        headers: { Accept: "text/event-stream" }
-      });
-      if (!response.ok) {
-        fail(`Failed to connect to log stream: ${response.status} ${response.statusText}`);
-        return;
-      }
-      if (!response.body) {
-        fail("No response body for SSE stream.");
-        return;
-      }
-      const decoder = new TextDecoder;
-      const reader = response.body.getReader();
-      const cleanup = () => {
-        reader.cancel().catch(() => {});
-        console.log(`
-Log stream ended.`);
-        process.exit(0);
-      };
-      process.on("SIGINT", cleanup);
-      process.on("SIGTERM", cleanup);
-      let buffer = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split(`
-`);
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6).trim();
-            if (!data || data === "[DONE]")
-              continue;
-            try {
-              const entry = JSON.parse(data);
-              const level = formatLogLevel(entry.level);
-              const source = entry.source ? colors.cyan(`[${entry.source}]`) : "";
-              const message = entry.message || "";
-              const time = entry.timestamp ? colors.dim(new Date(entry.timestamp).toLocaleTimeString()) : "";
-              console.log(`${level} ${source} ${message} ${time}`);
-            } catch {
-              if (data.trim())
-                console.log(data);
-            }
-          }
-        }
-      }
-    } catch (err) {
-      if (err.name === "AbortError")
-        return;
-      fail(err.message);
-    }
-  });
-}
-function formatLogLevel(level) {
-  if (!level)
-    return colors.dim("???");
-  switch (level.toLowerCase()) {
-    case "error":
-      return colors.red(colors.bold("ERR"));
-    case "warn":
-    case "warning":
-      return colors.yellow("WRN");
-    case "info":
-      return colors.blue("INF");
-    case "debug":
-      return colors.gray("DBG");
-    case "trace":
-      return colors.dim("TRC");
-    default:
-      return colors.dim(level.toUpperCase().slice(0, 3));
-  }
-}
+
 // src/services/completion.service.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  writeFileSync as writeFileSync2,
+  existsSync as existsSync2,
+  mkdirSync,
+  writeFileSync,
   unlinkSync,
-  readFileSync as readFileSync2
+  readFileSync
 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 function collectCommands(cmd) {
   return cmd.commands.map((sub) => ({
     name: sub.name(),
@@ -4603,7 +2737,7 @@ ${MARKER_END}`;
       return { shell: sh, path: rcFile };
     }
     case "zsh": {
-      const zshrc = join3(homedir3(), ".zshrc");
+      const zshrc = join2(homedir2(), ".zshrc");
       const evalLine = `${MARKER_START}
 eval "$(vibe completion zsh)"
 ${MARKER_END}`;
@@ -4611,11 +2745,11 @@ ${MARKER_END}`;
       return { shell: sh, path: zshrc };
     }
     case "fish": {
-      const dir = join3(process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config"), "fish", "completions");
-      if (!existsSync3(dir))
-        mkdirSync2(dir, { recursive: true });
-      const target = join3(dir, "vibe.fish");
-      writeFileSync2(target, generateFish(cmds), "utf8");
+      const dir = join2(process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config"), "fish", "completions");
+      if (!existsSync2(dir))
+        mkdirSync(dir, { recursive: true });
+      const target = join2(dir, "vibe.fish");
+      writeFileSync(target, generateFish(cmds), "utf8");
       return { shell: sh, path: target };
     }
   }
@@ -4629,52 +2763,52 @@ function uninstallCompletion(shell) {
       return { shell: sh, path: rcFile };
     }
     case "zsh": {
-      const zshrc = join3(homedir3(), ".zshrc");
+      const zshrc = join2(homedir2(), ".zshrc");
       removeMarkedBlock(zshrc);
       return { shell: sh, path: zshrc };
     }
     case "fish": {
-      const target = join3(process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config"), "fish", "completions", "vibe.fish");
-      if (existsSync3(target))
+      const target = join2(process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config"), "fish", "completions", "vibe.fish");
+      if (existsSync2(target))
         unlinkSync(target);
       return { shell: sh, path: target };
     }
   }
 }
 function bashrcPath() {
-  const bashrc = join3(homedir3(), ".bashrc");
-  if (existsSync3(bashrc))
+  const bashrc = join2(homedir2(), ".bashrc");
+  if (existsSync2(bashrc))
     return bashrc;
-  const profile = join3(homedir3(), ".bash_profile");
-  if (existsSync3(profile))
+  const profile = join2(homedir2(), ".bash_profile");
+  if (existsSync2(profile))
     return profile;
   return bashrc;
 }
 function appendIfMissing(file, marker, block) {
   let content = "";
-  if (existsSync3(file))
-    content = readFileSync2(file, "utf8");
+  if (existsSync2(file))
+    content = readFileSync(file, "utf8");
   if (content.includes(marker)) {
     removeMarkedBlock(file);
-    content = existsSync3(file) ? readFileSync2(file, "utf8") : "";
+    content = existsSync2(file) ? readFileSync(file, "utf8") : "";
   }
-  writeFileSync2(file, content + `
+  writeFileSync(file, content + `
 ` + block + `
 `, "utf8");
 }
 function removeMarkedBlock(file) {
-  if (!existsSync3(file))
+  if (!existsSync2(file))
     return;
-  const content = readFileSync2(file, "utf8");
+  const content = readFileSync(file, "utf8");
   const startIdx = content.indexOf(MARKER_START);
   const endIdx = content.indexOf(MARKER_END);
   if (startIdx === -1 || endIdx === -1)
     return;
-  writeFileSync2(file, content.substring(0, startIdx) + content.substring(endIdx + MARKER_END.length), "utf8");
+  writeFileSync(file, content.substring(0, startIdx) + content.substring(endIdx + MARKER_END.length), "utf8");
 }
 
 // src/cli/commands/completion.cmd.ts
-function register28(program2) {
+function register9(program2) {
   const cmd = program2.command("completion").description("Generate shell completion scripts (bash, zsh, fish)");
   cmd.command("bash").description("Print Bash completion script").action(() => {
     const cmds = collectCommands(program2);
@@ -4712,6 +2846,7 @@ function register28(program2) {
     }
   });
 }
+
 // src/cli.ts
 if (typeof Bun === "undefined") {
   console.error(`\x1B[31mError:\x1B[0m VibeControls Agent requires the Bun runtime.
@@ -4719,16 +2854,14 @@ if (typeof Bun === "undefined") {
 ` + "  Then run: bun run vibe ...");
   process.exit(1);
 }
-var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname2(__filename3);
 var packageVersion = "1.0.0";
 try {
-  const packageJsonPath = join4(__dirname3, "..", "package.json");
-  const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+  const packageJsonPath = join3(import.meta.dir, "..", "package.json");
+  const packageJson = await Bun.file(packageJsonPath).json();
   packageVersion = packageJson.version;
 } catch {}
 var program2 = new Command;
-program2.name("vibe").description("VibeControls Agent CLI \u2014 Remote development environment management").version(packageVersion, "-v, --version");
+program2.name("vibe").description("VibeControls Agent CLI \u2014 Remote development environment management").version(packageVersion, "-v, --version").option("--provider <name>", "Override the default provider for tunnel/session operations");
 register(program2);
 register2(program2);
 register3(program2);
@@ -4738,55 +2871,39 @@ register6(program2);
 register7(program2);
 register8(program2);
 register9(program2);
-register10(program2);
-register11(program2);
-register12(program2);
-register13(program2);
-register14(program2);
-register15(program2);
-register16(program2);
-register17(program2);
-register18(program2);
-register19(program2);
-register20(program2);
-register21(program2);
-register22(program2);
-register23(program2);
-register24(program2);
-register25(program2);
-register26(program2);
-register27(program2);
-register28(program2);
 async function main() {
   const pluginManager = new PluginManager;
+  try {
+    await pluginManager.loadCorePlugins();
+  } catch {}
   try {
     await pluginManager.loadAll();
   } catch {}
+  const serviceRegistry = new ServiceRegistry;
+  const cliStorage = {
+    async get() {
+      return null;
+    },
+    async set() {},
+    async delete() {
+      return false;
+    },
+    async list() {
+      return [];
+    },
+    async deleteAll() {
+      return 0;
+    }
+  };
+  const hostServices = {
+    storage: cliStorage,
+    logger,
+    serviceRegistry,
+    getProvider: (type) => serviceRegistry.getProvider(type),
+    getAgentBaseUrl: () => process.env.AGENT_URL || "http://localhost:3005",
+    getAgentVersion: () => packageVersion
+  };
   try {
-    const serviceRegistry = new ServiceRegistry;
-    const cliStorage = {
-      async get() {
-        return null;
-      },
-      async set() {},
-      async delete() {
-        return false;
-      },
-      async list() {
-        return [];
-      },
-      async deleteAll() {
-        return 0;
-      }
-    };
-    const hostServices = {
-      storage: cliStorage,
-      logger,
-      serviceRegistry,
-      getProvider: (type) => serviceRegistry.getProvider(type),
-      getAgentBaseUrl: () => process.env.AGENT_URL || "http://localhost:3005",
-      getAgentVersion: () => packageVersion
-    };
     await pluginManager.dispatchCliSetup(program2, hostServices);
   } catch {}
   program2.parse();
@@ -4796,5 +2913,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=7429A5527447039F64756E2164756E21
+//# debugId=B3B10A5CB7971CB864756E2164756E21
 //# sourceMappingURL=cli.js.map