@push.rocks/smartshell 3.2.3 → 3.3.0

package/dist_ts/classes.smartshell.js

@@ -5,6 +5,7 @@ import * as cp from 'child_process';
 export class Smartshell {
     constructor(optionsArg) {
         this.smartexit = new plugins.smartexit.SmartExit();
+        this.nodePty = null;
         this.shellEnv = new ShellEnv(optionsArg);
     }
     /**
@@ -38,71 +39,402 @@ export class Smartshell {
             });
         });
     }
+    /**
+     * Executes a command with args array (shell:false) for security
+     */
+    async _execSpawn(options) {
+        const shellLogInstance = new ShellLog();
+        let stderrBuffer = '';
+        const maxBuffer = options.maxBuffer || 200 * 1024 * 1024; // Default 200MB
+        let bufferExceeded = false;
+        // Handle PTY mode if requested
+        if (options.usePty) {
+            throw new Error('PTY mode is not yet supported with execSpawn. Use exec methods with shell:true for PTY.');
+        }
+        const execChildProcess = cp.spawn(options.command, options.args || [], {
+            shell: false, // SECURITY: Never use shell with untrusted input
+            cwd: process.cwd(),
+            env: options.env || process.env,
+            detached: false,
+            signal: options.signal,
+        });
+        this.smartexit.addProcess(execChildProcess);
+        // Handle timeout
+        let timeoutHandle = null;
+        if (options.timeout) {
+            timeoutHandle = setTimeout(() => {
+                if (options.debug) {
+                    console.log(`[smartshell] Timeout reached for process ${execChildProcess.pid}, terminating...`);
+                }
+                execChildProcess.kill('SIGTERM');
+            }, options.timeout);
+        }
+        // Connect stdin if passthrough is enabled (but not for interactive control)
+        if (options.passthrough && !options.interactiveControl && execChildProcess.stdin) {
+            process.stdin.pipe(execChildProcess.stdin);
+        }
+        // Create input methods for interactive control
+        const sendInput = async (input) => {
+            if (!execChildProcess.stdin) {
+                throw new Error('stdin is not available for this process');
+            }
+            if (execChildProcess.stdin.destroyed || !execChildProcess.stdin.writable) {
+                throw new Error('stdin has been destroyed or is not writable');
+            }
+            return new Promise((resolve, reject) => {
+                execChildProcess.stdin.write(input, 'utf8', (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+        const sendLine = async (line) => {
+            return sendInput(line + '\n');
+        };
+        const endInput = () => {
+            if (execChildProcess.stdin && !execChildProcess.stdin.destroyed) {
+                execChildProcess.stdin.end();
+            }
+        };
+        // Capture stdout and stderr output
+        execChildProcess.stdout.on('data', (data) => {
+            if (!options.silent) {
+                shellLogInstance.writeToConsole(data);
+            }
+            if (options.onData) {
+                options.onData(data);
+            }
+            if (!bufferExceeded) {
+                shellLogInstance.addToBuffer(data);
+                if (shellLogInstance.logStore.length > maxBuffer) {
+                    bufferExceeded = true;
+                    shellLogInstance.logStore = Buffer.from('[Output truncated - exceeded maxBuffer]');
+                }
+            }
+        });
+        execChildProcess.stderr.on('data', (data) => {
+            if (!options.silent) {
+                shellLogInstance.writeToConsole(data);
+            }
+            const dataStr = data.toString();
+            stderrBuffer += dataStr;
+            if (options.onData) {
+                options.onData(data);
+            }
+            if (!bufferExceeded) {
+                shellLogInstance.addToBuffer(data);
+                if (shellLogInstance.logStore.length > maxBuffer) {
+                    bufferExceeded = true;
+                    shellLogInstance.logStore = Buffer.from('[Output truncated - exceeded maxBuffer]');
+                }
+            }
+        });
+        // Wrap child process termination into a Promise
+        const childProcessEnded = new Promise((resolve, reject) => {
+            const handleExit = (code, signal) => {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                this.smartexit.removeProcess(execChildProcess);
+                // Safely unpipe stdin when process ends if passthrough was enabled
+                if (options.passthrough && !options.interactiveControl) {
+                    try {
+                        if (execChildProcess.stdin && !execChildProcess.stdin.destroyed) {
+                            process.stdin.unpipe(execChildProcess.stdin);
+                        }
+                    }
+                    catch (err) {
+                        if (options.debug) {
+                            console.log(`[smartshell] Error unpiping stdin: ${err}`);
+                        }
+                    }
+                }
+                const exitCode = typeof code === 'number' ? code : (signal ? 1 : 0);
+                const execResult = {
+                    exitCode,
+                    stdout: shellLogInstance.logStore.toString(),
+                    signal: signal || undefined,
+                    stderr: stderrBuffer,
+                };
+                if (options.strict && exitCode !== 0) {
+                    const errorMsg = signal
+                        ? `Command "${options.command}" terminated by signal ${signal}`
+                        : `Command "${options.command}" exited with code ${exitCode}`;
+                    reject(new Error(errorMsg));
+                }
+                else {
+                    resolve(execResult);
+                }
+            };
+            execChildProcess.once('exit', handleExit);
+            execChildProcess.once('error', (error) => {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                this.smartexit.removeProcess(execChildProcess);
+                // Safely unpipe stdin when process errors if passthrough was enabled
+                if (options.passthrough && !options.interactiveControl && execChildProcess.stdin) {
+                    try {
+                        if (!execChildProcess.stdin.destroyed) {
+                            process.stdin.unpipe(execChildProcess.stdin);
+                        }
+                    }
+                    catch (err) {
+                        if (options.debug) {
+                            console.log(`[smartshell] Error unpiping stdin on error: ${err}`);
+                        }
+                    }
+                }
+                reject(error);
+            });
+        });
+        // If interactive control is enabled but not streaming, return interactive interface
+        if (options.interactiveControl && !options.streaming) {
+            return {
+                exitCode: 0, // Will be updated when process ends
+                stdout: '', // Will be updated when process ends
+                sendInput,
+                sendLine,
+                endInput,
+                finalPromise: childProcessEnded,
+            };
+        }
+        // If streaming mode is enabled, return a streaming interface
+        if (options.streaming) {
+            return {
+                childProcess: execChildProcess,
+                finalPromise: childProcessEnded,
+                sendInput,
+                sendLine,
+                endInput,
+                kill: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+                    }
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGKILL');
+                },
+                terminate: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+                    }
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGTERM');
+                },
+                keyboardInterrupt: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGINT on process ${execChildProcess.pid}`);
+                    }
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGINT');
+                },
+                customSignal: async (signal) => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with custom signal ${signal} on process ${execChildProcess.pid}`);
+                    }
+                    await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, signal);
+                },
+            };
+        }
+        // For non-streaming mode, wait for the process to complete
+        return await childProcessEnded;
+    }
     /**
      * Executes a command and returns either a non-streaming result or a streaming interface.
      */
     async _execCommand(options) {
         const commandToExecute = this.shellEnv.createEnvExecString(options.commandString);
         const shellLogInstance = new ShellLog();
+        let stderrBuffer = '';
+        const maxBuffer = options.maxBuffer || 200 * 1024 * 1024; // Default 200MB
+        let bufferExceeded = false;
+        // Handle PTY mode if requested
+        if (options.usePty) {
+            return await this._execCommandPty(options, commandToExecute, shellLogInstance);
+        }
         const execChildProcess = cp.spawn(commandToExecute, [], {
             shell: true,
             cwd: process.cwd(),
-            env: process.env,
+            env: options.env || process.env,
             detached: false,
+            signal: options.signal,
         });
         this.smartexit.addProcess(execChildProcess);
-        // Capture stdout and stderr output.
+        // Handle timeout
+        let timeoutHandle = null;
+        if (options.timeout) {
+            timeoutHandle = setTimeout(() => {
+                if (options.debug) {
+                    console.log(`[smartshell] Timeout reached for process ${execChildProcess.pid}, terminating...`);
+                }
+                execChildProcess.kill('SIGTERM');
+            }, options.timeout);
+        }
+        // Connect stdin if passthrough is enabled (but not for interactive control)
+        if (options.passthrough && !options.interactiveControl && execChildProcess.stdin) {
+            process.stdin.pipe(execChildProcess.stdin);
+        }
+        // Create input methods for interactive control
+        const sendInput = async (input) => {
+            if (!execChildProcess.stdin) {
+                throw new Error('stdin is not available for this process');
+            }
+            if (execChildProcess.stdin.destroyed || !execChildProcess.stdin.writable) {
+                throw new Error('stdin has been destroyed or is not writable');
+            }
+            return new Promise((resolve, reject) => {
+                execChildProcess.stdin.write(input, 'utf8', (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+        const sendLine = async (line) => {
+            return sendInput(line + '\n');
+        };
+        const endInput = () => {
+            if (execChildProcess.stdin && !execChildProcess.stdin.destroyed) {
+                execChildProcess.stdin.end();
+            }
+        };
+        // Capture stdout and stderr output
         execChildProcess.stdout.on('data', (data) => {
             if (!options.silent) {
                 shellLogInstance.writeToConsole(data);
             }
-            shellLogInstance.addToBuffer(data);
+            if (options.onData) {
+                options.onData(data);
+            }
+            if (!bufferExceeded) {
+                shellLogInstance.addToBuffer(data);
+                if (shellLogInstance.logStore.length > maxBuffer) {
+                    bufferExceeded = true;
+                    shellLogInstance.logStore = Buffer.from('[Output truncated - exceeded maxBuffer]');
+                }
+            }
         });
         execChildProcess.stderr.on('data', (data) => {
             if (!options.silent) {
                 shellLogInstance.writeToConsole(data);
             }
-            shellLogInstance.addToBuffer(data);
+            const dataStr = data.toString();
+            stderrBuffer += dataStr;
+            if (options.onData) {
+                options.onData(data);
+            }
+            if (!bufferExceeded) {
+                shellLogInstance.addToBuffer(data);
+                if (shellLogInstance.logStore.length > maxBuffer) {
+                    bufferExceeded = true;
+                    shellLogInstance.logStore = Buffer.from('[Output truncated - exceeded maxBuffer]');
+                }
+            }
         });
-        // Wrap child process termination into a Promise.
+        // Wrap child process termination into a Promise
         const childProcessEnded = new Promise((resolve, reject) => {
-            execChildProcess.on('exit', (code, signal) => {
+            const handleExit = (code, signal) => {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
                 this.smartexit.removeProcess(execChildProcess);
+                // Safely unpipe stdin when process ends if passthrough was enabled
+                if (options.passthrough && !options.interactiveControl) {
+                    try {
+                        if (execChildProcess.stdin && !execChildProcess.stdin.destroyed) {
+                            process.stdin.unpipe(execChildProcess.stdin);
+                        }
+                    }
+                    catch (err) {
+                        if (options.debug) {
+                            console.log(`[smartshell] Error unpiping stdin: ${err}`);
+                        }
+                    }
+                }
+                const exitCode = typeof code === 'number' ? code : (signal ? 1 : 0);
                 const execResult = {
-                    exitCode: typeof code === 'number' ? code : (signal ? 1 : 0),
+                    exitCode,
                     stdout: shellLogInstance.logStore.toString(),
+                    signal: signal || undefined,
+                    stderr: stderrBuffer,
                 };
-                if (options.strict && code !== 0) {
-                    reject(new Error(`Command "${options.commandString}" exited with code ${code}`));
+                if (options.strict && exitCode !== 0) {
+                    const errorMsg = signal
+                        ? `Command "${options.commandString}" terminated by signal ${signal}`
+                        : `Command "${options.commandString}" exited with code ${exitCode}`;
+                    reject(new Error(errorMsg));
                 }
                 else {
                     resolve(execResult);
                 }
-            });
-            execChildProcess.on('error', (error) => {
+            };
+            execChildProcess.once('exit', handleExit);
+            execChildProcess.once('error', (error) => {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
                 this.smartexit.removeProcess(execChildProcess);
+                // Safely unpipe stdin when process errors if passthrough was enabled
+                if (options.passthrough && !options.interactiveControl && execChildProcess.stdin) {
+                    try {
+                        if (!execChildProcess.stdin.destroyed) {
+                            process.stdin.unpipe(execChildProcess.stdin);
+                        }
+                    }
+                    catch (err) {
+                        if (options.debug) {
+                            console.log(`[smartshell] Error unpiping stdin on error: ${err}`);
+                        }
+                    }
+                }
                 reject(error);
             });
         });
-        // If streaming mode is enabled, return a streaming interface immediately.
+        // If interactive control is enabled but not streaming, return interactive interface
+        if (options.interactiveControl && !options.streaming) {
+            return {
+                exitCode: 0, // Will be updated when process ends
+                stdout: '', // Will be updated when process ends
+                sendInput,
+                sendLine,
+                endInput,
+                finalPromise: childProcessEnded,
+            };
+        }
+        // If streaming mode is enabled, return a streaming interface
         if (options.streaming) {
             return {
                 childProcess: execChildProcess,
                 finalPromise: childProcessEnded,
+                sendInput,
+                sendLine,
+                endInput,
                 kill: async () => {
-                    console.log(`Running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGKILL on process ${execChildProcess.pid}`);
+                    }
                     await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGKILL');
                 },
                 terminate: async () => {
-                    console.log(`Running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGTERM on process ${execChildProcess.pid}`);
+                    }
                     await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGTERM');
                 },
                 keyboardInterrupt: async () => {
-                    console.log(`Running tree kill with SIGINT on process ${execChildProcess.pid}`);
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with SIGINT on process ${execChildProcess.pid}`);
+                    }
                     await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, 'SIGINT');
                 },
                 customSignal: async (signal) => {
-                    console.log(`Running tree kill with custom signal ${signal} on process ${execChildProcess.pid}`);
+                    if (options.debug) {
+                        console.log(`[smartshell] Running tree kill with custom signal ${signal} on process ${execChildProcess.pid}`);
+                    }
                     await plugins.smartexit.SmartExit.killTreeByPid(execChildProcess.pid, signal);
                 },
             };
@@ -111,7 +443,9 @@ export class Smartshell {
         return await childProcessEnded;
     }
     async exec(commandString) {
-        return (await this._exec({ commandString }));
+        const result = await this._exec({ commandString });
+        // Type assertion is safe here because non-streaming, non-interactive exec always returns IExecResult
+        return result;
     }
     async execSilent(commandString) {
         return (await this._exec({ commandString, silent: true }));
@@ -131,19 +465,256 @@ export class Smartshell {
     async execInteractive(commandString) {
         await this._exec({ commandString, interactive: true });
     }
-    async execAndWaitForLine(commandString, regex, silent = false) {
+    async execPassthrough(commandString) {
+        return await this._exec({ commandString, passthrough: true });
+    }
+    async execStreamingPassthrough(commandString) {
+        return await this._exec({ commandString, streaming: true, passthrough: true });
+    }
+    async execInteractiveControl(commandString) {
+        return await this._exec({ commandString, interactiveControl: true });
+    }
+    async execStreamingInteractiveControl(commandString) {
+        return await this._exec({ commandString, streaming: true, interactiveControl: true });
+    }
+    async execInteractiveControlPty(commandString) {
+        return await this._exec({ commandString, interactiveControl: true, usePty: true });
+    }
+    async execStreamingInteractiveControlPty(commandString) {
+        return await this._exec({ commandString, streaming: true, interactiveControl: true, usePty: true });
+    }
+    /**
+     * Executes a command with args array (shell:false) for security
+     * This is the recommended API for untrusted input
+     */
+    async execSpawn(command, args = [], options = {}) {
+        const result = await this._execSpawn({ command, args, ...options });
+        // Type assertion is safe here because non-streaming, non-interactive exec always returns IExecResult
+        return result;
+    }
+    /**
+     * Executes a command with args array in streaming mode
+     */
+    async execSpawnStreaming(command, args = [], options = {}) {
+        return await this._execSpawn({ command, args, streaming: true, ...options });
+    }
+    /**
+     * Executes a command with args array with interactive control
+     */
+    async execSpawnInteractiveControl(command, args = [], options = {}) {
+        return await this._execSpawn({ command, args, interactiveControl: true, ...options });
+    }
+    async execAndWaitForLine(commandString, regex, silent = false, options = {}) {
         const execStreamingResult = await this.execStreaming(commandString, silent);
-        return new Promise((resolve) => {
-            execStreamingResult.childProcess.stdout.on('data', (chunk) => {
+        return new Promise((resolve, reject) => {
+            let matched = false;
+            let timeoutHandle = null;
+            // Set up timeout if specified
+            if (options.timeout) {
+                timeoutHandle = setTimeout(async () => {
+                    if (!matched) {
+                        matched = true;
+                        // Remove listener to prevent memory leak
+                        execStreamingResult.childProcess.stdout.removeAllListeners('data');
+                        await execStreamingResult.terminate();
+                        reject(new Error(`Timeout waiting for pattern after ${options.timeout}ms`));
+                    }
+                }, options.timeout);
+            }
+            const dataHandler = async (chunk) => {
                 const data = typeof chunk === 'string' ? chunk : chunk.toString();
-                if (regex.test(data)) {
+                if (!matched && regex.test(data)) {
+                    matched = true;
+                    // Clear timeout if set
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    // Remove listener to prevent memory leak
+                    execStreamingResult.childProcess.stdout.removeListener('data', dataHandler);
+                    // Terminate process if requested
+                    if (options.terminateOnMatch) {
+                        await execStreamingResult.terminate();
+                        await execStreamingResult.finalPromise;
+                    }
                     resolve();
                 }
+            };
+            execStreamingResult.childProcess.stdout.on('data', dataHandler);
+            // Also resolve/reject when process ends
+            execStreamingResult.finalPromise.then(() => {
+                if (!matched) {
+                    matched = true;
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    reject(new Error('Process ended without matching pattern'));
+                }
+            }).catch((err) => {
+                if (!matched) {
+                    matched = true;
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    reject(err);
+                }
             });
         });
     }
-    async execAndWaitForLineSilent(commandString, regex) {
-        return this.execAndWaitForLine(commandString, regex, true);
+    async execAndWaitForLineSilent(commandString, regex, options) {
+        return this.execAndWaitForLine(commandString, regex, true, options);
+    }
+    async lazyLoadNodePty() {
+        if (this.nodePty) {
+            return this.nodePty;
+        }
+        try {
+            // Try to load node-pty if available
+            // @ts-ignore - node-pty is optional
+            this.nodePty = await import('node-pty');
+            return this.nodePty;
+        }
+        catch (error) {
+            throw new Error('node-pty is required for PTY support but is not installed.\n' +
+                'Please install it as an optional dependency:\n' +
+                '  pnpm add --save-optional node-pty\n' +
+                'Note: node-pty requires compilation and may have platform-specific requirements.');
+        }
+    }
+    async _execCommandPty(options, commandToExecute, shellLogInstance) {
+        const pty = await this.lazyLoadNodePty();
+        // Platform-aware shell selection
+        let shell;
+        let shellArgs;
+        if (options.ptyShell) {
+            // User-provided shell override
+            shell = options.ptyShell;
+            shellArgs = ['-c', commandToExecute];
+        }
+        else if (process.platform === 'win32') {
+            // Windows: Use PowerShell by default, or cmd as fallback
+            const powershell = process.env.PROGRAMFILES
+                ? `${process.env.PROGRAMFILES}\\PowerShell\\7\\pwsh.exe`
+                : 'powershell.exe';
+            // Check if PowerShell Core exists, otherwise use Windows PowerShell
+            const fs = await import('fs');
+            if (fs.existsSync(powershell)) {
+                shell = powershell;
+                shellArgs = ['-NoProfile', '-NonInteractive', '-Command', commandToExecute];
+            }
+            else if (process.env.COMSPEC) {
+                shell = process.env.COMSPEC;
+                shellArgs = ['/d', '/s', '/c', commandToExecute];
+            }
+            else {
+                shell = 'cmd.exe';
+                shellArgs = ['/d', '/s', '/c', commandToExecute];
+            }
+        }
+        else {
+            // POSIX: Use SHELL env var or bash as default
+            shell = process.env.SHELL || '/bin/bash';
+            shellArgs = ['-c', commandToExecute];
+        }
+        // Create PTY process
+        const ptyProcess = pty.spawn(shell, shellArgs, {
+            name: options.ptyTerm || 'xterm-256color',
+            cols: options.ptyCols || 120,
+            rows: options.ptyRows || 30,
+            cwd: process.cwd(),
+            env: options.env || process.env,
+        });
+        // Add to smartexit (wrap in a minimal object with pid)
+        this.smartexit.addProcess({ pid: ptyProcess.pid });
+        // Handle output (stdout and stderr are combined in PTY)
+        ptyProcess.onData((data) => {
+            if (!options.silent) {
+                shellLogInstance.writeToConsole(data);
+            }
+            shellLogInstance.addToBuffer(data);
+        });
+        // Wrap PTY termination into a Promise
+        const childProcessEnded = new Promise((resolve, reject) => {
+            ptyProcess.onExit(({ exitCode, signal }) => {
+                this.smartexit.removeProcess({ pid: ptyProcess.pid });
+                const execResult = {
+                    exitCode: exitCode ?? (signal ? 1 : 0),
+                    stdout: shellLogInstance.logStore.toString(),
+                };
+                if (options.strict && exitCode !== 0) {
+                    reject(new Error(`Command "${options.commandString}" exited with code ${exitCode}`));
+                }
+                else {
+                    resolve(execResult);
+                }
+            });
+        });
+        // Create input methods for PTY
+        const sendInput = async (input) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    ptyProcess.write(input);
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        };
+        const sendLine = async (line) => {
+            // Use \r for PTY (carriage return is typical for terminal line discipline)
+            return sendInput(line + '\r');
+        };
+        const endInput = () => {
+            // Send EOF (Ctrl+D) to PTY
+            ptyProcess.write('\x04');
+        };
+        // If interactive control is enabled but not streaming, return interactive interface
+        if (options.interactiveControl && !options.streaming) {
+            return {
+                exitCode: 0, // Will be updated when process ends
+                stdout: '', // Will be updated when process ends
+                sendInput,
+                sendLine,
+                endInput,
+                finalPromise: childProcessEnded,
+            };
+        }
+        // If streaming mode is enabled, return a streaming interface
+        if (options.streaming) {
+            return {
+                childProcess: { pid: ptyProcess.pid }, // Minimal compatibility object
+                finalPromise: childProcessEnded,
+                sendInput,
+                sendLine,
+                endInput,
+                kill: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Killing PTY process ${ptyProcess.pid}`);
+                    }
+                    ptyProcess.kill();
+                },
+                terminate: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Terminating PTY process ${ptyProcess.pid}`);
+                    }
+                    ptyProcess.kill('SIGTERM');
+                },
+                keyboardInterrupt: async () => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Sending SIGINT to PTY process ${ptyProcess.pid}`);
+                    }
+                    ptyProcess.kill('SIGINT');
+                },
+                customSignal: async (signal) => {
+                    if (options.debug) {
+                        console.log(`[smartshell] Sending ${signal} to PTY process ${ptyProcess.pid}`);
+                    }
+                    ptyProcess.kill(signal);
+                },
+            };
+        }
+        // For non-streaming mode, wait for the process to complete
+        return await childProcessEnded;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smartshell.js","sourceRoot":"","sources":["../ts/classes.smartshell.ts"],"names":[],"mappings":"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"}