cli-remote-agent 1.0.5 → 1.0.7

package/dist/cli.js

@@ -427,6 +427,51 @@ var init_local_control = __esm({
   }
 });
 
+// src/pty-helper-fix.ts
+function ensurePtyHelperExecutable() {
+  if (process.platform === "win32") return;
+  try {
+    const nodeRequire = (0, import_node_module.createRequire)(__filename);
+    const ptyMain = nodeRequire.resolve("node-pty");
+    const ptyDir = import_path3.default.dirname(import_path3.default.dirname(ptyMain));
+    const candidates = [import_path3.default.join(ptyDir, "build", "Release", "spawn-helper")];
+    const prebuilds = import_path3.default.join(ptyDir, "prebuilds");
+    try {
+      for (const d of import_fs4.default.readdirSync(prebuilds)) {
+        candidates.push(import_path3.default.join(prebuilds, d, "spawn-helper"));
+      }
+    } catch {
+    }
+    for (const file of candidates) {
+      try {
+        const mode = import_fs4.default.statSync(file).mode;
+        if (!(mode & 73)) {
+          import_fs4.default.chmodSync(file, mode | 493);
+          logger.info({ file }, "Restored execute bit on node-pty spawn-helper");
+        }
+      } catch {
+      }
+    }
+    if (process.platform === "darwin") {
+      (0, import_node_child_process.execFile)("xattr", ["-dr", "com.apple.quarantine", ptyDir], () => {
+      });
+    }
+  } catch (err) {
+    logger.warn({ error: err?.message }, "Could not verify node-pty spawn-helper permissions");
+  }
+}
+var import_node_module, import_node_child_process, import_fs4, import_path3;
+var init_pty_helper_fix = __esm({
+  "src/pty-helper-fix.ts"() {
+    "use strict";
+    import_node_module = require("module");
+    import_node_child_process = require("child_process");
+    import_fs4 = __toESM(require("fs"));
+    import_path3 = __toESM(require("path"));
+    init_logger();
+  }
+});
+
 // src/claude-live.ts
 function isAlive(pid) {
   try {
@@ -439,14 +484,14 @@ function isAlive(pid) {
 function getLiveClaudeSessions() {
   let files;
   try {
-    files = import_fs4.default.readdirSync(LIVE_SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    files = import_fs5.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"));
+      const obj = JSON.parse(import_fs5.default.readFileSync(import_path4.default.join(LIVE_SESSIONS_DIR, f), "utf-8"));
       if (typeof obj?.pid !== "number" || !isAlive(obj.pid)) continue;
       out.push({
         pid: obj.pid,
@@ -481,23 +526,42 @@ function isDescendantOf(pid, ancestor, parents) {
   }
   return false;
 }
-var import_fs4, import_path3, import_os2, import_child_process, import_util, execFileAsync, LIVE_SESSIONS_DIR;
+var import_fs5, import_path4, 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_fs5 = __toESM(require("fs"));
+    import_path4 = __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");
+    LIVE_SESSIONS_DIR = import_path4.default.join(import_os2.default.homedir(), ".claude", "sessions");
   }
 });
 
 // src/tmux.ts
+function resolveTmuxPath() {
+  if (cachedTmuxPath !== void 0) return cachedTmuxPath;
+  const dirs = (process.env.PATH || "").split(import_path5.default.delimiter).filter(Boolean);
+  for (const extra of ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/opt/local/bin"]) {
+    if (!dirs.includes(extra)) dirs.push(extra);
+  }
+  for (const dir of dirs) {
+    const candidate = import_path5.default.join(dir, "tmux");
+    try {
+      import_fs6.default.accessSync(candidate, import_fs6.default.constants.X_OK);
+      cachedTmuxPath = candidate;
+      return candidate;
+    } catch {
+    }
+  }
+  cachedTmuxPath = null;
+  return null;
+}
 function tmuxCmd(args) {
-  return IS_WIN ? { file: "wsl.exe", args: ["tmux", ...args] } : { file: "tmux", args };
+  if (IS_WIN) return { file: "wsl.exe", args: ["tmux", ...args] };
+  return { file: resolveTmuxPath() || "tmux", args };
 }
 async function listTmuxSessions() {
   const fmt = "#{session_name}	#{session_windows}	#{session_attached}	#{session_activity}";
@@ -536,8 +600,8 @@ async function enrichWithPanesAndClaude(sessions2) {
     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 [session, pid, path10, activeFlags] = line.split("	");
+      return { session, pid: parseInt(pid, 10) || 0, path: path10 || "", active: activeFlags === "11" };
     });
     const byName = new Map(sessions2.map((s) => [s.name, s]));
     for (const pane of panes) {
@@ -559,26 +623,31 @@ async function enrichWithPanesAndClaude(sessions2) {
   } catch {
   }
 }
-function shq(v) {
-  return `'${v.replace(/'/g, `'\\''`)}'`;
-}
-function buildTmuxLaunch(name, launch, shell) {
+function buildTmuxLaunch(name, launch) {
   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] };
+    const args2 = ["tmux", "new-session", "-A", "-s", name];
+    if (trimmed) args2.push(trimmed);
+    return { file: "wsl.exe", args: args2 };
+  }
+  const tmuxBin = resolveTmuxPath();
+  if (!tmuxBin) return null;
+  execFileAsync2(tmuxBin, ["set-option", "-g", "aggressive-resize", "on"], { timeout: 4e3 }).catch(
+    () => {
+    }
+  );
+  const args = ["new-session", "-A", "-s", name];
+  if (trimmed) args.push(trimmed);
+  return { file: tmuxBin, args };
 }
-var import_child_process2, import_util2, execFileAsync2, IS_WIN;
+var import_child_process2, import_util2, import_fs6, import_path5, execFileAsync2, IS_WIN, cachedTmuxPath;
 var init_tmux = __esm({
   "src/tmux.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
     import_util2 = require("util");
+    import_fs6 = __toESM(require("fs"));
+    import_path5 = __toESM(require("path"));
     init_claude_live();
     execFileAsync2 = (0, import_util2.promisify)(import_child_process2.execFile);
     IS_WIN = process.platform === "win32";
@@ -608,15 +677,15 @@ var init_shell = __esm({
 
 // src/pty-session.ts
 function ensureInitFiles() {
-  const versionFile = (0, import_path4.join)(INIT_DIR, ".version");
-  if ((0, import_fs5.existsSync)(versionFile)) {
+  const versionFile = (0, import_path6.join)(INIT_DIR, ".version");
+  if ((0, import_fs7.existsSync)(versionFile)) {
     try {
-      if ((0, import_fs5.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
+      if ((0, import_fs7.readFileSync)(versionFile, "utf-8").trim() === INIT_VERSION) return;
     } catch {
     }
   }
-  (0, import_fs5.mkdirSync)(ZSH_DIR, { recursive: true });
-  (0, import_fs5.writeFileSync)(BASH_INIT, [
+  (0, import_fs7.mkdirSync)(ZSH_DIR, { recursive: true });
+  (0, import_fs7.writeFileSync)(BASH_INIT, [
     "[ -f ~/.bash_profile ] && source ~/.bash_profile",
     "[ -f ~/.bashrc ] && source ~/.bashrc",
     "__crc_s=$SECONDS",
@@ -627,11 +696,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_fs5.writeFileSync)(ZSH_ENV, [
+  (0, import_fs7.writeFileSync)(ZSH_ENV, [
     '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshenv" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshenv"',
     ""
   ].join("\n"), "utf-8");
-  (0, import_fs5.writeFileSync)(ZSH_RC, [
+  (0, import_fs7.writeFileSync)(ZSH_RC, [
     '[ -f "${ZDOTDIR_ORIG:-$HOME}/.zshrc" ] && source "${ZDOTDIR_ORIG:-$HOME}/.zshrc"',
     "__crc_s=$SECONDS",
     "__crc_armed=0",
@@ -644,36 +713,36 @@ function ensureInitFiles() {
     "fi",
     ""
   ].join("\n"), "utf-8");
-  (0, import_fs5.writeFileSync)(versionFile, INIT_VERSION, "utf-8");
+  (0, import_fs7.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;
+        if ((0, import_fs7.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 pty, import_fs7, import_path6, 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_fs7 = require("fs");
+    import_path6 = 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_DIR = (0, import_path6.join)((0, import_os3.tmpdir)(), "crc-shell-init");
+    BASH_INIT = (0, import_path6.join)(INIT_DIR, "bashrc");
+    ZSH_DIR = (0, import_path6.join)(INIT_DIR, "zsh");
+    ZSH_RC = (0, import_path6.join)(ZSH_DIR, ".zshrc");
+    ZSH_ENV = (0, import_path6.join)(ZSH_DIR, ".zshenv");
     INIT_VERSION = "2";
     PtySession = class {
       id;
@@ -903,18 +972,18 @@ function buildHeartbeat(homeDir) {
     memoryUsage: Math.round((totalMem - freeMem) / totalMem * 100),
     uptime: Math.round(import_os4.default.uptime()),
     activeSessions: getActiveSessionCount(),
-    pathSeparator: import_path5.default.sep,
+    pathSeparator: import_path7.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 import_os4, import_path7, import_child_process4, prevCpu;
 var init_heartbeat = __esm({
   "src/heartbeat.ts"() {
     "use strict";
     import_os4 = __toESM(require("os"));
-    import_path5 = __toESM(require("path"));
+    import_path7 = __toESM(require("path"));
     import_child_process4 = require("child_process");
     init_terminal_manager();
     prevCpu = null;
@@ -923,28 +992,28 @@ var init_heartbeat = __esm({
 
 // 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);
+  const rel = import_path8.default.relative(SECRET_DIR, resolved);
+  return rel === "" || !rel.startsWith(".." + import_path8.default.sep) && rel !== ".." && !import_path8.default.isAbsolute(rel);
 }
 function listDirectory(dirPath) {
   try {
-    const resolved = import_path6.default.resolve(dirPath);
+    const resolved = import_path8.default.resolve(dirPath);
     if (isInSecretDir(resolved)) {
       return { entries: [], error: "Access denied" };
     }
-    if (!import_fs6.default.existsSync(resolved)) {
+    if (!import_fs8.default.existsSync(resolved)) {
       return { entries: [], error: "Path does not exist" };
     }
-    const stat = import_fs6.default.statSync(resolved);
+    const stat = import_fs8.default.statSync(resolved);
     if (!stat.isDirectory()) {
       return { entries: [], error: "Not a directory" };
     }
-    const dirents = import_fs6.default.readdirSync(resolved, { withFileTypes: true });
+    const dirents = import_fs8.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);
+        const fullPath = import_path8.default.join(resolved, dirent.name);
+        const s = import_fs8.default.statSync(fullPath);
         entries.push({
           name: dirent.name,
           isDirectory: dirent.isDirectory(),
@@ -966,22 +1035,22 @@ function listDirectory(dirPath) {
 }
 async function downloadFile(filePath, serverUrl, secret, agentId) {
   try {
-    const resolved = import_path6.default.resolve(filePath);
+    const resolved = import_path8.default.resolve(filePath);
     if (isInSecretDir(resolved)) {
       return { error: "Access denied" };
     }
-    if (!import_fs6.default.existsSync(resolved)) {
+    if (!import_fs8.default.existsSync(resolved)) {
       return { error: "File does not exist" };
     }
-    const stat = import_fs6.default.statSync(resolved);
+    const stat = import_fs8.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 fileName = import_path8.default.basename(resolved);
+    const fileStream = import_fs8.default.createReadStream(resolved);
     const baseUrl = serverUrl.replace("wss://", "https://").replace("ws://", "http://");
     const url = `${baseUrl}/api/files/receive`;
     const res = await fetch(url, {
@@ -1010,21 +1079,21 @@ async function downloadFile(filePath, serverUrl, secret, agentId) {
     return { error: err.message };
   }
 }
-var import_fs6, import_path6, import_os5, SECRET_DIR;
+var import_fs8, import_path8, 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_fs8 = __toESM(require("fs"));
+    import_path8 = __toESM(require("path"));
     import_os5 = __toESM(require("os"));
     init_logger();
     init_src();
-    SECRET_DIR = import_path6.default.join(import_os5.default.homedir(), ".crc-agent");
+    SECRET_DIR = import_path8.default.join(import_os5.default.homedir(), ".crc-agent");
   }
 });
 
 // src/vpn-manager.ts
-function shq2(value) {
+function shq(value) {
   return value.replace(/'/g, "'\\''");
 }
 function psq(value) {
@@ -1042,11 +1111,11 @@ async function runCmd(cmd2, shell) {
 }
 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);
+  if (import_path9.default.isAbsolute(file)) return file;
+  return import_path9.default.join(VPN_DIR, file);
 }
 async function getScutilStatus(serviceName) {
-  const { stdout } = await runCmd(`scutil --nc status '${shq2(serviceName)}'`);
+  const { stdout } = await runCmd(`scutil --nc status '${shq(serviceName)}'`);
   const firstLine = stdout.trim().split("\n")[0];
   if (firstLine === "Connected") return "connected";
   if (firstLine === "Connecting") return "connecting";
@@ -1054,11 +1123,11 @@ async function getScutilStatus(serviceName) {
   return "disconnected";
 }
 async function scutilStart(serviceName) {
-  const { stderr } = await runCmd(`scutil --nc start '${shq2(serviceName)}'`);
+  const { stderr } = await runCmd(`scutil --nc start '${shq(serviceName)}'`);
   return stderr || null;
 }
 async function scutilStop(serviceName) {
-  const { stderr } = await runCmd(`scutil --nc stop '${shq2(serviceName)}'`);
+  const { stderr } = await runCmd(`scutil --nc stop '${shq(serviceName)}'`);
   return stderr || null;
 }
 async function runOsascript(script) {
@@ -1107,7 +1176,7 @@ async function getWireGuardStatus(profile) {
     return getScutilStatus(profile.serviceName);
   }
   const tunnelName = profile.tunnelName || profile.id;
-  const { stdout } = await runCmd(`wg show '${shq2(tunnelName)}' 2>/dev/null`);
+  const { stdout } = await runCmd(`wg show '${shq(tunnelName)}' 2>/dev/null`);
   return stdout.trim() ? "connected" : "disconnected";
 }
 async function getOpenVpnStatus(profile) {
@@ -1159,7 +1228,7 @@ async function connectWireGuard(profile) {
   const tunnelName = profile.tunnelName || profile.id;
   if (isWindows) {
     const confPath2 = getConfigPath(profile);
-    if (!import_fs7.default.existsSync(confPath2)) {
+    if (!import_fs9.default.existsSync(confPath2)) {
       return `Config file not found: ${confPath2}`;
     }
     const script = `
@@ -1179,13 +1248,13 @@ async function connectWireGuard(profile) {
     return scutilStart(profile.serviceName);
   }
   const confPath = getConfigPath(profile);
-  const { stderr } = await runCmd(`sudo wg-quick up '${shq2(confPath)}'`);
+  const { stderr } = await runCmd(`sudo wg-quick up '${shq(confPath)}'`);
   return stderr || null;
 }
 async function connectOpenVpn(profile) {
   if (isWindows) {
     const confPath2 = getConfigPath(profile);
-    if (!import_fs7.default.existsSync(confPath2)) {
+    if (!import_fs9.default.existsSync(confPath2)) {
       return `Config file not found: ${confPath2}`;
     }
     const connector = "C:\\Program Files\\OpenVPN Connect\\ovpnconnector.exe";
@@ -1212,16 +1281,16 @@ async function connectOpenVpn(profile) {
     return scutilStart(profile.serviceName);
   }
   const confPath = getConfigPath(profile);
-  if (!import_fs7.default.existsSync(confPath)) {
+  if (!import_fs9.default.existsSync(confPath)) {
     return `Config file not found: ${confPath}`;
   }
-  const { stderr } = await runCmd(`sudo openvpn --config '${shq2(confPath)}' --daemon`);
+  const { stderr } = await runCmd(`sudo openvpn --config '${shq(confPath)}' --daemon`);
   return stderr || null;
 }
 async function connectAzure(profile) {
   if (isWindows) {
     const confPath = getConfigPath(profile);
-    if (!import_fs7.default.existsSync(confPath)) {
+    if (!import_fs9.default.existsSync(confPath)) {
       return `Config file not found: ${confPath}`;
     }
     await runCmd(`& 'AzureVpn.exe' -i '${psq(confPath)}' 2>&1`);
@@ -1265,7 +1334,7 @@ async function disconnectWireGuard(profile) {
     return scutilStop(profile.serviceName);
   }
   const confPath = getConfigPath(profile);
-  const { stderr } = await runCmd(`sudo wg-quick down '${shq2(confPath)}'`);
+  const { stderr } = await runCmd(`sudo wg-quick down '${shq(confPath)}'`);
   return stderr || null;
 }
 async function disconnectOpenVpn(profile) {
@@ -1341,19 +1410,19 @@ async function disconnectVpn(configs, profileId) {
   }
   return profiles;
 }
-var import_child_process5, import_util3, import_fs7, import_path7, import_os6, execAsync, isWindows, VPN_DIR;
+var import_child_process5, import_util3, import_fs9, import_path9, 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_fs9 = __toESM(require("fs"));
+    import_path9 = __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");
+    VPN_DIR = import_path9.default.join(import_os6.default.homedir(), ".crc-agent", "vpn");
   }
 });
 
@@ -1388,7 +1457,7 @@ var init_claude_path = __esm({
 // src/claude-sessions.ts
 async function parseSessionFile(filePath) {
   try {
-    const stream = import_fs8.default.createReadStream(filePath, { encoding: "utf-8" });
+    const stream = import_fs10.default.createReadStream(filePath, { encoding: "utf-8" });
     const rl = import_readline2.default.createInterface({ input: stream, crlfDelay: Infinity });
     let firstMessage = "";
     let lastTimestamp = "";
@@ -1436,17 +1505,17 @@ async function parseSessionFile(filePath) {
 }
 async function listClaudeSessions(filterProjectPath) {
   const sessions2 = [];
-  if (!import_fs8.default.existsSync(CLAUDE_PROJECTS_DIR)) return sessions2;
+  if (!import_fs10.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();
+      return import_fs10.default.statSync(import_path10.default.join(CLAUDE_PROJECTS_DIR, d)).isDirectory();
     } catch {
       return false;
     }
   };
   let allEntries;
   try {
-    allEntries = import_fs8.default.readdirSync(CLAUDE_PROJECTS_DIR);
+    allEntries = import_fs10.default.readdirSync(CLAUDE_PROJECTS_DIR);
   } catch {
     return sessions2;
   }
@@ -1459,16 +1528,16 @@ async function listClaudeSessions(filterProjectPath) {
     projectDirs = allEntries.filter((d) => isDirSafe(d) && !d.startsWith("-private-"));
   }
   for (const dirName of projectDirs) {
-    const dirPath = import_path8.default.join(CLAUDE_PROJECTS_DIR, dirName);
+    const dirPath = import_path10.default.join(CLAUDE_PROJECTS_DIR, dirName);
     let files;
     try {
-      files = import_fs8.default.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      files = import_fs10.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));
+      const parsed = await parseSessionFile(import_path10.default.join(dirPath, file));
       if (!parsed) continue;
       const projectPath = parsed.cwd || dirName.replace(/^-/, "/").replace(/-/g, "/");
       sessions2.push({
@@ -1486,31 +1555,31 @@ async function listClaudeSessions(filterProjectPath) {
   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 import_fs10, import_path10, 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_fs10 = __toESM(require("fs"));
+    import_path10 = __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");
+    CLAUDE_PROJECTS_DIR = import_path10.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;
+  const dirPath = import_path11.default.join(CLAUDE_PROJECTS_DIR2, encoded);
+  if (import_fs11.default.existsSync(dirPath)) return dirPath;
+  if (!import_fs11.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
   let allDirs;
   try {
-    allDirs = import_fs9.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
+    allDirs = import_fs11.default.readdirSync(CLAUDE_PROJECTS_DIR2).filter((d) => {
       try {
-        return import_fs9.default.statSync(import_path9.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
+        return import_fs11.default.statSync(import_path11.default.join(CLAUDE_PROJECTS_DIR2, d)).isDirectory();
       } catch {
         return false;
       }
@@ -1520,23 +1589,23 @@ function findProjectDir(projectPath) {
   }
   const matches = findProjectDirs(allDirs, projectPath);
   if (matches.length > 0) {
-    return import_path9.default.join(CLAUDE_PROJECTS_DIR2, matches[0]);
+    return import_path11.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;
+  if (!import_fs11.default.existsSync(CLAUDE_PROJECTS_DIR2)) return null;
   let dirs;
   try {
-    dirs = import_fs9.default.readdirSync(CLAUDE_PROJECTS_DIR2);
+    dirs = import_fs11.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`);
+    const candidate = import_path11.default.join(CLAUDE_PROJECTS_DIR2, dir, `${sessionId}.jsonl`);
     try {
-      if (import_fs9.default.statSync(candidate).isFile()) return candidate;
+      if (import_fs11.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -1547,20 +1616,20 @@ function findLatestSessionFile(projectPath) {
   if (!dirPath) return null;
   let entries;
   try {
-    entries = import_fs9.default.readdirSync(dirPath);
+    entries = import_fs11.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 };
+      return { name: f, mtime: import_fs11.default.statSync(import_path11.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),
+    filePath: import_path11.default.join(dirPath, files[0].name),
     sessionId: files[0].name.replace(".jsonl", "")
   };
 }
@@ -1570,8 +1639,8 @@ async function readConversation(projectPath, afterLine = 0, specificSessionId) {
   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)) {
+    const direct = dirPath ? import_path11.default.join(dirPath, `${specificSessionId}.jsonl`) : null;
+    if (direct && import_fs11.default.existsSync(direct)) {
       filePath = direct;
     } else {
       const byId = findSessionFileById(specificSessionId);
@@ -1585,7 +1654,7 @@ async function readConversation(projectPath, afterLine = 0, specificSessionId) {
     sessionId = found.sessionId;
   }
   try {
-    const stream = import_fs9.default.createReadStream(filePath, { encoding: "utf-8" });
+    const stream = import_fs11.default.createReadStream(filePath, { encoding: "utf-8" });
     const rl = import_readline3.default.createInterface({ input: stream, crlfDelay: Infinity });
     const messages = [];
     let lineNum = 0;
@@ -1666,17 +1735,17 @@ async function readConversation(projectPath, afterLine = 0, specificSessionId) {
     return null;
   }
 }
-var import_fs9, import_path9, import_os8, import_readline3, CLAUDE_PROJECTS_DIR2;
+var import_fs11, import_path11, 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_fs11 = __toESM(require("fs"));
+    import_path11 = __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");
+    CLAUDE_PROJECTS_DIR2 = import_path11.default.join(import_os8.default.homedir(), ".claude", "projects");
   }
 });
 
@@ -1692,8 +1761,8 @@ var init_index = __esm({
     init_logger();
     init_claude_plugin_installer();
     init_local_control();
+    init_pty_helper_fix();
     init_tmux();
-    init_shell();
     init_heartbeat();
     init_file_explorer();
     init_vpn_manager();
@@ -1706,6 +1775,7 @@ var init_index = __esm({
     }
     config = loadConfig();
     logger.info({ agentId: config.agentId, serverUrl: config.serverUrl }, "Starting agent");
+    ensurePtyHelperExecutable();
     process.on("unhandledRejection", (reason) => {
       logger.error({ reason }, "Unhandled promise rejection (agent kept alive)");
     });
@@ -1765,7 +1835,18 @@ var init_index = __esm({
     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;
+      let launchSpec;
+      if (tmux) {
+        const spec = buildTmuxLaunch(tmux, launch);
+        if (!spec) {
+          const msg = "\r\n\x1B[31mtmux is not installed on this machine.\x1B[0m\r\nInstall it to use tmux mirroring:\r\n  macOS:  brew install tmux\r\n  Linux:  sudo apt install tmux  (or your package manager)\r\n\r\n";
+          socket.emit(TERMINAL_OUTPUT, { sessionId, data: msg });
+          socket.emit(TERMINAL_EXIT, { sessionId, exitCode: 1 });
+          logger.warn({ sessionId, tmux }, "tmux launch requested but tmux not found");
+          return;
+        }
+        launchSpec = spec;
+      }
       createTerminalSession(
         sessionId,
         cols,