@arearseth/tmux-mcp 0.3.2 → 0.3.4

package/README.md

@@ -61,17 +61,24 @@ The CLI flag only sets the server-wide default. You can still override individua
 
 ## Available Tools
 
+### Session & Window Management
 - `list-sessions` - List all active tmux sessions
-- `find-session` - Find a tmux session by name
-- `list-windows` - List windows in a tmux session
-- `list-panes` - List panes in a tmux window
-- `capture-pane` - Capture content from a tmux pane with optional slicing (supports start/end offsets to walk full scrollback history)
+- `find-session` - Find tmux sessions by exact name, substring, or regex pattern
 - `create-session` - Create a new tmux session
-- `create-window` - Create a new window in a tmux session
-- `split-pane` - Split a tmux pane horizontally or vertically with optional size
 - `kill-session` - Kill a tmux session by ID
+- `list-windows` - List windows in a tmux session
+- `create-window` - Create a new window in a tmux session
 - `kill-window` - Kill a tmux window by ID
+
+### Pane Management
+- `list-panes` - List panes in a tmux window
+- `capture-pane` - Capture content from a tmux pane (line count accepts a number or numeric string)
+- `split-pane` - Split a tmux pane horizontally or vertically
 - `kill-pane` - Kill a tmux pane by ID
-- `set-shell-type` - Configure the shell used for command execution (supports bash, zsh, fish, tclsh). Provide a paneId to override a single pane, or omit to adjust the default.
+
+### Command Execution
+- `set-shell-type` - Configure the shell for command execution (bash, zsh, fish, tclsh)
 - `execute-command` - Execute a command in a tmux pane
 - `get-command-result` - Get the result of an executed command
+- `wait-command-completion` - Poll until a command completes or timeout expires
+- `grep-command-output` - Search completed command output using regex

package/build/index.js

