aicodeman 0.6.11 → 0.7.0

package/dist/tmux-manager.js

@@ -45,6 +45,8 @@ const TMUX_KILL_WAIT_MS = 200;
 const GRACEFUL_SHUTDOWN_WAIT_MS = 100;
 /** Default stats collection interval (2 seconds) */
 const DEFAULT_STATS_INTERVAL_MS = 2000;
+/** Claude Code native macOS recommendation for avoiding low nofile startup failures. */
+export const CLAUDE_CODE_NOFILE_LIMIT = 2147483646;
 /**
  * SAFETY: Test mode detection.
  * When running under vitest (VITEST env var is set automatically),
@@ -67,6 +69,10 @@ const SAFE_MUX_NAME_PATTERN = /^codeman-[a-f0-9-]+$/;
 const LEGACY_MUX_NAME_PATTERN = /^claudeman-[a-f0-9-]+$/;
 /** Regex to validate tmux pane targets (e.g., "%0", "%1", "0", "1") */
 const SAFE_PANE_TARGET_PATTERN = /^(%\d+|\d+)$/;
+/** Dedicated tmux socket for new Codeman-owned sessions. */
+const DEFAULT_CODEMAN_TMUX_SOCKET = 'codeman';
+/** Regex to validate tmux socket names passed to `tmux -L`. */
+const SAFE_TMUX_SOCKET_PATTERN = /^[a-zA-Z0-9_.-]+$/;
 /**
  * Separator used in `tmux list-panes -F` output between session name and pid.
  *
@@ -81,6 +87,18 @@ const SAFE_PANE_TARGET_PATTERN = /^(%\d+|\d+)$/;
 const PANE_LIST_SEP = '|';
 /** Format string for `tmux list-panes -F`. Keep in sync with {@link parsePaneList}. */
 const PANE_LIST_FORMAT = `#{session_name}${PANE_LIST_SEP}#{pane_pid}`;
+/**
+ * 构建 pane 启动前的 nofile 修复命令。
+ *
+ * macOS launchd/tmux 组合有时会让 pane 继承 256 的 soft nofile；
+ * 新版 Claude Code 会在这种环境下直接退出。这里避免使用 $变量
+ * 或命令替换，因为 fullCmd 目前经由双引号 bash -c 传递，外层
+ * shell 会提前展开它们。
+ */
+export function buildNofileLimitCommand(targetLimit = CLAUDE_CODE_NOFILE_LIMIT) {
+    const safeLimit = Number.isSafeInteger(targetLimit) && targetLimit > 0 ? targetLimit : CLAUDE_CODE_NOFILE_LIMIT;
+    return `ulimit -Sn ${safeLimit} 2>/dev/null || ulimit -n ${safeLimit} 2>/dev/null || true`;
+}
 /**
  * Parse the output of `tmux list-panes -a -F '#{session_name}|#{pane_pid}'`
  * into a Map of session-name → pane pid. Exported for unit testing.
@@ -126,6 +144,28 @@ function isValidPath(path) {
     }
     return SAFE_PATH_PATTERN.test(path);
 }
+// ===========================================================================
+// Single-socket architecture: ALL Codeman sessions live on one dedicated tmux
+// socket (`tmux -L codeman`), isolated from the user's default tmux server.
+// The socket name is a process-wide constant (env-overridable for test/multi-
+// instance isolation) — it is never stored per-session, so it cannot drift.
+// ===========================================================================
+/**
+ * Resolve the process-wide Codeman tmux socket name. Always returns a valid
+ * name: `CODEMAN_TMUX_SOCKET` env override if safe, else the built-in default.
+ */
+function resolveConfiguredTmuxSocket() {
+    const raw = process.env.CODEMAN_TMUX_SOCKET ?? DEFAULT_CODEMAN_TMUX_SOCKET;
+    if (!SAFE_TMUX_SOCKET_PATTERN.test(raw)) {
+        console.warn(`[TmuxManager] Ignoring invalid CODEMAN_TMUX_SOCKET: ${JSON.stringify(raw)}`);
+        return DEFAULT_CODEMAN_TMUX_SOCKET;
+    }
+    return raw;
+}
+/** Build the `tmux -L <socket>` command prefix. Socket name is shell-escaped. */
+function tmuxCommand(socket) {
+    return `tmux -L ${shellescape(socket)}`;
+}
 /**
  * Build Claude CLI permission flags for the tmux command string.
  * Validates allowedTools to prevent command injection.
@@ -201,7 +241,7 @@ function buildSpawnCommand(options) {
  * Set sensitive environment variables on a tmux session via setenv.
  * These are inherited by panes but not visible in ps output or tmux history.
  */
