centaurus-cli 3.0.1 → 3.1.0

package/dist/context/handlers/ssh-handler.js

@@ -1,1172 +1,1113 @@
-/**
- * SSH Handler for remote shell connections
- */
-import { Client } from 'ssh2';
-import { SubshellConnectionError, SubshellExecutionError } from '../types.js';
-import { randomBytes } from 'crypto';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { quickLog } from '../../utils/conversation-logger.js';
-/**
- * SSH Handler implementation
- */
-export class SSHHandler {
-    type = 'ssh';
-    detectionPatterns = [
-        /^ssh\s+/,
-        /^ssh\s+-[^\s]+\s+/,
-    ];
-    _client = null;
-    sftpClient = null;
-    config = null;
-    currentWorkingDirectory = '~';
-    shellType = 'bash';
-    osType = 'linux';
-    sessionId = '';
-    onPasswordRequest;
-    _isConnected = false;
-    onDisconnectCallback;
-    /**
-     * Get the underlying SSH client (used for PTY commands)
-     */
-    get client() {
-        return this._client;
+import { Client } from "ssh2";
+import { SubshellConnectionError, SubshellExecutionError } from "../types.js";
+import { randomBytes } from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { quickLog } from "../../utils/conversation-logger.js";
+class SSHHandler {
+  type = "ssh";
+  detectionPatterns = [
+    /^ssh\s+/,
+    /^ssh\s+-[^\s]+\s+/
+  ];
+  _client = null;
+  sftpClient = null;
+  config = null;
+  currentWorkingDirectory = "~";
+  shellType = "bash";
+  osType = "linux";
+  sessionId = "";
+  onPasswordRequest;
+  _isConnected = false;
+  onDisconnectCallback;
+  /**
+   * Get the underlying SSH client (used for PTY commands)
+   */
+  get client() {
+    return this._client;
+  }
+  /**
+   * Set password request callback
+   */
+  setPasswordRequestCallback(callback) {
+    this.onPasswordRequest = callback;
+  }
+  /**
+   * Set callback to be called when the connection is lost
+   */
+  setDisconnectCallback(callback) {
+    this.onDisconnectCallback = callback;
+  }
+  /**
+   * Check if the handler is currently connected
+   */
+  isConnected() {
+    return this._isConnected && this._client !== null;
+  }
+  /**
+   * Detect if a command should trigger this handler
+   */
+  detect(command) {
+    return this.detectionPatterns.some((pattern) => pattern.test(command));
+  }
+  /**
+   * Attach to an existing SSH session detected from PTY output.
+   * This is used for "Warpify" mode where the user has already established
+   * an SSH connection in the terminal and pressed Alt+E to attach.
+   * 
+   * Unlike connect(), this does NOT establish a new SSH connection.
+   * It creates a context based on the detected session info for AI awareness.
+   * Commands will continue to flow through the PTY, not via ssh2 library.
+   * 
+   * @param connectionString - The detected connection string (e.g., "user@hostname")
+   */
+  attachFromPtyOutput(connectionString) {
+    this.sessionId = `warpified-${Date.now()}`;
+    const parts = connectionString.split("@");
+    const username = parts.length > 1 ? parts[0] : "user";
+    const hostname = parts.length > 1 ? parts[1] : connectionString;
+    this.config = {
+      host: hostname,
+      port: 22,
+      username
+    };
+    this._isConnected = true;
+    return {
+      type: "ssh",
+      handler: this,
+      metadata: {
+        hostname,
+        username,
+        workingDirectory: "~",
+        shell: "bash",
+        // Assume bash for warpified sessions
+        os: "linux",
+        port: 22
+      },
+      connectionState: "connected",
+      sessionId: this.sessionId
+    };
+  }
+  /**
+   * Connect to the SSH server
+   */
+  async connect(command, cwd) {
+    this.sessionId = randomBytes(16).toString("hex");
+    try {
+      this.config = this.parseSSHCommand(command);
+      await this.establishConnection(this.config);
+      try {
+        await this.initializeSFTP();
+      } catch (e) {
+        this.sftpClient = null;
+      }
+      this.shellType = await this.detectShellType();
+      this.osType = await this.detectOSType();
+      this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
+      await this.injectShellIntegration();
+      return {
+        type: "ssh",
+        handler: this,
+        metadata: {
+          hostname: this.config.host,
+          username: this.config.username,
+          workingDirectory: this.currentWorkingDirectory,
+          shell: this.shellType,
+          os: this.osType,
+          port: this.config.port
+        },
+        connectionState: "connected",
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      throw new SubshellConnectionError(
+        "ssh",
+        error instanceof Error ? error.message : "Unknown error",
+        true
+      );
     }
-    /**
-     * Set password request callback
-     */
-    setPasswordRequestCallback(callback) {
-        this.onPasswordRequest = callback;
+  }
+  /**
+   * Connect from an existing remote context (nested session)
+   */
+  async connectFromRemote(command, cwd, parentContext) {
+    this.sessionId = randomBytes(16).toString("hex");
+    try {
+      this.config = this.parseSSHCommand(command);
+      this.config.isNested = true;
+      let streamFactory;
+      if (parentContext.handler && typeof parentContext.handler.createStream === "function") {
+        streamFactory = () => parentContext.handler.createStream(this.config.host, this.config.port);
+      } else {
+        throw new SubshellConnectionError("ssh", `Parent context (${parentContext.type}) does not support nested connections via tunneling.`, false);
+      }
+      await this.establishConnection(this.config, void 0, streamFactory);
+      try {
+        await this.initializeSFTP();
+      } catch (e) {
+        this.sftpClient = null;
+      }
+      this.shellType = await this.detectShellType();
+      this.osType = await this.detectOSType();
+      this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
+      await this.injectShellIntegration();
+      return {
+        type: "ssh",
+        handler: this,
+        metadata: {
+          hostname: this.config.host,
+          username: this.config.username,
+          workingDirectory: this.currentWorkingDirectory,
+          shell: this.shellType,
+          os: this.osType,
+          port: this.config.port
+        },
+        connectionState: "connected",
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      throw new SubshellConnectionError(
+        "ssh",
+        error instanceof Error ? error.message : "Unknown error",
+        true
+      );
     }
-    /**
-     * Set callback to be called when the connection is lost
-     */
-    setDisconnectCallback(callback) {
-        this.onDisconnectCallback = callback;
+  }
+  /**
+   * Create a network stream/tunnel through this SSH connection
+   */
+  async createStream(host, port) {
+    if (!this._client || !this._isConnected) {
+      throw new Error("Not connected to SSH server");
     }
-    /**
-     * Check if the handler is currently connected
-     */
-    isConnected() {
-        return this._isConnected && this._client !== null;
+    return new Promise((resolve, reject) => {
+      this._client.forwardOut("127.0.0.1", 0, host, port, (err, stream) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(stream);
+        }
+      });
+    });
+  }
+  /**
+   * Disconnect from the SSH server
+   */
+  async disconnect() {
+    this._isConnected = false;
+    if (this.sftpClient) {
+      this.sftpClient.end();
+      this.sftpClient = null;
     }
-    /**
-     * Detect if a command should trigger this handler
-     */
-    detect(command) {
-        return this.detectionPatterns.some(pattern => pattern.test(command));
+    if (this._client) {
+      this._client.end();
+      this._client = null;
     }
-    /**
-     * Attach to an existing SSH session detected from PTY output.
-     * This is used for "Warpify" mode where the user has already established
-     * an SSH connection in the terminal and pressed Alt+E to attach.
-     *
-     * Unlike connect(), this does NOT establish a new SSH connection.
-     * It creates a context based on the detected session info for AI awareness.
-     * Commands will continue to flow through the PTY, not via ssh2 library.
-     *
-     * @param connectionString - The detected connection string (e.g., "user@hostname")
-     */
-    attachFromPtyOutput(connectionString) {
-        this.sessionId = `warpified-${Date.now()}`;
-        // Parse connection string
-        const parts = connectionString.split('@');
-        const username = parts.length > 1 ? parts[0] : 'user';
-        const hostname = parts.length > 1 ? parts[1] : connectionString;
-        // Create minimal config for context tracking (no actual SSH connection)
-        this.config = {
-            host: hostname,
-            port: 22,
-            username: username,
-        };
-        // Mark as "connected" for context purposes (PTY handles actual connection)
-        this._isConnected = true;
-        return {
-            type: 'ssh',
-            handler: this,
-            metadata: {
-                hostname: hostname,
-                username: username,
-                workingDirectory: '~',
-                shell: 'bash', // Assume bash for warpified sessions
-                os: 'linux',
-                port: 22,
-            },
-            connectionState: 'connected',
-            sessionId: this.sessionId,
-        };
+    this.config = null;
+  }
+  /**
+   * Execute a command in the SSH session
+   */
+  async executeCommand(command) {
+    if (!this._client || !this._isConnected) {
+      throw new SubshellExecutionError(command, "Not connected to SSH server");
     }
-    /**
-     * Connect to the SSH server
-     */
-    async connect(command, cwd) {
-        this.sessionId = randomBytes(16).toString('hex');
-        try {
-            // Parse SSH command
-            this.config = this.parseSSHCommand(command);
-            // Establish SSH connection
-            await this.establishConnection(this.config);
-            // Initialize SFTP (non-fatal)
-            try {
-                await this.initializeSFTP();
-            }
-            catch (e) {
-                // Continue without SFTP; file ops will fallback to command-based methods
-                this.sftpClient = null;
-            }
-            // Detect shell type and OS
-            this.shellType = await this.detectShellType();
-            this.osType = await this.detectOSType();
-            // Get initial working directory
-            this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
-            // Inject shell integration script
-            await this.injectShellIntegration();
-            return {
-                type: 'ssh',
-                handler: this,
-                metadata: {
-                    hostname: this.config.host,
-                    username: this.config.username,
-                    workingDirectory: this.currentWorkingDirectory,
-                    shell: this.shellType,
-                    os: this.osType,
-                    port: this.config.port,
-                },
-                connectionState: 'connected',
-                sessionId: this.sessionId,
-            };
-        }
-        catch (error) {
-            throw new SubshellConnectionError('ssh', error instanceof Error ? error.message : 'Unknown error', true);
-        }
-    }
-    /**
-     * Connect from an existing remote context (nested session)
-     */
-    async connectFromRemote(command, cwd, parentContext) {
-        this.sessionId = randomBytes(16).toString('hex');
-        try {
-            // Parse SSH command
-            this.config = this.parseSSHCommand(command);
-            // Mark as nested session to disable implicit local authentication
-            this.config.isNested = true;
-            // Check if parent supports streaming
-            // Check if parent supports streaming
-            let streamFactory;
-            if (parentContext.handler && typeof parentContext.handler.createStream === 'function') {
-                streamFactory = () => parentContext.handler.createStream(this.config.host, this.config.port);
-            }
-            else {
-                throw new SubshellConnectionError('ssh', `Parent context (${parentContext.type}) does not support nested connections via tunneling.`, false);
-            }
-            // Establish SSH connection using the tunnel stream factory
-            await this.establishConnection(this.config, undefined, streamFactory);
-            // Initialize SFTP (non-fatal)
-            try {
-                await this.initializeSFTP();
-            }
-            catch (e) {
-                this.sftpClient = null;
+    const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new SubshellExecutionError(command, "Command timed out after 30 seconds"));
+      }, 3e4);
+      this._client.exec(
+        `cd "${this.currentWorkingDirectory}" && ${command}; echo "${pwdTag}:$(pwd)"`,
+        (err, stream) => {
+          if (err) {
+            clearTimeout(timeout);
+            reject(new SubshellExecutionError(command, err.message));
+            return;
+          }
+          let stdout = "";
+          let stderr = "";
+          stream.on("close", (code) => {
+            clearTimeout(timeout);
+            const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, "m");
+            const pwdMatch = stdout.match(pwdRegex);
+            if (pwdMatch) {
+              this.currentWorkingDirectory = pwdMatch[1].trim();
+              const removeRegex = new RegExp(`${pwdTag}:.+$`, "m");
+              stdout = stdout.replace(removeRegex, "").trim();
             }
-            // Detect shell type and OS
-            this.shellType = await this.detectShellType();
-            this.osType = await this.detectOSType();
-            // Get initial working directory
-            this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
-            // Inject shell integration script
-            await this.injectShellIntegration();
-            return {
-                type: 'ssh',
-                handler: this,
-                metadata: {
-                    hostname: this.config.host,
-                    username: this.config.username,
-                    workingDirectory: this.currentWorkingDirectory,
-                    shell: this.shellType,
-                    os: this.osType,
-                    port: this.config.port,
-                },
-                connectionState: 'connected',
-                sessionId: this.sessionId,
-            };
-        }
-        catch (error) {
-            throw new SubshellConnectionError('ssh', error instanceof Error ? error.message : 'Unknown error', true);
-        }
-    }
-    /**
-     * Create a network stream/tunnel through this SSH connection
-     */
-    async createStream(host, port) {
-        if (!this._client || !this._isConnected) {
-            throw new Error('Not connected to SSH server');
-        }
-        return new Promise((resolve, reject) => {
-            // Use arbitrary source IP/port (127.0.0.1:0) for the forwardOut call
-            this._client.forwardOut('127.0.0.1', 0, host, port, (err, stream) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(stream);
-                }
+            resolve({
+              stdout,
+              stderr,
+              exitCode: code || 0
             });
+          });
+          stream.on("data", (data) => {
+            stdout += data.toString();
+          });
+          stream.stderr.on("data", (data) => {
+            stderr += data.toString();
+          });
+        }
+      );
+    });
+  }
+  /**
+   * Read a file from the remote filesystem
+   */
+  async readFile(path2) {
+    const absolutePath = this.resolveAbsolutePath(path2);
+    if (this.sftpClient) {
+      return new Promise((resolve, reject) => {
+        this.sftpClient.readFile(absolutePath, "utf8", (err, data) => {
+          if (err) {
+            reject(new Error(`Failed to read file ${path2}: ${err.message}`));
+          } else {
+            resolve(data);
+          }
         });
+      });
     }
-    /**
-     * Disconnect from the SSH server
-     */
-    async disconnect() {
-        // Mark as disconnected first to prevent close/end handlers from firing callback
-        this._isConnected = false;
-        if (this.sftpClient) {
-            this.sftpClient.end();
-            this.sftpClient = null;
-        }
-        if (this._client) {
-            this._client.end();
-            this._client = null;
-        }
-        this.config = null;
+    const result = await this.executeCommand(`base64 "${absolutePath}" || cat "${absolutePath}" | base64`);
+    const base64Out = result.stdout.replace(/\s+/g, "");
+    try {
+      return Buffer.from(base64Out, "base64").toString("utf8");
+    } catch (e) {
+      throw new Error(`Failed to decode file ${path2}: ${e.message}`);
     }
-    /**
-     * Execute a command in the SSH session
-     */
-    async executeCommand(command) {
-        if (!this._client || !this._isConnected) {
-            throw new SubshellExecutionError(command, 'Not connected to SSH server');
-        }
-        const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new SubshellExecutionError(command, 'Command timed out after 30 seconds'));
-            }, 30000);
-            this._client.exec(`cd "${this.currentWorkingDirectory}" && ${command}; echo "${pwdTag}:$(pwd)"`, (err, stream) => {
-                if (err) {
-                    clearTimeout(timeout);
-                    reject(new SubshellExecutionError(command, err.message));
-                    return;
-                }
-                let stdout = '';
-                let stderr = '';
-                stream.on('close', (code) => {
-                    clearTimeout(timeout);
-                    // Extract working directory from output using unique tag
-                    // We use a constructed regex to match the specific tag for this session
-                    const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, 'm');
-                    const pwdMatch = stdout.match(pwdRegex);
-                    if (pwdMatch) {
-                        this.currentWorkingDirectory = pwdMatch[1].trim();
-                        // Remove the tag line from stdout
-                        const removeRegex = new RegExp(`${pwdTag}:.+$`, 'm');
-                        stdout = stdout.replace(removeRegex, '').trim();
-                    }
-                    resolve({
-                        stdout,
-                        stderr,
-                        exitCode: code || 0,
-                    });
-                });
-                stream.on('data', (data) => {
-                    stdout += data.toString();
-                });
-                stream.stderr.on('data', (data) => {
-                    stderr += data.toString();
-                });
-            });
+  }
+  /**
+   * Write a file to the remote filesystem
+   */
+  async writeFile(path2, content) {
+    const absolutePath = this.resolveAbsolutePath(path2);
+    if (this.sftpClient) {
+      return new Promise((resolve, reject) => {
+        const options = Buffer.isBuffer(content) ? void 0 : "utf8";
+        this.sftpClient.writeFile(absolutePath, content, options, (err) => {
+          if (err) {
+            reject(new Error(`Failed to write file ${path2}: ${err.message}`));
+          } else {
+            resolve();
+          }
         });
+      });
     }
-    /**
-     * Read a file from the remote filesystem
-     */
-    async readFile(path) {
-        const absolutePath = this.resolveAbsolutePath(path);
-        // Prefer SFTP when available
-        if (this.sftpClient) {
-            return new Promise((resolve, reject) => {
-                this.sftpClient.readFile(absolutePath, 'utf8', (err, data) => {
-                    if (err) {
-                        reject(new Error(`Failed to read file ${path}: ${err.message}`));
-                    }
-                    else {
-                        resolve(data);
-                    }
-                });
-            });
-        }
-        // Fallback: use base64 over exec
-        const result = await this.executeCommand(`base64 "${absolutePath}" || cat "${absolutePath}" | base64`);
-        const base64Out = result.stdout.replace(/\s+/g, '');
-        try {
-            return Buffer.from(base64Out, 'base64').toString('utf8');
-        }
-        catch (e) {
-            throw new Error(`Failed to decode file ${path}: ${e.message}`);
-        }
-    }
-    /**
-     * Write a file to the remote filesystem
-     */
-    async writeFile(path, content) {
-        const absolutePath = this.resolveAbsolutePath(path);
-        // Prefer SFTP when available
-        if (this.sftpClient) {
-            return new Promise((resolve, reject) => {
-                // ssh2 sftp writeFile supports Buffer or string
-                // If buffer, encoding is ignored/not needed
-                const options = Buffer.isBuffer(content) ? undefined : 'utf8';
-                this.sftpClient.writeFile(absolutePath, content, options, (err) => {
-                    if (err) {
-                        reject(new Error(`Failed to write file ${path}: ${err.message}`));
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            });
-        }
-        // Fallback: base64 via exec (robust against special chars), chunked
-        const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
-        const base64Content = inputBuffer.toString('base64');
-        const CHUNK_SIZE = 32000;
-        // Truncate file first
-        let result = await this.executeCommand(`: > "${absolutePath}"`);
-        if (result.exitCode !== 0) {
-            throw new Error(`Failed to initialize file ${path}: ${result.stderr || 'unknown error'}`);
-        }
-        for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
-            const chunk = base64Content.slice(i, i + CHUNK_SIZE);
-            result = await this.executeCommand(`echo "${chunk}" | base64 -d >> "${absolutePath}"`);
-            if (result.exitCode !== 0) {
-                throw new Error(`Failed to write file chunk for ${path}: ${result.stderr || 'unknown error'}`);
-            }
-        }
+    const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    const base64Content = inputBuffer.toString("base64");
+    const CHUNK_SIZE = 32e3;
+    let result = await this.executeCommand(`: > "${absolutePath}"`);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to initialize file ${path2}: ${result.stderr || "unknown error"}`);
     }
-    /**
-     * List directory contents
-     */
-    async listDirectory(path) {
-        const absolutePath = this.resolveAbsolutePath(path);
-        // Prefer SFTP when available
-        if (this.sftpClient) {
-            return new Promise((resolve, reject) => {
-                this.sftpClient.readdir(absolutePath, (err, list) => {
-                    if (err) {
-                        reject(new Error(`Failed to list directory ${path}: ${err.message}`));
-                    }
-                    else {
-                        const entries = list.map(item => ({
-                            name: item.filename,
-                            type: item.attrs.isDirectory() ? 'directory' : 'file',
-                            size: item.attrs.size,
-                            permissions: item.attrs.mode?.toString(8),
-                        }));
-                        resolve(entries);
-                    }
-                });
-            });
-        }
-        // Fallback: parse ls -la output
-        const result = await this.executeCommand(`ls -la "${absolutePath}"`);
-        if (result.exitCode !== 0) {
-            throw new Error(`Failed to list directory ${path}: ${result.stderr || 'unknown error'}`);
-        }
-        return this.parseDirectoryListing(result.stdout);
+    for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
+      const chunk = base64Content.slice(i, i + CHUNK_SIZE);
+      result = await this.executeCommand(`echo "${chunk}" | base64 -d >> "${absolutePath}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to write file chunk for ${path2}: ${result.stderr || "unknown error"}`);
+      }
     }
-    /**
-     * Search for files matching a pattern
-     */
-    async searchFiles(pattern, directory) {
-        const absolutePath = this.resolveAbsolutePath(directory);
-        const escapedPattern = pattern.replace(/'/g, "'\\''");
-        const command = `grep -rn '${escapedPattern}' "${absolutePath}" 2>/dev/null || true`;
-        const result = await this.executeCommand(command);
-        const results = [];
-        const lines = result.stdout.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            const match = line.match(/^(.+?):(\d+):(.+)$/);
-            if (match) {
-                results.push({
-                    file: match[1],
-                    line: parseInt(match[2], 10),
-                    content: match[3],
-                });
-            }
-        }
-        return results;
+  }
+  /**
+   * List directory contents
+   */
+  async listDirectory(path2) {
+    const absolutePath = this.resolveAbsolutePath(path2);
+    if (this.sftpClient) {
+      return new Promise((resolve, reject) => {
+        this.sftpClient.readdir(absolutePath, (err, list) => {
+          if (err) {
+            reject(new Error(`Failed to list directory ${path2}: ${err.message}`));
+          } else {
+            const entries = list.map((item) => ({
+              name: item.filename,
+              type: item.attrs.isDirectory() ? "directory" : "file",
+              size: item.attrs.size,
+              permissions: item.attrs.mode?.toString(8)
+            }));
+            resolve(entries);
+          }
+        });
+      });
     }
-    /**
-     * Get the current working directory
-     */
-    async getCurrentWorkingDirectory() {
-        const result = await this.executeCommand('pwd');
-        return result.stdout.trim();
+    const result = await this.executeCommand(`ls -la "${absolutePath}"`);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to list directory ${path2}: ${result.stderr || "unknown error"}`);
     }
-    /**
-     * Get the shell type
-     */
-    async getShellType() {
-        return this.shellType;
+    return this.parseDirectoryListing(result.stdout);
+  }
+  /**
+   * Search for files matching a pattern
+   */
+  async searchFiles(pattern, directory) {
+    const absolutePath = this.resolveAbsolutePath(directory);
+    const escapedPattern = pattern.replace(/'/g, "'\\''");
+    const command = `grep -rn '${escapedPattern}' "${absolutePath}" 2>/dev/null || true`;
+    const result = await this.executeCommand(command);
+    const results = [];
+    const lines = result.stdout.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const match = line.match(/^(.+?):(\d+):(.+)$/);
+      if (match) {
+        results.push({
+          file: match[1],
+          line: parseInt(match[2], 10),
+          content: match[3]
+        });
+      }
     }
-    /**
-     * Get the operating system type
-     */
-    async getOSType() {
-        return this.osType;
+    return results;
+  }
+  /**
+   * Get the current working directory
+   */
+  async getCurrentWorkingDirectory() {
+    const result = await this.executeCommand("pwd");
+    return result.stdout.trim();
+  }
+  /**
+   * Get the shell type
+   */
+  async getShellType() {
+    return this.shellType;
+  }
+  /**
+   * Get the operating system type
+   */
+  async getOSType() {
+    return this.osType;
+  }
+  /**
+   * Get breadcrumb information for the UI
+   */
+  getBreadcrumbs() {
+    if (!this.config) {
+      return [];
     }
-    /**
-     * Get breadcrumb information for the UI
-     */
-    getBreadcrumbs() {
-        if (!this.config) {
-            return [];
-        }
-        return [
-            {
-                label: 'ssh',
-                color: 'cyan',
+    return [
+      {
+        label: "ssh",
+        color: "cyan"
+      },
+      {
+        label: `${this.config.username}@${this.config.host}`,
+        color: "cyan"
+      }
+    ];
+  }
+  // Private helper methods
+  /**
+   * Parse SSH command to extract connection details
+   */
+  parseSSHCommand(command) {
+    const parts = this.tokenizeSSHCommand(command);
+    let host = "";
+    let port = 22;
+    let username = "";
+    let identityFilePath;
+    const optionsWithValue = /* @__PURE__ */ new Set([
+      "-b",
+      "-c",
+      "-D",
+      "-E",
+      "-F",
+      "-I",
+      "-J",
+      "-L",
+      "-l",
+      "-m",
+      "-O",
+      "-o",
+      "-p",
+      "-Q",
+      "-R",
+      "-S",
+      "-W",
+      "-w"
+    ]);
+    for (let i = 1; i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "--") {
+        if (!host && i + 1 < parts.length) {
+          host = parts[i + 1];
+        }
+        break;
+      }
+      if (part === "-p" && i + 1 < parts.length) {
+        port = this.parsePort(parts[i + 1], port);
+        i++;
+      } else if (part.startsWith("-p") && part.length > 2) {
+        port = this.parsePort(part.slice(2), port);
+      } else if (part === "-l" && i + 1 < parts.length) {
+        username = parts[i + 1];
+        i++;
+      } else if (part.startsWith("-l") && part.length > 2) {
+        username = part.slice(2);
+      } else if (part === "-i" && i + 1 < parts.length) {
+        identityFilePath = parts[i + 1];
+        i++;
+      } else if (part.startsWith("-i") && part.length > 2) {
+        identityFilePath = part.slice(2);
+      } else if (part === "-o" && i + 1 < parts.length) {
+        const optionToken = parts[i + 1];
+        if (optionToken.includes("=")) {
+          this.applySSHOption(
+            optionToken,
+            (value) => {
+              port = value;
+            },
+            (value) => {
+              username = value;
             },
-            {
-                label: `${this.config.username}@${this.config.host}`,
-                color: 'cyan',
+            (value) => {
+              identityFilePath = value;
             },
-        ];
+            port
+          );
+          i++;
+        } else if (i + 2 < parts.length) {
+          this.applySSHOption(
+            `${optionToken}=${parts[i + 2]}`,
+            (value) => {
+              port = value;
+            },
+            (value) => {
+              username = value;
+            },
+            (value) => {
+              identityFilePath = value;
+            },
+            port
+          );
+          i += 2;
+        } else {
+          i++;
+        }
+      } else if (part.startsWith("-o") && part.length > 2) {
+        this.applySSHOption(part.slice(2), (value) => {
+          port = value;
+        }, (value) => {
+          username = value;
+        }, (value) => {
+          identityFilePath = value;
+        }, port);
+      } else if (part.startsWith("-") && part !== "-p") {
+        if (optionsWithValue.has(part) && i + 1 < parts.length) {
+          i++;
+        }
+        continue;
+      } else if (!host) {
+        if (part.includes("@")) {
+          const atIndex = part.indexOf("@");
+          const user = part.slice(0, atIndex);
+          const hostname = part.slice(atIndex + 1);
+          if (user) {
+            username = user;
+          }
+          host = hostname;
+        } else {
+          host = part;
+        }
+      }
     }
-    // Private helper methods
-    /**
-     * Parse SSH command to extract connection details
-     */
-    parseSSHCommand(command) {
-        const parts = this.tokenizeSSHCommand(command);
-        let host = '';
-        let port = 22;
-        let username = '';
-        let identityFilePath;
-        // SSH options that consume the next token as a value.
-        // We skip those values so they are not mistaken as the host.
-        const optionsWithValue = new Set([
-            '-b', '-c', '-D', '-E', '-F', '-I', '-J', '-L', '-l', '-m', '-O', '-o', '-p', '-Q', '-R', '-S', '-W', '-w'
-        ]);
-        // Parse command line arguments
-        for (let i = 1; i < parts.length; i++) {
-            const part = parts[i];
-            if (part === '--') {
-                // End of options; next token is the host
-                if (!host && i + 1 < parts.length) {
-                    host = parts[i + 1];
-                }
-                break;
-            }
-            if (part === '-p' && i + 1 < parts.length) {
-                port = this.parsePort(parts[i + 1], port);
-                i++;
-            }
-            else if (part.startsWith('-p') && part.length > 2) {
-                port = this.parsePort(part.slice(2), port);
-            }
-            else if (part === '-l' && i + 1 < parts.length) {
-                username = parts[i + 1];
-                i++;
-            }
-            else if (part.startsWith('-l') && part.length > 2) {
-                username = part.slice(2);
-            }
-            else if (part === '-i' && i + 1 < parts.length) {
-                identityFilePath = parts[i + 1];
-                i++;
-            }
-            else if (part.startsWith('-i') && part.length > 2) {
-                identityFilePath = part.slice(2);
-            }
-            else if (part === '-o' && i + 1 < parts.length) {
-                // Support both "-o Key=Value" and "-o Key Value" styles.
-                const optionToken = parts[i + 1];
-                if (optionToken.includes('=')) {
-                    this.applySSHOption(optionToken, (value) => { port = value; }, (value) => { username = value; }, (value) => { identityFilePath = value; }, port);
-                    i++;
-                }
-                else if (i + 2 < parts.length) {
-                    this.applySSHOption(`${optionToken}=${parts[i + 2]}`, (value) => { port = value; }, (value) => { username = value; }, (value) => { identityFilePath = value; }, port);
-                    i += 2;
-                }
-                else {
-                    i++;
-                }
-            }
-            else if (part.startsWith('-o') && part.length > 2) {
-                this.applySSHOption(part.slice(2), (value) => { port = value; }, (value) => { username = value; }, (value) => { identityFilePath = value; }, port);
-            }
-            else if (part.startsWith('-') && part !== '-p') {
-                // Skip flags and their value, if any
-                if (optionsWithValue.has(part) && i + 1 < parts.length) {
-                    i++;
-                }
-                continue;
-            }
-            else if (!host) {
-                // This should be the host (possibly with username)
-                if (part.includes('@')) {
-                    const atIndex = part.indexOf('@');
-                    const user = part.slice(0, atIndex);
-                    const hostname = part.slice(atIndex + 1);
-                    if (user) {
-                        username = user;
-                    }
-                    host = hostname;
-                }
-                else {
-                    host = part;
-                }
-            }
-        }
-        // Default username to current user if not specified
-        if (!username) {
-            username = process.env.USER || process.env.USERNAME || 'user';
-        }
-        if (!host) {
-            throw new Error('Could not parse SSH host from command');
-        }
-        const parsedConfig = {
-            host,
-            port,
-            username,
-        };
-        if (identityFilePath) {
-            parsedConfig.privateKey = this.loadIdentityFile(identityFilePath);
-        }
-        return parsedConfig;
+    if (!username) {
+      username = process.env.USER || process.env.USERNAME || "user";
+    }
+    if (!host) {
+      throw new Error("Could not parse SSH host from command");
+    }
+    const parsedConfig = {
+      host,
+      port,
+      username
+    };
+    if (identityFilePath) {
+      parsedConfig.privateKey = this.loadIdentityFile(identityFilePath);
     }
-    /**
-     * Establish SSH connection
-     */
-    /**
-     * Establish SSH connection.
-     * Handles authentication retries (agent -> keys -> password).
-     * For nested connections, uses streamFactory to get a fresh stream for each attempt.
-     */
-    async establishConnection(config, stream, streamFactory) {
-        let promptedForPassword = false;
-        let firstError;
-        quickLog(`[SSH Auth] Starting auth for ${config.username}@${config.host}:${config.port}\n`);
-        quickLog(`[SSH Auth] Has privateKey: ${!!config.privateKey}, Has password: ${!!config.password}\n`);
+    return parsedConfig;
+  }
+  /**
+   * Establish SSH connection
+   */
+  /**
+   * Establish SSH connection.
+   * Handles authentication retries (agent -> keys -> password).
+   * For nested connections, uses streamFactory to get a fresh stream for each attempt.
+   */
+  async establishConnection(config, stream, streamFactory) {
+    let promptedForPassword = false;
+    let firstError;
+    quickLog(`[SSH Auth] Starting auth for ${config.username}@${config.host}:${config.port}
+`);
+    quickLog(`[SSH Auth] Has privateKey: ${!!config.privateKey}, Has password: ${!!config.password}
+`);
+    try {
+      quickLog(`[SSH Auth] Attempt 1: agent/none (tryKeyboard=false)
+`);
+      const currentStream = streamFactory ? await streamFactory() : stream;
+      await this.establishConnectionOnce(config, currentStream, false, () => {
+        promptedForPassword = true;
+      });
+      quickLog(`[SSH Auth] Attempt 1 succeeded (agent or none auth)
+`);
+      return;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      quickLog(`[SSH Auth] Attempt 1 failed: ${errMsg}, promptedForPassword=${promptedForPassword}
+`);
+      firstError = error;
+      if (!this.isAuthenticationFailure(error) || promptedForPassword) {
+        quickLog(`[SSH Auth] Stopping early: isAuthFailure=${this.isAuthenticationFailure(error)}, prompted=${promptedForPassword}
+`);
+        throw error;
+      }
+    }
+    if (!config.privateKey && !config.isNested) {
+      const defaultKeys = this.loadDefaultIdentityFiles(config.host);
+      quickLog(`[SSH Auth] Found ${defaultKeys.length} default identity file(s)
+`);
+      for (let ki = 0; ki < defaultKeys.length; ki++) {
+        const key = defaultKeys[ki];
         try {
-            quickLog(`[SSH Auth] Attempt 1: agent/none (tryKeyboard=false)\n`);
-            // Get fresh stream if factory provided
-            const currentStream = streamFactory ? await streamFactory() : stream;
-            await this.establishConnectionOnce(config, currentStream, false, () => {
-                promptedForPassword = true;
-            });
-            quickLog(`[SSH Auth] Attempt 1 succeeded (agent or none auth)\n`);
-            return;
-        }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : String(error);
-            quickLog(`[SSH Auth] Attempt 1 failed: ${errMsg}, promptedForPassword=${promptedForPassword}\n`);
-            firstError = error;
-            // Stop early for non-auth failures or if user was already prompted.
-            if (!this.isAuthenticationFailure(error) || promptedForPassword) {
-                quickLog(`[SSH Auth] Stopping early: isAuthFailure=${this.isAuthenticationFailure(error)}, prompted=${promptedForPassword}\n`);
-                throw error;
-            }
-        }
-        // If no explicit key was provided, try default identity files before prompting for password.
-        // Skip this for nested sessions to avoid using local keys where remote ones are expected.
-        if (!config.privateKey && !config.isNested) {
-            const defaultKeys = this.loadDefaultIdentityFiles(config.host);
-            quickLog(`[SSH Auth] Found ${defaultKeys.length} default identity file(s)\n`);
-            for (let ki = 0; ki < defaultKeys.length; ki++) {
-                const key = defaultKeys[ki];
-                try {
-                    quickLog(`[SSH Auth] Trying key file ${ki + 1}/${defaultKeys.length} (${key.length} bytes)\n`);
-                    // Get fresh stream if factory provided
-                    const keyStream = streamFactory ? await streamFactory() : stream;
-                    const keyConfig = {
-                        ...config,
-                        privateKey: key,
-                        password: undefined,
-                    };
-                    await this.establishConnectionOnce(keyConfig, keyStream, false, () => {
-                        promptedForPassword = true;
-                    });
-                    quickLog(`[SSH Auth] Key file ${ki + 1} succeeded!\n`);
-                    config.privateKey = key;
-                    return;
-                }
-                catch (keyError) {
-                    const keyErrMsg = keyError instanceof Error ? keyError.message : String(keyError);
-                    quickLog(`[SSH Auth] Key file ${ki + 1} failed: ${keyErrMsg}\n`);
-                    if (promptedForPassword) {
-                        // User already provided a secret once for this connection attempt.
-                        throw keyError;
-                    }
-                    // Continue trying other keys for expected auth/key-format failures.
-                    if (this.isAuthenticationFailure(keyError) || this.isKeyParseFailure(keyError)) {
-                        continue;
-                    }
-                    throw keyError;
-                }
-            }
-        }
-        else {
-            quickLog(`[SSH Auth] Explicit key provided, skipping default key search\n`);
-        }
-        // Password retry (only if callback exists).
-        quickLog(`[SSH Auth] All key-based auth methods exhausted, falling back to password\n`);
-        if (!this.onPasswordRequest) {
-            throw (firstError instanceof Error ? firstError : new Error('SSH authentication failed'));
-        }
-        const password = await this.requestPassword(config);
-        config.password = password;
-        config.privateKey = undefined;
-        // Get fresh stream for password attempt
-        const passwordStream = streamFactory ? await streamFactory() : stream;
-        await this.establishConnectionOnce(config, passwordStream, true, () => {
+          quickLog(`[SSH Auth] Trying key file ${ki + 1}/${defaultKeys.length} (${key.length} bytes)
+`);
+          const keyStream = streamFactory ? await streamFactory() : stream;
+          const keyConfig = {
+            ...config,
+            privateKey: key,
+            password: void 0
+          };
+          await this.establishConnectionOnce(keyConfig, keyStream, false, () => {
             promptedForPassword = true;
-        });
+          });
+          quickLog(`[SSH Auth] Key file ${ki + 1} succeeded!
+`);
+          config.privateKey = key;
+          return;
+        } catch (keyError) {
+          const keyErrMsg = keyError instanceof Error ? keyError.message : String(keyError);
+          quickLog(`[SSH Auth] Key file ${ki + 1} failed: ${keyErrMsg}
+`);
+          if (promptedForPassword) {
+            throw keyError;
+          }
+          if (this.isAuthenticationFailure(keyError) || this.isKeyParseFailure(keyError)) {
+            continue;
+          }
+          throw keyError;
+        }
+      }
+    } else {
+      quickLog(`[SSH Auth] Explicit key provided, skipping default key search
+`);
     }
-    /**
-     * Single SSH connection attempt.
-     * Password retry logic is handled by establishConnection().
-     * @param enableKeyboard - Whether to enable keyboard-interactive auth.
-     *   Set to false for key-based attempts so the server doesn't prompt for password prematurely.
-     *   Set to true only for the final password-retry attempt.
-     */
-    async establishConnectionOnce(config, stream, enableKeyboard, onPasswordPrompt) {
-        return new Promise((resolve, reject) => {
-            const client = new Client();
-            this._client = client;
-            let settled = false;
-            const settleResolve = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                this._isConnected = true;
-                resolve();
-            };
-            const settleReject = (error) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                this._isConnected = false;
-                this._client = null;
-                try {
-                    client.end();
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-                reject(error);
-            };
-            client.on('ready', () => {
-                settleResolve();
-            });
-            client.on('error', (err) => {
-                settleReject(new Error(`ssh connection failed: ${err.message}`));
-            });
-            client.on('keyboard-interactive', async (_name, _instructions, _lang, prompts, finish) => {
-                if (!prompts || prompts.length === 0 || !this.onPasswordRequest) {
-                    finish([]);
-                    return;
-                }
-                try {
-                    const responses = [];
-                    for (const prompt of prompts) {
-                        onPasswordPrompt();
-                        const message = this.buildPasswordPromptMessage(config, prompt.prompt);
-                        const response = await this.requestPassword(config, message);
-                        responses.push(response);
-                        if (!prompt.echo) {
-                            config.password = response;
-                        }
-                    }
-                    finish(responses);
-                }
-                catch (error) {
-                    finish([]);
-                    settleReject(error instanceof Error ? error : new Error('Password input cancelled'));
-                }
-            });
-            // Listen for unexpected disconnections
-            client.on('close', () => {
-                if (this._isConnected) {
-                    // Unexpected disconnect (not initiated by us calling disconnect())
-                    this._isConnected = false;
-                    this._client = null;
-                    if (this.onDisconnectCallback) {
-                        this.onDisconnectCallback('Connection closed by server');
-                    }
-                }
-            });
-            client.on('end', () => {
-                if (this._isConnected) {
-                    // Unexpected disconnect
-                    this._isConnected = false;
-                    this._client = null;
-                    if (this.onDisconnectCallback) {
-                        this.onDisconnectCallback('Connection ended');
-                    }
-                }
-            });
-            client.connect(this.buildConnectConfig(config, stream, enableKeyboard));
-        });
+    quickLog(`[SSH Auth] All key-based auth methods exhausted, falling back to password
+`);
+    if (!this.onPasswordRequest) {
+      throw firstError instanceof Error ? firstError : new Error("SSH authentication failed");
     }
-    /**
-     * Build ssh2 connection config.
-     * @param enableKeyboard - When true, enables keyboard-interactive auth.
-     *   This should only be true for the final password-retry attempt;
-     *   otherwise the server's keyboard-interactive challenge fires before
-     *   key-based auth methods (agent, key files) have been tried.
-     */
-    buildConnectConfig(config, stream, enableKeyboard = false) {
-        const connectConfig = {
-            host: config.host,
-            port: config.port,
-            username: config.username,
-            tryKeyboard: enableKeyboard,
-        };
-        if (stream) {
-            connectConfig.sock = stream;
-        }
-        // Skip local SSH agent for nested sessions
-        if (!config.isNested) {
-            if (process.env.SSH_AUTH_SOCK) {
-                connectConfig.agent = process.env.SSH_AUTH_SOCK;
-                quickLog(`[SSH Auth] Using SSH_AUTH_SOCK agent: ${process.env.SSH_AUTH_SOCK}\n`);
-            }
-            else if (os.platform() === 'win32') {
-                // Windows OpenSSH agent uses a named pipe, not SSH_AUTH_SOCK.
-                // The ssh2 library supports this via the agent option.
-                // Pipe path: \\.\pipe\openssh-ssh-agent
-                const winPipe = ['', '', '.', 'pipe', 'openssh-ssh-agent'].join('\\');
-                quickLog(`[SSH Auth] Windows detected, checking agent pipe: ${winPipe}\n`);
-                try {
-                    // Did not stat the pipe as it returns EBUSY on Windows sometimes
-                    // Just try to use it
-                    connectConfig.agent = winPipe;
-                    quickLog(`[SSH Auth] Using Windows agent pipe (blind trust)\n`);
-                }
-                catch (e) {
-                    // Named pipe not available (agent service not running).
-                    // Fall through to key file / password auth.
-                    quickLog(`[SSH Auth] Windows agent pipe error: ${e.message}\n`);
-                }
-            }
-            else {
-                quickLog(`[SSH Auth] No SSH agent available (no SSH_AUTH_SOCK, not Windows)\n`);
-            }
+    const password = await this.requestPassword(config);
+    config.password = password;
+    config.privateKey = void 0;
+    const passwordStream = streamFactory ? await streamFactory() : stream;
+    await this.establishConnectionOnce(config, passwordStream, true, () => {
+      promptedForPassword = true;
+    });
+  }
+  /**
+   * Single SSH connection attempt.
+   * Password retry logic is handled by establishConnection().
+   * @param enableKeyboard - Whether to enable keyboard-interactive auth.
+   *   Set to false for key-based attempts so the server doesn't prompt for password prematurely.
+   *   Set to true only for the final password-retry attempt.
+   */
+  async establishConnectionOnce(config, stream, enableKeyboard, onPasswordPrompt) {
+    return new Promise((resolve, reject) => {
+      const client = new Client();
+      this._client = client;
+      let settled = false;
+      const settleResolve = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        this._isConnected = true;
+        resolve();
+      };
+      const settleReject = (error) => {
+        if (settled) {
+          return;
         }
-        if (config.password) {
-            connectConfig.password = config.password;
+        settled = true;
+        this._isConnected = false;
+        this._client = null;
+        try {
+          client.end();
+        } catch {
+        }
+        reject(error);
+      };
+      client.on("ready", () => {
+        settleResolve();
+      });
+      client.on("error", (err) => {
+        settleReject(new Error(`ssh connection failed: ${err.message}`));
+      });
+      client.on("keyboard-interactive", async (_name, _instructions, _lang, prompts, finish) => {
+        if (!prompts || prompts.length === 0 || !this.onPasswordRequest) {
+          finish([]);
+          return;
         }
-        if (config.privateKey) {
-            connectConfig.privateKey = config.privateKey;
-            if (config.passphrase) {
-                connectConfig.passphrase = config.passphrase;
+        try {
+          const responses = [];
+          for (const prompt of prompts) {
+            onPasswordPrompt();
+            const message = this.buildPasswordPromptMessage(config, prompt.prompt);
+            const response = await this.requestPassword(config, message);
+            responses.push(response);
+            if (!prompt.echo) {
+              config.password = response;
             }
-        }
-        // Add keepalive settings to prevent connection drops by NATs/Firewalls (e.g. GCP)
-        connectConfig.keepaliveInterval = 10000; // 10 seconds
-        connectConfig.keepaliveCountMax = 3;
-        return connectConfig;
+          }
+          finish(responses);
+        } catch (error) {
+          finish([]);
+          settleReject(error instanceof Error ? error : new Error("Password input cancelled"));
+        }
+      });
+      client.on("close", () => {
+        if (this._isConnected) {
+          this._isConnected = false;
+          this._client = null;
+          if (this.onDisconnectCallback) {
+            this.onDisconnectCallback("Connection closed by server");
+          }
+        }
+      });
+      client.on("end", () => {
+        if (this._isConnected) {
+          this._isConnected = false;
+          this._client = null;
+          if (this.onDisconnectCallback) {
+            this.onDisconnectCallback("Connection ended");
+          }
+        }
+      });
+      client.connect(this.buildConnectConfig(config, stream, enableKeyboard));
+    });
+  }
+  /**
+   * Build ssh2 connection config.
+   * @param enableKeyboard - When true, enables keyboard-interactive auth.
+   *   This should only be true for the final password-retry attempt;
+   *   otherwise the server's keyboard-interactive challenge fires before
+   *   key-based auth methods (agent, key files) have been tried.
+   */
+  buildConnectConfig(config, stream, enableKeyboard = false) {
+    const connectConfig = {
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      tryKeyboard: enableKeyboard
+    };
+    if (stream) {
+      connectConfig.sock = stream;
     }
-    async requestPassword(config, promptMessage) {
-        if (!this.onPasswordRequest) {
-            throw new Error('Password authentication required but no password prompt handler is configured');
-        }
+    if (!config.isNested) {
+      if (process.env.SSH_AUTH_SOCK) {
+        connectConfig.agent = process.env.SSH_AUTH_SOCK;
+        quickLog(`[SSH Auth] Using SSH_AUTH_SOCK agent: ${process.env.SSH_AUTH_SOCK}
+`);
+      } else if (os.platform() === "win32") {
+        const winPipe = ["", "", ".", "pipe", "openssh-ssh-agent"].join("\\");
+        quickLog(`[SSH Auth] Windows detected, checking agent pipe: ${winPipe}
+`);
         try {
-            return await this.onPasswordRequest(promptMessage || `Password for ${config.username}@${config.host}:`);
-        }
-        catch {
-            throw new Error('Password input cancelled');
-        }
+          connectConfig.agent = winPipe;
+          quickLog(`[SSH Auth] Using Windows agent pipe (blind trust)
+`);
+        } catch (e) {
+          quickLog(`[SSH Auth] Windows agent pipe error: ${e.message}
+`);
+        }
+      } else {
+        quickLog(`[SSH Auth] No SSH agent available (no SSH_AUTH_SOCK, not Windows)
+`);
+      }
     }
-    buildPasswordPromptMessage(config, rawPrompt) {
-        const trimmedPrompt = rawPrompt?.trim();
-        if (trimmedPrompt) {
-            return trimmedPrompt;
-        }
-        return `Password for ${config.username}@${config.host}:`;
+    if (config.password) {
+      connectConfig.password = config.password;
     }
-    isAuthenticationFailure(error) {
-        const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-        return (message.includes('all configured authentication methods failed') ||
-            message.includes('authentication failed') ||
-            message.includes('permission denied'));
+    if (config.privateKey) {
+      connectConfig.privateKey = config.privateKey;
+      if (config.passphrase) {
+        connectConfig.passphrase = config.passphrase;
+      }
     }
-    isKeyParseFailure(error) {
-        const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-        return (message.includes('cannot parse privatekey') ||
-            message.includes('bad passphrase') ||
-            message.includes('no passphrase given') ||
-            message.includes('invalid private key'));
+    connectConfig.keepaliveInterval = 1e4;
+    connectConfig.keepaliveCountMax = 3;
+    return connectConfig;
+  }
+  async requestPassword(config, promptMessage) {
+    if (!this.onPasswordRequest) {
+      throw new Error("Password authentication required but no password prompt handler is configured");
     }
-    parsePort(value, fallbackPort) {
-        const parsed = Number.parseInt(value, 10);
-        return Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackPort;
+    try {
+      return await this.onPasswordRequest(
+        promptMessage || `Password for ${config.username}@${config.host}:`
+      );
+    } catch {
+      throw new Error("Password input cancelled");
     }
-    applySSHOption(option, setPort, setUsername, setIdentityFile, fallbackPort) {
-        const trimmed = option.trim();
-        if (!trimmed) {
-            return;
-        }
-        const equalsIndex = trimmed.indexOf('=');
-        const key = (equalsIndex >= 0 ? trimmed.slice(0, equalsIndex) : trimmed).trim().toLowerCase();
-        const value = (equalsIndex >= 0 ? trimmed.slice(equalsIndex + 1) : '').trim();
-        if (!value) {
-            return;
-        }
-        if (key === 'identityfile') {
-            setIdentityFile(value);
-            return;
-        }
-        if (key === 'user') {
-            setUsername(value);
-            return;
-        }
-        if (key === 'port') {
-            setPort(this.parsePort(value, fallbackPort));
-        }
+  }
+  buildPasswordPromptMessage(config, rawPrompt) {
+    const trimmedPrompt = rawPrompt?.trim();
+    if (trimmedPrompt) {
+      return trimmedPrompt;
     }
-    tokenizeSSHCommand(command) {
-        const tokens = [];
-        let current = '';
-        let quote = null;
-        let escaped = false;
-        for (const char of command.trim()) {
-            if (escaped) {
-                current += char;
-                escaped = false;
-                continue;
-            }
-            if (char === '\\' && quote !== '\'') {
-                escaped = true;
-                continue;
-            }
-            if (quote) {
-                if (char === quote) {
-                    quote = null;
-                }
-                else {
-                    current += char;
-                }
-                continue;
-            }
-            if (char === '"' || char === '\'') {
-                quote = char;
-                continue;
-            }
-            if (/\s/.test(char)) {
-                if (current) {
-                    tokens.push(current);
-                    current = '';
-                }
-                continue;
-            }
-            current += char;
-        }
+    return `Password for ${config.username}@${config.host}:`;
+  }
+  isAuthenticationFailure(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return message.includes("all configured authentication methods failed") || message.includes("authentication failed") || message.includes("permission denied");
+  }
+  isKeyParseFailure(error) {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return message.includes("cannot parse privatekey") || message.includes("bad passphrase") || message.includes("no passphrase given") || message.includes("invalid private key");
+  }
+  parsePort(value, fallbackPort) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackPort;
+  }
+  applySSHOption(option, setPort, setUsername, setIdentityFile, fallbackPort) {
+    const trimmed = option.trim();
+    if (!trimmed) {
+      return;
+    }
+    const equalsIndex = trimmed.indexOf("=");
+    const key = (equalsIndex >= 0 ? trimmed.slice(0, equalsIndex) : trimmed).trim().toLowerCase();
+    const value = (equalsIndex >= 0 ? trimmed.slice(equalsIndex + 1) : "").trim();
+    if (!value) {
+      return;
+    }
+    if (key === "identityfile") {
+      setIdentityFile(value);
+      return;
+    }
+    if (key === "user") {
+      setUsername(value);
+      return;
+    }
+    if (key === "port") {
+      setPort(this.parsePort(value, fallbackPort));
+    }
+  }
+  tokenizeSSHCommand(command) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const char of command.trim()) {
+      if (escaped) {
+        current += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\" && quote !== "'") {
+        escaped = true;
+        continue;
+      }
+      if (quote) {
+        if (char === quote) {
+          quote = null;
+        } else {
+          current += char;
+        }
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        continue;
+      }
+      if (/\s/.test(char)) {
         if (current) {
-            tokens.push(current);
+          tokens.push(current);
+          current = "";
         }
-        return tokens;
+        continue;
+      }
+      current += char;
     }
-    loadIdentityFile(identityPath) {
-        const resolvedPath = this.resolveIdentityPath(identityPath);
-        try {
-            return fs.readFileSync(resolvedPath);
-        }
-        catch (error) {
-            if (error?.code === 'ENOENT') {
-                throw new Error(`SSH identity file not found: ${resolvedPath}`);
-            }
-            throw new Error(`Failed to read SSH identity file "${resolvedPath}": ${error?.message || 'Unknown error'}`);
-        }
+    if (current) {
+      tokens.push(current);
     }
-    resolveIdentityPath(identityPath) {
-        const trimmed = identityPath.trim();
-        if (!trimmed) {
-            return trimmed;
-        }
-        if (trimmed.startsWith('~')) {
-            const homeDir = os.homedir();
-            return path.resolve(homeDir, trimmed.slice(1));
-        }
-        return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
+    return tokens;
+  }
+  loadIdentityFile(identityPath) {
+    const resolvedPath = this.resolveIdentityPath(identityPath);
+    try {
+      return fs.readFileSync(resolvedPath);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        throw new Error(`SSH identity file not found: ${resolvedPath}`);
+      }
+      throw new Error(`Failed to read SSH identity file "${resolvedPath}": ${error?.message || "Unknown error"}`);
     }
-    loadDefaultIdentityFiles(host) {
-        const homeDir = os.homedir();
-        const candidatePaths = [
-            path.join(homeDir, '.ssh', 'id_ed25519'),
-            path.join(homeDir, '.ssh', 'id_rsa'),
-            path.join(homeDir, '.ssh', 'id_ecdsa'),
-            path.join(homeDir, '.ssh', 'id_dsa'),
-        ];
-        // Add keys from ~/.ssh/config if host is provided
-        if (host) {
-            const configKeys = this.getIdentityFilesFromConfig(host);
-            quickLog(`[SSH Config] Found ${configKeys.length} keys in config for host ${host}\n`);
-            for (const keyPath of configKeys) {
-                // Resolving relative paths in config (relative to ~/.ssh)
-                let resolvedKeyPath = keyPath;
-                if (!path.isAbsolute(keyPath)) {
-                    if (keyPath.startsWith('~')) {
-                        resolvedKeyPath = keyPath.replace(/^~/, homeDir);
-                    }
-                    else {
-                        resolvedKeyPath = path.join(homeDir, '.ssh', keyPath);
-                    }
-                }
-                // Avoid duplicates if user config points to standard keys
-                if (!candidatePaths.includes(resolvedKeyPath)) {
-                    candidatePaths.unshift(resolvedKeyPath); // Priority to config keys
-                }
-            }
-        }
-        const keys = [];
-        for (const candidate of candidatePaths) {
+  }
+  resolveIdentityPath(identityPath) {
+    const trimmed = identityPath.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    if (trimmed.startsWith("~")) {
+      const homeDir = os.homedir();
+      return path.resolve(homeDir, trimmed.slice(1));
+    }
+    return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
+  }
+  loadDefaultIdentityFiles(host) {
+    const homeDir = os.homedir();
+    const candidatePaths = [
+      path.join(homeDir, ".ssh", "id_ed25519"),
+      path.join(homeDir, ".ssh", "id_rsa"),
+      path.join(homeDir, ".ssh", "id_ecdsa"),
+      path.join(homeDir, ".ssh", "id_dsa")
+    ];
+    if (host) {
+      const configKeys = this.getIdentityFilesFromConfig(host);
+      quickLog(`[SSH Config] Found ${configKeys.length} keys in config for host ${host}
+`);
+      for (const keyPath of configKeys) {
+        let resolvedKeyPath = keyPath;
+        if (!path.isAbsolute(keyPath)) {
+          if (keyPath.startsWith("~")) {
+            resolvedKeyPath = keyPath.replace(/^~/, homeDir);
+          } else {
+            resolvedKeyPath = path.join(homeDir, ".ssh", keyPath);
+          }
+        }
+        if (!candidatePaths.includes(resolvedKeyPath)) {
+          candidatePaths.unshift(resolvedKeyPath);
+        }
+      }
+    }
+    const keys = [];
+    for (const candidate of candidatePaths) {
+      try {
+        if (fs.existsSync(candidate)) {
+          quickLog(`[SSH Auth] Loading key from: ${candidate}
+`);
+          keys.push(fs.readFileSync(candidate));
+        }
+      } catch {
+      }
+    }
+    return keys;
+  }
+  /**
+   * Parse ~/.ssh/config to find IdentityFile entries for the given host.
+   * Supports standard SSH config patterns including wildcards (*, ?) and quoted paths.
+   */
+  getIdentityFilesFromConfig(targetHost) {
+    const homeDir = os.homedir();
+    const configPath = path.join(homeDir, ".ssh", "config");
+    const identityFiles = [];
+    if (!fs.existsSync(configPath)) {
+      return identityFiles;
+    }
+    try {
+      const content = fs.readFileSync(configPath, "utf8");
+      const lines = content.split("\n");
+      let inMatchingHost = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const parts = trimmed.split(/\s+/);
+        const key = parts[0].toLowerCase();
+        if (key === "host") {
+          const patterns = parts.slice(1);
+          inMatchingHost = patterns.some((pattern) => {
             try {
-                if (fs.existsSync(candidate)) {
-                    quickLog(`[SSH Auth] Loading key from: ${candidate}\n`);
-                    keys.push(fs.readFileSync(candidate));
-                }
+              const regex = this.convertGlobToRegex(pattern);
+              return regex.test(targetHost);
+            } catch {
+              return false;
             }
-            catch {
-                // Ignore unreadable key files and keep trying.
+          });
+        } else if (inMatchingHost && key === "identityfile") {
+          const keyMatch = trimmed.match(/^\S+/);
+          if (keyMatch) {
+            let fileValue = trimmed.substring(keyMatch[0].length).trim();
+            if (fileValue.startsWith('"') && fileValue.endsWith('"') || fileValue.startsWith("'") && fileValue.endsWith("'")) {
+              fileValue = fileValue.slice(1, -1);
             }
-        }
-        return keys;
-    }
-    /**
-     * Parse ~/.ssh/config to find IdentityFile entries for the given host.
-     * Supports standard SSH config patterns including wildcards (*, ?) and quoted paths.
-     */
-    getIdentityFilesFromConfig(targetHost) {
-        const homeDir = os.homedir();
-        const configPath = path.join(homeDir, '.ssh', 'config');
-        const identityFiles = [];
-        if (!fs.existsSync(configPath)) {
-            return identityFiles;
-        }
-        try {
-            const content = fs.readFileSync(configPath, 'utf8');
-            const lines = content.split('\n');
-            let inMatchingHost = false;
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#'))
-                    continue;
-                // Split by whitespace to get key and arguments
-                const parts = trimmed.split(/\s+/);
-                const key = parts[0].toLowerCase();
-                if (key === 'host') {
-                    // Check if this Host block matches our target
-                    // Patterns can be separated by whitespace
-                    const patterns = parts.slice(1);
-                    inMatchingHost = patterns.some(pattern => {
-                        // Convert SSH glob pattern to regex
-                        try {
-                            const regex = this.convertGlobToRegex(pattern);
-                            return regex.test(targetHost);
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                }
-                else if (inMatchingHost && key === 'identityfile') {
-                    // Found an IdentityFile for a matching host.
-                    // Extract the value robustly (handling potential quotes and spaces)
-                    // Find where the key ends and value begins in the original line
-                    const keyMatch = trimmed.match(/^\S+/);
-                    if (keyMatch) {
-                        let fileValue = trimmed.substring(keyMatch[0].length).trim();
-                        // Remove surrounding quotes if present
-                        if ((fileValue.startsWith('"') && fileValue.endsWith('"')) ||
-                            (fileValue.startsWith("'") && fileValue.endsWith("'"))) {
-                            fileValue = fileValue.slice(1, -1);
-                        }
-                        if (fileValue) {
-                            identityFiles.push(fileValue);
-                        }
-                    }
-                }
+            if (fileValue) {
+              identityFiles.push(fileValue);
             }
+          }
         }
-        catch (e) {
-            quickLog(`[SSH Config] Failed to parse config file: ${e}\n`);
-        }
-        return identityFiles;
+      }
+    } catch (e) {
+      quickLog(`[SSH Config] Failed to parse config file: ${e}
+`);
     }
-    /**
-     * Convert standard SSH config glob pattern to RegExp.
-     * Supports * (wildcard) and ? (single char).
-     */
-    convertGlobToRegex(pattern) {
-        // Escape special regex characters
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        // Convert * to .* and ? to .
-        const regexString = '^' + escaped.replace(/\*/g, '.*').replace(/\?/g, '.') + '$';
-        return new RegExp(regexString);
-    }
-    /**
-     * Initialize SFTP session
-     */
-    async initializeSFTP() {
-        if (!this._client) {
-            throw new Error('SSH client not connected');
-        }
-        return new Promise((resolve, reject) => {
-            this._client.sftp((err, sftp) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    this.sftpClient = sftp;
-                    resolve();
-                }
-            });
-        });
+    return identityFiles;
+  }
+  /**
+   * Convert standard SSH config glob pattern to RegExp.
+   * Supports * (wildcard) and ? (single char).
+   */
+  convertGlobToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const regexString = "^" + escaped.replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
+    return new RegExp(regexString);
+  }
+  /**
+   * Initialize SFTP session
+   */
+  async initializeSFTP() {
+    if (!this._client) {
+      throw new Error("SSH client not connected");
     }
-    /**
-     * Detect the shell type on the remote system
-     */
-    async detectShellType() {
-        try {
-            const result = await this.executeCommand('echo $SHELL');
-            const shellPath = result.stdout.trim();
-            if (shellPath.includes('bash'))
-                return 'bash';
-            if (shellPath.includes('zsh'))
-                return 'zsh';
-            if (shellPath.includes('fish'))
-                return 'fish';
-            return 'bash'; // Default to bash
-        }
-        catch {
-            return 'bash';
-        }
+    return new Promise((resolve, reject) => {
+      this._client.sftp((err, sftp) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.sftpClient = sftp;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Detect the shell type on the remote system
+   */
+  async detectShellType() {
+    try {
+      const result = await this.executeCommand("echo $SHELL");
+      const shellPath = result.stdout.trim();
+      if (shellPath.includes("bash")) return "bash";
+      if (shellPath.includes("zsh")) return "zsh";
+      if (shellPath.includes("fish")) return "fish";
+      return "bash";
+    } catch {
+      return "bash";
     }
-    /**
-     * Detect the operating system type
-     */
-    async detectOSType() {
-        try {
-            const result = await this.executeCommand('uname -s');
-            const osName = result.stdout.trim().toLowerCase();
-            if (osName.includes('darwin'))
-                return 'macos';
-            if (osName.includes('linux'))
-                return 'linux';
-            return 'linux'; // Default to linux
-        }
-        catch {
-            return 'linux';
-        }
+  }
+  /**
+   * Detect the operating system type
+   */
+  async detectOSType() {
+    try {
+      const result = await this.executeCommand("uname -s");
+      const osName = result.stdout.trim().toLowerCase();
+      if (osName.includes("darwin")) return "macos";
+      if (osName.includes("linux")) return "linux";
+      return "linux";
+    } catch {
+      return "linux";
     }
-    /**
-     * Inject shell integration script
-     */
-    async injectShellIntegration() {
-        try {
-            const script = this.getShellIntegrationScript();
-            await this.executeCommand(script);
-        }
-        catch (error) {
-            // Shell integration is optional, don't fail if it doesn't work
-            console.warn('Failed to inject shell integration:', error);
-        }
+  }
+  /**
+   * Inject shell integration script
+   */
+  async injectShellIntegration() {
+    try {
+      const script = this.getShellIntegrationScript();
+      await this.executeCommand(script);
+    } catch (error) {
+      console.warn("Failed to inject shell integration:", error);
     }
-    /**
-     * Get shell integration script based on shell type
-     */
-    getShellIntegrationScript() {
-        const sessionId = this.sessionId;
-        if (this.shellType === 'bash') {
-            return `
-export CENTAURUS_SUBSHELL=1
-export CENTAURUS_SESSION_ID="${sessionId}"
-_centaurus_pwd_hook() {
-  echo "__CENTAURUS_PWD_${sessionId}__:$(pwd)"
-}
-export PROMPT_COMMAND="_centaurus_pwd_hook; \${PROMPT_COMMAND}"
+  }
+  /**
+   * Get shell integration script based on shell type
+   */
+  getShellIntegrationScript() {
+    const sessionId = this.sessionId;
+    if (this.shellType === "bash") {
+      return `
+export CENTAURUS_SUBSHELL=1
+export CENTAURUS_SESSION_ID="${sessionId}"
+_centaurus_pwd_hook() {
+  echo "__CENTAURUS_PWD_${sessionId}__:$(pwd)"
+}
+export PROMPT_COMMAND="_centaurus_pwd_hook; \${PROMPT_COMMAND}"
       `.trim();
-        }
-        else if (this.shellType === 'zsh') {
-            return `
-export CENTAURUS_SUBSHELL=1
-export CENTAURUS_SESSION_ID="${sessionId}"
-_centaurus_pwd_hook() {
-  echo "__CENTAURUS_PWD_${sessionId}__:$(pwd)"
-}
-precmd_functions+=(_centaurus_pwd_hook)
+    } else if (this.shellType === "zsh") {
+      return `
+export CENTAURUS_SUBSHELL=1
+export CENTAURUS_SESSION_ID="${sessionId}"
+_centaurus_pwd_hook() {
+  echo "__CENTAURUS_PWD_${sessionId}__:$(pwd)"
+}
+precmd_functions+=(_centaurus_pwd_hook)
       `.trim();
-        }
-        else if (this.shellType === 'fish') {
-            return `
-set -x CENTAURUS_SUBSHELL 1
-set -x CENTAURUS_SESSION_ID "${sessionId}"
-function _centaurus_pwd_hook --on-event fish_prompt
-  echo "__CENTAURUS_PWD_${sessionId}__:"(pwd)
-end
+    } else if (this.shellType === "fish") {
+      return `
+set -x CENTAURUS_SUBSHELL 1
+set -x CENTAURUS_SESSION_ID "${sessionId}"
+function _centaurus_pwd_hook --on-event fish_prompt
+  echo "__CENTAURUS_PWD_${sessionId}__:"(pwd)
+end
       `.trim();
-        }
-        // Default POSIX-compatible script
-        return `
-export CENTAURUS_SUBSHELL=1
-export CENTAURUS_SESSION_ID="${sessionId}"
+    }
+    return `
+export CENTAURUS_SUBSHELL=1
+export CENTAURUS_SESSION_ID="${sessionId}"
     `.trim();
+  }
+  /**
+   * Resolve a path to an absolute path
+   */
+  resolveAbsolutePath(path2) {
+    if (path2.startsWith("/")) {
+      return path2;
     }
-    /**
-     * Resolve a path to an absolute path
-     */
-    resolveAbsolutePath(path) {
-        if (path.startsWith('/')) {
-            return path;
-        }
-        if (path.startsWith('~')) {
-            return path;
-        }
-        return `${this.currentWorkingDirectory}/${path}`;
+    if (path2.startsWith("~")) {
+      return path2;
     }
-    /**
-     * Parse directory listing output (ls -la)
-     */
-    parseDirectoryListing(output) {
-        const entries = [];
-        const lines = output.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            // Skip total line and . .. entries
-            if (line.startsWith('total') || line.endsWith(' .') || line.endsWith(' ..'))
-                continue;
-            const match = line.match(/^([drwx-]+)\s+\d+\s+\S+\s+\S+\s+(\d+)\s+\S+\s+\S+\s+\S+\s+(.+)$/);
-            if (match) {
-                const permissions = match[1];
-                const size = parseInt(match[2], 10);
-                const name = match[3];
-                entries.push({
-                    name,
-                    type: permissions.startsWith('d') ? 'directory' : 'file',
-                    size,
-                    permissions,
-                });
-            }
-        }
-        return entries;
+    return `${this.currentWorkingDirectory}/${path2}`;
+  }
+  /**
+   * Parse directory listing output (ls -la)
+   */
+  parseDirectoryListing(output) {
+    const entries = [];
+    const lines = output.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.startsWith("total") || line.endsWith(" .") || line.endsWith(" ..")) continue;
+      const match = line.match(/^([drwx-]+)\s+\d+\s+\S+\s+\S+\s+(\d+)\s+\S+\s+\S+\s+\S+\s+(.+)$/);
+      if (match) {
+        const permissions = match[1];
+        const size = parseInt(match[2], 10);
+        const name = match[3];
+        entries.push({
+          name,
+          type: permissions.startsWith("d") ? "directory" : "file",
+          size,
+          permissions
+        });
+      }
     }
-    /**
-     * Create a new instance of this handler
-     */
-    createNew() {
-        const newHandler = new SSHHandler();
-        if (this.onPasswordRequest) {
-            newHandler.setPasswordRequestCallback(this.onPasswordRequest);
-        }
-        if (this.onDisconnectCallback) {
-            newHandler.setDisconnectCallback(this.onDisconnectCallback);
-        }
-        return newHandler;
+    return entries;
+  }
+  /**
+   * Create a new instance of this handler
+   */
+  createNew() {
+    const newHandler = new SSHHandler();
+    if (this.onPasswordRequest) {
+      newHandler.setPasswordRequestCallback(this.onPasswordRequest);
+    }
+    if (this.onDisconnectCallback) {
+      newHandler.setDisconnectCallback(this.onDisconnectCallback);
     }
+    return newHandler;
+  }
 }
+export {
+  SSHHandler
+};
 //# sourceMappingURL=ssh-handler.js.map