codebuff 1.0.316 → 1.0.317

package/dist/terminal/base.js

@@ -0,0 +1,671 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNewTerminalOutput = exports.runCommandPtyManager = exports.runCommandPty = exports.runTerminalCommand = exports.resetShell = exports.recreateShell = exports.isCommandRunning = exports.persistentProcess = void 0;
+exports.killAndResetPersistentProcess = killAndResetPersistentProcess;
+exports.clearScreen = clearScreen;
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path_1 = __importDefault(require("path"));
+const analytics_events_1 = require("../common/constants/analytics-events");
+const array_1 = require("../common/util/array");
+const string_1 = require("../common/util/string");
+const picocolors_1 = require("picocolors");
+const project_files_1 = require("../project-files");
+const analytics_1 = require("../utils/analytics");
+const detect_shell_1 = require("../utils/detect-shell");
+const logger_1 = require("../utils/logger");
+const background_1 = require("./background");
+let pty;
+const tempConsoleError = console.error;
+console.error = () => { };
+try {
+    pty = require('@homebridge/node-pty-prebuilt-multiarch');
+}
+catch (error) {
+}
+finally {
+    console.error = tempConsoleError;
+}
+const COMMAND_OUTPUT_LIMIT = 10_000;
+const promptIdentifier = '@36261@';
+const needleIdentifier = '@76593@';
+const createPersistantProcess = (dir, forceChildProcess = false) => {
+    if (pty && process.env.NODE_ENV !== 'test' && !forceChildProcess) {
+        const isWindows = os.platform() === 'win32';
+        const currShell = (0, detect_shell_1.detectShell)();
+        const shell = isWindows
+            ? currShell === 'powershell'
+                ? 'powershell.exe'
+                : 'cmd.exe'
+            : 'bash';
+        const shellWithoutExe = shell.split('.')[0];
+        // Prepare shell init commands
+        let shellInitCommands = '';
+        if (!isWindows) {
+            // Source all relevant config files based on shell type
+            if (currShell === 'zsh') {
+                shellInitCommands = `
+          source ~/.zshenv 2>/dev/null || true
+          source ~/.zprofile 2>/dev/null || true
+          source ~/.zshrc 2>/dev/null || true
+          source ~/.zlogin 2>/dev/null || true
+        `;
+            }
+            else if (currShell === 'fish') {
+                shellInitCommands = `
+          source ~/.config/fish/config.fish 2>/dev/null || true
+        `;
+            }
+            else {
+                // Bash - source both profile and rc files
+                shellInitCommands = `
+          source ~/.bash_profile 2>/dev/null || true
+          source ~/.profile 2>/dev/null || true
+          source ~/.bashrc 2>/dev/null || true
+        `;
+            }
+        }
+        else if (currShell === 'powershell') {
+            // Try to source all possible PowerShell profile locations
+            shellInitCommands = `
+        $profiles = @(
+          $PROFILE.AllUsersAllHosts,
+          $PROFILE.AllUsersCurrentHost,
+          $PROFILE.CurrentUserAllHosts,
+          $PROFILE.CurrentUserCurrentHost
+        )
+        foreach ($prof in $profiles) {
+          if (Test-Path $prof) { . $prof }
+        }
+      `;
+        }
+        const persistentPty = pty.spawn(shell, isWindows ? [] : ['--login'], {
+            name: 'xterm-256color',
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            cwd: dir,
+            env: {
+                ...process.env,
+                PAGER: 'cat',
+                GIT_PAGER: 'cat',
+                GIT_TERMINAL_PROMPT: '0',
+                ...(isWindows
+                    ? {
+                        TERM: 'cygwin',
+                        ANSICON: '1',
+                        PROMPT: promptIdentifier,
+                    }
+                    : {
+                        TERM: 'xterm-256color',
+                        // Preserve important environment variables
+                        PATH: process.env.PATH,
+                        HOME: process.env.HOME,
+                        USER: process.env.USER,
+                        SHELL: shellWithoutExe,
+                    }),
+                LESS: '-FRX',
+                TERM_PROGRAM: 'mintty',
+                FORCE_COLOR: '1',
+                // Locale settings for consistent output
+                LANG: 'en_US.UTF-8',
+                LC_ALL: 'en_US.UTF-8',
+            },
+        });
+        // Source the shell config files
+        if (shellInitCommands) {
+            persistentPty.write(shellInitCommands);
+        }
+        // Set prompt for Unix shells after sourcing config
+        if (!isWindows) {
+            persistentPty.write(`PS1=${promptIdentifier} && PS2=${promptIdentifier}\n`);
+        }
+        const persistentProcessInfo = {
+            type: 'pty',
+            shell,
+            pty: persistentPty,
+            timerId: null,
+            globalOutputBuffer: '',
+            globalOutputLastReadLength: 0,
+        };
+        // Add a persistent listener to capture all output for manager mode
+        persistentPty.onData((data) => {
+            if (persistentProcessInfo.type === 'pty') {
+                persistentProcessInfo.globalOutputBuffer += data.toString(); // Should we use stripColors(...)?
+            }
+        });
+        return persistentProcessInfo;
+    }
+    else {
+        // Fallback to child_process
+        const isWindows = os.platform() === 'win32';
+        const currShell = (0, detect_shell_1.detectShell)();
+        const shell = isWindows
+            ? currShell === 'powershell'
+                ? 'powershell.exe'
+                : 'cmd.exe'
+            : 'bash';
+        const childProcess = null;
+        return {
+            type: 'process',
+            shell,
+            childProcess,
+            timerId: null,
+            globalOutputBuffer: '',
+            globalOutputLastReadLength: 0,
+        };
+    }
+};
+exports.persistentProcess = null;
+process.stdout.on('resize', () => {
+    if (!exports.persistentProcess)
+        return;
+    if (exports.persistentProcess.type === 'pty') {
+        exports.persistentProcess.pty.resize(process.stdout.columns, process.stdout.rows);
+    }
+});
+let commandIsRunning = false;
+const isCommandRunning = () => {
+    return commandIsRunning;
+};
+exports.isCommandRunning = isCommandRunning;
+const recreateShell = (cwd, forceChildProcess = false) => {
+    exports.persistentProcess = createPersistantProcess(cwd, forceChildProcess);
+};
+exports.recreateShell = recreateShell;
+const resetShell = (cwd) => {
+    commandIsRunning = false;
+    if (exports.persistentProcess) {
+        if (exports.persistentProcess.timerId) {
+            clearTimeout(exports.persistentProcess.timerId);
+            exports.persistentProcess.timerId = null;
+        }
+        if (exports.persistentProcess.type === 'pty') {
+            exports.persistentProcess.pty.kill();
+            (0, exports.recreateShell)(cwd);
+        }
+        else {
+            exports.persistentProcess.childProcess?.kill();
+            exports.persistentProcess = {
+                ...exports.persistentProcess,
+                childProcess: null,
+            };
+        }
+    }
+};
+exports.resetShell = resetShell;
+function formatResult(command, stdout, status) {
+    return (0, array_1.buildArray)(`<command>${command}</command>`, '<terminal_command_result>', stdout &&
+        `<output>${(0, string_1.truncateStringWithMessage)({ str: (0, string_1.stripColors)(stdout), maxLength: COMMAND_OUTPUT_LIMIT, remove: 'MIDDLE' })}</output>`, `<status>${status}</status>`, '</terminal_command_result>').join('\n');
+}
+const runTerminalCommand = async (toolCallId, command, mode, processType, timeoutSeconds, cwd, stdoutFile, stderrFile) => {
+    const maybeTimeoutSeconds = timeoutSeconds < 0 ? null : timeoutSeconds;
+    cwd = cwd || (mode === 'assistant' ? (0, project_files_1.getProjectRoot)() : (0, project_files_1.getWorkingDirectory)());
+    return new Promise((resolve) => {
+        if (!exports.persistentProcess) {
+            throw new Error('Shell not initialized');
+        }
+        if (commandIsRunning) {
+            (0, exports.resetShell)(cwd);
+        }
+        commandIsRunning = true;
+        // Add special case for git log to limit output
+        const modifiedCommand = command.trim() === 'git log' ? 'git log -n 5' : command;
+        const resolveCommand = (value) => {
+            commandIsRunning = false;
+            (0, analytics_1.trackEvent)(analytics_events_1.AnalyticsEvent.TERMINAL_COMMAND_COMPLETED, {
+                command,
+                result: value.result,
+                stdout: value.stdout,
+                exitCode: value.exitCode,
+                mode,
+                processType,
+            });
+            resolve(value);
+        };
+        if (processType === 'BACKGROUND') {
+            (0, background_1.runBackgroundCommand)({
+                toolCallId,
+                command: modifiedCommand,
+                mode,
+                cwd,
+                stdoutFile,
+                stderrFile,
+            }, resolveCommand);
+        }
+        else if (exports.persistentProcess.type === 'pty') {
+            if (mode === 'manager') {
+                (0, exports.runCommandPtyManager)(exports.persistentProcess, modifiedCommand, cwd, maybeTimeoutSeconds, resolveCommand);
+            }
+            else {
+                (0, exports.runCommandPty)(exports.persistentProcess, modifiedCommand, mode, cwd, maybeTimeoutSeconds, resolveCommand);
+            }
+        }
+        else {
+            // Fallback to child_process implementation
+            runCommandChildProcess(exports.persistentProcess, modifiedCommand, mode, cwd, maybeTimeoutSeconds, resolveCommand);
+        }
+    });
+};
+exports.runTerminalCommand = runTerminalCommand;
+const echoLinePattern = new RegExp(`${promptIdentifier}[^\n]*\n`, 'g');
+const getNeedlePatternCache = {};
+function getNeedlePattern(middlePattern = '.*') {
+    if (!(middlePattern in getNeedlePatternCache)) {
+        getNeedlePatternCache[middlePattern] = new RegExp(`${needleIdentifier}(${middlePattern})${needleIdentifier}`);
+    }
+    return getNeedlePatternCache[middlePattern];
+}
+/**
+ * Executes a single command in a PTY process and returns the result when complete.
+ *
+ * This function handles the low-level details of running a command in a pseudo-terminal,
+ * including parsing the output to separate command echoes from actual output, detecting
+ * command completion
+ *
+ * @param ptyProcess - The IPty instance to execute the command in
+ * @param command - The shell command to execute
+ * @param onChunk - Callback function called for each chunk of output as it's received
+ *
+ * @returns Promise that resolves with:
+ *   - The complete output from the command (excluding echo lines)
+ *
+ * @example
+ * ```typescript
+ * const result = await runSinglePtyCommand(
+ *   ptyProcess,
+ *   'ls -la',
+ *   process.stdout.write
+ * );
+ * ```
+ *
+ * @internal This is a low-level utility function used by other terminal command runners.
+ * It handles platform-specific differences between Windows and Unix-like systems.
+ *
+ * The function works by:
+ * 1. Setting up a data listener on the PTY process
+ * 2. Filtering out command echo lines (the command being typed)
+ * 3. Detecting command completion markers (promptIdentifier)
+ */
+function runSinglePtyCommand(ptyProcess, command, onChunk) {
+    const isWindows = os.platform() === 'win32';
+    let commandOutput = '';
+    let buffer = promptIdentifier;
+    let echoLinesRemaining = isWindows ? 1 : command.split('\n').length;
+    const resultPromise = new Promise((resolve) => {
+        const dataDisposable = ptyProcess.onData((data) => {
+            buffer += data;
+            // Wait for pending promptIdentifier
+            const suffix = (0, string_1.suffixPrefixOverlap)(buffer, promptIdentifier);
+            let toProcess = buffer.slice(0, buffer.length - suffix.length);
+            buffer = suffix;
+            // Remove echo lines from the output
+            const matches = toProcess.match(echoLinePattern);
+            if (matches) {
+                for (let i = 0; i < matches.length && echoLinesRemaining > 0; i++) {
+                    echoLinesRemaining = Math.max(echoLinesRemaining - 1, 0);
+                    toProcess = toProcess.replace(echoLinePattern, '');
+                }
+            }
+            // Do not process anything after a promptIdentifier (pending line)
+            const promptIdentifierIndex = toProcess.indexOf(promptIdentifier);
+            if (promptIdentifierIndex !== -1) {
+                buffer = toProcess.slice(promptIdentifierIndex) + buffer;
+                toProcess = toProcess.slice(0, promptIdentifierIndex);
+            }
+            onChunk(toProcess);
+            commandOutput += toProcess;
+            const commandDone = buffer.startsWith(promptIdentifier);
+            if (commandDone && echoLinesRemaining === 0) {
+                // Command is done
+                dataDisposable.dispose();
+                resolve(commandOutput);
+            }
+        });
+    });
+    // Write the command
+    ptyProcess.write(`${command}\r`);
+    return resultPromise;
+}
+const runCommandPty = (persistentProcess, command, mode, cwd, maybeTimeoutSeconds, resolve) => {
+    const ptyProcess = persistentProcess.pty;
+    if (command.trim() === 'clear') {
+        // `clear` needs access to the main process stdout. This is a workaround.
+        (0, child_process_1.execSync)('clear', { stdio: 'inherit' });
+        resolve({
+            result: formatResult(command, '', `Complete`),
+            stdout: '',
+            exitCode: 0,
+        });
+        return;
+    }
+    const projectRoot = (0, project_files_1.getProjectRoot)();
+    const isWindows = os.platform() === 'win32';
+    if (mode === 'assistant') {
+        const displayDirectory = path_1.default.join(path_1.default.parse(projectRoot).base, path_1.default.relative(projectRoot, path_1.default.resolve(projectRoot, cwd)));
+        console.log((0, picocolors_1.green)(`${displayDirectory} > ${command}`));
+    }
+    let commandOutput = '';
+    let timer = null;
+    if (maybeTimeoutSeconds !== null) {
+        timer = setTimeout(() => {
+            if (mode === 'assistant') {
+                // Kill and recreate PTY
+                (0, exports.resetShell)(cwd);
+                resolve({
+                    result: formatResult(command, commandOutput, `Command timed out after ${maybeTimeoutSeconds} seconds and was terminated. Shell has been restarted.`),
+                    stdout: commandOutput,
+                    exitCode: 124,
+                });
+            }
+        }, maybeTimeoutSeconds * 1000);
+    }
+    persistentProcess.timerId = timer;
+    new Promise(async () => {
+        await runSinglePtyCommand(ptyProcess, `cd ${cwd}`, () => { });
+        await runSinglePtyCommand(ptyProcess, command, (data) => {
+            commandOutput += data;
+            process.stdout.write(data);
+        });
+        const exitCodeHaystack = await runSinglePtyCommand(ptyProcess, persistentProcess.shell === 'cmd.exe'
+            ? `echo ${needleIdentifier}%ERRORLEVEL%${needleIdentifier}`
+            : `echo ${needleIdentifier}$?${needleIdentifier}`, () => { });
+        let exitCode = null;
+        const exitCodeMatch = exitCodeHaystack.match(getNeedlePattern('\\d+'));
+        if (exitCodeMatch) {
+            exitCode = parseInt(exitCodeMatch[1].trim());
+        }
+        else {
+            logger_1.logger.error({ exitCodeHaystack }, 'Could not find exitCode in output');
+        }
+        const cwdHaystack = await runSinglePtyCommand(ptyProcess, isWindows
+            ? `echo ${needleIdentifier}%cd%${needleIdentifier}`
+            : `echo ${needleIdentifier}$(pwd)${needleIdentifier}`, () => { });
+        const m = cwdHaystack.match(getNeedlePattern());
+        let newWorkingDirectory;
+        if (m) {
+            newWorkingDirectory = m[1].trim();
+        }
+        else {
+            logger_1.logger.error({ cwdHaystack }, 'Could not find cwd in output');
+            newWorkingDirectory = cwd;
+        }
+        const statusMessage = exitCode === null
+            ? ''
+            : exitCode === 0
+                ? 'Complete'
+                : `Failed with exit code: ${exitCode}`;
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (mode === 'assistant') {
+            await runSinglePtyCommand(ptyProcess, `cd ${(0, project_files_1.getWorkingDirectory)()}`, () => { });
+            resolve({
+                result: formatResult(command, commandOutput, (0, array_1.buildArray)([
+                    `cwd: ${path_1.default.resolve(projectRoot, cwd)}`,
+                    statusMessage,
+                ]).join('\n\n')),
+                stdout: commandOutput,
+                exitCode,
+            });
+            return;
+        }
+        let outsideProject = false;
+        const currentWorkingDirectory = (0, project_files_1.getWorkingDirectory)();
+        let finalCwd = currentWorkingDirectory;
+        if (newWorkingDirectory !== currentWorkingDirectory) {
+            (0, analytics_1.trackEvent)(analytics_events_1.AnalyticsEvent.CHANGE_DIRECTORY, {
+                from: currentWorkingDirectory,
+                to: newWorkingDirectory,
+                isSubdir: (0, project_files_1.isSubdir)(currentWorkingDirectory, newWorkingDirectory),
+            });
+            if (path_1.default.relative(projectRoot, newWorkingDirectory).startsWith('..')) {
+                outsideProject = true;
+                console.log(`
+Unable to cd outside of the project root (${projectRoot})
+      
+If you want to change the project root:
+1. Exit Codebuff (type "exit")
+2. Navigate into the target directory (type "cd ${newWorkingDirectory}")
+3. Restart Codebuff`);
+                await runSinglePtyCommand(ptyProcess, `cd ${currentWorkingDirectory}`, () => { });
+            }
+            else {
+                (0, project_files_1.setWorkingDirectory)(newWorkingDirectory);
+                finalCwd = newWorkingDirectory;
+            }
+        }
+        resolve({
+            result: formatResult(command, commandOutput, (0, array_1.buildArray)([
+                `cwd: ${currentWorkingDirectory}`,
+                `${statusMessage}\n`,
+                outsideProject &&
+                    `Detected final cwd outside project root. Reset cwd to ${currentWorkingDirectory}`,
+                `Final **user** cwd: ${finalCwd} (Assistant's cwd is still project root)`,
+            ]).join('\n')),
+            stdout: commandOutput,
+            exitCode,
+        });
+    });
+};
+exports.runCommandPty = runCommandPty;
+const runCommandChildProcess = (persistentProcess, command, mode, cwd, maybeTimeoutSeconds, resolve) => {
+    const isWindows = os.platform() === 'win32';
+    let commandOutput = '';
+    if (mode === 'assistant') {
+        console.log((0, picocolors_1.green)(`> ${command}`));
+    }
+    const childProcess = (0, child_process_1.spawn)(persistentProcess.shell, [isWindows ? '/c' : '-c', command], {
+        cwd,
+        env: {
+            ...process.env,
+            PAGER: 'cat',
+            GIT_PAGER: 'cat',
+            GIT_TERMINAL_PROMPT: '0',
+            LESS: '-FRX',
+        },
+    });
+    persistentProcess = {
+        ...persistentProcess,
+        childProcess,
+    };
+    let timer = null;
+    if (maybeTimeoutSeconds !== null) {
+        timer = setTimeout(() => {
+            (0, exports.resetShell)(cwd);
+            if (mode === 'assistant') {
+                resolve({
+                    result: formatResult(command, commandOutput, `Command timed out after ${maybeTimeoutSeconds} seconds and was terminated.`),
+                    stdout: commandOutput,
+                    exitCode: 124,
+                });
+            }
+        }, maybeTimeoutSeconds * 1000);
+    }
+    persistentProcess.timerId = timer;
+    childProcess.stdout.on('data', (data) => {
+        const output = data.toString();
+        process.stdout.write(output);
+        commandOutput += output;
+    });
+    childProcess.stderr.on('data', (data) => {
+        const output = data.toString();
+        process.stdout.write(output);
+        commandOutput += output;
+    });
+    childProcess.on('close', (code) => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (command.startsWith('cd ') && mode === 'user') {
+            const newWorkingDirectory = command.split(' ')[1];
+            cwd = (0, project_files_1.setWorkingDirectory)(path_1.default.join(cwd, newWorkingDirectory));
+        }
+        if (mode === 'assistant') {
+            console.log((0, picocolors_1.green)(`Command completed`));
+        }
+        resolve({
+            result: formatResult(command, commandOutput, `complete`),
+            stdout: commandOutput,
+            exitCode: childProcess.exitCode,
+        });
+    });
+};
+function killAndResetPersistentProcess() {
+    if (exports.persistentProcess?.type === 'pty') {
+        exports.persistentProcess.pty.kill();
+        exports.persistentProcess = null;
+    }
+}
+function clearScreen() {
+    process.stdout.write('\u001b[2J\u001b[0;0H');
+}
+// New function specifically for manager mode with settling behavior
+const runCommandPtyManager = (persistentProcess, command, cwd, maybeTimeoutSeconds, resolve) => {
+    const ptyProcess = persistentProcess.pty;
+    if (command.trim() === 'clear') {
+        // `clear` needs access to the main process stdout. This is a workaround.
+        (0, child_process_1.execSync)('clear', { stdio: 'inherit' });
+        resolve({
+            result: formatResult(command, '', `Complete`),
+            stdout: '',
+            exitCode: 0,
+        });
+        return;
+    }
+    const projectRoot = (0, project_files_1.getProjectRoot)();
+    const isWindows = os.platform() === 'win32';
+    console.log((0, picocolors_1.green)(`${cwd} > ${command}`));
+    let commandOutput = '';
+    let buffer = promptIdentifier;
+    let echoLinesRemaining = isWindows ? 1 : command.split('\n').length;
+    let timer = null;
+    let settleTimer = null;
+    // Use the provided timeout or default to 30 seconds for manager mode
+    const managerTimeoutMs = maybeTimeoutSeconds !== null ? maybeTimeoutSeconds * 1000 : 30000;
+    if (maybeTimeoutSeconds !== null) {
+        timer = setTimeout(() => {
+            // In manager mode, don't kill the terminal - just report what we have
+            if (timer) {
+                clearTimeout(timer);
+            }
+            if (settleTimer) {
+                clearTimeout(settleTimer);
+            }
+            dataDisposable.dispose();
+            resolve({
+                result: formatResult(command, commandOutput, `Command timed out after ${managerTimeoutMs / 1000} seconds. Output captured so far. Terminal is still running.`),
+                stdout: commandOutput,
+                exitCode: null, // null indicates timeout, not failure
+            });
+        }, managerTimeoutMs);
+    }
+    persistentProcess.timerId = timer;
+    const finishCommand = (exitCode = null) => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        if (settleTimer) {
+            clearTimeout(settleTimer);
+        }
+        dataDisposable.dispose();
+        const statusMessage = exitCode === 0
+            ? 'Complete'
+            : exitCode === null
+                ? 'Comand started'
+                : `Failed with exit code: ${exitCode}`;
+        resolve({
+            result: formatResult(command, undefined, `cwd: ${path_1.default.resolve(projectRoot, cwd)}\n\n${statusMessage}`),
+            stdout: commandOutput,
+            exitCode,
+        });
+    };
+    const dataDisposable = ptyProcess.onData((data) => {
+        buffer += data;
+        const suffix = (0, string_1.suffixPrefixOverlap)(buffer, promptIdentifier);
+        let toProcess = buffer.slice(0, buffer.length - suffix.length);
+        buffer = suffix;
+        const matches = toProcess.match(echoLinePattern);
+        if (matches) {
+            for (let i = 0; i < matches.length && echoLinesRemaining > 0; i++) {
+                echoLinesRemaining = Math.max(echoLinesRemaining - 1, 0);
+                // Process normal output line
+                toProcess = toProcess.replace(echoLinePattern, '');
+            }
+        }
+        const indexOfPromptIdentifier = toProcess.indexOf(promptIdentifier);
+        if (indexOfPromptIdentifier !== -1) {
+            buffer = toProcess.slice(indexOfPromptIdentifier) + buffer;
+            toProcess = toProcess.slice(0, indexOfPromptIdentifier);
+        }
+        process.stdout.write(toProcess);
+        commandOutput += toProcess;
+        // Reset settle timer whenever we get new output
+        if (settleTimer) {
+            clearTimeout(settleTimer);
+        }
+        // Set settle timer for 3000ms - if no new output comes, finish the command
+        settleTimer = setTimeout(() => {
+            finishCommand();
+        }, 3000);
+        const commandDone = buffer.startsWith(promptIdentifier);
+        if (commandDone && echoLinesRemaining === 0) {
+            // Command is done
+            const exitCode = buffer.includes('Command completed')
+                ? 0
+                : (() => {
+                    const match = buffer.match(/Command failed with exit code (\d+)\./);
+                    return match ? parseInt(match[1]) : null;
+                })();
+            finishCommand(exitCode);
+            return;
+        }
+    });
+    ptyProcess.write(`${command}`);
+    setTimeout(() => {
+        ptyProcess.write('\r');
+    }, 50);
+};
+exports.runCommandPtyManager = runCommandPtyManager;
+// Add a function to get new terminal output since last read
+const readNewTerminalOutput = (options = { maxLength: COMMAND_OUTPUT_LIMIT }) => {
+    if (!exports.persistentProcess) {
+        return '';
+    }
+    const currentLength = exports.persistentProcess.globalOutputBuffer.length;
+    const newOutput = exports.persistentProcess.globalOutputBuffer.slice(exports.persistentProcess.globalOutputLastReadLength);
+    // Update the last read position
+    exports.persistentProcess.globalOutputLastReadLength = currentLength;
+    return (0, string_1.truncateStringWithMessage)({
+        str: newOutput,
+        maxLength: options.maxLength,
+        remove: 'MIDDLE',
+    });
+};
+exports.readNewTerminalOutput = readNewTerminalOutput;
+//# sourceMappingURL=base.js.map