@arearseth/tmux-mcp 0.3.0 → 0.3.2

package/README.md

@@ -65,7 +65,7 @@ The CLI flag only sets the server-wide default. You can still override individua
 - `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
+- `capture-pane` - Capture content from a tmux pane with optional slicing (supports start/end offsets to walk full scrollback history)
 - `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

package/build/index.js

@@ -7,7 +7,7 @@ import * as tmux from "./tmux.js";
 // Create MCP server
 const server = new McpServer({
     name: "tmux-mcp",
-    version: "0.2.2"
+    version: "0.3.1" // Keep in sync with package.json
 }, {
     capabilities: {
         resources: {
@@ -154,11 +154,13 @@ 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", {
-    name: z.string().describe("Name for the new tmux session")
-}, async ({ name }) => {
+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."),
+    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 {
-        const session = await tmux.createSession(name);
+        const session = await tmux.createSession(name, { minimal: minimal === true, shellCommand });
         return {
             content: [{
                     type: "text",
@@ -366,11 +368,14 @@ server.tool("execute-command", "Execute a command in a tmux pane and get results
 });
 // Get command result - Tool
 server.tool("get-command-result", "Get the result of an executed command", {
-    commandId: z.string().describe("ID of the executed command")
-}, async ({ commandId }) => {
+    commandId: z.string().describe("ID of the executed command"),
+    lines: z.number().int().positive().optional().describe("Return only the last N lines of output"),
+    start: z.number().int().min(0).optional().describe("Start line index (0-based) of slice to return"),
+    end: z.number().int().min(0).optional().describe("End line index (0-based, inclusive) of slice to return")
+}, async ({ commandId, lines, start, end }) => {
     try {
         // Check and update command status
-        const command = await tmux.checkCommandStatus(commandId);
+        const command = await tmux.checkCommandStatus(commandId, { lines, start, end });
         if (!command) {
             return {
                 content: [{
@@ -391,7 +396,19 @@ server.tool("get-command-result", "Get the result of an executed command", {
             }
         }
         else {
-            resultText = `Status: ${command.status}\nExit code: ${command.exitCode}\nCommand: ${command.command}\n\n--- Output ---\n${command.result}`;
+            const metaLines = [
+                `Status: ${command.status}`,
+                `Exit code: ${command.exitCode}`,
+                `Command: ${command.command}`
+            ];
+            if (command.truncated) {
+                const endIdxDisplay = command.lineEndIndex !== undefined ? command.lineEndIndex - 1 : (command.returnedLines ? (command.lineStartIndex ?? 0) + (command.returnedLines - 1) : 'unknown');
+                metaLines.push(`Output truncated: showing ${command.returnedLines} of ${command.totalLines} lines (slice ${command.lineStartIndex}..${endIdxDisplay})`);
+            }
+            else if (command.outputLines) {
+                metaLines.push(`Lines returned: ${command.returnedLines ?? command.outputLines.length}`);
+            }
+            resultText = metaLines.join("\n") + `\n\n--- Output ---\n${command.result}`;
         }
         return {
             content: [{
@@ -410,6 +427,92 @@ 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.", {
+    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)"),
+    lines: z.number().int().positive().optional().describe("Return only the last N lines of output when completed"),
+    start: z.number().int().min(0).optional().describe("Start line index (0-based) slice"),
+    end: z.number().int().min(0).optional().describe("End line index (0-based, inclusive) slice")
+}, async ({ commandId, timeoutMs, intervalMs, lines, start, end }) => {
+    try {
+        const status = await tmux.waitForCompletion(commandId, timeoutMs ?? 10000, intervalMs ?? 150);
+        if (!status) {
+            return { content: [{ type: 'text', text: `Command not found: ${commandId}` }], isError: true };
+        }
+        // If completed we may want a sliced result
+        if (status.status !== 'pending' && (lines !== undefined || start !== undefined || end !== undefined)) {
+            const refreshed = await tmux.checkCommandStatus(commandId, { lines, start, end });
+            if (refreshed) {
+                // Adopt sliced result and metadata for consistency with get-command-result
+                status.result = refreshed.result;
+                status.returnedLines = refreshed.returnedLines;
+                status.lineStartIndex = refreshed.lineStartIndex;
+                status.lineEndIndex = refreshed.lineEndIndex;
+                status.truncated = refreshed.truncated;
+                status.totalLines = refreshed.totalLines;
+                status.outputLines = refreshed.outputLines;
+            }
+        }
+        const meta = [
+            `Status: ${status.status}`,
+            `Exit code: ${status.exitCode ?? 'n/a'}`,
+            `Command: ${status.command}`
+        ];
+        if (status.truncated) {
+            const endIdxDisplay = status.lineEndIndex !== undefined ? status.lineEndIndex - 1 : 'unknown';
+            meta.push(`Output truncated: showing ${status.returnedLines} of ${status.totalLines} lines (slice ${status.lineStartIndex}..${endIdxDisplay})`);
+        }
+        else if (status.outputLines) {
+            meta.push(`Lines returned: ${status.returnedLines ?? status.outputLines.length}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: meta.join('\n') + `\n\n--- Output ---\n${status.result || ''}`
+                }]
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error waiting for command: ${error}` }], isError: true };
+    }
+});
+// Grep command output - Tool
+server.tool("grep-command-output", "Search completed command output lines using a regular expression. Requires the command to have completed (non-pending). Returns matching lines.", {
+    commandId: z.string().describe("ID of the executed command"),
+    pattern: z.string().describe("Regular expression pattern (ECMAScript syntax)"),
+    flags: z.string().optional().describe("Regex flags (e.g. i, m, g). 'g' is ignored for matching lines but allowed."),
+    limit: z.number().int().positive().optional().describe("Maximum number of matching lines to return (from first match onward)")
+}, async ({ commandId, pattern, flags, limit }) => {
+    try {
+        const command = tmux.getCommand(commandId);
+        if (!command) {
+            return { content: [{ type: 'text', text: `Command not found: ${commandId}` }], isError: true };
+        }
+        if (command.status === 'pending') {
+            return { content: [{ type: 'text', text: `Command still pending: ${commandId}` }], isError: true };
+        }
+        const lines = tmux.grepCommandOutput(commandId, pattern, flags);
+        const limited = limit ? lines.slice(0, limit) : lines;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        commandId,
+                        pattern,
+                        flags: flags || '',
+                        totalMatches: lines.length,
+                        returned: limited.length,
+                        matches: limited
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error during grep: ${error}` }], isError: true };
+    }
+});
 // Expose tmux session list as a resource
 server.resource("Tmux Sessions", "tmux://sessions", async () => {
     try {

package/build/tmux.js

@@ -2,6 +2,14 @@ import { exec as execCallback } from "child_process";
 import { promisify } from "util";
 import { v4 as uuidv4 } from 'uuid';
 const exec = promisify(execCallback);
+// Debug helper (enable by setting env TMUX_MCP_DEBUG=1 when launching server)
+const DEBUG_ENABLED = process.env.TMUX_MCP_DEBUG === '1';
+function debug(...args) {
+    if (DEBUG_ENABLED) {
+        // stderr to avoid interfering with captured pane content
+        console.error('[tmux-mcp-debug]', ...args);
+    }
+}
 export const supportedShellTypes = ['bash', 'zsh', 'fish', 'tclsh'];
 const shellConfig = {
     defaultType: 'bash',
@@ -120,23 +128,70 @@ 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.
  */
 export async function capturePaneContent(paneId, options = {}) {
     const { lines = 200, start, end, includeColors = false } = options;
-    const startValue = start !== undefined ? String(start) : `-${lines}`;
-    const endValue = end !== undefined ? String(end) : '-';
+    // Determine start value for tmux capture
+    // We'll use this to capture enough data, then slice accurately
+    let tmuxStart;
+    if (start !== undefined) {
+        tmuxStart = String(start);
+    }
+    else if (lines === 0) {
+        // Capture all available lines
+        tmuxStart = '-'; // start from the beginning of history
+    }
+    else {
+        // Default: capture the last N lines from history
+        tmuxStart = `-${lines}`;
+    }
     const commandParts = ['capture-pane', '-p'];
     if (includeColors) {
         commandParts.push('-e');
     }
-    commandParts.push('-t', `'${paneId}'`, '-S', startValue, '-E', endValue);
-    return executeTmux(commandParts.join(' '));
+    commandParts.push('-t', `'${paneId}'`, '-S', tmuxStart, '-E', '-' // Always use '-' for end because specific line numbers are unreliable
+    );
+    const capturedLines = await executeTmux(commandParts.join(' '));
+    // Now slice the output in JavaScript for accurate results
+    const linesArray = capturedLines.split('\n');
+    // 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;
+    }
+    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;
+    }
+    return linesArray.slice(sliceStart, sliceEnd).join('\n');
 }
 /**
  * Create a new tmux session
  */
-export async function createSession(name) {
-    await executeTmux(`new-session -d -s "${name}"`);
+export async function createSession(name, options) {
+    // Allow launching with a minimal shell to skip startup scripts.
+    let launchCmd = `new-session -d -s "${name}"`;
+    if (options?.minimal) {
+        const shell = options.shellCommand || 'bash --noprofile --norc';
+        // Quote shell command separately so user shell isn't expanded prematurely.
+        launchCmd += ` '${shell.replace(/'/g, "'\\''")}'`;
+    }
+    else if (options?.shellCommand) {
+        launchCmd += ` '${options.shellCommand.replace(/'/g, "'\\''")}'`;
+    }
+    await executeTmux(launchCmd);
     return findSessionByName(name);
 }
 /**
@@ -195,15 +250,19 @@ export async function splitPane(targetPaneId, direction = 'vertical', size) {
 }
 // Map to track ongoing command executions
 const activeCommands = new Map();
-const startMarkerText = 'TMUX_MCP_START';
-const endMarkerPrefix = "TMUX_MCP_DONE_";
+const startMarkerBase = 'TMUX_MCP_START';
+const endMarkerBase = 'TMUX_MCP_DONE';
+const DEFAULT_RESULT_LINES = 100; // default number of lines returned when output is large
 // Track tclsh initialization per pane to keep terminal output minimal
 const tclshInitializedPanes = new Set();
+let wrappedCommandSequenceCounter = 0; // incremented for each non-raw wrapped command (sequence numbers)
 // 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;
+    debug('executeCommand: preparing', { paneId, command, rawMode, noEnter, shellType, sequenceNumber });
     let fullCommand;
     if (rawMode || noEnter) {
         fullCommand = command;
@@ -211,20 +270,26 @@ export async function executeCommand(paneId, command, rawMode, noEnter) {
     else {
         if (shellType === 'tclsh') {
             await ensureTclshInitialized(paneId);
-            fullCommand = buildTclshCommand(command);
+            fullCommand = buildTclshCommand(command, sequenceNumber);
         }
         else {
-            fullCommand = buildWrappedCommand(command, shellType);
+            fullCommand = buildWrappedCommand(command, shellType, sequenceNumber);
         }
+        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,
         paneId,
         command,
         status: 'pending',
         startTime: new Date(),
-        rawMode: rawMode || noEnter
+        rawMode: rawMode || noEnter,
+        sequenceNumber
     });
     // Send the command to the tmux pane
     if (noEnter) {
@@ -250,48 +315,126 @@ export async function executeCommand(paneId, command, rawMode, noEnter) {
     }
     return commandId;
 }
-export async function checkCommandStatus(commandId) {
+export async function checkCommandStatus(commandId, options) {
     const command = activeCommands.get(commandId);
     if (!command)
         return null;
     if (command.status !== 'pending')
         return command;
-    const content = await capturePaneContent(command.paneId, { lines: 1000 });
+    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) {
         command.result = 'Status tracking unavailable for rawMode commands. Use capture-pane to monitor interactive apps instead.';
         return command;
     }
-    // Find the last occurrence of the markers
-    const startIndex = content.lastIndexOf(startMarkerText);
-    const endIndex = content.lastIndexOf(endMarkerPrefix);
-    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
-        command.result = "Command output could not be captured properly";
-        return command;
-    }
-    // Extract exit code from the end marker line
-    const endLine = content.substring(endIndex).split('\n')[0];
-    const endMarkerRegex = new RegExp(`${endMarkerPrefix}(\\d+)`);
-    const exitCodeMatch = endLine.match(endMarkerRegex);
-    if (exitCodeMatch) {
-        const exitCode = parseInt(exitCodeMatch[1], 10);
-        command.status = exitCode === 0 ? 'completed' : 'error';
-        command.exitCode = exitCode;
-        // Extract output between the start and end markers
-        const outputStart = startIndex + startMarkerText.length;
-        const outputContent = content.substring(outputStart, endIndex).trim();
-        const outputLines = outputContent ? outputContent.split('\n') : [];
-        if (outputLines.length > 0) {
-            const firstLine = outputLines[0].trim();
-            if (firstLine === command.command.trim()) {
-                outputLines.shift();
+    // Build marker blocks keyed by sequence number.
+    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+)$`));
+        if (startMatch) {
+            const seq = parseInt(startMatch[1], 10);
+            const existing = blocksBySeq.get(seq) || { endLine: -1, exitCode: -1, seq };
+            existing.startLine = i;
+            blocksBySeq.set(seq, existing);
+            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]+)$`));
+        if (endMatch) {
+            const exitCode = parseInt(endMatch[1], 10);
+            const seq = parseInt(endMatch[2], 10);
+            const existing = blocksBySeq.get(seq) || { startLine: undefined, endLine: i, exitCode, seq };
+            existing.endLine = i;
+            existing.exitCode = exitCode;
+            // If startLine missing (scrolled out), approximate start as previous end + 1
+            if (existing.startLine === undefined && lastEndLine >= 0) {
+                existing.startLine = lastEndLine + 1;
             }
+            blocksBySeq.set(seq, existing);
+            lastEndLine = i;
+            debug('checkCommandStatus: end marker found', { seq, exitCode, lineIndex: i, line });
         }
-        command.result = outputLines.join('\n').trim();
-        // Update in map
-        activeCommands.set(commandId, command);
     }
+    debug('checkCommandStatus: blocks summary', Array.from(blocksBySeq.values()));
+    // Determine this command's block by sequenceNumber ordering
+    const sequenceNumber = command.sequenceNumber;
+    if (sequenceNumber === undefined) {
+        // Raw mode: keep showing tail
+        const tail = linesArr.slice(-10).join('\n').trim();
+        command.result = tail ? tail : '(no recent output)';
+        return command;
+    }
+    const block = sequenceNumber !== undefined ? blocksBySeq.get(sequenceNumber) : undefined;
+    if (!block) {
+        // Not completed yet; show tail snapshot
+        const tail = linesArr.slice(-10).join('\n').trim();
+        command.result = tail ? tail : '(no recent output)';
+        debug('checkCommandStatus: block not yet complete', { sequenceNumber, tailPreview: command.result });
+        return command;
+    }
+    // If end marker not yet observed (endLine < 0), keep pending and show tail preview
+    if (block.endLine < 0) {
+        const tail = linesArr.slice(-10).join('\n').trim();
+        command.result = tail ? tail : '(no recent output)';
+        debug('checkCommandStatus: end marker missing, still pending', { sequenceNumber, tailPreview: command.result });
+        return command;
+    }
+    // Mark completion
+    command.status = block.exitCode === 0 ? 'completed' : 'error';
+    command.exitCode = block.exitCode;
+    command.markerStartLost = block.startLine === undefined;
+    debug('checkCommandStatus: block completed', { sequenceNumber, exitCode: command.exitCode, markerStartLost: command.markerStartLost, startLine: block.startLine, endLine: block.endLine });
+    // Extract lines between markers (exclusive of marker lines)
+    const sliceStartLine = (block.startLine !== undefined ? block.startLine + 1 : 0);
+    const sliceEndLine = block.endLine; // exclude end marker line
+    let outputLines = linesArr.slice(sliceStartLine, sliceEndLine);
+    // Remove echoed command if present at first line
+    if (outputLines.length && outputLines[0].trim() === command.command.trim()) {
+        outputLines.shift();
+    }
+    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;
+    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;
 }
+// Poll until a command finishes or timeout expires
+export async function waitForCompletion(commandId, timeoutMs = 10000, intervalMs = 150) {
+    const start = Date.now();
+    let status = await checkCommandStatus(commandId);
+    while (status && status.status === 'pending' && (Date.now() - start) < timeoutMs) {
+        await new Promise(r => setTimeout(r, intervalMs));
+        status = await checkCommandStatus(commandId);
+    }
+    return status;
+}
 // Get command by ID
 export function getCommand(commandId) {
     return activeCommands.get(commandId) || null;
@@ -301,7 +444,7 @@ export function getActiveCommandIds() {
     return Array.from(activeCommands.keys());
 }
 // Clean up completed commands older than a certain time
-export function cleanupOldCommands(maxAgeMinutes = 60) {
+export function cleanupOldCommands(maxAgeMinutes = 30) {
     const now = new Date();
     for (const [id, command] of activeCommands.entries()) {
         const ageMinutes = (now.getTime() - command.startTime.getTime()) / (1000 * 60);
@@ -310,30 +453,17 @@ export function cleanupOldCommands(maxAgeMinutes = 60) {
         }
     }
 }
-function getEndMarkerText(shellType) {
-    if (shellType === 'fish') {
-        return `${endMarkerPrefix}$status`;
-    }
-    if (shellType === 'tclsh') {
-        return `${endMarkerPrefix}$::tmux_mcp_status`;
-    }
-    return `${endMarkerPrefix}$?`;
+function buildWrappedCommand(command, shellType, seq) {
+    // End marker uses shell-specific exit variable but includes sequence
+    const exitVar = shellType === 'fish' ? '$status' : '$?';
+    const wrapped = `echo "${startMarkerBase}_${seq}"; ${command}; echo "${endMarkerBase}_${exitVar}_${seq}"`;
+    debug('buildWrappedCommand', { shellType, seq, wrapped });
+    return wrapped;
 }
-function buildWrappedCommand(command, shellType) {
-    const endMarkerText = getEndMarkerText(shellType);
-    return `echo "${startMarkerText}"; ${command}; echo "${endMarkerText}"`;
-}
-function buildTclshCommand(command) {
-    const escaped = escapeForTcl(command);
-    return `::tmux_mcp::run {${escaped}}`;
-}
-function escapeForTcl(command) {
-    return command
-        .replace(/\\/g, '\\\\')
-        .replace(/\r/g, '\\r')
-        .replace(/\n/g, '\\n')
-        .replace(/\{/g, '\\{')
-        .replace(/\}/g, '\\}');
+function buildTclshCommand(command, seq) {
+    const wrapped = `::tmux_mcp::run ${seq} {${command}}`;
+    debug('buildTclshCommand', { seq, wrapped });
+    return wrapped;
 }
 async function ensureTclshInitialized(paneId) {
     if (tclshInitializedPanes.has(paneId)) {
@@ -341,19 +471,77 @@ async function ensureTclshInitialized(paneId) {
     }
     const definitionCommand = [
         'namespace eval ::tmux_mcp {',
-        'proc run {cmd} {',
-        `puts "${startMarkerText}";`,
+        'proc run {seq cmd} {',
+        'puts "' + startMarkerBase + '_${seq}"; flush stdout;',
         'set status [catch {uplevel #0 $cmd} result opts];',
         'if {$status == 0} {',
-        'if {[info exists result] && $result ne ""} { puts $result }',
+        'if {[info exists result] && $result ne ""} { puts $result; flush stdout }',
         '} else {',
-        'if {[info exists opts(-errorinfo)]} { puts $opts(-errorinfo) } else { puts $result }',
+        'if {[info exists opts(-errorinfo)]} { puts $opts(-errorinfo); flush stdout } else { puts $result; flush stdout }',
         '};',
-        `puts "${endMarkerPrefix}$status"`,
+        'puts "' + endMarkerBase + '_${status}_${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');
+}
+// Grep command output lines with a regular expression; returns matching lines
+export function grepCommandOutput(commandId, pattern, flags) {
+    const command = activeCommands.get(commandId);
+    if (!command || !command.outputLines)
+        return [];
+    let regex;
+    try {
+        regex = new RegExp(pattern, flags);
+    }
+    catch {
+        return [];
+    }
+    return command.outputLines.filter(line => regex.test(line));
+}
+// Switch pane to a minimal shell variant (bash only for now) to skip heavy startup scripts.
+export async function switchPaneToMinimalShell(paneId) {
+    const shellType = resolveShellType(paneId);
+    if (shellType !== 'bash') {
+        return false; // Only implemented for bash currently
+    }
+    // Use exec to replace current shell, suppress profile and rc loading.
+    await executeTmux(`send-keys -t '${paneId}' 'exec bash --noprofile --norc' Enter`);
+    // Emit a readiness marker after replacement
+    await executeTmux(`send-keys -t '${paneId}' 'echo MINIMAL_READY' Enter`);
+    // Poll for readiness marker appearing in last captured lines
+    for (let attempt = 0; attempt < 20; attempt++) {
+        const tail = await capturePaneContent(paneId, { lines: 50 });
+        if (tail.split('\n').some(l => l.includes('MINIMAL_READY'))) {
+            debug('switchPaneToMinimalShell: minimal shell ready');
+            return true;
+        }
+        await new Promise(r => setTimeout(r, 100));
+    }
+    debug('switchPaneToMinimalShell: timeout waiting for readiness');
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arearseth/tmux-mcp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "MCP Server for interfacing with tmux sessions",
   "type": "module",
   "main": "build/index.js",
@@ -36,7 +36,10 @@
     "vitest": "^1.6.0",
     "typescript": "^5.3.3"
   },
-  "repository": "github:AreAArseth/tmux-mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AreAArseth/tmux-mcp.git"
+  },
   "bugs": {
     "url": "https://github.com/AreAArseth/tmux-mcp/issues"
   },