cli-remote-agent 1.0.2 → 1.0.4

package/dist/index.js

@@ -57,6 +57,8 @@ var CLAUDE_SESSIONS_RESULT = "claude:sessions:result";
 var CLAUDE_HOOK = "claude:hook";
 var TMUX_LIST = "tmux:list";
 var TMUX_LIST_RESULT = "tmux:list:result";
+var TMUX_KILL = "tmux:kill";
+var TMUX_KILL_RESULT = "tmux:kill:result";
 
 // ../shared/src/constants.ts
 var HEARTBEAT_INTERVAL = 15e3;
@@ -250,9 +252,73 @@ function startLocalControl(port, onHook) {
 }
 
 // src/tmux.ts
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
+
+// src/claude-live.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
 var import_child_process = require("child_process");
 var import_util = require("util");
 var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+var LIVE_SESSIONS_DIR = import_path3.default.join(import_os2.default.homedir(), ".claude", "sessions");
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getLiveClaudeSessions() {
+  let files;
+  try {
+    files = import_fs3.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_fs3.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;
+}
+
+// src/tmux.ts
+var execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
 var IS_WIN = process.platform === "win32";
 function tmuxCmd(args) {
   return IS_WIN ? { file: "wsl.exe", args: ["tmux", ...args] } : { file: "tmux", args };
@@ -261,8 +327,8 @@ 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 { 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,
@@ -271,10 +337,52 @@ async function listTmuxSessions() {
         activity: parseInt(activity, 10) || void 0
       };
     });
+    await enrichWithPanesAndClaude(sessions2);
+    return sessions2;
   } catch {
     return [];
   }
 }
+async function killTmuxSession(name) {
+  const { file, args } = tmuxCmd(["kill-session", "-t", `=${name}`]);
+  try {
+    await execFileAsync2(file, args, { timeout: 6e3 });
+    return { ok: true };
+  } catch (err) {
+    const msg = (err?.stderr || err?.message || "tmux kill failed").toString().trim();
+    return { ok: false, error: msg };
+  }
+}
+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, `'\\''`)}'`;
 }
@@ -291,12 +399,12 @@ function buildTmuxLaunch(name, launch, shell) {
 }
 
 // src/shell.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = 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" });
