cli-remote-agent 1.0.0

package/dist/index.js

@@ -0,0 +1,1526 @@
+#!/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 __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/index.ts
+var import_socket = require("socket.io-client");
+
+// ../shared/src/protocol.ts
+var AGENT_HEARTBEAT = "agent:heartbeat";
+var TERMINAL_OUTPUT = "terminal:output";
+var TERMINAL_EXIT = "terminal:exit";
+var TERMINAL_OPEN = "terminal:open";
+var TERMINAL_INPUT = "terminal:input";
+var TERMINAL_RESIZE = "terminal:resize";
+var TERMINAL_CLOSE = "terminal:close";
+var SESSION_ATTACH = "session:attach";
+var SESSION_DETACH = "session:detach";
+var SESSION_BUFFER = "session:buffer";
+var SESSION_SYNC = "session:sync";
+var SESSION_SYNC_RESULT = "session:sync:result";
+var VPN_LIST = "vpn:list";
+var VPN_CONNECT = "vpn:connect";
+var VPN_DISCONNECT = "vpn:disconnect";
+var VPN_UPDATE = "vpn:update";
+var FILES_LIST = "files:list";
+var FILES_DOWNLOAD = "files:download";
+var FILES_LIST_RESULT = "files:list:result";
+var FILES_DOWNLOAD_READY = "files:download:ready";
+var FILES_DOWNLOAD_ERROR = "files:download:error";
+var AGENT_EXEC = "agent:exec";
+var AGENT_EXEC_RESULT = "agent:exec:result";
+var CLAUDE_CONV_READ = "claude:conv:read";
+var CLAUDE_CONV_DATA = "claude:conv:data";
+var CLAUDE_SESSIONS_LIST = "claude:sessions:list";
+var CLAUDE_SESSIONS_RESULT = "claude:sessions:result";
+var CLAUDE_HOOK = "claude:hook";
+var TMUX_LIST = "tmux:list";
+var TMUX_LIST_RESULT = "tmux:list:result";
+
+// ../shared/src/constants.ts
+var HEARTBEAT_INTERVAL = 15e3;
+var SESSION_BUFFER_SIZE = 5e4;
+var FILE_MAX_SIZE = 524288e3;
+
+// src/config.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_crypto = __toESM(require("crypto"));
+var CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".crc-agent");
+var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+var PLACEHOLDER_SECRET = "changeme";
+var LOCAL_CONTROL_PORT = Number(process.env.CRC_LOCAL_PORT) || 47600;
+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();
+  }
+}
+
+// src/logger.ts
+var import_pino = __toESM(require("pino"));
+var logger = (0, import_pino.default)({
+  level: "info",
+  transport: { target: "pino-pretty", options: { colorize: true } }
+});
+
+// src/claude-plugin-installer.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+function getSettingsPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return (0, import_path2.join)(home, ".claude", "settings.json");
+}
+var INSTALL_EVENTS = ["Stop"];
+var MANAGED_EVENTS = ["Stop", "Notification", "SubagentStop"];
+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_fs2.existsSync)(settingsPath)) {
+      settings = JSON.parse((0, import_fs2.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_fs2.mkdirSync)((0, import_path2.dirname)(settingsPath), { recursive: true });
+    (0, import_fs2.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_fs2.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;
+}
+
+// src/local-control.ts
+var import_http = __toESM(require("http"));
+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;
+}
+
+// src/tmux.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+var IS_WIN = process.platform === "win32";
+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 execFileAsync(file, args, { timeout: 6e3 });
+    return 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
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+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 cmd = `tmux set-option -g aggressive-resize on 2>/dev/null; exec tmux new-session -A -s ${shq(name)}`;
+  if (trimmed) cmd += ` ${shq(trimmed)}`;
+  return { file: shell, args: ["-l", "-c", cmd] };
+}
+
+// src/shell.ts
+var import_child_process2 = require("child_process");
+function detectShell(preference) {
+  if (preference !== "auto") return preference;
+  if (process.platform === "win32") {
+    try {
+      (0, import_child_process2.execSync)("where pwsh", { stdio: "ignore" });
+      return "pwsh.exe";
+    } catch {
+      return "powershell.exe";
+    }
+  }
+  return process.env.SHELL || "/bin/bash";
+}
+
+// src/heartbeat.ts
+var import_os3 = __toESM(require("os"));
+var import_path4 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+
+// src/pty-session.ts
+var pty = __toESM(require("node-pty"));
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os2 = require("os");
+var THRESHOLD = 3;
+var INIT_DIR = (0, import_path3.join)((0, import_os2.tmpdir)(), "crc-shell-init");
+var BASH_INIT = (0, import_path3.join)(INIT_DIR, "bashrc");
+var ZSH_DIR = (0, import_path3.join)(INIT_DIR, "zsh");
+var ZSH_RC = (0, import_path3.join)(ZSH_DIR, ".zshrc");
+var ZSH_ENV = (0, import_path3.join)(ZSH_DIR, ".zshenv");
+var INIT_VERSION = "2";
+function ensureInitFiles() {
+  const versionFile = (0, import_path3.join)(INIT_DIR, ".version");
+  if ((0, import_fs3.existsSync)(versionFile)) {
+    try {
+      if ((0, import_fs3.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
+    } catch {
+    }
+  }
+  (0, import_fs3.mkdirSync)(ZSH_DIR, { recursive: true });
+  (0, import_fs3.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_fs3.writeFileSync)(ZSH_ENV, [
+    '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshenv" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshenv"',
+    ""
+  ].join("\n"), "utf-8");
+  (0, import_fs3.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_fs3.writeFileSync)(versionFile, INIT_VERSION, "utf-8");
+}
+function resolveCwd(cwd) {
+  const candidates = process.platform === "win32" ? [cwd, (0, import_os2.homedir)(), process.env.USERPROFILE, process.env.HOME] : [cwd, (0, import_os2.homedir)(), process.env.HOME, process.env.USERPROFILE];
+  for (const c of candidates) {
+    if (c) {
+      try {
+        if ((0, import_fs3.existsSync)(c)) return c;
+      } catch {
+      }
+    }
+  }
+  return (0, import_os2.homedir)();
+}
+var 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_os2.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
+var sessions = /* @__PURE__ */ new Map();
+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;
+}
+
+// src/heartbeat.ts
+var prevCpu = null;
+function getCpuUsage() {
+  const cpus = import_os3.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_process3.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_os3.default.totalmem();
+  const freeMem = import_os3.default.freemem();
+  return {
+    hostname: import_os3.default.hostname(),
+    platform: process.platform,
+    arch: import_os3.default.arch(),
+    cpuUsage: getCpuUsage(),
+    memoryUsage: Math.round((totalMem - freeMem) / totalMem * 100),
+    uptime: Math.round(import_os3.default.uptime()),
+    activeSessions: getActiveSessionCount(),
+    pathSeparator: import_path4.default.sep,
+    homeDirectory: homeDir || import_os3.default.homedir(),
+    rootPaths: getRootPaths(),
+    capabilities: { terminal: true, fileTransfer: false }
+  };
+}
+
+// src/file-explorer.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
+var SECRET_DIR = import_path5.default.join(import_os4.default.homedir(), ".crc-agent");
+function isInSecretDir(resolved) {
+  const rel = import_path5.default.relative(SECRET_DIR, resolved);
+  return rel === "" || !rel.startsWith(".." + import_path5.default.sep) && rel !== ".." && !import_path5.default.isAbsolute(rel);
+}
+function listDirectory(dirPath) {
+  try {
+    const resolved = import_path5.default.resolve(dirPath);
+    if (isInSecretDir(resolved)) {
+      return { entries: [], error: "Access denied" };
+    }
+    if (!import_fs4.default.existsSync(resolved)) {
+      return { entries: [], error: "Path does not exist" };
+    }
+    const stat = import_fs4.default.statSync(resolved);
+    if (!stat.isDirectory()) {
+      return { entries: [], error: "Not a directory" };
+    }
+    const dirents = import_fs4.default.readdirSync(resolved, { withFileTypes: true });
+    const entries = [];
+    for (const dirent of dirents) {
+      try {
+        const fullPath = import_path5.default.join(resolved, dirent.name);
+        const s = import_fs4.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_path5.default.resolve(filePath);
+    if (isInSecretDir(resolved)) {
+      return { error: "Access denied" };
+    }
+    if (!import_fs4.default.existsSync(resolved)) {
+      return { error: "File does not exist" };
+    }
+    const stat = import_fs4.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_path5.default.basename(resolved);
+    const fileStream = import_fs4.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 };
+  }
+}
+
+// src/vpn-manager.ts
+var import_child_process4 = require("child_process");
+var import_util2 = require("util");
+var import_fs5 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_os5 = __toESM(require("os"));
+var execAsync = (0, import_util2.promisify)(import_child_process4.exec);
+var isWindows = process.platform === "win32";
+var VPN_DIR = import_path6.default.join(import_os5.default.homedir(), ".crc-agent", "vpn");
+function shq2(value) {
+  return value.replace(/'/g, "'\\''");
+}
+function psq(value) {
+  return value.replace(/'/g, "''");
+}
+async function runCmd(cmd, shell) {
+  try {
+    return await execAsync(cmd, {
+      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_path6.default.isAbsolute(file)) return file;
+  return import_path6.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_fs5.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_fs5.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_fs5.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_fs5.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;
+}
+
+// src/claude-sessions.ts
+var import_fs6 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os6 = __toESM(require("os"));
+var import_readline = __toESM(require("readline"));
+
+// 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));
+}
+
+// src/claude-sessions.ts
+var CLAUDE_PROJECTS_DIR = import_path7.default.join(import_os6.default.homedir(), ".claude", "projects");
+async function parseSessionFile(filePath) {
+  try {
+    const stream = import_fs6.default.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = import_readline.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_fs6.default.existsSync(CLAUDE_PROJECTS_DIR)) return sessions2;
+  const isDirSafe = (d) => {
+    try {
+      return import_fs6.default.statSync(import_path7.default.join(CLAUDE_PROJECTS_DIR, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  let allEntries;
+  try {
+    allEntries = import_fs6.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_path7.default.join(CLAUDE_PROJECTS_DIR, dirName);
+    let files;
+    try {
+      files = import_fs6.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_path7.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;
+}
+
+// src/claude-conversation.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
+var import_os7 = __toESM(require("os"));
+var import_readline2 = __toESM(require("readline"));
+var CLAUDE_PROJECTS_DIR2 = import_path8.default.join(import_os7.default.homedir(), ".claude", "projects");
+function findProjectDir(projectPath) {
+  const encoded = encodeProjectPath(projectPath);
+  const dirPath = import_path8.default.join(CLAUDE_PROJECTS_DIR2, encoded);
+  if (import_fs7.default.existsSync(dirPath)) return dirPath;
+  if (!import_fs7.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
+  let allDirs;
+  try {
+    allDirs = import_fs7.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
+      try {
+        return import_fs7.default.statSync(import_path8.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return null;
+  }
+  const matches = findProjectDirs(allDirs, projectPath);
+  if (matches.length > 0) {
+    return import_path8.default.join(CLAUDE_PROJECTS_DIR2, matches[0]);
+  }
+  return null;
+}
+function findLatestSessionFile(projectPath) {
+  const dirPath = findProjectDir(projectPath);
+  if (!dirPath) return null;
+  let entries;
+  try {
+    entries = import_fs7.default.readdirSync(dirPath);
+  } catch {
+    return null;
+  }
+  const files = entries.filter((f) => f.endsWith(".jsonl") && !f.includes("/")).map((f) => {
+    try {
+      return { name: f, mtime: import_fs7.default.statSync(import_path8.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_path8.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) {
+    const dirPath = findProjectDir(projectPath);
+    if (!dirPath) return null;
+    filePath = import_path8.default.join(dirPath, `${specificSessionId}.jsonl`);
+    sessionId = specificSessionId;
+    if (!import_fs7.default.existsSync(filePath)) return null;
+  } else {
+    const found = findLatestSessionFile(projectPath);
+    if (!found) return null;
+    filePath = found.filePath;
+    sessionId = found.sessionId;
+  }
+  try {
+    const stream = import_fs7.default.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = import_readline2.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;
+  }
+}
+
+// src/index.ts
+if (!isConfigured()) {
+  console.error("No agent configured. Run: crc-agent setup");
+  process.exit(1);
+}
+var 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);
+var 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);
+var SESSION_MAX_IDLE_MS = 6 * 60 * 60 * 1e3;
+var 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
+  });
+});
+var 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: promisify3 } = await import("util");
+  const execAsync2 = promisify3(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);
+});
+//# sourceMappingURL=index.js.map