cli-remote-agent 1.0.1 → 1.0.3

package/dist/cli.js

@@ -0,0 +1,1921 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/config.ts
+function defaultAgentId() {
+  return import_os.default.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-");
+}
+function defaultConfig() {
+  return {
+    agentId: defaultAgentId(),
+    // No serverUrl by default — the agent must be enrolled via `crc-agent setup`.
+    serverUrl: "",
+    // Random secret so an unconfigured install never ships a known secret.
+    secret: import_crypto.default.randomBytes(24).toString("hex"),
+    shell: "auto"
+  };
+}
+function isConfigured() {
+  if (!import_fs.default.existsSync(CONFIG_FILE)) return false;
+  try {
+    const raw = import_fs.default.readFileSync(CONFIG_FILE, "utf-8");
+    const cfg = JSON.parse(raw.replace(/^/, ""));
+    if (!cfg.serverUrl || !cfg.secret) return false;
+    if (cfg.secret === PLACEHOLDER_SECRET) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadConfig() {
+  if (!import_fs.default.existsSync(CONFIG_FILE)) {
+    const config2 = defaultConfig();
+    import_fs.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    import_fs.default.writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+    console.log(`Created default config at ${CONFIG_FILE} \u2014 run \`crc-agent setup\` to enroll.`);
+    return config2;
+  }
+  try {
+    const raw = import_fs.default.readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw.replace(/^/, ""));
+  } catch (err) {
+    console.error(
+      `Failed to read/parse config at ${CONFIG_FILE}: ${err.message}
+Falling back to default config. Fix the file and restart to apply your settings.`
+    );
+    return defaultConfig();
+  }
+}
+var import_fs, import_path, import_os, import_crypto, CONFIG_DIR, CONFIG_FILE, PLACEHOLDER_SECRET, LOCAL_CONTROL_PORT;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    import_path = __toESM(require("path"));
+    import_os = __toESM(require("os"));
+    import_crypto = __toESM(require("crypto"));
+    CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".crc-agent");
+    CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+    PLACEHOLDER_SECRET = "changeme";
+    LOCAL_CONTROL_PORT = Number(process.env.CRC_LOCAL_PORT) || 47600;
+  }
+});
+
+// src/setup.ts
+var setup_exports = {};
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--token" || a === "-t") {
+      out.token = argv[++i];
+    } else if (a.startsWith("--token=")) {
+      out.token = a.slice("--token=".length);
+    } else if (a === "--help" || a === "-h") {
+      out.help = true;
+    }
+  }
+  return out;
+}
+function decodeToken(token) {
+  const json = Buffer.from(token, "base64url").toString("utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error("Invalid token: not valid base64url-encoded JSON.");
+  }
+  if (!parsed || typeof parsed !== "object") throw new Error("Invalid token payload.");
+  if (!parsed.serverUrl || !parsed.agentId || !parsed.secret) {
+    throw new Error("Invalid token: missing serverUrl, agentId, or secret.");
+  }
+  return parsed;
+}
+function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, (answer) => resolve(answer)));
+}
+function writeConfig(cfg) {
+  import_fs2.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  import_fs2.default.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+  console.log(`Saved. Start the agent with: crc-agent`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(
+      [
+        "Usage: crc-agent setup [--token <base64url>]",
+        "",
+        "Enroll this machine as a Claude Remote agent.",
+        "",
+        "Modes:",
+        '  --token <token>   Enroll from the token shown in the web "Add agent" dialog.',
+        "  (no args)         Interactive prompts for serverUrl, agentId, secret.",
+        "",
+        "Environment overrides (skip prompts): CRC_SERVER_URL, CRC_AGENT_ID, CRC_SECRET",
+        "",
+        `Config is written to ${CONFIG_FILE}`
+      ].join("\n")
+    );
+    return;
+  }
+  const exists = import_fs2.default.existsSync(CONFIG_FILE);
+  if (args.token) {
+    const t = decodeToken(args.token);
+    writeConfig({ agentId: t.agentId, serverUrl: t.serverUrl, secret: t.secret, shell: "auto" });
+    return;
+  }
+  const envServer = process.env.CRC_SERVER_URL;
+  const envAgent = process.env.CRC_AGENT_ID;
+  const envSecret = process.env.CRC_SECRET;
+  if (envServer && envSecret) {
+    writeConfig({
+      agentId: envAgent || defaultAgentId(),
+      serverUrl: envServer,
+      secret: envSecret,
+      shell: "auto"
+    });
+    return;
+  }
+  const rl = import_readline.default.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    if (exists) {
+      const overwrite = await ask(rl, `Config already exists at ${CONFIG_FILE}. Overwrite? (y/N) `);
+      if (!/^y(es)?$/i.test(overwrite.trim())) {
+        console.log("Aborted. Existing config left unchanged.");
+        return;
+      }
+    }
+    const serverUrl = (envServer || await ask(rl, "Server URL (e.g. wss://crc.example.com): ")).trim();
+    if (!serverUrl) throw new Error("Server URL is required.");
+    const agentIdRaw = envAgent || await ask(rl, `Agent ID [${defaultAgentId()}]: `);
+    const agentId = (agentIdRaw || "").trim() || defaultAgentId();
+    const secret = (envSecret || await ask(rl, "Agent secret: ")).trim();
+    if (!secret) throw new Error("Secret is required.");
+    writeConfig({ agentId, serverUrl, secret, shell: "auto" });
+  } finally {
+    rl.close();
+  }
+}
+var import_fs2, import_readline;
+var init_setup = __esm({
+  "src/setup.ts"() {
+    "use strict";
+    import_fs2 = __toESM(require("fs"));
+    import_readline = __toESM(require("readline"));
+    init_config();
+    main().catch((err) => {
+      console.error(`Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    });
+  }
+});
+
+// ../shared/src/types.ts
+var init_types = __esm({
+  "../shared/src/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../shared/src/protocol.ts
+var AGENT_HEARTBEAT, TERMINAL_OUTPUT, TERMINAL_EXIT, TERMINAL_OPEN, TERMINAL_INPUT, TERMINAL_RESIZE, TERMINAL_CLOSE, SESSION_ATTACH, SESSION_DETACH, SESSION_BUFFER, SESSION_SYNC, SESSION_SYNC_RESULT, VPN_LIST, VPN_CONNECT, VPN_DISCONNECT, VPN_UPDATE, FILES_LIST, FILES_DOWNLOAD, FILES_LIST_RESULT, FILES_DOWNLOAD_READY, FILES_DOWNLOAD_ERROR, AGENT_EXEC, AGENT_EXEC_RESULT, CLAUDE_CONV_READ, CLAUDE_CONV_DATA, CLAUDE_SESSIONS_LIST, CLAUDE_SESSIONS_RESULT, CLAUDE_HOOK, TMUX_LIST, TMUX_LIST_RESULT;
+var init_protocol = __esm({
+  "../shared/src/protocol.ts"() {
+    "use strict";
+    AGENT_HEARTBEAT = "agent:heartbeat";
+    TERMINAL_OUTPUT = "terminal:output";
+    TERMINAL_EXIT = "terminal:exit";
+    TERMINAL_OPEN = "terminal:open";
+    TERMINAL_INPUT = "terminal:input";
+    TERMINAL_RESIZE = "terminal:resize";
+    TERMINAL_CLOSE = "terminal:close";
+    SESSION_ATTACH = "session:attach";
+    SESSION_DETACH = "session:detach";
+    SESSION_BUFFER = "session:buffer";
+    SESSION_SYNC = "session:sync";
+    SESSION_SYNC_RESULT = "session:sync:result";
+    VPN_LIST = "vpn:list";
+    VPN_CONNECT = "vpn:connect";
+    VPN_DISCONNECT = "vpn:disconnect";
+    VPN_UPDATE = "vpn:update";
+    FILES_LIST = "files:list";
+    FILES_DOWNLOAD = "files:download";
+    FILES_LIST_RESULT = "files:list:result";
+    FILES_DOWNLOAD_READY = "files:download:ready";
+    FILES_DOWNLOAD_ERROR = "files:download:error";
+    AGENT_EXEC = "agent:exec";
+    AGENT_EXEC_RESULT = "agent:exec:result";
+    CLAUDE_CONV_READ = "claude:conv:read";
+    CLAUDE_CONV_DATA = "claude:conv:data";
+    CLAUDE_SESSIONS_LIST = "claude:sessions:list";
+    CLAUDE_SESSIONS_RESULT = "claude:sessions:result";
+    CLAUDE_HOOK = "claude:hook";
+    TMUX_LIST = "tmux:list";
+    TMUX_LIST_RESULT = "tmux:list:result";
+  }
+});
+
+// ../shared/src/constants.ts
+var HEARTBEAT_INTERVAL, SESSION_BUFFER_SIZE, FILE_MAX_SIZE;
+var init_constants = __esm({
+  "../shared/src/constants.ts"() {
+    "use strict";
+    HEARTBEAT_INTERVAL = 15e3;
+    SESSION_BUFFER_SIZE = 5e4;
+    FILE_MAX_SIZE = 524288e3;
+  }
+});
+
+// ../shared/src/index.ts
+var init_src = __esm({
+  "../shared/src/index.ts"() {
+    "use strict";
+    init_types();
+    init_protocol();
+    init_constants();
+  }
+});
+
+// src/logger.ts
+var import_pino, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    import_pino = __toESM(require("pino"));
+    logger = (0, import_pino.default)({
+      level: "info",
+      transport: { target: "pino-pretty", options: { colorize: true } }
+    });
+  }
+});
+
+// src/claude-plugin-installer.ts
+function getSettingsPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return (0, import_path2.join)(home, ".claude", "settings.json");
+}
+function installClaudeHooks(port) {
+  const settingsPath = getSettingsPath();
+  const url = `http://127.0.0.1:${port}/hook`;
+  const command = `curl -s -m 2 -X POST -H "Content-Type: application/json" --data-binary @- ${url} >/dev/null 2>&1 || true`;
+  let settings = {};
+  try {
+    if ((0, import_fs3.existsSync)(settingsPath)) {
+      settings = JSON.parse((0, import_fs3.readFileSync)(settingsPath, "utf-8"));
+    }
+  } catch (err) {
+    logger.warn({ err }, "Could not parse ~/.claude/settings.json \u2014 skipping hook install");
+    return;
+  }
+  const hooks = settings.hooks || (settings.hooks = {});
+  const isOurs = (group) => JSON.stringify(group).includes(url);
+  const desired = { hooks: [{ type: "command", command }] };
+  let changed = false;
+  for (const ev of MANAGED_EVENTS) {
+    const existed = Array.isArray(hooks[ev]);
+    const kept = (existed ? hooks[ev] : []).filter((g) => !isOurs(g));
+    const next = INSTALL_EVENTS.includes(ev) ? [...kept, desired] : kept;
+    const before = existed ? JSON.stringify(hooks[ev]) : "";
+    if (next.length === 0) {
+      if (existed) {
+        delete hooks[ev];
+        changed = true;
+      }
+    } else if (before !== JSON.stringify(next)) {
+      hooks[ev] = next;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    logger.info("CRC Claude notify hooks already present in settings.json");
+    return;
+  }
+  try {
+    (0, import_fs3.mkdirSync)((0, import_path2.dirname)(settingsPath), { recursive: true });
+    (0, import_fs3.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    logger.info({ install: INSTALL_EVENTS, url }, "Installed CRC Claude notify hooks into settings.json (restart claude to apply)");
+  } catch (err) {
+    logger.warn({ err }, "Failed to write CRC notify hooks to settings.json");
+  }
+}
+function normalizeClaudeHook(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  if (typeof raw.event === "string" && !raw.hook_event_name) return raw;
+  const name = raw.hook_event_name;
+  if (name === "Stop" || name === "SubagentStop") {
+    return {
+      event: "stop",
+      projectPath: typeof raw.cwd === "string" ? raw.cwd : void 0,
+      claudeSessionId: typeof raw.session_id === "string" ? raw.session_id : void 0
+    };
+  }
+  return null;
+}
+function lastAssistantSummary(transcriptPath) {
+  if (!transcriptPath) return void 0;
+  try {
+    const lines = (0, import_fs3.readFileSync)(transcriptPath, "utf-8").split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj?.type === "assistant" && obj.message?.content) {
+          const c = obj.message.content;
+          const text = Array.isArray(c) ? c.filter((x) => x?.type === "text").map((x) => x.text).join(" ") : typeof c === "string" ? c : "";
+          if (text.trim()) return text.trim().replace(/\s+/g, " ").slice(0, 180);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+var import_fs3, import_path2, INSTALL_EVENTS, MANAGED_EVENTS;
+var init_claude_plugin_installer = __esm({
+  "src/claude-plugin-installer.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    import_path2 = require("path");
+    init_logger();
+    INSTALL_EVENTS = ["Stop"];
+    MANAGED_EVENTS = ["Stop", "Notification", "SubagentStop"];
+  }
+});
+
+// src/local-control.ts
+function startLocalControl(port, onHook) {
+  const server = import_http.default.createServer((req, res) => {
+    if (req.method === "POST" && req.url === "/hook") {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+        if (body.length > 64 * 1024) req.destroy();
+      });
+      req.on("end", () => {
+        try {
+          const payload = JSON.parse(body);
+          if (payload && typeof payload === "object") onHook(payload);
+        } catch {
+        }
+        res.writeHead(204);
+        res.end();
+      });
+      req.on("error", () => {
+        res.writeHead(400);
+        res.end();
+      });
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+  server.on("error", (err) => {
+    logger.warn({ err, port }, "Local control server error (Claude hooks may not reach push)");
+  });
+  server.listen(port, "127.0.0.1", () => {
+    logger.info({ port }, "Local control endpoint listening (127.0.0.1) for Claude hooks");
+  });
+  return server;
+}
+var import_http;
+var init_local_control = __esm({
+  "src/local-control.ts"() {
+    "use strict";
+    import_http = __toESM(require("http"));
+    init_logger();
+  }
+});
+
+// src/claude-live.ts
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getLiveClaudeSessions() {
+  let files;
+  try {
+    files = import_fs4.default.readdirSync(LIVE_SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files) {
+    try {
+      const obj = JSON.parse(import_fs4.default.readFileSync(import_path3.default.join(LIVE_SESSIONS_DIR, f), "utf-8"));
+      if (typeof obj?.pid !== "number" || !isAlive(obj.pid)) continue;
+      out.push({
+        pid: obj.pid,
+        cwd: typeof obj.cwd === "string" ? obj.cwd : "",
+        name: typeof obj.name === "string" ? obj.name : void 0,
+        status: typeof obj.status === "string" ? obj.status : void 0,
+        updatedAt: typeof obj.updatedAt === "number" ? obj.updatedAt : void 0
+      });
+    } catch {
+    }
+  }
+  out.sort((a, b) => (a.updatedAt || 0) - (b.updatedAt || 0));
+  return out;
+}
+async function getPidParents() {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid="], { timeout: 5e3 });
+    for (const line of stdout.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)$/);
+      if (m) map.set(parseInt(m[1], 10), parseInt(m[2], 10));
+    }
+  } catch {
+  }
+  return map;
+}
+function isDescendantOf(pid, ancestor, parents) {
+  let cur = pid;
+  for (let i = 0; i < 25 && cur !== void 0 && cur > 1; i++) {
+    if (cur === ancestor) return true;
+    cur = parents.get(cur);
+  }
+  return false;
+}
+var import_fs4, import_path3, import_os2, import_child_process, import_util, execFileAsync, LIVE_SESSIONS_DIR;
+var init_claude_live = __esm({
+  "src/claude-live.ts"() {
+    "use strict";
+    import_fs4 = __toESM(require("fs"));
+    import_path3 = __toESM(require("path"));
+    import_os2 = __toESM(require("os"));
+    import_child_process = require("child_process");
+    import_util = require("util");
+    execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+    LIVE_SESSIONS_DIR = import_path3.default.join(import_os2.default.homedir(), ".claude", "sessions");
+  }
+});
+
+// src/tmux.ts
+function tmuxCmd(args) {
+  return IS_WIN ? { file: "wsl.exe", args: ["tmux", ...args] } : { file: "tmux", args };
+}
+async function listTmuxSessions() {
+  const fmt = "#{session_name}	#{session_windows}	#{session_attached}	#{session_activity}";
+  const { file, args } = tmuxCmd(["list-sessions", "-F", fmt]);
+  try {
+    const { stdout } = await execFileAsync2(file, args, { timeout: 6e3 });
+    const sessions2 = stdout.split("\n").map((line) => line.replace(/\r$/, "").trim()).filter(Boolean).map((line) => {
+      const [name, windows, attached, activity] = line.split("	");
+      return {
+        name,
+        windows: parseInt(windows, 10) || 1,
+        attached: attached === "1",
+        activity: parseInt(activity, 10) || void 0
+      };
+    });
+    await enrichWithPanesAndClaude(sessions2);
+    return sessions2;
+  } catch {
+    return [];
+  }
+}
+async function enrichWithPanesAndClaude(sessions2) {
+  if (IS_WIN || sessions2.length === 0) return;
+  try {
+    const paneFmt = "#{session_name}	#{pane_pid}	#{pane_current_path}	#{window_active}#{pane_active}";
+    const { file, args } = tmuxCmd(["list-panes", "-a", "-F", paneFmt]);
+    const { stdout } = await execFileAsync2(file, args, { timeout: 6e3 });
+    const panes = stdout.split("\n").map((line) => line.replace(/\r$/, "").trim()).filter(Boolean).map((line) => {
+      const [session, pid, path8, activeFlags] = line.split("	");
+      return { session, pid: parseInt(pid, 10) || 0, path: path8 || "", active: activeFlags === "11" };
+    });
+    const byName = new Map(sessions2.map((s) => [s.name, s]));
+    for (const pane of panes) {
+      const s = byName.get(pane.session);
+      if (s && (!s.path || pane.active)) s.path = pane.path || s.path;
+    }
+    const live = getLiveClaudeSessions();
+    if (live.length === 0) return;
+    const parents = await getPidParents();
+    for (const cs of live) {
+      const target = parents.size > 0 ? panes.find((p) => p.pid > 0 && isDescendantOf(cs.pid, p.pid, parents)) : panes.find((p) => cs.cwd && p.path === cs.cwd);
+      if (!target) continue;
+      const s = byName.get(target.session);
+      if (!s) continue;
+      s.claudeTitle = cs.name;
+      s.claudeStatus = cs.status;
+      if (cs.cwd) s.path = cs.cwd;
+    }
+  } catch {
+  }
+}
+function shq(v) {
+  return `'${v.replace(/'/g, `'\\''`)}'`;
+}
+function buildTmuxLaunch(name, launch, shell) {
+  const trimmed = launch && launch.trim() ? launch.trim() : void 0;
+  if (IS_WIN) {
+    const args = ["tmux", "new-session", "-A", "-s", name];
+    if (trimmed) args.push(trimmed);
+    return { file: "wsl.exe", args };
+  }
+  let cmd2 = `tmux set-option -g aggressive-resize on 2>/dev/null; exec tmux new-session -A -s ${shq(name)}`;
+  if (trimmed) cmd2 += ` ${shq(trimmed)}`;
+  return { file: shell, args: ["-l", "-c", cmd2] };
+}
+var import_child_process2, import_util2, execFileAsync2, IS_WIN;
+var init_tmux = __esm({
+  "src/tmux.ts"() {
+    "use strict";
+    import_child_process2 = require("child_process");
+    import_util2 = require("util");
+    init_claude_live();
+    execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
+    IS_WIN = process.platform === "win32";
+  }
+});
+
+// src/shell.ts
+function detectShell(preference) {
+  if (preference !== "auto") return preference;
+  if (process.platform === "win32") {
+    try {
+      (0, import_child_process3.execSync)("where pwsh", { stdio: "ignore" });
+      return "pwsh.exe";
+    } catch {
+      return "powershell.exe";
+    }
+  }
+  return process.env.SHELL || "/bin/bash";
+}
+var import_child_process3;
+var init_shell = __esm({
+  "src/shell.ts"() {
+    "use strict";
+    import_child_process3 = require("child_process");
+  }
+});
+
+// src/pty-session.ts
+function ensureInitFiles() {
+  const versionFile = (0, import_path4.join)(INIT_DIR, ".version");
+  if ((0, import_fs5.existsSync)(versionFile)) {
+    try {
+      if ((0, import_fs5.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
+    } catch {
+    }
+  }
+  (0, import_fs5.mkdirSync)(ZSH_DIR, { recursive: true });
+  (0, import_fs5.writeFileSync)(BASH_INIT, [
+    "[ -f ~/.bash_profile ] && source ~/.bash_profile",
+    "[ -f ~/.bashrc ] && source ~/.bashrc",
+    "__crc_s=$SECONDS",
+    "__crc_elapsed=0",
+    "__crc_armed=0",
+    '__crc_orig_pc="$PROMPT_COMMAND"',
+    `trap '__crc_elapsed=$((SECONDS - __crc_s)); __crc_s=$SECONDS' DEBUG`,
+    `PROMPT_COMMAND='[ "$__crc_armed" = 1 ] && [ \${__crc_elapsed:-0} -ge ${THRESHOLD} ] && printf "\\a"; __crc_armed=1; eval "$__crc_orig_pc"'`,
+    ""
+  ].join("\n"), "utf-8");
+  (0, import_fs5.writeFileSync)(ZSH_ENV, [
+    '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshenv" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshenv"',
+    ""
+  ].join("\n"), "utf-8");
+  (0, import_fs5.writeFileSync)(ZSH_RC, [
+    '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshrc" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshrc"',
+    "__crc_s=$SECONDS",
+    "__crc_armed=0",
+    `__crc_preexec() { __crc_s=$SECONDS; }`,
+    `__crc_precmd() { (( __crc_armed )) && (( SECONDS - __crc_s >= ${THRESHOLD} )) && printf '\\a'; __crc_armed=1; }`,
+    "autoload -Uz add-zsh-hook 2>/dev/null",
+    "if type add-zsh-hook &>/dev/null; then",
+    "  add-zsh-hook preexec __crc_preexec",
+    "  add-zsh-hook precmd __crc_precmd",
+    "fi",
+    ""
+  ].join("\n"), "utf-8");
+  (0, import_fs5.writeFileSync)(versionFile, INIT_VERSION, "utf-8");
+}
+function resolveCwd(cwd) {
+  const candidates = process.platform === "win32" ? [cwd, (0, import_os3.homedir)(), process.env.USERPROFILE, process.env.HOME] : [cwd, (0, import_os3.homedir)(), process.env.HOME, process.env.USERPROFILE];
+  for (const c of candidates) {
+    if (c) {
+      try {
+        if ((0, import_fs5.existsSync)(c)) return c;
+      } catch {
+      }
+    }
+  }
+  return (0, import_os3.homedir)();
+}
+var pty, import_fs5, import_path4, import_os3, THRESHOLD, INIT_DIR, BASH_INIT, ZSH_DIR, ZSH_RC, ZSH_ENV, INIT_VERSION, PtySession;
+var init_pty_session = __esm({
+  "src/pty-session.ts"() {
+    "use strict";
+    pty = __toESM(require("node-pty"));
+    import_fs5 = require("fs");
+    import_path4 = require("path");
+    import_os3 = require("os");
+    init_src();
+    init_shell();
+    THRESHOLD = 3;
+    INIT_DIR = (0, import_path4.join)((0, import_os3.tmpdir)(), "crc-shell-init");
+    BASH_INIT = (0, import_path4.join)(INIT_DIR, "bashrc");
+    ZSH_DIR = (0, import_path4.join)(INIT_DIR, "zsh");
+    ZSH_RC = (0, import_path4.join)(ZSH_DIR, ".zshrc");
+    ZSH_ENV = (0, import_path4.join)(ZSH_DIR, ".zshenv");
+    INIT_VERSION = "2";
+    PtySession = class {
+      id;
+      pty;
+      buffer = "";
+      maxBufferSize = SESSION_BUFFER_SIZE;
+      _attached = true;
+      _detachedAt = 0;
+      constructor(id, cols, rows, shellPreference, cwd, launch) {
+        this.id = id;
+        const shell = detectShell(shellPreference);
+        const isBash = /bash(\.exe)?$/.test(shell);
+        const isZsh = /zsh(\.exe)?$/.test(shell);
+        const env = { ...process.env, TERM: "xterm-256color" };
+        let file = shell;
+        const args = [];
+        if (launch) {
+          file = launch.file;
+          args.push(...launch.args);
+        } else {
+          ensureInitFiles();
+          if (isBash) {
+            args.push("--rcfile", BASH_INIT);
+          } else if (isZsh) {
+            env.ZDOTDIR_ORIG = process.env.ZDOTDIR || process.env.HOME || "";
+            env.ZDOTDIR = ZSH_DIR;
+          }
+        }
+        const resolvedCwd = resolveCwd(cwd);
+        try {
+          this.pty = pty.spawn(file, args, {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: resolvedCwd,
+            env
+          });
+        } catch (err) {
+          console.error(`[pty] spawn failed (file=${file}, cwd=${resolvedCwd}):`, err);
+          this.pty = pty.spawn(file, args, {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: (0, import_os3.homedir)(),
+            env
+          });
+        }
+      }
+      write(data) {
+        this.pty.write(data);
+      }
+      resize(cols, rows) {
+        this.pty.resize(cols, rows);
+      }
+      kill() {
+        this.pty.kill();
+      }
+      onData(callback) {
+        this.pty.onData(callback);
+      }
+      onExit(callback) {
+        this.pty.onExit(callback);
+      }
+      appendToBuffer(data) {
+        this.buffer += data;
+        if (this.buffer.length > this.maxBufferSize) {
+          let sliced = this.buffer.slice(this.buffer.length - this.maxBufferSize);
+          const nl = sliced.indexOf("\n");
+          const esc = sliced.indexOf("\x1B");
+          if (nl !== -1 && (esc === -1 || nl < esc)) {
+            sliced = sliced.slice(nl + 1);
+          } else if (esc > 0) {
+            sliced = sliced.slice(esc);
+          }
+          this.buffer = sliced;
+        }
+      }
+      getAndClearBuffer() {
+        const data = this.buffer;
+        this.buffer = "";
+        return data;
+      }
+      setAttached(v) {
+        this._attached = v;
+        this._detachedAt = v ? 0 : Date.now();
+      }
+      isAttached() {
+        return this._attached;
+      }
+      // Timestamp (ms) when this session was last detached, or 0 if attached.
+      getDetachedAt() {
+        return this._detachedAt;
+      }
+    };
+  }
+});
+
+// src/terminal-manager.ts
+function createTerminalSession(sessionId, cols, rows, shellPreference, cwd, onData, onExit, launch) {
+  const session = new PtySession(sessionId, cols, rows, shellPreference, cwd, launch);
+  session.onData((data) => {
+    session.appendToBuffer(data);
+    if (session.isAttached()) {
+      onData(sessionId, data);
+    }
+  });
+  session.onExit((exit) => {
+    sessions.delete(sessionId);
+    onExit(sessionId, exit.exitCode);
+    logger.info({ sessionId, exitCode: exit.exitCode }, "PTY exited");
+  });
+  sessions.set(sessionId, session);
+  logger.info({ sessionId, cols, rows }, "PTY session created");
+}
+function writeToSession(sessionId, data) {
+  sessions.get(sessionId)?.write(data);
+}
+function resizeSession(sessionId, cols, rows) {
+  sessions.get(sessionId)?.resize(cols, rows);
+}
+function detachSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.setAttached(false);
+    logger.info({ sessionId }, "PTY session detached");
+  }
+}
+function attachSession(sessionId, cols, rows) {
+  const session = sessions.get(sessionId);
+  if (!session) return "";
+  session.setAttached(true);
+  session.resize(cols, rows);
+  const buffered = session.getAndClearBuffer();
+  logger.info({ sessionId, bufferSize: buffered.length }, "PTY session reattached");
+  return buffered;
+}
+function closeSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.kill();
+    sessions.delete(sessionId);
+    logger.info({ sessionId }, "PTY session closed");
+  }
+}
+function closeAllSessions() {
+  for (const [id, session] of sessions) {
+    session.kill();
+    logger.info({ sessionId: id }, "PTY session force-closed");
+  }
+  sessions.clear();
+}
+function detachAllSessions() {
+  for (const [id, session] of sessions) {
+    session.setAttached(false);
+    logger.info({ sessionId: id }, "PTY session detached (disconnect)");
+  }
+}
+function getAliveSessionIds() {
+  return Array.from(sessions.keys());
+}
+function getActiveSessionCount() {
+  return sessions.size;
+}
+function reapDetachedSessions(maxIdleMs) {
+  const now = Date.now();
+  const reaped = [];
+  for (const [id, session] of sessions) {
+    if (session.isAttached()) continue;
+    const detachedAt = session.getDetachedAt();
+    if (detachedAt > 0 && now - detachedAt > maxIdleMs) {
+      session.kill();
+      sessions.delete(id);
+      reaped.push(id);
+      logger.info({ sessionId: id, idleMs: now - detachedAt }, "PTY session reaped (idle)");
+    }
+  }
+  return reaped;
+}
+var sessions;
+var init_terminal_manager = __esm({
+  "src/terminal-manager.ts"() {
+    "use strict";
+    init_pty_session();
+    init_logger();
+    sessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/heartbeat.ts
+function getCpuUsage() {
+  const cpus = import_os4.default.cpus();
+  let idle = 0;
+  let total = 0;
+  for (const cpu of cpus) {
+    for (const type of Object.values(cpu.times)) {
+      total += type;
+    }
+    idle += cpu.times.idle;
+  }
+  const prev = prevCpu;
+  prevCpu = { idle, total };
+  if (!prev) return 0;
+  const idleDelta = idle - prev.idle;
+  const totalDelta = total - prev.total;
+  if (totalDelta <= 0) return 0;
+  return Math.round((1 - idleDelta / totalDelta) * 100);
+}
+function getRootPaths() {
+  if (process.platform === "win32") {
+    try {
+      const output = (0, import_child_process4.execSync)("wmic logicaldisk get name", { encoding: "utf-8" });
+      return output.split("\n").map((l) => l.trim()).filter((l) => /^[A-Z]:$/.test(l)).map((l) => l + "\\");
+    } catch {
+      return ["C:\\"];
+    }
+  }
+  return ["/"];
+}
+function buildHeartbeat(homeDir) {
+  const totalMem = import_os4.default.totalmem();
+  const freeMem = import_os4.default.freemem();
+  return {
+    hostname: import_os4.default.hostname(),
+    platform: process.platform,
+    arch: import_os4.default.arch(),
+    cpuUsage: getCpuUsage(),
+    memoryUsage: Math.round((totalMem - freeMem) / totalMem * 100),
+    uptime: Math.round(import_os4.default.uptime()),
+    activeSessions: getActiveSessionCount(),
+    pathSeparator: import_path5.default.sep,
+    homeDirectory: homeDir || import_os4.default.homedir(),
+    rootPaths: getRootPaths(),
+    capabilities: { terminal: true, fileTransfer: false }
+  };
+}
+var import_os4, import_path5, import_child_process4, prevCpu;
+var init_heartbeat = __esm({
+  "src/heartbeat.ts"() {
+    "use strict";
+    import_os4 = __toESM(require("os"));
+    import_path5 = __toESM(require("path"));
+    import_child_process4 = require("child_process");
+    init_terminal_manager();
+    prevCpu = null;
+  }
+});
+
+// src/file-explorer.ts
+function isInSecretDir(resolved) {
+  const rel = import_path6.default.relative(SECRET_DIR, resolved);
+  return rel === "" || !rel.startsWith(".." + import_path6.default.sep) && rel !== ".." && !import_path6.default.isAbsolute(rel);
+}
+function listDirectory(dirPath) {
+  try {
+    const resolved = import_path6.default.resolve(dirPath);
+    if (isInSecretDir(resolved)) {
+      return { entries: [], error: "Access denied" };
+    }
+    if (!import_fs6.default.existsSync(resolved)) {
+      return { entries: [], error: "Path does not exist" };
+    }
+    const stat = import_fs6.default.statSync(resolved);
+    if (!stat.isDirectory()) {
+      return { entries: [], error: "Not a directory" };
+    }
+    const dirents = import_fs6.default.readdirSync(resolved, { withFileTypes: true });
+    const entries = [];
+    for (const dirent of dirents) {
+      try {
+        const fullPath = import_path6.default.join(resolved, dirent.name);
+        const s = import_fs6.default.statSync(fullPath);
+        entries.push({
+          name: dirent.name,
+          isDirectory: dirent.isDirectory(),
+          size: dirent.isDirectory() ? 0 : s.size,
+          modified: s.mtimeMs
+        });
+      } catch {
+      }
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return { entries };
+  } catch (err) {
+    logger.error({ path: dirPath, error: err.message }, "Failed to list directory");
+    return { entries: [], error: err.message };
+  }
+}
+async function downloadFile(filePath, serverUrl, secret, agentId) {
+  try {
+    const resolved = import_path6.default.resolve(filePath);
+    if (isInSecretDir(resolved)) {
+      return { error: "Access denied" };
+    }
+    if (!import_fs6.default.existsSync(resolved)) {
+      return { error: "File does not exist" };
+    }
+    const stat = import_fs6.default.statSync(resolved);
+    if (stat.isDirectory()) {
+      return { error: "Cannot download a directory" };
+    }
+    if (stat.size > FILE_MAX_SIZE) {
+      return { error: `File too large (max ${FILE_MAX_SIZE} bytes)` };
+    }
+    const fileName = import_path6.default.basename(resolved);
+    const fileStream = import_fs6.default.createReadStream(resolved);
+    const baseUrl = serverUrl.replace("wss://", "https://").replace("ws://", "http://");
+    const url = `${baseUrl}/api/files/receive`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "X-File-Name": fileName,
+        "X-Agent-Id": agentId,
+        "X-Agent-Secret": secret,
+        "Content-Length": String(stat.size)
+      },
+      body: fileStream,
+      duplex: "half"
+    });
+    if (!res.ok) {
+      return { error: `Upload failed: ${res.status}` };
+    }
+    const result = await res.json();
+    return {
+      fileId: result.fileId,
+      fileName: result.fileName,
+      downloadUrl: result.downloadUrl,
+      size: stat.size
+    };
+  } catch (err) {
+    logger.error({ path: filePath, error: err.message }, "Failed to download file");
+    return { error: err.message };
+  }
+}
+var import_fs6, import_path6, import_os5, SECRET_DIR;
+var init_file_explorer = __esm({
+  "src/file-explorer.ts"() {
+    "use strict";
+    import_fs6 = __toESM(require("fs"));
+    import_path6 = __toESM(require("path"));
+    import_os5 = __toESM(require("os"));
+    init_logger();
+    init_src();
+    SECRET_DIR = import_path6.default.join(import_os5.default.homedir(), ".crc-agent");
+  }
+});
+
+// src/vpn-manager.ts
+function shq2(value) {
+  return value.replace(/'/g, "'\\''");
+}
+function psq(value) {
+  return value.replace(/'/g, "''");
+}
+async function runCmd(cmd2, shell) {
+  try {
+    return await execAsync(cmd2, {
+      timeout: 2e4,
+      shell: shell || (isWindows ? "powershell.exe" : "/bin/sh")
+    });
+  } catch (err) {
+    return { stdout: err.stdout || "", stderr: err.stderr || err.message };
+  }
+}
+function getConfigPath(profile) {
+  const file = profile.configFile || `${profile.id}.conf`;
+  if (import_path7.default.isAbsolute(file)) return file;
+  return import_path7.default.join(VPN_DIR, file);
+}
+async function getScutilStatus(serviceName) {
+  const { stdout } = await runCmd(`scutil --nc status '${shq2(serviceName)}'`);
+  const firstLine = stdout.trim().split("\n")[0];
+  if (firstLine === "Connected") return "connected";
+  if (firstLine === "Connecting") return "connecting";
+  if (firstLine === "Disconnecting") return "disconnecting";
+  return "disconnected";
+}
+async function scutilStart(serviceName) {
+  const { stderr } = await runCmd(`scutil --nc start '${shq2(serviceName)}'`);
+  return stderr || null;
+}
+async function scutilStop(serviceName) {
+  const { stderr } = await runCmd(`scutil --nc stop '${shq2(serviceName)}'`);
+  return stderr || null;
+}
+async function runOsascript(script) {
+  return runCmd(
+    `osascript -e 'with timeout of 15 seconds' -e ${JSON.stringify(script)} -e 'end timeout'`
+  );
+}
+function asq(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function getTunnelblickStatus(configName) {
+  const { stdout } = await runOsascript(
+    `tell application "Tunnelblick" to get state of first configuration where name = "${asq(configName)}"`
+  );
+  const s = stdout.trim();
+  if (s === "CONNECTED") return "connected";
+  if (s === "CONNECTING" || s === "RECONNECTING") return "connecting";
+  if (s === "DISCONNECTING") return "disconnecting";
+  return "disconnected";
+}
+async function tunnelblickConnect(configName) {
+  const { stderr } = await runOsascript(
+    `tell application "Tunnelblick" to connect "${asq(configName)}"`
+  );
+  return stderr || null;
+}
+async function tunnelblickDisconnect(configName) {
+  const { stderr } = await runOsascript(
+    `tell application "Tunnelblick" to disconnect "${asq(configName)}"`
+  );
+  return stderr || null;
+}
+async function getWireGuardStatus(profile) {
+  if (isWindows) {
+    const tunnelName2 = profile.tunnelName || profile.id;
+    const { stdout: stdout2 } = await runCmd(
+      `Get-Service -Name 'WireGuardTunnel$${psq(tunnelName2)}' -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Status`
+    );
+    const s = stdout2.trim();
+    if (s === "Running") return "connected";
+    if (s === "StartPending") return "connecting";
+    if (s === "StopPending") return "disconnecting";
+    return "disconnected";
+  }
+  if (profile.serviceName) {
+    return getScutilStatus(profile.serviceName);
+  }
+  const tunnelName = profile.tunnelName || profile.id;
+  const { stdout } = await runCmd(`wg show '${shq2(tunnelName)}' 2>/dev/null`);
+  return stdout.trim() ? "connected" : "disconnected";
+}
+async function getOpenVpnStatus(profile) {
+  if (isWindows) {
+    const { stdout: stdout2 } = await runCmd(
+      `Get-Service -Name 'ovpnconnector' -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Status`
+    );
+    if (stdout2.trim() === "Running") {
+      const { stdout: netOut } = await runCmd(
+        `Get-NetAdapter | Where-Object { $_.InterfaceDescription -like '*OpenVPN*' -and $_.Status -eq 'Up' } | Measure-Object | Select-Object -ExpandProperty Count`
+      );
+      return parseInt(netOut.trim(), 10) > 0 ? "connected" : "connecting";
+    }
+    return "disconnected";
+  }
+  if (profile.tunnelblickName) {
+    return getTunnelblickStatus(profile.tunnelblickName);
+  }
+  if (profile.serviceName) {
+    return getScutilStatus(profile.serviceName);
+  }
+  const { stdout } = await runCmd('pgrep -f "openvpn.*\\.ovpn" | head -1');
+  return stdout.trim() ? "connected" : "disconnected";
+}
+async function getAzureStatus(profile) {
+  if (isWindows) {
+    return getOpenVpnStatus(profile);
+  }
+  if (profile.serviceName) {
+    return getScutilStatus(profile.serviceName);
+  }
+  return "disconnected";
+}
+async function getStatus(profile) {
+  try {
+    if (profile.type === "wireguard") {
+      return await getWireGuardStatus(profile);
+    }
+    if (profile.type === "azure") {
+      return await getAzureStatus(profile);
+    }
+    return await getOpenVpnStatus(profile);
+  } catch (err) {
+    logger.error({ profile: profile.id, error: err.message }, "Status check failed");
+    return "disconnected";
+  }
+}
+async function connectWireGuard(profile) {
+  const tunnelName = profile.tunnelName || profile.id;
+  if (isWindows) {
+    const confPath2 = getConfigPath(profile);
+    if (!import_fs7.default.existsSync(confPath2)) {
+      return `Config file not found: ${confPath2}`;
+    }
+    const script = `
+      & 'C:\\Program Files\\WireGuard\\wireguard.exe' /installtunnelservice '${confPath2.replace(/'/g, "''")}';
+      Start-Sleep -Seconds 2;
+      Set-Service -Name 'WireGuardTunnel$${psq(tunnelName)}' -StartupType Manual -ErrorAction SilentlyContinue
+    `.trim();
+    await runCmd(
+      `Start-Process powershell -ArgumentList '-NoProfile','-Command','${script.replace(/'/g, "''")}' -Verb RunAs -Wait -ErrorAction Stop 2>&1`
+    );
+    await new Promise((r) => setTimeout(r, 2e3));
+    const status = await getWireGuardStatus(profile);
+    if (status !== "connected") return "Tunnel installed but not connected \u2014 check WireGuard GUI";
+    return null;
+  }
+  if (profile.serviceName) {
+    return scutilStart(profile.serviceName);
+  }
+  const confPath = getConfigPath(profile);
+  const { stderr } = await runCmd(`sudo wg-quick up '${shq2(confPath)}'`);
+  return stderr || null;
+}
+async function connectOpenVpn(profile) {
+  if (isWindows) {
+    const confPath2 = getConfigPath(profile);
+    if (!import_fs7.default.existsSync(confPath2)) {
+      return `Config file not found: ${confPath2}`;
+    }
+    const connector = "C:\\Program Files\\OpenVPN Connect\\ovpnconnector.exe";
+    await runCmd(`Stop-Process -Name 'OpenVPNConnect' -Force -ErrorAction SilentlyContinue`);
+    await runCmd(`& '${connector}' install 2>&1`);
+    await runCmd(`& '${connector}' stop 2>&1`);
+    await new Promise((r) => setTimeout(r, 1e3));
+    const { stdout: setOut, stderr: setErr } = await runCmd(`& '${connector}' set-config profile '${psq(confPath2)}' 2>&1`);
+    const setOutput = setOut + setErr;
+    if (setOutput.toLowerCase().includes("failed")) {
+      return `Failed to set profile: ${setOutput.trim()}`;
+    }
+    const { stdout: startOut, stderr: startErr } = await runCmd(`& '${connector}' start 2>&1`);
+    const startOutput = startOut + startErr;
+    if (startOutput.toLowerCase().includes("error") || startOutput.toLowerCase().includes("aborting")) {
+      return startOutput.trim();
+    }
+    return null;
+  }
+  if (profile.tunnelblickName) {
+    return tunnelblickConnect(profile.tunnelblickName);
+  }
+  if (profile.serviceName) {
+    return scutilStart(profile.serviceName);
+  }
+  const confPath = getConfigPath(profile);
+  if (!import_fs7.default.existsSync(confPath)) {
+    return `Config file not found: ${confPath}`;
+  }
+  const { stderr } = await runCmd(`sudo openvpn --config '${shq2(confPath)}' --daemon`);
+  return stderr || null;
+}
+async function connectAzure(profile) {
+  if (isWindows) {
+    const confPath = getConfigPath(profile);
+    if (!import_fs7.default.existsSync(confPath)) {
+      return `Config file not found: ${confPath}`;
+    }
+    await runCmd(`& 'AzureVpn.exe' -i '${psq(confPath)}' 2>&1`);
+    await new Promise((r) => setTimeout(r, 2e3));
+    await runCmd(`Start-Process 'shell:AppsFolder\\Microsoft.AzureVpn_8wekyb3d8bbwe!App'`);
+    return "Azure VPN app opened \u2014 requires Azure AD sign-in to connect";
+  }
+  if (profile.serviceName) {
+    const err = await scutilStart(profile.serviceName);
+    if (err) return err;
+    await runCmd(`open -a 'Azure VPN Client'`);
+    return null;
+  }
+  return "Azure VPN: set serviceName in config (from scutil --nc list)";
+}
+async function disconnectAzure(profile) {
+  if (isWindows) {
+    await runCmd(`Start-Process 'shell:AppsFolder\\Microsoft.AzureVpn_8wekyb3d8bbwe!App'`);
+    return "Azure VPN app opened \u2014 disconnect from the app";
+  }
+  if (profile.serviceName) {
+    return scutilStop(profile.serviceName);
+  }
+  return "Azure VPN: set serviceName in config (from scutil --nc list)";
+}
+async function disconnectWireGuard(profile) {
+  const tunnelName = profile.tunnelName || profile.id;
+  if (isWindows) {
+    const script = `& 'C:\\Program Files\\WireGuard\\wireguard.exe' /uninstalltunnelservice '${psq(tunnelName)}'`;
+    await runCmd(
+      `Start-Process powershell -ArgumentList '-NoProfile','-Command','${script.replace(/'/g, "''")}' -Verb RunAs -Wait -ErrorAction Stop 2>&1`
+    );
+    await new Promise((r) => setTimeout(r, 2e3));
+    const status = await getWireGuardStatus(profile);
+    if (status === "connected") {
+      return "Failed to disconnect \u2014 try disconnecting from WireGuard GUI";
+    }
+    return null;
+  }
+  if (profile.serviceName) {
+    return scutilStop(profile.serviceName);
+  }
+  const confPath = getConfigPath(profile);
+  const { stderr } = await runCmd(`sudo wg-quick down '${shq2(confPath)}'`);
+  return stderr || null;
+}
+async function disconnectOpenVpn(profile) {
+  if (isWindows) {
+    const connector = "C:\\Program Files\\OpenVPN Connect\\ovpnconnector.exe";
+    const { stderr, stdout } = await runCmd(`& '${connector}' stop 2>&1`);
+    const output = stdout + stderr;
+    if (output.toLowerCase().includes("error")) return output.trim();
+    return null;
+  }
+  if (profile.tunnelblickName) {
+    return tunnelblickDisconnect(profile.tunnelblickName);
+  }
+  if (profile.serviceName) {
+    return scutilStop(profile.serviceName);
+  }
+  await runCmd('sudo pkill -f "openvpn.*\\.ovpn"');
+  return null;
+}
+async function getProfiles(configs) {
+  const profiles = [];
+  for (const cfg of configs) {
+    const status = await getStatus(cfg);
+    profiles.push({ id: cfg.id, name: cfg.name, type: cfg.type, status });
+  }
+  return profiles;
+}
+async function connectVpn(configs, profileId) {
+  const cfg = configs.find((c) => c.id === profileId);
+  if (!cfg) return getProfiles(configs);
+  logger.info({ profileId, type: cfg.type }, "Connecting VPN");
+  let error = null;
+  if (cfg.type === "wireguard") {
+    error = await connectWireGuard(cfg);
+  } else if (cfg.type === "azure") {
+    error = await connectAzure(cfg);
+  } else {
+    error = await connectOpenVpn(cfg);
+  }
+  if (error) logger.error({ profileId, error }, "VPN connect failed");
+  await new Promise((r) => setTimeout(r, 3e3));
+  const profiles = await getProfiles(configs);
+  if (error) {
+    const p = profiles.find((p2) => p2.id === profileId);
+    if (p) {
+      p.status = "error";
+      p.error = error.slice(0, 200);
+    }
+  }
+  return profiles;
+}
+async function disconnectVpn(configs, profileId) {
+  const cfg = configs.find((c) => c.id === profileId);
+  if (!cfg) return getProfiles(configs);
+  logger.info({ profileId, type: cfg.type }, "Disconnecting VPN");
+  let error = null;
+  if (cfg.type === "wireguard") {
+    error = await disconnectWireGuard(cfg);
+  } else if (cfg.type === "azure") {
+    error = await disconnectAzure(cfg);
+  } else {
+    error = await disconnectOpenVpn(cfg);
+  }
+  if (error) logger.error({ profileId, error }, "VPN disconnect failed");
+  await new Promise((r) => setTimeout(r, 2e3));
+  const profiles = await getProfiles(configs);
+  if (error) {
+    const p = profiles.find((p2) => p2.id === profileId);
+    if (p) {
+      p.status = "error";
+      p.error = error.slice(0, 200);
+    }
+  }
+  return profiles;
+}
+var import_child_process5, import_util3, import_fs7, import_path7, import_os6, execAsync, isWindows, VPN_DIR;
+var init_vpn_manager = __esm({
+  "src/vpn-manager.ts"() {
+    "use strict";
+    import_child_process5 = require("child_process");
+    import_util3 = require("util");
+    import_fs7 = __toESM(require("fs"));
+    import_path7 = __toESM(require("path"));
+    import_os6 = __toESM(require("os"));
+    init_logger();
+    execAsync = (0, import_util3.promisify)(import_child_process5.exec);
+    isWindows = process.platform === "win32";
+    VPN_DIR = import_path7.default.join(import_os6.default.homedir(), ".crc-agent", "vpn");
+  }
+});
+
+// src/claude-path.ts
+function encodeProjectPath(projectPath) {
+  return projectPath.replace(/[^A-Za-z0-9]/g, "-");
+}
+function findProjectDirs(allDirs, filterProjectPath) {
+  const encoded = encodeProjectPath(filterProjectPath);
+  if (allDirs.includes(encoded)) {
+    return [encoded];
+  }
+  const lowerEncoded = encoded.toLowerCase();
+  const caseMatch = allDirs.filter((d) => d.toLowerCase() === lowerEncoded);
+  if (caseMatch.length > 0) {
+    return caseMatch;
+  }
+  const isAnchoredMatch = (a, b) => {
+    if (a === b) return true;
+    if (a.startsWith(b) && a[b.length] === "-") return true;
+    if (b.startsWith(a) && b[a.length] === "-") return true;
+    return false;
+  };
+  return allDirs.filter((d) => isAnchoredMatch(d.toLowerCase(), lowerEncoded));
+}
+var init_claude_path = __esm({
+  "src/claude-path.ts"() {
+    "use strict";
+  }
+});
+
+// src/claude-sessions.ts
+async function parseSessionFile(filePath) {
+  try {
+    const stream = import_fs8.default.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = import_readline2.default.createInterface({ input: stream, crlfDelay: Infinity });
+    let firstMessage = "";
+    let lastTimestamp = "";
+    let messageCount = 0;
+    let model;
+    let slug;
+    let gitBranch;
+    let cwd;
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.timestamp) lastTimestamp = obj.timestamp;
+        if (obj.cwd && !cwd) cwd = obj.cwd;
+        if (obj.type === "user" && !firstMessage) {
+          const content = obj.message?.content;
+          if (typeof content === "string") {
+            firstMessage = content.slice(0, 200);
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block?.type === "text" && block.text) {
+                firstMessage = block.text.slice(0, 200);
+                break;
+              }
+            }
+          }
+          messageCount++;
+        } else if (obj.type === "user" || obj.type === "assistant") {
+          messageCount++;
+          if (obj.type === "assistant") {
+            if (obj.message?.model) model = obj.message.model;
+            if (obj.slug) slug = obj.slug;
+          }
+          if (obj.gitBranch) gitBranch = obj.gitBranch;
+        }
+      } catch {
+      }
+    }
+    if (!firstMessage && messageCount === 0) return null;
+    return { firstMessage: firstMessage || "(no message)", lastTimestamp, messageCount, model, slug, gitBranch, cwd };
+  } catch (err) {
+    logger.error({ filePath, error: err.message }, "Failed to parse session file");
+    return null;
+  }
+}
+async function listClaudeSessions(filterProjectPath) {
+  const sessions2 = [];
+  if (!import_fs8.default.existsSync(CLAUDE_PROJECTS_DIR)) return sessions2;
+  const isDirSafe = (d) => {
+    try {
+      return import_fs8.default.statSync(import_path8.default.join(CLAUDE_PROJECTS_DIR, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  let allEntries;
+  try {
+    allEntries = import_fs8.default.readdirSync(CLAUDE_PROJECTS_DIR);
+  } catch {
+    return sessions2;
+  }
+  let projectDirs;
+  if (filterProjectPath) {
+    const allDirs = allEntries.filter(isDirSafe);
+    projectDirs = findProjectDirs(allDirs, filterProjectPath);
+    if (projectDirs.length === 0) return sessions2;
+  } else {
+    projectDirs = allEntries.filter((d) => isDirSafe(d) && !d.startsWith("-private-"));
+  }
+  for (const dirName of projectDirs) {
+    const dirPath = import_path8.default.join(CLAUDE_PROJECTS_DIR, dirName);
+    let files;
+    try {
+      files = import_fs8.default.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const sessionId = file.replace(".jsonl", "");
+      const parsed = await parseSessionFile(import_path8.default.join(dirPath, file));
+      if (!parsed) continue;
+      const projectPath = parsed.cwd || dirName.replace(/^-/, "/").replace(/-/g, "/");
+      sessions2.push({
+        sessionId,
+        projectPath,
+        firstMessage: parsed.firstMessage,
+        lastTimestamp: parsed.lastTimestamp,
+        messageCount: parsed.messageCount,
+        model: parsed.model,
+        slug: parsed.slug,
+        gitBranch: parsed.gitBranch
+      });
+    }
+  }
+  sessions2.sort((a, b) => b.lastTimestamp > a.lastTimestamp ? 1 : -1);
+  return sessions2;
+}
+var import_fs8, import_path8, import_os7, import_readline2, CLAUDE_PROJECTS_DIR;
+var init_claude_sessions = __esm({
+  "src/claude-sessions.ts"() {
+    "use strict";
+    import_fs8 = __toESM(require("fs"));
+    import_path8 = __toESM(require("path"));
+    import_os7 = __toESM(require("os"));
+    import_readline2 = __toESM(require("readline"));
+    init_logger();
+    init_claude_path();
+    CLAUDE_PROJECTS_DIR = import_path8.default.join(import_os7.default.homedir(), ".claude", "projects");
+  }
+});
+
+// src/claude-conversation.ts
+function findProjectDir(projectPath) {
+  const encoded = encodeProjectPath(projectPath);
+  const dirPath = import_path9.default.join(CLAUDE_PROJECTS_DIR2, encoded);
+  if (import_fs9.default.existsSync(dirPath)) return dirPath;
+  if (!import_fs9.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
+  let allDirs;
+  try {
+    allDirs = import_fs9.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
+      try {
+        return import_fs9.default.statSync(import_path9.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return null;
+  }
+  const matches = findProjectDirs(allDirs, projectPath);
+  if (matches.length > 0) {
+    return import_path9.default.join(CLAUDE_PROJECTS_DIR2, matches[0]);
+  }
+  return null;
+}
+function findSessionFileById(sessionId) {
+  if (!/^[A-Za-z0-9._-]+$/.test(sessionId)) return null;
+  if (!import_fs9.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
+  let dirs;
+  try {
+    dirs = import_fs9.default.readdirSync(CLAUDE_PROJECTS_DIR2);
+  } catch {
+    return null;
+  }
+  for (const dir of dirs) {
+    const candidate = import_path9.default.join(CLAUDE_PROJECTS_DIR2, dir, `${sessionId}.jsonl`);
+    try {
+      if (import_fs9.default.statSync(candidate).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function findLatestSessionFile(projectPath) {
+  const dirPath = findProjectDir(projectPath);
+  if (!dirPath) return null;
+  let entries;
+  try {
+    entries = import_fs9.default.readdirSync(dirPath);
+  } catch {
+    return null;
+  }
+  const files = entries.filter((f) => f.endsWith(".jsonl") && !f.includes("/")).map((f) => {
+    try {
+      return { name: f, mtime: import_fs9.default.statSync(import_path9.default.join(dirPath, f)).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+  if (files.length === 0) return null;
+  return {
+    filePath: import_path9.default.join(dirPath, files[0].name),
+    sessionId: files[0].name.replace(".jsonl", "")
+  };
+}
+async function readConversation(projectPath, afterLine = 0, specificSessionId) {
+  let filePath;
+  let sessionId;
+  if (specificSessionId) {
+    sessionId = specificSessionId;
+    const dirPath = findProjectDir(projectPath);
+    const direct = dirPath ? import_path9.default.join(dirPath, `${specificSessionId}.jsonl`) : null;
+    if (direct && import_fs9.default.existsSync(direct)) {
+      filePath = direct;
+    } else {
+      const byId = findSessionFileById(specificSessionId);
+      if (!byId) return null;
+      filePath = byId;
+    }
+  } else {
+    const found = findLatestSessionFile(projectPath);
+    if (!found) return null;
+    filePath = found.filePath;
+    sessionId = found.sessionId;
+  }
+  try {
+    const stream = import_fs9.default.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = import_readline3.default.createInterface({ input: stream, crlfDelay: Infinity });
+    const messages = [];
+    let lineNum = 0;
+    for await (const line of rl) {
+      lineNum++;
+      if (lineNum <= afterLine) continue;
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "user") {
+          const content = obj.message?.content;
+          let text = "";
+          if (typeof content === "string") {
+            text = content;
+          } else if (Array.isArray(content)) {
+            text = content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+          }
+          if (text) {
+            messages.push({
+              type: "user",
+              content: text,
+              timestamp: obj.timestamp
+            });
+          }
+        } else if (obj.type === "assistant") {
+          const content = obj.message?.content;
+          if (!Array.isArray(content)) continue;
+          for (const block of content) {
+            if (block.type === "text" && block.text?.trim()) {
+              messages.push({
+                type: "assistant",
+                content: block.text,
+                timestamp: obj.timestamp,
+                model: obj.message?.model
+              });
+            } else if (block.type === "tool_use") {
+              let inputSummary = "";
+              const input = block.input || {};
+              if (input.command) inputSummary = input.command;
+              else if (input.file_path) inputSummary = input.file_path;
+              else if (input.pattern) inputSummary = input.pattern;
+              else if (input.prompt) inputSummary = input.prompt.slice(0, 100);
+              else {
+                const keys = Object.keys(input);
+                if (keys.length > 0) inputSummary = keys.join(", ");
+              }
+              messages.push({
+                type: "tool_use",
+                content: inputSummary,
+                toolName: block.name,
+                toolId: block.id,
+                timestamp: obj.timestamp
+              });
+            } else if (block.type === "tool_result") {
+              let resultText = "";
+              if (typeof block.content === "string") {
+                resultText = block.content;
+              } else if (Array.isArray(block.content)) {
+                resultText = block.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+              }
+              if (resultText) {
+                messages.push({
+                  type: "tool_result",
+                  content: resultText.length > 500 ? resultText.slice(0, 500) + "..." : resultText,
+                  toolId: block.tool_use_id,
+                  timestamp: obj.timestamp
+                });
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return { sessionId, messages, totalLines: lineNum };
+  } catch (err) {
+    logger.error({ filePath, error: err.message }, "Failed to read conversation");
+    return null;
+  }
+}
+var import_fs9, import_path9, import_os8, import_readline3, CLAUDE_PROJECTS_DIR2;
+var init_claude_conversation = __esm({
+  "src/claude-conversation.ts"() {
+    "use strict";
+    import_fs9 = __toESM(require("fs"));
+    import_path9 = __toESM(require("path"));
+    import_os8 = __toESM(require("os"));
+    import_readline3 = __toESM(require("readline"));
+    init_logger();
+    init_claude_path();
+    CLAUDE_PROJECTS_DIR2 = import_path9.default.join(import_os8.default.homedir(), ".claude", "projects");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+var import_socket, config, socket, SESSION_MAX_IDLE_MS, reaperInterval, vpnProfiles;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_socket = require("socket.io-client");
+    init_src();
+    init_config();
+    init_logger();
+    init_claude_plugin_installer();
+    init_local_control();
+    init_tmux();
+    init_shell();
+    init_heartbeat();
+    init_file_explorer();
+    init_vpn_manager();
+    init_claude_sessions();
+    init_claude_conversation();
+    init_terminal_manager();
+    if (!isConfigured()) {
+      console.error("No agent configured. Run: crc-agent setup");
+      process.exit(1);
+    }
+    config = loadConfig();
+    logger.info({ agentId: config.agentId, serverUrl: config.serverUrl }, "Starting agent");
+    process.on("unhandledRejection", (reason) => {
+      logger.error({ reason }, "Unhandled promise rejection (agent kept alive)");
+    });
+    process.on("uncaughtException", (err) => {
+      logger.error({ error: err instanceof Error ? err.message : String(err) }, "Uncaught exception (agent kept alive)");
+    });
+    installClaudeHooks(LOCAL_CONTROL_PORT);
+    socket = (0, import_socket.io)(config.serverUrl + "/agent", {
+      auth: { agentId: config.agentId, secret: config.secret },
+      transports: ["websocket"],
+      reconnection: true,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 3e4,
+      reconnectionAttempts: Infinity
+    });
+    socket.on("connect", () => {
+      logger.info("Connected to server");
+      socket.emit(AGENT_HEARTBEAT, buildHeartbeat(config.homeDir));
+    });
+    socket.on("connect_error", (err) => {
+      logger.error({ error: err.message }, "Connection error");
+    });
+    socket.on("disconnect", (reason) => {
+      logger.warn({ reason }, "Disconnected from server");
+      detachAllSessions();
+    });
+    setInterval(() => {
+      if (socket.connected) {
+        socket.emit(AGENT_HEARTBEAT, buildHeartbeat(config.homeDir));
+      }
+    }, HEARTBEAT_INTERVAL);
+    SESSION_MAX_IDLE_MS = 6 * 60 * 60 * 1e3;
+    reaperInterval = setInterval(() => {
+      const reaped = reapDetachedSessions(SESSION_MAX_IDLE_MS);
+      if (reaped.length > 0) {
+        logger.info({ sessionIds: reaped, count: reaped.length }, "Reaped detached sessions");
+      }
+    }, 6e4);
+    reaperInterval.unref();
+    startLocalControl(LOCAL_CONTROL_PORT, (raw) => {
+      const payload = normalizeClaudeHook(raw);
+      if (!payload) return;
+      logger.info(
+        { rawEvent: raw?.hook_event_name || raw?.event, mapped: payload.event, project: payload.projectPath || null },
+        "Claude hook received"
+      );
+      const transcript = raw?.transcript_path;
+      if (payload.event === "stop" && typeof transcript === "string") {
+        setTimeout(() => {
+          payload.response = lastAssistantSummary(transcript);
+          if (socket.connected) socket.emit(CLAUDE_HOOK, payload);
+        }, 600);
+      } else if (socket.connected) {
+        socket.emit(CLAUDE_HOOK, payload);
+      }
+    });
+    socket.on(TERMINAL_OPEN, (payload) => {
+      const { sessionId, cols, rows, tmux, launch } = payload;
+      if (!sessionId) return;
+      const launchSpec = tmux ? buildTmuxLaunch(tmux, launch, detectShell(config.shell)) : void 0;
+      createTerminalSession(
+        sessionId,
+        cols,
+        rows,
+        config.shell,
+        config.homeDir,
+        (sid, data) => {
+          socket.emit(TERMINAL_OUTPUT, { sessionId: sid, data });
+        },
+        (sid, exitCode) => {
+          socket.emit(TERMINAL_EXIT, { sessionId: sid, exitCode });
+        },
+        launchSpec
+      );
+    });
+    socket.on(TMUX_LIST, async (payload) => {
+      const { requestId } = payload;
+      if (!requestId) return;
+      try {
+        const sessions2 = await listTmuxSessions();
+        socket.emit(TMUX_LIST_RESULT, { requestId, sessions: sessions2 });
+      } catch (err) {
+        socket.emit(TMUX_LIST_RESULT, { requestId, sessions: [], error: err?.message || "tmux list failed" });
+      }
+    });
+    socket.on(TERMINAL_INPUT, (payload) => {
+      writeToSession(payload.sessionId, payload.data);
+    });
+    socket.on(TERMINAL_RESIZE, (payload) => {
+      resizeSession(payload.sessionId, payload.cols, payload.rows);
+    });
+    socket.on(TERMINAL_CLOSE, (payload) => {
+      closeSession(payload.sessionId);
+    });
+    socket.on(SESSION_SYNC, () => {
+      const aliveIds = getAliveSessionIds();
+      socket.emit(SESSION_SYNC_RESULT, { sessionIds: aliveIds });
+      logger.info({ count: aliveIds.length }, "Session sync responded");
+    });
+    socket.on(SESSION_ATTACH, (payload) => {
+      const buffered = attachSession(payload.sessionId, payload.cols, payload.rows);
+      if (buffered) {
+        socket.emit(SESSION_BUFFER, { sessionId: payload.sessionId, data: buffered });
+      }
+    });
+    socket.on(SESSION_DETACH, (payload) => {
+      detachSession(payload.sessionId);
+    });
+    socket.on(FILES_LIST, (payload) => {
+      const { requestId, path: dirPath } = payload;
+      if (!requestId) return;
+      const result = listDirectory(dirPath);
+      socket.emit(FILES_LIST_RESULT, {
+        requestId,
+        path: dirPath,
+        entries: result.entries,
+        error: result.error
+      });
+    });
+    socket.on(FILES_DOWNLOAD, async (payload) => {
+      const { requestId, path: filePath } = payload;
+      if (!requestId) return;
+      const result = await downloadFile(filePath, config.serverUrl, config.secret, config.agentId);
+      if ("error" in result) {
+        logger.error({ requestId, error: result.error }, "File download failed");
+        socket.emit(FILES_DOWNLOAD_ERROR, { requestId, error: result.error });
+        return;
+      }
+      socket.emit(FILES_DOWNLOAD_READY, {
+        requestId,
+        fileId: result.fileId,
+        fileName: result.fileName,
+        downloadUrl: result.downloadUrl,
+        size: result.size
+      });
+    });
+    vpnProfiles = process.platform === "win32" ? [] : config.vpn?.profiles || [];
+    socket.on(VPN_LIST, async () => {
+      const profiles = await getProfiles(vpnProfiles);
+      socket.emit(VPN_UPDATE, { profiles });
+    });
+    socket.on(VPN_CONNECT, async (payload) => {
+      const profiles = await connectVpn(vpnProfiles, payload.profileId);
+      socket.emit(VPN_UPDATE, { profiles });
+    });
+    socket.on(VPN_DISCONNECT, async (payload) => {
+      const profiles = await disconnectVpn(vpnProfiles, payload.profileId);
+      socket.emit(VPN_UPDATE, { profiles });
+    });
+    socket.on(AGENT_EXEC, async (payload) => {
+      const { requestId, command, cwd } = payload;
+      if (!requestId) return;
+      const { exec: exec2 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync2 = promisify4(exec2);
+      try {
+        const { stdout, stderr } = await execAsync2(command, { cwd, timeout: 3e4 });
+        socket.emit(AGENT_EXEC_RESULT, { requestId, stdout: stdout || "", stderr: stderr || "" });
+      } catch (err) {
+        socket.emit(AGENT_EXEC_RESULT, {
+          requestId,
+          stdout: err.stdout || "",
+          stderr: err.stderr || "",
+          error: err.message
+        });
+      }
+    });
+    socket.on(CLAUDE_CONV_READ, async (payload) => {
+      try {
+        const result = await readConversation(payload.projectPath, payload.afterLine || 0, payload.sessionId);
+        if (result) {
+          socket.emit(CLAUDE_CONV_DATA, {
+            sessionId: result.sessionId,
+            messages: result.messages,
+            totalLines: result.totalLines
+          });
+        } else {
+          socket.emit(CLAUDE_CONV_DATA, {
+            sessionId: "",
+            messages: [],
+            totalLines: 0,
+            error: "No conversation found"
+          });
+        }
+      } catch (err) {
+        logger.error({ error: err?.message }, "Failed to read conversation");
+        socket.emit(CLAUDE_CONV_DATA, {
+          sessionId: "",
+          messages: [],
+          totalLines: 0,
+          error: err?.message || "Failed to read conversation"
+        });
+      }
+    });
+    socket.on(CLAUDE_SESSIONS_LIST, async (payload) => {
+      try {
+        const sessions2 = await listClaudeSessions(payload.projectPath);
+        socket.emit(CLAUDE_SESSIONS_RESULT, { sessions: sessions2 });
+      } catch (err) {
+        logger.error({ error: err?.message }, "Failed to list Claude sessions");
+        socket.emit(CLAUDE_SESSIONS_RESULT, { sessions: [], error: err?.message || "Failed to list sessions" });
+      }
+    });
+    process.on("SIGINT", () => {
+      logger.info("Shutting down...");
+      closeAllSessions();
+      socket.disconnect();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      logger.info("Shutting down...");
+      closeAllSessions();
+      socket.disconnect();
+      process.exit(0);
+    });
+  }
+});
+
+// src/cli.ts
+var cmd = process.argv[2];
+if (cmd === "setup") {
+  process.argv.splice(2, 1);
+  Promise.resolve().then(() => init_setup());
+} else if (cmd === "--help" || cmd === "-h") {
+  console.log(
+    [
+      "Usage: crc-agent [setup [--token <token>]]",
+      "",
+      "Run with no arguments to start the agent.",
+      "Enroll this machine first with: crc-agent setup --help"
+    ].join("\n")
+  );
+} else {
+  Promise.resolve().then(() => init_index());
+}
+//# sourceMappingURL=cli.js.map