@@ -4,10 +4,11 @@ import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mc
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import * as tmux from "./tmux.js";
+import pkg from "../package.json" with { type: "json" };
 // Create MCP server
 const server = new McpServer({
     name: "tmux-mcp",
-    version: "0.3.1" // Keep in sync with package.json
+    version: pkg.version
 }, {
     capabilities: {
         resources: {
@@ -21,6 +22,23 @@ const server = new McpServer({
     }
 });
 const shellTypeSchema = z.enum(tmux.supportedShellTypes);
+/**
+ * Calculate the end index for display purposes when output is truncated.
+ * Returns the actual end index minus 1, or calculates it from start index and returned lines,
+ * or returns 'unknown' if not enough information is available.
+ */
+function calculateEndIndexDisplay(lineEndIndex, lineStartIndex, returnedLines) {
+    if (lineEndIndex !== undefined) {
+        return lineEndIndex - 1;
+    }
+    if (returnedLines !== undefined && lineStartIndex !== undefined) {
+        return lineStartIndex + returnedLines - 1;
+    }
+    if (returnedLines !== undefined) {
+        return returnedLines - 1;
+    }
+    return 'unknown';
+}
 // List all tmux sessions - Tool
 server.tool("list-sessions", "List all active tmux sessions", {}, async () => {
     try {
@@ -43,15 +61,17 @@ server.tool("list-sessions", "List all active tmux sessions", {}, async () => {
     }
 });
 // Find session by name - Tool
-server.tool("find-session", "Find a tmux session by name", {
-    name: z.string().describe("Name of the tmux session to find")
+server.tool("find-session", "Find tmux sessions by name. Tries an exact name match first, then a case-insensitive substring match, then a regular-expression match, so you can pass a partial name or pattern. Returns all matches.", {
+    name: z.string().describe("Exact name, substring, or regular expression to match against session names")
 }, async ({ name }) => {
     try {
-        const session = await tmux.findSessionByName(name);
+        const sessions = await tmux.findSessions(name);
         return {
             content: [{
                     type: "text",
-                    text: session ? JSON.stringify(session, null, 2) : `Session not found: ${name}`
+                    text: sessions.length > 0
+                        ? JSON.stringify(sessions.length === 1 ? sessions[0] : sessions, null, 2)
+                        : `Session not found: ${name}`
                 }]
         };
     }
@@ -114,19 +134,19 @@ server.tool("list-panes", "List panes in a tmux window", {
 // Capture pane content - Tool
 server.tool("capture-pane", "Capture content from a tmux pane. Defaults to the last N lines, but you can provide tmux-style start/end offsets (like 0 and -) to walk the full scrollback.", {
     paneId: z.string().describe("ID of the tmux pane"),
-    lines: z.string().optional().describe("Number of trailing lines to capture when start/end offsets are omitted (defaults to 200)"),
-    start: z.string().optional().describe("tmux -S offset; use 0 for the oldest line or a negative value to offset from the bottom"),
-    end: z.string().optional().describe("tmux -E offset; use - for the newest line or 0 for the active cursor line"),
+    lines: z.union([z.string(), z.number()]).optional().describe("Number of trailing lines to capture when start/end offsets are omitted (defaults to 200). Accepts a number or numeric string."),
+    start: z.union([z.string(), z.number()]).optional().describe("tmux -S offset; use 0 for the oldest line or a negative value to offset from the bottom. Accepts a number or string."),
+    end: z.union([z.string(), z.number()]).optional().describe("tmux -E offset; use - for the newest line or 0 for the active cursor line. Accepts a number or string."),
     colors: z.boolean().optional().describe("Include color/escape sequences for text and background attributes in output")
 }, async ({ paneId, lines, start, end, colors }) => {
     try {
-        // Parse lines parameter if provided
-        const parsedLines = lines !== undefined ? parseInt(lines, 10) : undefined;
+        // Accept lines as a number or numeric string and ignore non-positive values.
+        const parsedLines = tmux.coerceLineCount(lines, 0);
         const includeColors = colors ?? false;
         const options = {
             includeColors
         };
-        if (parsedLines !== undefined && !Number.isNaN(parsedLines) && parsedLines > 0) {
+        if (parsedLines > 0) {
             options.lines = parsedLines;
         }
         if (start !== undefined && start !== '') {
@@ -156,7 +176,7 @@ server.tool("capture-pane", "Capture content from a tmux pane. Defaults to the l
 // Create new session - Tool
 server.tool("create-session", "Create a new tmux session (optionally minimal to skip startup scripts)", {
     name: z.string().describe("Name for the new tmux session"),
-    minimal: z.boolean().optional().describe("Launch with a minimal shell (bash --noprofile --norc) to skip startup scripts for speed."),
+    minimal: z.boolean().optional().describe("Launch with a minimal shell (bash --noprofile --norc) to skip startup scripts for speed. If shellCommand is provided, it overrides the minimal shell setting."),
     shellCommand: z.string().optional().describe("Custom shell command in the new session. If minimal=true and shellCommand provided, it overrides the default minimal bash. Examples: 'bash --noprofile --norc', 'zsh -f'"),
 }, async ({ name, minimal, shellCommand }) => {
     try {
@@ -328,10 +348,10 @@ server.tool("set-shell-type", "Configure the shell for command execution (bash,
     }
 });
 // Execute command in pane - Tool
-server.tool("execute-command", "Execute a command in a tmux pane and get results. For interactive applications (REPLs, editors), use `rawMode=true`. IMPORTANT: When `rawMode=false` (default), avoid heredoc syntax (cat << EOF) and other multi-line constructs as they conflict with command wrapping. For file writing, prefer: printf 'content\\n' > file, echo statements, or write to temp files instead", {
+server.tool("execute-command", "Execute a command in a tmux pane and get results. Tcl REPLs (fc_shell, dc_shell, pt_shell, icc2_shell, tclsh) do NOT need rawMode: tracked mode auto-probes for Tcl, injects the tracking namespace, and pairs with wait-command-completion for immediate completion. Use rawMode=true only for true interactive edge cases (vim, less, btop); it disables status tracking and forces manual capture-pane polling. IMPORTANT: When rawMode=false (default), avoid heredoc syntax (cat << EOF) and other multi-line constructs as they conflict with command wrapping. For file writing, prefer: printf 'content\\n' > file, echo statements, or write to temp files instead. For tracked Tcl REPLs the command is wrapped in braces ({command}); multi-word/multi-arg commands work fine, but the command must contain balanced braces (almost all Tcl does). For the rare command with unbalanced braces, use rawMode and verify with capture-pane.", {
     paneId: z.string().describe("ID of the tmux pane"),
     command: z.string().describe("Command to execute"),
-    rawMode: z.boolean().optional().describe("Execute command without wrapper markers for REPL/interactive compatibility. Disables get-command-result status tracking. Use capture-pane after execution to verify command outcome."),
+    rawMode: z.boolean().optional().describe("Skip wrapper markers and status tracking. Do not use for Tcl REPLs (fc_shell/tclsh): tracked mode auto-detects Tcl and wait-command-completion returns as soon as the command finishes. Use only for non-Tcl interactive apps (vim, less) where wrapping breaks input; then verify with capture-pane."),
     noEnter: z.boolean().optional().describe("Send keystrokes without pressing Enter. For TUI navigation in apps like btop, vim, less. Supports special keys (Up, Down, Escape, Tab, etc.) and strings (sent char-by-char for proper filtering). Automatically applies rawMode. Use capture-pane after to see results.")
 }, async ({ paneId, command, rawMode, noEnter }) => {
     try {
@@ -402,7 +422,7 @@ server.tool("get-command-result", "Get the result of an executed command", {
                 `Command: ${command.command}`
             ];
             if (command.truncated) {
-                const endIdxDisplay = command.lineEndIndex !== undefined ? command.lineEndIndex - 1 : (command.returnedLines ? (command.lineStartIndex ?? 0) + (command.returnedLines - 1) : 'unknown');
+                const endIdxDisplay = calculateEndIndexDisplay(command.lineEndIndex, command.lineStartIndex, command.returnedLines);
                 metaLines.push(`Output truncated: showing ${command.returnedLines} of ${command.totalLines} lines (slice ${command.lineStartIndex}..${endIdxDisplay})`);
             }
             else if (command.outputLines) {
@@ -428,7 +448,7 @@ server.tool("get-command-result", "Get the result of an executed command", {
     }
 });
 // Wait for command completion - Tool
-server.tool("wait-command-completion", "Poll until a command completes or timeout expires. Returns final or intermediate status with sliced output.", {
+server.tool("wait-command-completion", "Wait until a tracked command completes or timeout expires. Returns as soon as completion markers are detected (not a fixed sleep); polls at intervalMs only while still pending. Pair with execute-command (rawMode=false) for Tcl and shell commands.", {
     commandId: z.string().describe("ID of the executed command"),
     timeoutMs: z.number().int().positive().optional().describe("Maximum milliseconds to wait (default 10000)"),
     intervalMs: z.number().int().positive().optional().describe("Polling interval milliseconds (default 150)"),
@@ -461,7 +481,7 @@ server.tool("wait-command-completion", "Poll until a command completes or timeou
             `Command: ${status.command}`
         ];
         if (status.truncated) {
-            const endIdxDisplay = status.lineEndIndex !== undefined ? status.lineEndIndex - 1 : 'unknown';
+            const endIdxDisplay = calculateEndIndexDisplay(status.lineEndIndex, status.lineStartIndex, status.returnedLines);
             meta.push(`Output truncated: showing ${status.returnedLines} of ${status.totalLines} lines (slice ${status.lineStartIndex}..${endIdxDisplay})`);
         }
         else if (status.outputLines) {

package/build/tmux.js

@@ -10,6 +10,35 @@ function debug(...args) {
         console.error('[tmux-mcp-debug]', ...args);
     }
 }
+/**
+ * Coerce a line-count input (accepted as either a number or a numeric string)
+ * into a number. Returns the provided fallback when the value is missing or
+ * not a positive integer, so callers can pass "40" or 40 interchangeably.
+ */
+export function coerceLineCount(value, fallback) {
+    if (value === undefined || value === '') {
+        return fallback;
+    }
+    const numeric = typeof value === 'number' ? value : Number.parseInt(value, 10);
+    return Number.isNaN(numeric) ? fallback : numeric;
+}
+function interpretCaptureIndex(value) {
+    if (value === undefined) {
+        return { kind: 'none' };
+    }
+    if (value === '-') {
+        return { kind: 'dash' };
+    }
+    const numeric = typeof value === 'number' ? value : Number(value);
+    if (Number.isNaN(numeric)) {
+        return { kind: 'none' };
+    }
+    const normalized = Math.trunc(numeric);
+    if (normalized >= 0) {
+        return { kind: 'absolute', value: normalized };
+    }
+    return { kind: 'relative', value: normalized };
+}
 export const supportedShellTypes = ['bash', 'zsh', 'fish', 'tclsh'];
 const shellConfig = {
     defaultType: 'bash',
@@ -26,9 +55,11 @@ export function setShellConfig(config) {
         shellConfig.paneOverrides.set(config.paneId, normalized);
         // Reset cached initialization so the helper can be installed on demand
         tclshInitializedPanes.delete(config.paneId);
+        paneDetectedShell.delete(config.paneId);
         return;
     }
     shellConfig.defaultType = normalized;
+    paneDetectedShell.clear();
     if (normalized !== 'tclsh') {
         tclshInitializedPanes.clear();
     }
@@ -36,6 +67,9 @@ export function setShellConfig(config) {
 function resolveShellType(paneId) {
     return shellConfig.paneOverrides.get(paneId) ?? shellConfig.defaultType;
 }
+function escapeForSingleQuotes(value) {
+    return value.replace(/'/g, "'\\''");
+}
 /**
  * Execute a tmux command and return the result
  */
@@ -90,6 +124,39 @@ export async function findSessionByName(name) {
         return null;
     }
 }
+/**
+ * Find sessions matching a query, trying progressively looser strategies so a
+ * caller does not need to know the exact session name:
+ *   1. exact name match
+ *   2. case-insensitive substring match
+ *   3. regular-expression match (when the query is a valid regex)
+ * Returns all matches for the first strategy that yields a result.
+ */
+export async function findSessions(query) {
+    let sessions;
+    try {
+        sessions = await listSessions();
+    }
+    catch (error) {
+        return [];
+    }
+    const exact = sessions.filter(session => session.name === query);
+    if (exact.length > 0) {
+        return exact;
+    }
+    const lowered = query.toLowerCase();
+    const substring = sessions.filter(session => session.name.toLowerCase().includes(lowered));
+    if (substring.length > 0) {
+        return substring;
+    }
+    try {
+        const pattern = new RegExp(query);
+        return sessions.filter(session => pattern.test(session.name));
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * List windows in a session
  */
@@ -128,11 +195,15 @@ export async function listPanes(windowId) {
 }
 /**
  * Capture content from a specific pane, by default the latest 200 lines.
- * Note: tmux's -S and -E flags are unreliable due to cursor position,
- * so we capture a range and slice in JavaScript.
+ * Note: tmux's -S and -E flags are unreliable due to cursor position.
+ * We treat tmux start/end offsets as hints, rely on JavaScript slicing for
+ * relative (negative) offsets, and avoid re-applying positive offsets that
+ * tmux already honored to prevent double trimming.
  */
 export async function capturePaneContent(paneId, options = {}) {
-    const { lines = 200, start, end, includeColors = false } = options;
+    const { start, end, includeColors = false } = options;
+    // Accept either a number or a numeric string (e.g. "40") for the line count.
+    const lines = coerceLineCount(options.lines, 200);
     // Determine start value for tmux capture
     // We'll use this to capture enough data, then slice accurately
     let tmuxStart;
@@ -156,24 +227,50 @@ export async function capturePaneContent(paneId, options = {}) {
     const capturedLines = await executeTmux(commandParts.join(' '));
     // Now slice the output in JavaScript for accurate results
     const linesArray = capturedLines.split('\n');
+    const startInfo = interpretCaptureIndex(start);
+    const endInfo = interpretCaptureIndex(end);
     // Calculate actual slice indices
     let sliceStart = 0;
     let sliceEnd = linesArray.length;
-    // Handle start parameter
-    if (start !== undefined) {
-        const startNum = typeof start === 'number' ? start : parseInt(start, 10);
-        // Negative values count from end
-        sliceStart = startNum < 0 ? Math.max(0, linesArray.length + startNum) : 0;
+    const absoluteStartBase = startInfo.kind === 'absolute'
+        ? startInfo.value
+        : startInfo.kind === 'dash'
+            ? 0
+            : undefined;
+    if (startInfo.kind === 'relative') {
+        sliceStart = Math.max(0, linesArray.length + startInfo.value);
+    }
+    else if (startInfo.kind === 'absolute' || startInfo.kind === 'dash') {
+        sliceStart = 0;
     }
     else if (lines !== undefined && lines > 0) {
-        // If no start specified but lines is, take last N lines
         sliceStart = Math.max(0, linesArray.length - lines);
     }
-    // Handle end parameter
-    if (end !== undefined) {
-        const endNum = typeof end === 'number' ? end : parseInt(end, 10);
-        // Negative values count from end
-        sliceEnd = endNum < 0 ? linesArray.length + endNum + 1 : endNum + 1;
+    if (endInfo.kind === 'dash') {
+        sliceEnd = linesArray.length;
+    }
+    else if (endInfo.kind === 'relative') {
+        sliceEnd = Math.max(0, linesArray.length + endInfo.value + 1);
+    }
+    else if (endInfo.kind === 'absolute') {
+        if (absoluteStartBase !== undefined) {
+            const desiredLength = endInfo.value - absoluteStartBase + 1;
+            if (desiredLength <= 0) {
+                sliceEnd = sliceStart;
+            }
+            else {
+                sliceEnd = Math.min(linesArray.length, sliceStart + desiredLength);
+            }
+        }
+        else {
+            sliceEnd = Math.min(linesArray.length, endInfo.value + 1);
+        }
+    }
+    if (end === undefined && lines !== undefined && lines > 0) {
+        sliceEnd = Math.min(sliceEnd, sliceStart + lines);
+    }
+    if (sliceEnd < sliceStart) {
+        sliceEnd = sliceStart;
     }
     return linesArray.slice(sliceStart, sliceEnd).join('\n');
 }
@@ -182,7 +279,8 @@ export async function capturePaneContent(paneId, options = {}) {
  */
 export async function createSession(name, options) {
     // Allow launching with a minimal shell to skip startup scripts.
-    let launchCmd = `new-session -d -s "${name}"`;
+    const safeName = escapeForSingleQuotes(name);
+    let launchCmd = `new-session -d -s '${safeName}'`;
     if (options?.minimal) {
         const shell = options.shellCommand || 'bash --noprofile --norc';
         // Quote shell command separately so user shell isn't expanded prematurely.
@@ -198,7 +296,8 @@ export async function createSession(name, options) {
  * Create a new window in a session
  */
 export async function createWindow(sessionId, name) {
-    const output = await executeTmux(`new-window -t '${sessionId}' -n '${name}'`);
+    const safeName = escapeForSingleQuotes(name);
+    const output = await executeTmux(`new-window -t '${sessionId}' -n '${safeName}'`);
     const windows = await listWindows(sessionId);
     return windows.find(window => window.name === name) || null;
 }
@@ -252,16 +351,145 @@ export async function splitPane(targetPaneId, direction = 'vertical', size) {
 const activeCommands = new Map();
 const startMarkerBase = 'TMUX_MCP_START';
 const endMarkerBase = 'TMUX_MCP_DONE';
+/**
+ * Per-process session nonce embedded in completion markers.
+ *
+ * tmux panes (e.g. a long-lived fc_shell) outlive the MCP server process and
+ * retain old TMUX_MCP_START/DONE markers in their scrollback. The sequence
+ * counter resets to 0 on every server restart, so a fresh command can reuse a
+ * sequence number whose DONE marker is still sitting in the pane history. Since
+ * completion is inferred by scanning the entire scrollback, the stale DONE
+ * marker would falsely complete the new command (often with empty output,
+ * because the stale DONE precedes the fresh START). Tagging markers with a
+ * nonce that is unique to this server process makes a previous run's markers
+ * impossible to match, so only this process's own markers can complete a wait.
+ *
+ * Disabled (empty) under Vitest so existing fixtures keep the legacy
+ * TMUX_MCP_START_<seq> / TMUX_MCP_DONE_<exit>_<seq> format; tests that exercise
+ * the nonce set it explicitly via setSessionNonce.
+ */
+function generateSessionNonce() {
+    return `s${Math.random().toString(36).slice(2, 8)}${Date.now().toString(36).slice(-4)}`;
+}
+let sessionNonce = process.env.TMUX_MCP_SESSION_NONCE
+    ?? (process.env.VITEST ? '' : generateSessionNonce());
+export function getSessionNonce() {
+    return sessionNonce;
+}
+export function setSessionNonce(nonce) {
+    sessionNonce = nonce;
+}
+// Marker infix that carries the nonce, e.g. "s12ab_" (empty when disabled).
+function markerNonceInfix() {
+    return sessionNonce ? `${sessionNonce}_` : '';
+}
 const DEFAULT_RESULT_LINES = 100; // default number of lines returned when output is large
+function hasSliceOptions(options) {
+    return Boolean(options && (options.lines !== undefined || options.start !== undefined || options.end !== undefined));
+}
+function computeSliceBounds(totalLines, options, defaultLimit) {
+    let sliceStart = 0;
+    let sliceEnd = totalLines;
+    if (options?.start !== undefined || options?.end !== undefined) {
+        if (options.start !== undefined) {
+            sliceStart = Math.max(0, options.start);
+        }
+        if (options.end !== undefined) {
+            sliceEnd = Math.min(totalLines, options.end + 1);
+        }
+    }
+    else if (options?.lines !== undefined) {
+        sliceStart = Math.max(0, totalLines - options.lines);
+    }
+    else if (defaultLimit !== undefined && totalLines > defaultLimit) {
+        sliceStart = Math.max(0, totalLines - defaultLimit);
+    }
+    if (sliceEnd < sliceStart) {
+        sliceEnd = sliceStart;
+    }
+    return { start: sliceStart, end: sliceEnd };
+}
+function applyOutputSlicing(command, options) {
+    if (!command.outputLines) {
+        return;
+    }
+    const defaultLimit = hasSliceOptions(options) ? undefined : DEFAULT_RESULT_LINES;
+    const { start: sliceStart, end: sliceEnd } = computeSliceBounds(command.outputLines.length, options, defaultLimit);
+    const finalLines = command.outputLines.slice(sliceStart, sliceEnd);
+    command.result = finalLines.join('\n').trim();
+    command.returnedLines = finalLines.length;
+    command.lineStartIndex = sliceStart;
+    command.lineEndIndex = sliceEnd;
+    command.totalLines = command.outputLines.length;
+    command.truncated = command.outputLines.length > finalLines.length || Boolean(command.markerStartLost);
+}
 // Track tclsh initialization per pane to keep terminal output minimal
 const tclshInitializedPanes = new Set();
+// Track in-flight initialization so concurrent first-time commands share a
+// single helper definition instead of each queuing their own behind a busy shell.
+const tclshInitInFlight = new Map();
+const paneDetectedShell = new Map();
 let wrappedCommandSequenceCounter = 0; // incremented for each non-raw wrapped command (sequence numbers)
+const PROBE_POLL_INTERVAL_MS = process.env.VITEST ? 0 : 100;
+const PROBE_MAX_ATTEMPTS = process.env.VITEST ? 1 : 15;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Probe whether the pane is in a Tcl REPL by sending a harmless Tcl command.
+ * pane_current_command is unreliable (often qrsh/make); this uses interpreter behavior.
+ */
+async function detectPaneShellType(paneId) {
+    const marker = `TMUX_MCP_PROBE_${Date.now()}`;
+    const probeCommand = `puts ${marker}_[info tclversion]`;
+    const escapedProbe = probeCommand.replace(/'/g, "'\\''");
+    await executeTmux(`send-keys -t '${paneId}' '${escapedProbe}' Enter`);
+    const markerPattern = new RegExp(`^${escapeRegExp(marker)}_\\d`);
+    for (let attempt = 0; attempt < PROBE_MAX_ATTEMPTS; attempt++) {
+        if (PROBE_POLL_INTERVAL_MS > 0) {
+            await new Promise(r => setTimeout(r, PROBE_POLL_INTERVAL_MS));
+        }
+        const content = await capturePaneContent(paneId, { lines: 50 });
+        for (const line of content.split('\n')) {
+            if (markerPattern.test(line.trim())) {
+                debug('detectPaneShellType: Tcl REPL detected', { paneId, marker, line: line.trim() });
+                return 'tclsh';
+            }
+        }
+    }
+    debug('detectPaneShellType: inconclusive', { paneId, marker });
+    return null;
+}
+async function resolveShellTypeWithDetection(paneId) {
+    const override = shellConfig.paneOverrides.get(paneId);
+    if (override) {
+        return override;
+    }
+    const cached = paneDetectedShell.get(paneId);
+    if (cached) {
+        return cached;
+    }
+    const detected = await detectPaneShellType(paneId);
+    if (detected) {
+        paneDetectedShell.set(paneId, detected);
+        return detected;
+    }
+    return shellConfig.defaultType;
+}
 // Execute a command in a tmux pane and track its execution
 export async function executeCommand(paneId, command, rawMode, noEnter) {
     // Generate unique ID for this command execution
     const commandId = uuidv4();
-    const shellType = resolveShellType(paneId);
-    const sequenceNumber = (!rawMode && !noEnter) ? (wrappedCommandSequenceCounter + 1) : undefined;
+    // Reserve a sequence number synchronously, before any await. Concurrent
+    // executeCommand calls (e.g. probes fired while a long create_placement runs)
+    // otherwise interleave at the awaits below, read the same counter value, and
+    // receive duplicate sequence numbers. Since completion tracking keys on the
+    // sequence number, duplicates make two commands match the same DONE marker,
+    // causing false completions and cross-command output attribution.
+    const sequenceNumber = (!rawMode && !noEnter) ? ++wrappedCommandSequenceCounter : undefined;
+    const shellType = (rawMode || noEnter)
+        ? resolveShellType(paneId)
+        : await resolveShellTypeWithDetection(paneId);
     debug('executeCommand: preparing', { paneId, command, rawMode, noEnter, shellType, sequenceNumber });
     let fullCommand;
     if (rawMode || noEnter) {
@@ -278,9 +506,6 @@ export async function executeCommand(paneId, command, rawMode, noEnter) {
         debug('executeCommand: wrapped command', fullCommand);
     }
     // Store command in tracking map
-    if (sequenceNumber) {
-        wrappedCommandSequenceCounter = sequenceNumber; // commit increment
-    }
     debug('executeCommand: sending keys', { paneId, fullCommand, noEnter });
     activeCommands.set(commandId, {
         id: commandId,
@@ -319,8 +544,13 @@ export async function checkCommandStatus(commandId, options) {
     const command = activeCommands.get(commandId);
     if (!command)
         return null;
-    if (command.status !== 'pending')
+    if (command.status !== 'pending') {
+        if (command.outputLines && (hasSliceOptions(options) || command.result === undefined)) {
+            applyOutputSlicing(command, options);
+            activeCommands.set(commandId, command);
+        }
         return command;
+    }
     const content = await capturePaneContent(command.paneId, { lines: 0 }); // capture entire scrollback to avoid missing markers
     debug('checkCommandStatus: captured content length', content.length, 'lines approx', content.split('\n').length);
     if (command.rawMode) {
@@ -328,13 +558,20 @@ export async function checkCommandStatus(commandId, options) {
         return command;
     }
     // Build marker blocks keyed by sequence number.
+    // Markers are matched against the current process's session nonce only, so a
+    // previous server run's stale markers (which may reuse the same sequence
+    // number) can never complete this command. When the nonce is disabled the
+    // patterns fall back to the legacy nonce-less marker format.
+    const nonceInfixPattern = sessionNonce ? `${escapeRegExp(sessionNonce)}_` : '';
+    const startMarkerRegex = new RegExp(`^${startMarkerBase}_${nonceInfixPattern}(\\d+)$`);
+    const endMarkerRegex = new RegExp(`^${endMarkerBase}_(\\d+)_${nonceInfixPattern}(\\d+)$`);
     const linesArr = content.split('\n');
     const blocksBySeq = new Map();
     let lastEndLine = -1;
     for (let i = 0; i < linesArr.length; i++) {
         const line = linesArr[i].trim();
-        // Start marker pattern: TMUX_MCP_START_<seq>
-        const startMatch = line.match(new RegExp(`^${startMarkerBase}_(\\d+)$`));
+        // Start marker pattern: TMUX_MCP_START_<nonce?>_<seq>
+        const startMatch = line.match(startMarkerRegex);
         if (startMatch) {
             const seq = parseInt(startMatch[1], 10);
             const existing = blocksBySeq.get(seq) || { endLine: -1, exitCode: -1, seq };
@@ -343,8 +580,8 @@ export async function checkCommandStatus(commandId, options) {
             debug('checkCommandStatus: start marker found', { seq, lineIndex: i, line });
             continue;
         }
-        // End marker pattern: TMUX_MCP_DONE_<exit>_<seq>
-        const endMatch = line.match(new RegExp(`^${endMarkerBase}_(\\d+)_([0-9]+)$`));
+        // End marker pattern: TMUX_MCP_DONE_<exit>_<nonce?>_<seq>
+        const endMatch = line.match(endMarkerRegex);
         if (endMatch) {
             const exitCode = parseInt(endMatch[1], 10);
             const seq = parseInt(endMatch[2], 10);
@@ -384,6 +621,17 @@ export async function checkCommandStatus(commandId, options) {
         debug('checkCommandStatus: end marker missing, still pending', { sequenceNumber, tailPreview: command.result });
         return command;
     }
+    // Defense-in-depth: a DONE marker that appears BEFORE this command's START
+    // marker is stale (left over from a prior run that reused the sequence
+    // number). The fresh command has started but not finished, so stay pending.
+    // (When the start marker is genuinely scrolled out, startLine is undefined
+    // and we fall through to normal completion handling.)
+    if (block.startLine !== undefined && block.endLine < block.startLine) {
+        const tail = linesArr.slice(-10).join('\n').trim();
+        command.result = tail ? tail : '(no recent output)';
+        debug('checkCommandStatus: stale end marker precedes fresh start, still pending', { sequenceNumber, startLine: block.startLine, endLine: block.endLine });
+        return command;
+    }
     // Mark completion
     command.status = block.exitCode === 0 ? 'completed' : 'error';
     command.exitCode = block.exitCode;
@@ -399,28 +647,7 @@ export async function checkCommandStatus(commandId, options) {
     }
     debug('checkCommandStatus: output lines after echo removal', { total: outputLines.length });
     command.outputLines = outputLines.map(l => l);
-    command.totalLines = outputLines.length;
-    const { lines, start, end } = options || {};
-    let sliceIdxStart = 0;
-    let sliceIdxEnd = outputLines.length;
-    if (start !== undefined || end !== undefined) {
-        if (start !== undefined)
-            sliceIdxStart = Math.max(0, start);
-        if (end !== undefined)
-            sliceIdxEnd = Math.min(outputLines.length, end + 1);
-    }
-    else if (lines !== undefined) {
-        sliceIdxStart = Math.max(0, outputLines.length - lines);
-    }
-    else if (outputLines.length > DEFAULT_RESULT_LINES) {
-        sliceIdxStart = Math.max(0, outputLines.length - DEFAULT_RESULT_LINES);
-    }
-    const finalLines = outputLines.slice(sliceIdxStart, sliceIdxEnd);
-    command.result = finalLines.join('\n').trim();
-    command.returnedLines = finalLines.length;
-    command.lineStartIndex = sliceIdxStart;
-    command.lineEndIndex = sliceIdxEnd;
-    command.truncated = outputLines.length > finalLines.length || command.markerStartLost;
+    applyOutputSlicing(command, options);
     debug('checkCommandStatus: final slicing applied', { returned: command.returnedLines, total: command.totalLines, truncated: command.truncated, sliceStart: command.lineStartIndex, sliceEndExclusive: command.lineEndIndex });
     activeCommands.set(commandId, command);
     return command;
@@ -455,8 +682,13 @@ export function cleanupOldCommands(maxAgeMinutes = 30) {
 }
 function buildWrappedCommand(command, shellType, seq) {
     // End marker uses shell-specific exit variable but includes sequence
+    // For fish, use braces to prevent variable name ambiguity (e.g., $status_1 would be interpreted as variable 'status_1')
     const exitVar = shellType === 'fish' ? '$status' : '$?';
-    const wrapped = `echo "${startMarkerBase}_${seq}"; ${command}; echo "${endMarkerBase}_${exitVar}_${seq}"`;
+    const fishExitWrapped = `{${exitVar}}`;
+    const nonceInfix = markerNonceInfix();
+    const wrapped = shellType === 'fish'
+        ? `echo "${startMarkerBase}_${nonceInfix}${seq}"; ${command}; echo "${endMarkerBase}_"${fishExitWrapped}"_${nonceInfix}${seq}"`
+        : `echo "${startMarkerBase}_${nonceInfix}${seq}"; ${command}; echo "${endMarkerBase}_${exitVar}_${nonceInfix}${seq}"`;
     debug('buildWrappedCommand', { shellType, seq, wrapped });
     return wrapped;
 }
@@ -469,45 +701,47 @@ async function ensureTclshInitialized(paneId) {
     if (tclshInitializedPanes.has(paneId)) {
         return;
     }
+    const pending = tclshInitInFlight.get(paneId);
+    if (pending) {
+        return pending;
+    }
+    const initPromise = sendTclshHelperDefinition(paneId);
+    tclshInitInFlight.set(paneId, initPromise);
+    try {
+        await initPromise;
+        tclshInitializedPanes.add(paneId);
+    }
+    finally {
+        tclshInitInFlight.delete(paneId);
+    }
+}
+async function sendTclshHelperDefinition(paneId) {
+    const nonceInfix = markerNonceInfix();
     const definitionCommand = [
         'namespace eval ::tmux_mcp {',
         'proc run {seq cmd} {',
-        'puts "' + startMarkerBase + '_${seq}"; flush stdout;',
+        'puts "' + startMarkerBase + '_' + nonceInfix + '${seq}"; flush stdout;',
         'set status [catch {uplevel #0 $cmd} result opts];',
         'if {$status == 0} {',
         'if {[info exists result] && $result ne ""} { puts $result; flush stdout }',
         '} else {',
         'if {[info exists opts(-errorinfo)]} { puts $opts(-errorinfo); flush stdout } else { puts $result; flush stdout }',
         '};',
-        'puts "' + endMarkerBase + '_${status}_${seq}"; flush stdout',
+        'puts "' + endMarkerBase + '_${status}_' + nonceInfix + '${seq}"; flush stdout',
         '}',
         '}'
     ].join(' ');
     debug('ensureTclshInitialized: sending helper definition');
     const escapedCommand = definitionCommand.replace(/'/g, "'\\''");
     await executeTmux(`send-keys -t '${paneId}' '${escapedCommand}' Enter`);
-    tclshInitializedPanes.add(paneId);
 }
 // Retrieve sliced command output after completion without re-parsing markers
 export function getCommandOutput(commandId, options) {
     const command = activeCommands.get(commandId);
     if (!command || !command.outputLines)
         return null;
-    const { lines, start, end } = options || {};
-    let sliceStart = 0;
-    let sliceEnd = command.outputLines.length; // exclusive
-    if (start !== undefined || end !== undefined) {
-        if (start !== undefined) {
-            sliceStart = Math.max(0, start);
-        }
-        if (end !== undefined) {
-            sliceEnd = Math.min(command.outputLines.length, end + 1); // inclusive external end
-        }
-    }
-    else if (lines !== undefined) {
-        sliceStart = Math.max(0, command.outputLines.length - lines);
-    }
-    return command.outputLines.slice(sliceStart, sliceEnd).join('\n');
+    const { start, end } = computeSliceBounds(command.outputLines.length, options, undefined);
+    return command.outputLines.slice(start, end).join('\n');
 }
 // Grep command output lines with a regular expression; returns matching lines
 export function grepCommandOutput(commandId, pattern, flags) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arearseth/tmux-mcp",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "MCP Server for interfacing with tmux sessions",
   "type": "module",
   "main": "build/index.js",