+      (0, import_child_process3.execSync)("where pwsh", { stdio: "ignore" });
       return "pwsh.exe";
     } catch {
       return "powershell.exe";
@@ -306,32 +414,32 @@ function detectShell(preference) {
 }
 
 // src/heartbeat.ts
-var import_os3 = __toESM(require("os"));
-var import_path4 = __toESM(require("path"));
-var import_child_process3 = require("child_process");
+var import_os4 = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_child_process4 = 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 import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_os3 = 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_DIR = (0, import_path4.join)((0, import_os3.tmpdir)(), "crc-shell-init");
+var BASH_INIT = (0, import_path4.join)(INIT_DIR, "bashrc");
+var ZSH_DIR = (0, import_path4.join)(INIT_DIR, "zsh");
+var ZSH_RC = (0, import_path4.join)(ZSH_DIR, ".zshrc");
+var ZSH_ENV = (0, import_path4.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)) {
+  const versionFile = (0, import_path4.join)(INIT_DIR, ".version");
+  if ((0, import_fs4.existsSync)(versionFile)) {
     try {
-      if ((0, import_fs3.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
+      if ((0, import_fs4.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
     } catch {
     }
   }
-  (0, import_fs3.mkdirSync)(ZSH_DIR, { recursive: true });
-  (0, import_fs3.writeFileSync)(BASH_INIT, [
+  (0, import_fs4.mkdirSync)(ZSH_DIR, { recursive: true });
+  (0, import_fs4.writeFileSync)(BASH_INIT, [
     "[ -f ~/.bash_profile ] && source ~/.bash_profile",
     "[ -f ~/.bashrc ] && source ~/.bashrc",
     "__crc_s=$SECONDS",
@@ -342,11 +450,11 @@ function ensureInitFiles() {
     `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, [
+  (0, import_fs4.writeFileSync)(ZSH_ENV, [
     '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshenv" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshenv"',
     ""
   ].join("\n"), "utf-8");
-  (0, import_fs3.writeFileSync)(ZSH_RC, [
+  (0, import_fs4.writeFileSync)(ZSH_RC, [
     '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshrc" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshrc"',
     "__crc_s=$SECONDS",
     "__crc_armed=0",
@@ -359,19 +467,19 @@ function ensureInitFiles() {
     "fi",
     ""
   ].join("\n"), "utf-8");
-  (0, import_fs3.writeFileSync)(versionFile, INIT_VERSION, "utf-8");
+  (0, import_fs4.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];
+  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_fs3.existsSync)(c)) return c;
+        if ((0, import_fs4.existsSync)(c)) return c;
       } catch {
       }
     }
   }
-  return (0, import_os2.homedir)();
+  return (0, import_os3.homedir)();
 }
 var PtySession = class {
   id;
@@ -415,7 +523,7 @@ var PtySession = class {
         name: "xterm-256color",
         cols,
         rows,
-        cwd: (0, import_os2.homedir)(),
+        cwd: (0, import_os3.homedir)(),
         env
       });
     }
@@ -553,7 +661,7 @@ function reapDetachedSessions(maxIdleMs) {
 // src/heartbeat.ts
 var prevCpu = null;
 function getCpuUsage() {
-  const cpus = import_os3.default.cpus();
+  const cpus = import_os4.default.cpus();
   let idle = 0;
   let total = 0;
   for (const cpu of cpus) {
@@ -573,7 +681,7 @@ function getCpuUsage() {
 function getRootPaths() {
   if (process.platform === "win32") {
     try {
-      const output = (0, import_child_process3.execSync)("wmic logicaldisk get name", { encoding: "utf-8" });
+      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:\\"];
@@ -582,51 +690,51 @@ function getRootPaths() {
   return ["/"];
 }
 function buildHeartbeat(homeDir) {
-  const totalMem = import_os3.default.totalmem();
-  const freeMem = import_os3.default.freemem();
+  const totalMem = import_os4.default.totalmem();
+  const freeMem = import_os4.default.freemem();
   return {
-    hostname: import_os3.default.hostname(),
+    hostname: import_os4.default.hostname(),
     platform: process.platform,
-    arch: import_os3.default.arch(),
+    arch: import_os4.default.arch(),
     cpuUsage: getCpuUsage(),
     memoryUsage: Math.round((totalMem - freeMem) / totalMem * 100),
-    uptime: Math.round(import_os3.default.uptime()),
+    uptime: Math.round(import_os4.default.uptime()),
     activeSessions: getActiveSessionCount(),
-    pathSeparator: import_path4.default.sep,
-    homeDirectory: homeDir || import_os3.default.homedir(),
+    pathSeparator: import_path5.default.sep,
+    homeDirectory: homeDir || import_os4.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");
+var import_fs5 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_os5 = __toESM(require("os"));
+var SECRET_DIR = import_path6.default.join(import_os5.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);
+  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_path5.default.resolve(dirPath);
+    const resolved = import_path6.default.resolve(dirPath);
     if (isInSecretDir(resolved)) {
       return { entries: [], error: "Access denied" };
     }
-    if (!import_fs4.default.existsSync(resolved)) {
+    if (!import_fs5.default.existsSync(resolved)) {
       return { entries: [], error: "Path does not exist" };
     }
-    const stat = import_fs4.default.statSync(resolved);
+    const stat = import_fs5.default.statSync(resolved);
     if (!stat.isDirectory()) {
       return { entries: [], error: "Not a directory" };
     }
-    const dirents = import_fs4.default.readdirSync(resolved, { withFileTypes: true });
+    const dirents = import_fs5.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);
+        const fullPath = import_path6.default.join(resolved, dirent.name);
+        const s = import_fs5.default.statSync(fullPath);
         entries.push({
           name: dirent.name,
           isDirectory: dirent.isDirectory(),
@@ -648,22 +756,22 @@ function listDirectory(dirPath) {
 }
 async function downloadFile(filePath, serverUrl, secret, agentId) {
   try {
-    const resolved = import_path5.default.resolve(filePath);
+    const resolved = import_path6.default.resolve(filePath);
     if (isInSecretDir(resolved)) {
       return { error: "Access denied" };
     }
-    if (!import_fs4.default.existsSync(resolved)) {
+    if (!import_fs5.default.existsSync(resolved)) {
       return { error: "File does not exist" };
     }
-    const stat = import_fs4.default.statSync(resolved);
+    const stat = import_fs5.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 fileName = import_path6.default.basename(resolved);
+    const fileStream = import_fs5.default.createReadStream(resolved);
     const baseUrl = serverUrl.replace("wss://", "https://").replace("ws://", "http://");
     const url = `${baseUrl}/api/files/receive`;
     const res = await fetch(url, {
@@ -694,14 +802,14 @@ async function downloadFile(filePath, serverUrl, secret, agentId) {
 }
 
 // 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 import_child_process5 = require("child_process");
+var import_util3 = require("util");
+var import_fs6 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os6 = __toESM(require("os"));
+var execAsync = (0, import_util3.promisify)(import_child_process5.exec);
 var isWindows = process.platform === "win32";
-var VPN_DIR = import_path6.default.join(import_os5.default.homedir(), ".crc-agent", "vpn");
+var VPN_DIR = import_path7.default.join(import_os6.default.homedir(), ".crc-agent", "vpn");
 function shq2(value) {
   return value.replace(/'/g, "'\\''");
 }
@@ -720,8 +828,8 @@ async function runCmd(cmd, shell) {
 }
 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);
+  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)}'`);
@@ -837,7 +945,7 @@ async function connectWireGuard(profile) {
   const tunnelName = profile.tunnelName || profile.id;
   if (isWindows) {
     const confPath2 = getConfigPath(profile);
-    if (!import_fs5.default.existsSync(confPath2)) {
+    if (!import_fs6.default.existsSync(confPath2)) {
       return `Config file not found: ${confPath2}`;
     }
     const script = `
@@ -863,7 +971,7 @@ async function connectWireGuard(profile) {
 async function connectOpenVpn(profile) {
   if (isWindows) {
     const confPath2 = getConfigPath(profile);
-    if (!import_fs5.default.existsSync(confPath2)) {
+    if (!import_fs6.default.existsSync(confPath2)) {
       return `Config file not found: ${confPath2}`;
     }
     const connector = "C:\\Program Files\\OpenVPN Connect\\ovpnconnector.exe";
@@ -890,7 +998,7 @@ async function connectOpenVpn(profile) {
     return scutilStart(profile.serviceName);
   }
   const confPath = getConfigPath(profile);
-  if (!import_fs5.default.existsSync(confPath)) {
+  if (!import_fs6.default.existsSync(confPath)) {
     return `Config file not found: ${confPath}`;
   }
   const { stderr } = await runCmd(`sudo openvpn --config '${shq2(confPath)}' --daemon`);
@@ -899,7 +1007,7 @@ async function connectOpenVpn(profile) {
 async function connectAzure(profile) {
   if (isWindows) {
     const confPath = getConfigPath(profile);
-    if (!import_fs5.default.existsSync(confPath)) {
+    if (!import_fs6.default.existsSync(confPath)) {
       return `Config file not found: ${confPath}`;
     }
     await runCmd(`& 'AzureVpn.exe' -i '${psq(confPath)}' 2>&1`);
@@ -1021,9 +1129,9 @@ async function disconnectVpn(configs, profileId) {
 }
 
 // src/claude-sessions.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
-var import_os6 = __toESM(require("os"));
+var import_fs7 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
+var import_os7 = __toESM(require("os"));
 var import_readline = __toESM(require("readline"));
 
 // src/claude-path.ts
@@ -1050,10 +1158,10 @@ function findProjectDirs(allDirs, filterProjectPath) {
 }
 
 // src/claude-sessions.ts
-var CLAUDE_PROJECTS_DIR = import_path7.default.join(import_os6.default.homedir(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR = import_path8.default.join(import_os7.default.homedir(), ".claude", "projects");
 async function parseSessionFile(filePath) {
   try {
-    const stream = import_fs6.default.createReadStream(filePath, { encoding: "utf-8" });
+    const stream = import_fs7.default.createReadStream(filePath, { encoding: "utf-8" });
     const rl = import_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
     let firstMessage = "";
     let lastTimestamp = "";
@@ -1101,17 +1209,17 @@ async function parseSessionFile(filePath) {
 }
 async function listClaudeSessions(filterProjectPath) {
   const sessions2 = [];
-  if (!import_fs6.default.existsSync(CLAUDE_PROJECTS_DIR)) return sessions2;
+  if (!import_fs7.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();
+      return import_fs7.default.statSync(import_path8.default.join(CLAUDE_PROJECTS_DIR, d)).isDirectory();
     } catch {
       return false;
     }
   };
   let allEntries;
   try {
-    allEntries = import_fs6.default.readdirSync(CLAUDE_PROJECTS_DIR);
+    allEntries = import_fs7.default.readdirSync(CLAUDE_PROJECTS_DIR);
   } catch {
     return sessions2;
   }
@@ -1124,16 +1232,16 @@ async function listClaudeSessions(filterProjectPath) {
     projectDirs = allEntries.filter((d) => isDirSafe(d) && !d.startsWith("-private-"));
   }
   for (const dirName of projectDirs) {
-    const dirPath = import_path7.default.join(CLAUDE_PROJECTS_DIR, dirName);
+    const dirPath = import_path8.default.join(CLAUDE_PROJECTS_DIR, dirName);
     let files;
     try {
-      files = import_fs6.default.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      files = import_fs7.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));
+      const parsed = await parseSessionFile(import_path8.default.join(dirPath, file));
       if (!parsed) continue;
       const projectPath = parsed.cwd || dirName.replace(/^-/, "/").replace(/-/g, "/");
       sessions2.push({
@@ -1153,21 +1261,21 @@ async function listClaudeSessions(filterProjectPath) {
 }
 
 // src/claude-conversation.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path8 = __toESM(require("path"));
-var import_os7 = __toESM(require("os"));
+var import_fs8 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
+var import_os8 = __toESM(require("os"));
 var import_readline2 = __toESM(require("readline"));
-var CLAUDE_PROJECTS_DIR2 = import_path8.default.join(import_os7.default.homedir(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR2 = import_path9.default.join(import_os8.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;
+  const dirPath = import_path9.default.join(CLAUDE_PROJECTS_DIR2, encoded);
+  if (import_fs8.default.existsSync(dirPath)) return dirPath;
+  if (!import_fs8.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
   let allDirs;
   try {
-    allDirs = import_fs7.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
+    allDirs = import_fs8.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
       try {
-        return import_fs7.default.statSync(import_path8.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
+        return import_fs8.default.statSync(import_path9.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
       } catch {
         return false;
       }
@@ -1177,23 +1285,23 @@ function findProjectDir(projectPath) {
   }
   const matches = findProjectDirs(allDirs, projectPath);
   if (matches.length > 0) {
-    return import_path8.default.join(CLAUDE_PROJECTS_DIR2, matches[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_fs7.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
+  if (!import_fs8.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
   let dirs;
   try {
-    dirs = import_fs7.default.readdirSync(CLAUDE_PROJECTS_DIR2);
+    dirs = import_fs8.default.readdirSync(CLAUDE_PROJECTS_DIR2);
   } catch {
     return null;
   }
   for (const dir of dirs) {
-    const candidate = import_path8.default.join(CLAUDE_PROJECTS_DIR2, dir, `${sessionId}.jsonl`);
+    const candidate = import_path9.default.join(CLAUDE_PROJECTS_DIR2, dir, `${sessionId}.jsonl`);
     try {
-      if (import_fs7.default.statSync(candidate).isFile()) return candidate;
+      if (import_fs8.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -1204,20 +1312,20 @@ function findLatestSessionFile(projectPath) {
   if (!dirPath) return null;
   let entries;
   try {
-    entries = import_fs7.default.readdirSync(dirPath);
+    entries = import_fs8.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 };
+      return { name: f, mtime: import_fs8.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_path8.default.join(dirPath, files[0].name),
+    filePath: import_path9.default.join(dirPath, files[0].name),
     sessionId: files[0].name.replace(".jsonl", "")
   };
 }
@@ -1227,8 +1335,8 @@ async function readConversation(projectPath, afterLine = 0, specificSessionId) {
   if (specificSessionId) {
     sessionId = specificSessionId;
     const dirPath = findProjectDir(projectPath);
-    const direct = dirPath ? import_path8.default.join(dirPath, `${specificSessionId}.jsonl`) : null;
-    if (direct && import_fs7.default.existsSync(direct)) {
+    const direct = dirPath ? import_path9.default.join(dirPath, `${specificSessionId}.jsonl`) : null;
+    if (direct && import_fs8.default.existsSync(direct)) {
       filePath = direct;
     } else {
       const byId = findSessionFileById(specificSessionId);
@@ -1242,7 +1350,7 @@ async function readConversation(projectPath, afterLine = 0, specificSessionId) {
     sessionId = found.sessionId;
   }
   try {
-    const stream = import_fs7.default.createReadStream(filePath, { encoding: "utf-8" });
+    const stream = import_fs8.default.createReadStream(filePath, { encoding: "utf-8" });
     const rl = import_readline2.default.createInterface({ input: stream, crlfDelay: Infinity });
     const messages = [];
     let lineNum = 0;
@@ -1416,6 +1524,13 @@ socket.on(TMUX_LIST, async (payload) => {
     socket.emit(TMUX_LIST_RESULT, { requestId, sessions: [], error: err?.message || "tmux list failed" });
   }
 });
+socket.on(TMUX_KILL, async (payload) => {
+  const { requestId, name } = payload;
+  if (!requestId || !name) return;
+  const result = await killTmuxSession(name);
+  logger.info({ name, ok: result.ok, error: result.error }, "tmux kill requested");
+  socket.emit(TMUX_KILL_RESULT, { requestId, name, ok: result.ok, error: result.error });
+});
 socket.on(TERMINAL_INPUT, (payload) => {
   writeToSession(payload.sessionId, payload.data);
 });
@@ -1484,8 +1599,8 @@ 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);
+  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 || "" });