-function setOpenCodeEnvVars(muxName) {
+function setOpenCodeEnvVars(tmuxCmd, muxName) {
     const sensitiveVars = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
     for (const key of sensitiveVars) {
         const val = process.env[key];
@@ -209,7 +249,7 @@ function setOpenCodeEnvVars(muxName) {
             // Shell-escape: wrap in single quotes, escape any inner single quotes
             const escaped = val.replace(/'/g, "'\\''");
             try {
-                execSync(`tmux setenv -t '${muxName}' ${key} '${escaped}'`, {
+                execSync(`${tmuxCmd} setenv -t '${muxName}' ${key} '${escaped}'`, {
                     encoding: 'utf8',
                     timeout: EXEC_TIMEOUT_MS,
                     stdio: ['pipe', 'pipe', 'pipe'],
@@ -225,7 +265,7 @@ function setOpenCodeEnvVars(muxName) {
  * Set OPENCODE_CONFIG_CONTENT on a tmux session via setenv.
  * Uses tmux setenv to avoid shell metacharacter injection from user-supplied JSON.
  */
-function setOpenCodeConfigContent(muxName, config) {
+function setOpenCodeConfigContent(tmuxCmd, muxName, config) {
     if (!config)
         return;
     let jsonContent;
@@ -257,7 +297,7 @@ function setOpenCodeConfigContent(muxName, config) {
     if (jsonContent) {
         const escaped = jsonContent.replace(/'/g, "'\\''");
         try {
-            execSync(`tmux setenv -t '${muxName}' OPENCODE_CONFIG_CONTENT '${escaped}'`, {
+            execSync(`${tmuxCmd} setenv -t '${muxName}' OPENCODE_CONFIG_CONTENT '${escaped}'`, {
                 encoding: 'utf8',
                 timeout: EXEC_TIMEOUT_MS,
                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -290,6 +330,7 @@ function setOpenCodeConfigContent(muxName, config) {
 export class TmuxManager extends EventEmitter {
     backend = 'tmux';
     sessions = new Map();
+    tmuxSocket = resolveConfiguredTmuxSocket();
     statsInterval = null;
     mouseSyncInterval = null;
     /** Track last-known pane count per session to avoid unnecessary tmux set-option calls */
@@ -302,6 +343,13 @@ export class TmuxManager extends EventEmitter {
             this.loadSessions();
         }
     }
+    /** The dedicated tmux socket all Codeman sessions live on (see {@link TerminalMultiplexer.muxSocket}). */
+    get muxSocket() {
+        return this.tmuxSocket;
+    }
+    tmux() {
+        return tmuxCommand(this.tmuxSocket);
+    }
     // Load saved sessions from disk (NEVER called in test mode)
     loadSessions() {
         if (IS_TEST_MODE)
@@ -311,8 +359,41 @@ export class TmuxManager extends EventEmitter {
                 const content = readFileSync(MUX_SESSIONS_FILE, 'utf-8');
                 const data = JSON.parse(content);
                 if (Array.isArray(data)) {
+                    // Dedup by muxName: one live tmux session must map to exactly one
+                    // tracked entry. A per-session socket-tag mismatch could historically
+                    // let the same session be tracked twice — once under its real UUID and
+                    // once under a "restored-<id>" placeholder — surfacing as duplicate tabs.
+                    // Single-socket unification removed that failure mode; this pass stays
+                    // to clean any stale duplicates already on disk. Keep the real (UUID)
+                    // entry and drop placeholder twins.
+                    let dropped = 0;
+                    const keptByMuxName = new Map(); // muxName -> kept sessionId
                     for (const session of data) {
+                        // Strip the obsolete per-session tmuxSocket tag (now a process-wide
+                        // constant). Left in place it would be written back by saveSessions()
+                        // and linger on disk as a zombie field forever.
+                        delete session.tmuxSocket;
+                        const muxName = session.muxName;
+                        const priorId = muxName ? keptByMuxName.get(muxName) : undefined;
+                        if (priorId) {
+                            const incomingIsPlaceholder = String(session.sessionId).startsWith('restored-');
+                            const priorIsPlaceholder = priorId.startsWith('restored-');
+                            // Drop the incoming unless it's the real twin of a placeholder we kept.
+                            if (incomingIsPlaceholder || !priorIsPlaceholder) {
+                                dropped++;
+                                continue;
+                            }
+                            this.sessions.delete(priorId);
+                            dropped++;
+                        }
                         this.sessions.set(session.sessionId, session);
+                        if (muxName)
+                            keptByMuxName.set(muxName, session.sessionId);
+                    }
+                    // Persist the cleaned list so the stale duplicates don't reload.
+                    if (dropped > 0) {
+                        console.log(`[TmuxManager] Dropped ${dropped} duplicate mux session record(s) on load`);
+                        this.saveSessions();
                     }
                 }
             }
@@ -390,7 +471,7 @@ export class TmuxManager extends EventEmitter {
                 continue;
             }
             try {
-                execSync(`tmux setenv -t ${shellescape(muxName)} ${key} ${shellescape(value)}`, {
+                execSync(`${this.tmux()} setenv -t ${shellescape(muxName)} ${key} ${shellescape(value)}`, {
                     timeout: EXEC_TIMEOUT_MS,
                     stdio: ['pipe', 'pipe', 'pipe'],
                 });
@@ -422,8 +503,9 @@ export class TmuxManager extends EventEmitter {
      * (not visible in ps output or tmux history, inherited by panes).
      */
     _configureOpenCode(muxName, openCodeConfig) {
-        setOpenCodeEnvVars(muxName);
-        setOpenCodeConfigContent(muxName, openCodeConfig);
+        const tmuxCmd = this.tmux();
+        setOpenCodeEnvVars(tmuxCmd, muxName);
+        setOpenCodeConfigContent(tmuxCmd, muxName, openCodeConfig);
     }
     /**
      * Creates a new tmux session wrapping Claude CLI or a shell.
@@ -476,7 +558,7 @@ export class TmuxManager extends EventEmitter {
         const cmd = wrapWithNice(baseCmd, config);
         try {
             // Build the full command to run inside tmux
-            const fullCmd = `${pathExport}${envExportsStr} && ${cmd}`;
+            const fullCmd = `${buildNofileLimitCommand()} && ${pathExport}${envExportsStr} && ${cmd}`;
             // Create tmux session in three steps to handle cold-start (no server running)
             // and avoid the race where the command exits before remain-on-exit is set:
             // 1. Create session with default shell (starts tmux server, stays alive)
@@ -486,7 +568,7 @@ export class TmuxManager extends EventEmitter {
             // (Production uses systemd which has a clean env, but dev/test may be nested.)
             const cleanEnv = { ...process.env };
             delete cleanEnv.TMUX;
-            execSync(`tmux new-session -ds "${muxName}" -c "${workingDir}"`, {
+            execSync(`${this.tmux()} new-session -ds "${muxName}" -c "${workingDir}"`, {
                 cwd: workingDir,
                 timeout: EXEC_TIMEOUT_MS,
                 stdio: 'ignore',
@@ -494,7 +576,7 @@ export class TmuxManager extends EventEmitter {
             });
             // Set remain-on-exit now that the server is running — must be before respawn-pane
             try {
-                execSync(`tmux set-option -t "${muxName}" remain-on-exit on`, {
+                execSync(`${this.tmux()} set-option -t "${muxName}" remain-on-exit on`, {
                     timeout: EXEC_TIMEOUT_MS,
                     stdio: 'ignore',
                 });
@@ -511,7 +593,7 @@ export class TmuxManager extends EventEmitter {
             // so secret values stay off the bash command line. Must run before respawn-pane.
             this.applyEnvOverrides(muxName, envOverrides);
             // Replace the shell with the actual command (no echo in terminal)
-            execSync(`tmux respawn-pane -k -t "${muxName}" bash -c ${JSON.stringify(fullCmd)}`, {
+            execSync(`${this.tmux()} respawn-pane -k -t "${muxName}" bash -c ${JSON.stringify(fullCmd)}`, {
                 timeout: EXEC_TIMEOUT_MS,
                 stdio: 'ignore',
             });
@@ -523,20 +605,20 @@ export class TmuxManager extends EventEmitter {
             // It gets enabled dynamically when panes are split (agent teams).
             const configPromises = [
                 // Disable tmux status bar — Codeman's web UI provides session info
-                execAsync(`tmux set-option -t "${muxName}" status off`, { timeout: EXEC_TIMEOUT_MS })
+                execAsync(`${this.tmux()} set-option -t "${muxName}" status off`, { timeout: EXEC_TIMEOUT_MS })
                     .then(() => { })
                     .catch(() => {
                     /* Non-critical — session still works with status bar */
                 }),
                 // Override global remain-on-exit with session-level setting
-                execAsync(`tmux set-option -t "${muxName}" remain-on-exit on`, { timeout: EXEC_TIMEOUT_MS })
+                execAsync(`${this.tmux()} set-option -t "${muxName}" remain-on-exit on`, { timeout: EXEC_TIMEOUT_MS })
                     .then(() => { })
                     .catch(() => {
                     /* Already set globally as fallback */
                 }),
                 // Raise tmux scrollback from its 2000-line default so re-attach preserves
                 // more context. Matches the xterm-side default in constants.js.
-                execAsync(`tmux set-option -t "${muxName}" history-limit 50000`, { timeout: EXEC_TIMEOUT_MS })
+                execAsync(`${this.tmux()} set-option -t "${muxName}" history-limit 50000`, { timeout: EXEC_TIMEOUT_MS })
                     .then(() => { })
                     .catch(() => {
                     /* Non-critical — falls back to tmux default */
@@ -544,7 +626,7 @@ export class TmuxManager extends EventEmitter {
             ];
             // Enable 24-bit true color passthrough — server-wide, set once per lifetime
             if (!this.trueColorConfigured) {
-                configPromises.push(execAsync(`tmux set-option -sa terminal-overrides ",*:Tc"`, { timeout: EXEC_TIMEOUT_MS })
+                configPromises.push(execAsync(`${this.tmux()} set-option -sa terminal-overrides ",*:Tc"`, { timeout: EXEC_TIMEOUT_MS })
                     .then(() => {
                     this.trueColorConfigured = true;
                 })
@@ -594,7 +676,7 @@ export class TmuxManager extends EventEmitter {
             return null;
         }
         try {
-            const output = execSync(`tmux display-message -t "${muxName}" -p '#{pane_pid}'`, {
+            const output = execSync(`${this.tmux()} display-message -t "${muxName}" -p '#{pane_pid}'`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             }).trim();
@@ -621,7 +703,7 @@ export class TmuxManager extends EventEmitter {
         if (!isValidMuxName(muxName))
             return false;
         try {
-            const output = execSync(`tmux display-message -t "${muxName}" -p '#{pane_dead}'`, {
+            const output = execSync(`${this.tmux()} display-message -t "${muxName}" -p '#{pane_dead}'`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             }).trim();
@@ -658,7 +740,7 @@ export class TmuxManager extends EventEmitter {
         });
         const config = niceConfig || DEFAULT_NICE_CONFIG;
         const cmd = wrapWithNice(baseCmd, config);
-        const fullCmd = `${pathExport}${envExportsStr} && ${cmd}`;
+        const fullCmd = `${buildNofileLimitCommand()} && ${pathExport}${envExportsStr} && ${cmd}`;
         try {
             // For OpenCode: set sensitive env vars via tmux setenv before respawn
             if (mode === 'opencode') {
@@ -666,7 +748,7 @@ export class TmuxManager extends EventEmitter {
             }
             // Re-apply user env overrides before respawn so the new shell inherits them.
             this.applyEnvOverrides(muxName, envOverrides);
-            await execAsync(`tmux respawn-pane -k -t "${muxName}" bash -c ${JSON.stringify(fullCmd)}`, {
+            await execAsync(`${this.tmux()} respawn-pane -k -t "${muxName}" bash -c ${JSON.stringify(fullCmd)}`, {
                 timeout: EXEC_TIMEOUT_MS,
             });
             // Wait for the respawned process to start
@@ -685,7 +767,7 @@ export class TmuxManager extends EventEmitter {
         if (IS_TEST_MODE)
             return false;
         try {
-            execSync(`tmux has-session -t "${muxName}" 2>/dev/null`, {
+            execSync(`${this.tmux()} has-session -t "${muxName}" 2>/dev/null`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -814,7 +896,7 @@ export class TmuxManager extends EventEmitter {
         }
         // Strategy 3: Kill tmux session by name
         try {
-            execSync(`tmux kill-session -t "${session.muxName}" 2>/dev/null`, {
+            execSync(`${this.tmux()} kill-session -t "${session.muxName}" 2>/dev/null`, {
                 timeout: EXEC_TIMEOUT_MS,
             });
         }
@@ -871,26 +953,29 @@ export class TmuxManager extends EventEmitter {
         const alive = [];
         const dead = [];
         const discovered = [];
-        // Batch: single tmux call to get all session names + pane PIDs (replaces N per-session subprocess calls)
-        let activeSessions = new Map();
+        // Single batched query against the one socket Codeman owns. With a single
+        // socket a session's location is a constant, so there is no per-session
+        // socket tag to reconcile and no cross-socket ambiguity that could mark a
+        // live session dead (the root cause of vanished/duplicate tabs).
+        let active;
         try {
-            const output = execSync(`tmux list-panes -a -F '${PANE_LIST_FORMAT}' 2>/dev/null || true`, {
+            const output = execSync(`${this.tmux()} list-panes -a -F '${PANE_LIST_FORMAT}' 2>/dev/null || true`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             }).trim();
-            activeSessions = parsePaneList(output);
+            active = parsePaneList(output);
         }
         catch (err) {
             console.error('[TmuxManager] Failed to list tmux panes:', err);
+            active = new Map();
         }
-        // Check known sessions against the batch result (O(1) map lookup instead of subprocess per session)
+        // Check tracked sessions against the live pane list.
         for (const [sessionId, session] of this.sessions) {
-            const pid = activeSessions.get(session.muxName);
+            const pid = active.get(session.muxName);
             if (pid !== undefined) {
                 alive.push(sessionId);
-                if (pid !== session.pid) {
+                if (pid !== session.pid)
                     session.pid = pid;
-                }
             }
             else {
                 dead.push(sessionId);
@@ -898,12 +983,14 @@ export class TmuxManager extends EventEmitter {
                 this.emit('sessionDied', { sessionId });
             }
         }
-        // Discover unknown codeman/claudeman sessions from the same batch result
+        // Discover untracked codeman/claudeman sessions on our socket. Dedup by
+        // muxName (globally unique) so a name we already track never spawns a
+        // second "Restored:" entry.
         const knownMuxNames = new Set();
         for (const session of this.sessions.values()) {
             knownMuxNames.add(session.muxName);
         }
-        for (const [sessionName, pid] of activeSessions) {
+        for (const [sessionName, pid] of active) {
             if (!sessionName.startsWith('codeman-') && !sessionName.startsWith('claudeman-'))
                 continue;
             if (knownMuxNames.has(sessionName))
@@ -921,6 +1008,7 @@ export class TmuxManager extends EventEmitter {
                 name: `Restored: ${sessionName}`,
             };
             this.sessions.set(sessionId, session);
+            knownMuxNames.add(sessionName);
             discovered.push(sessionId);
             console.log(`[TmuxManager] Discovered unknown tmux session: ${sessionName} (PID ${pid})`);
         }
@@ -1187,23 +1275,23 @@ export class TmuxManager extends EventEmitter {
                 // Ink (Claude CLI's terminal framework) needs them split — sending both in a
                 // single tmux invocation (via \;) causes Ink to interpret Enter as a newline
                 // character in the input buffer rather than as form submission.
-                await execAsync(`tmux send-keys -t "${session.muxName}" -l ${shellescape(textPart)}`, {
+                await execAsync(`${this.tmux()} send-keys -t "${session.muxName}" -l ${shellescape(textPart)}`, {
                     timeout: EXEC_TIMEOUT_MS,
                 });
                 await new Promise((resolve) => setTimeout(resolve, 50));
-                await execAsync(`tmux send-keys -t "${session.muxName}" Enter`, {
+                await execAsync(`${this.tmux()} send-keys -t "${session.muxName}" Enter`, {
                     timeout: EXEC_TIMEOUT_MS,
                 });
             }
             else if (textPart) {
                 // Text only, no Enter
-                await execAsync(`tmux send-keys -t "${session.muxName}" -l ${shellescape(textPart)}`, {
+                await execAsync(`${this.tmux()} send-keys -t "${session.muxName}" -l ${shellescape(textPart)}`, {
                     timeout: EXEC_TIMEOUT_MS,
                 });
             }
             else if (hasCarriageReturn) {
                 // Enter only
-                await execAsync(`tmux send-keys -t "${session.muxName}" Enter`, {
+                await execAsync(`${this.tmux()} send-keys -t "${session.muxName}" Enter`, {
                     timeout: EXEC_TIMEOUT_MS,
                 });
             }
@@ -1228,7 +1316,7 @@ export class TmuxManager extends EventEmitter {
             return false;
         }
         try {
-            execSync(`tmux set-option -t "${muxName}" mouse on`, {
+            execSync(`${this.tmux()} set-option -t "${muxName}" mouse on`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -1252,7 +1340,7 @@ export class TmuxManager extends EventEmitter {
             return false;
         }
         try {
-            execSync(`tmux set-option -t "${muxName}" mouse off`, {
+            execSync(`${this.tmux()} set-option -t "${muxName}" mouse off`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -1292,7 +1380,7 @@ export class TmuxManager extends EventEmitter {
             return [];
         }
         try {
-            const output = execSync(`tmux list-panes -t "${muxName}" -F '#{pane_id}:#{pane_index}:#{pane_pid}:#{pane_width}:#{pane_height}'`, { encoding: 'utf-8', timeout: EXEC_TIMEOUT_MS }).trim();
+            const output = execSync(`${this.tmux()} list-panes -t "${muxName}" -F '#{pane_id}:#{pane_index}:#{pane_pid}:#{pane_width}:#{pane_height}'`, { encoding: 'utf-8', timeout: EXEC_TIMEOUT_MS }).trim();
             return output
                 .split('\n')
                 .map((line) => {
@@ -1328,27 +1416,28 @@ export class TmuxManager extends EventEmitter {
         }
         // Build target: sessionName.paneId (e.g., "codeman-abc12345.%1")
         const target = paneTarget.startsWith('%') ? `${muxName}.${paneTarget}` : `${muxName}.%${paneTarget}`;
+        const tmux = this.tmux();
         try {
             const hasCarriageReturn = input.includes('\r');
             const textPart = input.replace(/\r/g, '').replace(/\n/g, '').trimEnd();
             if (textPart && hasCarriageReturn) {
-                execSync(`tmux send-keys -t ${shellescape(target)} -l ${shellescape(textPart)}`, {
+                execSync(`${tmux} send-keys -t ${shellescape(target)} -l ${shellescape(textPart)}`, {
                     encoding: 'utf-8',
                     timeout: EXEC_TIMEOUT_MS,
                 });
-                execSync(`tmux send-keys -t ${shellescape(target)} Enter`, {
+                execSync(`${tmux} send-keys -t ${shellescape(target)} Enter`, {
                     encoding: 'utf-8',
                     timeout: EXEC_TIMEOUT_MS,
                 });
             }
             else if (textPart) {
-                execSync(`tmux send-keys -t ${shellescape(target)} -l ${shellescape(textPart)}`, {
+                execSync(`${tmux} send-keys -t ${shellescape(target)} -l ${shellescape(textPart)}`, {
                     encoding: 'utf-8',
                     timeout: EXEC_TIMEOUT_MS,
                 });
             }
             else if (hasCarriageReturn) {
-                execSync(`tmux send-keys -t ${shellescape(target)} Enter`, {
+                execSync(`${tmux} send-keys -t ${shellescape(target)} Enter`, {
                     encoding: 'utf-8',
                     timeout: EXEC_TIMEOUT_MS,
                 });
@@ -1377,7 +1466,7 @@ export class TmuxManager extends EventEmitter {
         }
         const target = paneTarget.startsWith('%') ? `${muxName}.${paneTarget}` : `${muxName}.%${paneTarget}`;
         try {
-            return execSync(`tmux capture-pane -p -e -t ${shellescape(target)} -S -5000`, {
+            return execSync(`${this.tmux()} capture-pane -p -e -t ${shellescape(target)} -S -5000`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -1408,7 +1497,7 @@ export class TmuxManager extends EventEmitter {
         }
         const target = paneTarget.startsWith('%') ? `${muxName}.${paneTarget}` : `${muxName}.%${paneTarget}`;
         try {
-            execSync(`tmux pipe-pane -O -t ${shellescape(target)} ${shellescape('cat >> ' + outputFile)}`, {
+            execSync(`${this.tmux()} pipe-pane -O -t ${shellescape(target)} ${shellescape('cat >> ' + outputFile)}`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -1435,7 +1524,7 @@ export class TmuxManager extends EventEmitter {
         }
         const target = paneTarget.startsWith('%') ? `${muxName}.${paneTarget}` : `${muxName}.%${paneTarget}`;
         try {
-            execSync(`tmux pipe-pane -t ${shellescape(target)}`, {
+            execSync(`${this.tmux()} pipe-pane -t ${shellescape(target)}`, {
                 encoding: 'utf-8',
                 timeout: EXEC_TIMEOUT_MS,
             });
@@ -1450,7 +1539,7 @@ export class TmuxManager extends EventEmitter {
         return 'tmux';
     }
     getAttachArgs(muxName) {
-        return ['attach-session', '-t', muxName];
+        return ['-L', this.tmuxSocket, 'attach-session', '-t', muxName];
     }
     isAvailable() {
         return TmuxManager.isTmuxAvailable();