@ebowwa/terminal 0.2.1 → 0.3.0

package/src/pool.js

@@ -1,840 +0,0 @@
-"use strict";
-/**
- * SSH Connection Pool Manager
- * Maintains persistent SSH connections for reuse across commands
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSHConnectionPool = void 0;
-exports.getSSHPool = getSSHPool;
-exports.closeGlobalSSHPool = closeGlobalSSHPool;
-exports.getActiveSSHConnections = getActiveSSHConnections;
-var node_ssh_1 = require("node-ssh");
-var node_path_1 = require("node:path");
-var DEFAULT_CONFIG = {
-    maxConnections: 50,
-    maxConnectionsPerHost: 5, // Allow up to 5 connections per host for parallel ops
-    idleTimeout: 5 * 60 * 1000, // 5 minutes
-    connectionTimeout: 10 * 1000, // 10 seconds
-    keepAliveInterval: 30 * 1000, // 30 seconds
-};
-/**
- * SSH Connection Pool Class
- */
-var SSHConnectionPool = /** @class */ (function () {
-    function SSHConnectionPool(config) {
-        if (config === void 0) { config = {}; }
-        this.connections = new Map();
-        this.cleanupInterval = null;
-        this.nextId = 0; // Counter for generating unique connection IDs
-        this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
-        this.startCleanup();
-    }
-    /**
-     * Generate a unique key for the connection (host-based)
-     */
-    SSHConnectionPool.prototype.getKey = function (host, port, user) {
-        return "".concat(user, "@").concat(host, ":").concat(port);
-    };
-    /**
-     * Get all connections for a given host
-     */
-    SSHConnectionPool.prototype.getConnectionsList = function (key) {
-        var list = this.connections.get(key);
-        if (!list) {
-            list = [];
-            this.connections.set(key, list);
-        }
-        return list;
-    };
-    /**
-     * Get or create a connection (returns least recently used connection)
-     */
-    SSHConnectionPool.prototype.getConnection = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var connections;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getConnections(options, 1)];
-                    case 1:
-                        connections = _a.sent();
-                        return [2 /*return*/, connections[0]];
-                }
-            });
-        });
-    };
-    /**
-     * Get or create a connection using password authentication
-     */
-    SSHConnectionPool.prototype.getConnectionWithPassword = function (host_1, user_1, password_1) {
-        return __awaiter(this, arguments, void 0, function (host, user, password, port) {
-            if (port === void 0) { port = 22; }
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getConnection({ host: host, user: user, password: password, port: port })];
-            });
-        });
-    };
-    /**
-     * Get or create multiple connections for parallel execution
-     * @param options - SSH connection options
-     * @param count - Number of connections to retrieve
-     * @returns Array of SSH connections
-     */
-    SSHConnectionPool.prototype.getConnections = function (options, count) {
-        return __awaiter(this, void 0, void 0, function () {
-            var host, _a, user, _b, port, keyPath, password, key, list, now, result, i, existing, _c, _d, _loop_1, _i, result_1, conn, currentHostCount, ssh;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        host = options.host, _a = options.user, user = _a === void 0 ? 'root' : _a, _b = options.port, port = _b === void 0 ? 22 : _b, keyPath = options.keyPath, password = options.password;
-                        key = this.getKey(host, port, user);
-                        list = this.getConnectionsList(key);
-                        now = Date.now();
-                        result = [];
-                        i = list.length - 1;
-                        _e.label = 1;
-                    case 1:
-                        if (!(i >= 0 && result.length < count)) return [3 /*break*/, 10];
-                        existing = list[i];
-                        // If used recently (within 30 seconds), reuse without verification
-                        if (now - existing.lastUsed < 30000) {
-                            existing.lastUsed = now;
-                            result.push(existing.ssh);
-                            list.splice(i, 1);
-                            return [3 /*break*/, 9];
-                        }
-                        _e.label = 2;
-                    case 2:
-                        _e.trys.push([2, 4, , 9]);
-                        return [4 /*yield*/, existing.ssh.exec('echo', ['ok'])];
-                    case 3:
-                        _e.sent();
-                        existing.lastUsed = now;
-                        result.push(existing.ssh);
-                        list.splice(i, 1);
-                        return [3 /*break*/, 9];
-                    case 4:
-                        _c = _e.sent();
-                        // Connection is dead, remove and dispose
-                        list.splice(i, 1);
-                        _e.label = 5;
-                    case 5:
-                        _e.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, existing.ssh.dispose()];
-                    case 6:
-                        _e.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        _d = _e.sent();
-                        return [3 /*break*/, 8];
-                    case 8: return [3 /*break*/, 9];
-                    case 9:
-                        i--;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        _loop_1 = function (conn) {
-                            var pooled = list.find(function (c) { return c.ssh === conn; });
-                            if (pooled) {
-                                // Move to end of list (most recently used)
-                                list.splice(list.indexOf(pooled), 1);
-                                list.push(pooled);
-                            }
-                        };
-                        // Put back the connections we're reusing at the end (most recently used)
-                        for (_i = 0, result_1 = result; _i < result_1.length; _i++) {
-                            conn = result_1[_i];
-                            _loop_1(conn);
-                        }
-                        _e.label = 11;
-                    case 11:
-                        if (!(result.length < count)) return [3 /*break*/, 15];
-                        if (!(this.getTotalConnectionCount() >= this.config.maxConnections)) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.evictOldest()];
-                    case 12:
-                        _e.sent();
-                        _e.label = 13;
-                    case 13:
-                        currentHostCount = list.length + result.length;
-                        if (currentHostCount >= this.config.maxConnectionsPerHost) {
-                            // Can't create more connections for this host
-                            return [3 /*break*/, 15];
-                        }
-                        return [4 /*yield*/, this.createConnection(host, port, user, keyPath, password)
-                            // Add to result and pool
-                        ];
-                    case 14:
-                        ssh = _e.sent();
-                        // Add to result and pool
-                        result.push(ssh);
-                        list.push({
-                            ssh: ssh,
-                            lastUsed: now,
-                            host: host,
-                            port: port,
-                            user: user,
-                            id: "".concat(key, "-").concat(this.nextId++),
-                        });
-                        return [3 /*break*/, 11];
-                    case 15: return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    /**
-     * Create a new SSH connection
-     * Tries key-based auth first, then password auth, then SSH agent
-     */
-    SSHConnectionPool.prototype.createConnection = function (host, port, user, keyPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ssh, baseConfig, authMethods, resolvedKeyPath, projectRoot, keyName, errors, _loop_2, this_1, _i, authMethods_1, method, state_1;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        ssh = new node_ssh_1.NodeSSH();
-                        baseConfig = {
-                            host: host,
-                            port: port,
-                            username: user,
-                            readyTimeout: this.config.connectionTimeout,
-                            keepaliveInterval: this.config.keepAliveInterval,
-                        };
-                        authMethods = [];
-                        // 1. Key-based authentication (if keyPath provided)
-                        if (keyPath) {
-                            resolvedKeyPath = keyPath;
-                            if (!node_path_1.default.isAbsolute(keyPath)) {
-                                projectRoot = node_path_1.default.resolve(import.meta.dir, '../../com.hetzner.codespaces');
-                                if (keyPath.includes('.ssh-keys')) {
-                                    keyName = node_path_1.default.basename(keyPath);
-                                    resolvedKeyPath = node_path_1.default.join(projectRoot, '.ssh-keys', keyName);
-                                }
-                                else {
-                                    resolvedKeyPath = node_path_1.default.resolve(keyPath);
-                                }
-                            }
-                            authMethods.push({
-                                name: 'key',
-                                config: __assign(__assign({}, baseConfig), { privateKeyPath: resolvedKeyPath }),
-                            });
-                        }
-                        // 2. Password authentication (if password provided)
-                        if (password) {
-                            authMethods.push({
-                                name: 'password',
-                                config: __assign(__assign({}, baseConfig), { password: password }),
-                            });
-                        }
-                        // 3. SSH agent (fallback if available)
-                        if (process.env.SSH_AUTH_SOCK) {
-                            authMethods.push({
-                                name: 'agent',
-                                config: __assign(__assign({}, baseConfig), { agent: process.env.SSH_AUTH_SOCK }),
-                            });
-                        }
-                        // If no auth methods available, try with empty config (will fail)
-                        if (authMethods.length === 0) {
-                            authMethods.push({
-                                name: 'default',
-                                config: baseConfig,
-                            });
-                        }
-                        errors = [];
-                        _loop_2 = function (method) {
-                            var underlyingClient, connectionKey_1, error_1, errMsg;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        _b.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, ssh.connect(method.config)
-                                            // Attach error handler to underlying ssh2 client to catch keepalive and other errors
-                                            // The NodeSSH instance exposes the underlying ssh2 Client via the 'ssh' property
-                                        ];
-                                    case 1:
-                                        _b.sent();
-                                        // Attach error handler to underlying ssh2 client to catch keepalive and other errors
-                                        // The NodeSSH instance exposes the underlying ssh2 Client via the 'ssh' property
-                                        if (ssh.ssh) {
-                                            underlyingClient = ssh.ssh;
-                                            connectionKey_1 = this_1.getKey(host, port, user);
-                                            underlyingClient.on('error', function (err) {
-                                                // Handle keepalive timeouts gracefully - these are network issues, not fatal errors
-                                                var isKeepalive = err.message.includes('Keepalive') || err.level === 'client-timeout';
-                                                if (isKeepalive) {
-                                                    console.warn("[SSH Pool] Keepalive timeout for ".concat(user, "@").concat(host, ":").concat(port, " - removing stale connection"));
-                                                }
-                                                else {
-                                                    console.error("[SSH Pool] Connection error for ".concat(user, "@").concat(host, ":").concat(port, ":"), err.message);
-                                                }
-                                                // Remove failed connection from pool
-                                                var list = _this.connections.get(connectionKey_1);
-                                                if (list) {
-                                                    var index = list.findIndex(function (c) { return c.ssh === ssh; });
-                                                    if (index !== -1) {
-                                                        var removed = list.splice(index, 1)[0];
-                                                        // Dispose connection
-                                                        try {
-                                                            ssh.dispose();
-                                                        }
-                                                        catch (_a) {
-                                                            // Ignore dispose errors
-                                                        }
-                                                        console.log("[SSH Pool] Removed errored connection ".concat(removed.id, " from pool (will reconnect on next use)"));
-                                                        // Clean up empty lists
-                                                        if (list.length === 0) {
-                                                            _this.connections.delete(connectionKey_1);
-                                                        }
-                                                    }
-                                                }
-                                            });
-                                            // Also handle 'close' event for unexpected disconnections
-                                            underlyingClient.on('close', function () {
-                                                var list = _this.connections.get(connectionKey_1);
-                                                if (list) {
-                                                    var index = list.findIndex(function (c) { return c.ssh === ssh; });
-                                                    if (index !== -1) {
-                                                        var removed = list.splice(index, 1)[0];
-                                                        console.log("[SSH Pool] Connection ".concat(removed.id, " closed unexpectedly (will reconnect on next use)"));
-                                                        if (list.length === 0) {
-                                                            _this.connections.delete(connectionKey_1);
-                                                        }
-                                                    }
-                                                }
-                                            });
-                                        }
-                                        return [2 /*return*/, { value: ssh }];
-                                    case 2:
-                                        error_1 = _b.sent();
-                                        errMsg = error_1 instanceof Error ? error_1.message : String(error_1);
-                                        errors.push("".concat(method.name, ": ").concat(errMsg));
-                                        return [3 /*break*/, 3];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _i = 0, authMethods_1 = authMethods;
-                        _a.label = 1;
-                    case 1:
-                        if (!(_i < authMethods_1.length)) return [3 /*break*/, 4];
-                        method = authMethods_1[_i];
-                        return [5 /*yield**/, _loop_2(method)];
-                    case 2:
-                        state_1 = _a.sent();
-                        if (typeof state_1 === "object")
-                            return [2 /*return*/, state_1.value];
-                        _a.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: 
-                    // All methods failed
-                    throw new Error("SSH connection failed to ".concat(host, " (tried: ").concat(authMethods.map(function (m) { return m.name; }).join(', '), "): ").concat(errors.join('; ')));
-                }
-            });
-        });
-    };
-    /**
-     * Get total number of connections across all hosts
-     */
-    SSHConnectionPool.prototype.getTotalConnectionCount = function () {
-        var count = 0;
-        for (var _i = 0, _a = this.connections.values(); _i < _a.length; _i++) {
-            var list = _a[_i];
-            count += list.length;
-        }
-        return count;
-    };
-    /**
-     * Execute a command using a pooled connection
-     *
-     * ERROR HANDLING BEHAVIOR:
-     * =========================
-     * If result.stderr exists AND result.stdout is empty, we throw an error.
-     * This is intentional - commands that fail should return fallback values
-     * via shell redirection (e.g., `|| echo "0"` or `2>/dev/null`).
-     *
-     * Example of proper fallback handling:
-     *   `type nvidia-smi 2>/dev/null && nvidia-smi ... || echo NOGPU`
-     *
-     * This ensures commands don't silently fail - they must handle their own
-     * error cases and return sensible defaults.
-     */
-    SSHConnectionPool.prototype.exec = function (command, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ssh, result, output, error_2, host, _a, user, _b, port, key, list, index, removed, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.getConnection(options)];
-                    case 1:
-                        ssh = _d.sent();
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 10]);
-                        return [4 /*yield*/, ssh.execCommand(command, {
-                                execOptions: {
-                                    timeout: (options.timeout || 5) * 1000,
-                                },
-                            })
-                            // If we have stderr but no stdout, the command failed
-                            // Commands should handle their own fallbacks (|| echo fallback, 2>/dev/null, etc)
-                        ];
-                    case 3:
-                        result = _d.sent();
-                        // If we have stderr but no stdout, the command failed
-                        // Commands should handle their own fallbacks (|| echo fallback, 2>/dev/null, etc)
-                        if (result.stderr && !result.stdout) {
-                            output = result.stdout ? "".concat(result.stderr, "\n").concat(result.stdout) : result.stderr;
-                            throw new Error(output);
-                        }
-                        return [2 /*return*/, result.stdout.trim()];
-                    case 4:
-                        error_2 = _d.sent();
-                        host = options.host, _a = options.user, user = _a === void 0 ? 'root' : _a, _b = options.port, port = _b === void 0 ? 22 : _b;
-                        key = this.getKey(host, port, user);
-                        list = this.connections.get(key);
-                        if (!list) return [3 /*break*/, 9];
-                        index = list.findIndex(function (c) { return c.ssh === ssh; });
-                        if (!(index !== -1)) return [3 /*break*/, 8];
-                        removed = list.splice(index, 1)[0];
-                        _d.label = 5;
-                    case 5:
-                        _d.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, removed.ssh.dispose()];
-                    case 6:
-                        _d.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        _c = _d.sent();
-                        return [3 /*break*/, 8];
-                    case 8:
-                        // Clean up empty lists
-                        if (list.length === 0) {
-                            this.connections.delete(key);
-                        }
-                        _d.label = 9;
-                    case 9: throw error_2;
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Check if a connection exists and is alive for a given host
-     */
-    SSHConnectionPool.prototype.hasConnection = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var host, _a, user, _b, port, key, list, i, conn, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        host = options.host, _a = options.user, user = _a === void 0 ? 'root' : _a, _b = options.port, port = _b === void 0 ? 22 : _b;
-                        key = this.getKey(host, port, user);
-                        list = this.connections.get(key);
-                        if (!list || list.length === 0) {
-                            return [2 /*return*/, false];
-                        }
-                        i = list.length - 1;
-                        _e.label = 1;
-                    case 1:
-                        if (!(i >= 0)) return [3 /*break*/, 10];
-                        conn = list[i];
-                        _e.label = 2;
-                    case 2:
-                        _e.trys.push([2, 4, , 9]);
-                        return [4 /*yield*/, conn.ssh.exec('echo', ['ok'])];
-                    case 3:
-                        _e.sent();
-                        return [2 /*return*/, true];
-                    case 4:
-                        _c = _e.sent();
-                        // Remove dead connection
-                        list.splice(i, 1);
-                        _e.label = 5;
-                    case 5:
-                        _e.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, conn.ssh.dispose()];
-                    case 6:
-                        _e.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        _d = _e.sent();
-                        return [3 /*break*/, 8];
-                    case 8: return [3 /*break*/, 9];
-                    case 9:
-                        i--;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        // Clean up empty list
-                        if (list.length === 0) {
-                            this.connections.delete(key);
-                        }
-                        return [2 /*return*/, false];
-                }
-            });
-        });
-    };
-    /**
-     * Close a specific connection by SSH instance
-     */
-    SSHConnectionPool.prototype.closeConnectionInstance = function (ssh) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, _b, key, list, index, removed, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _i = 0, _a = this.connections.entries();
-                        _d.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 7];
-                        _b = _a[_i], key = _b[0], list = _b[1];
-                        index = list.findIndex(function (c) { return c.ssh === ssh; });
-                        if (!(index !== -1)) return [3 /*break*/, 6];
-                        removed = list.splice(index, 1)[0];
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, removed.ssh.dispose()];
-                    case 3:
-                        _d.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _c = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 5:
-                        // Clean up empty lists
-                        if (list.length === 0) {
-                            this.connections.delete(key);
-                        }
-                        return [2 /*return*/];
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Close all connections for a specific host
-     */
-    SSHConnectionPool.prototype.closeConnection = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var host, _a, user, _b, port, key, list, _i, list_1, conn, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        host = options.host, _a = options.user, user = _a === void 0 ? 'root' : _a, _b = options.port, port = _b === void 0 ? 22 : _b;
-                        key = this.getKey(host, port, user);
-                        list = this.connections.get(key);
-                        if (!list) return [3 /*break*/, 6];
-                        this.connections.delete(key);
-                        _i = 0, list_1 = list;
-                        _d.label = 1;
-                    case 1:
-                        if (!(_i < list_1.length)) return [3 /*break*/, 6];
-                        conn = list_1[_i];
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, conn.ssh.dispose()];
-                    case 3:
-                        _d.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _c = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Evict the oldest connection from the pool
-     */
-    SSHConnectionPool.prototype.evictOldest = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var oldest, _i, _a, _b, key, list, i, conn, list, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        oldest = null;
-                        for (_i = 0, _a = this.connections.entries(); _i < _a.length; _i++) {
-                            _b = _a[_i], key = _b[0], list = _b[1];
-                            for (i = 0; i < list.length; i++) {
-                                conn = list[i];
-                                if (!oldest || conn.lastUsed < oldest.conn.lastUsed) {
-                                    oldest = { key: key, conn: conn, listIndex: i };
-                                }
-                            }
-                        }
-                        if (!oldest) return [3 /*break*/, 4];
-                        list = this.connections.get(oldest.key);
-                        if (list) {
-                            list.splice(oldest.listIndex, 1);
-                            // Clean up empty lists
-                            if (list.length === 0) {
-                                this.connections.delete(oldest.key);
-                            }
-                        }
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, oldest.conn.ssh.dispose()];
-                    case 2:
-                        _d.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _c = _d.sent();
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Clean up idle connections
-     */
-    SSHConnectionPool.prototype.cleanupIdle = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var now, _i, _a, _b, key, list, toRemove, i, _c, _d, index, conn, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        now = Date.now();
-                        _i = 0, _a = this.connections.entries();
-                        _f.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 9];
-                        _b = _a[_i], key = _b[0], list = _b[1];
-                        toRemove = [];
-                        for (i = 0; i < list.length; i++) {
-                            if (now - list[i].lastUsed > this.config.idleTimeout) {
-                                toRemove.push(i);
-                            }
-                        }
-                        _c = 0, _d = toRemove.reverse();
-                        _f.label = 2;
-                    case 2:
-                        if (!(_c < _d.length)) return [3 /*break*/, 7];
-                        index = _d[_c];
-                        conn = list.splice(index, 1)[0];
-                        _f.label = 3;
-                    case 3:
-                        _f.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, conn.ssh.dispose()];
-                    case 4:
-                        _f.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        _e = _f.sent();
-                        return [3 /*break*/, 6];
-                    case 6:
-                        _c++;
-                        return [3 /*break*/, 2];
-                    case 7:
-                        // Clean up empty lists
-                        if (list.length === 0) {
-                            this.connections.delete(key);
-                        }
-                        _f.label = 8;
-                    case 8:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Start periodic cleanup
-     */
-    SSHConnectionPool.prototype.startCleanup = function () {
-        var _this = this;
-        // Run cleanup every minute
-        this.cleanupInterval = setInterval(function () {
-            _this.cleanupIdle().catch(console.error);
-        }, 60 * 1000);
-    };
-    /**
-     * Stop cleanup interval
-     */
-    SSHConnectionPool.prototype.stopCleanup = function () {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-    };
-    /**
-     * Close all connections and stop cleanup
-     */
-    SSHConnectionPool.prototype.closeAll = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var closePromises, _i, _a, list, _loop_3, _b, list_2, conn;
-            var _this = this;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        this.stopCleanup();
-                        closePromises = [];
-                        for (_i = 0, _a = this.connections.values(); _i < _a.length; _i++) {
-                            list = _a[_i];
-                            _loop_3 = function (conn) {
-                                closePromises.push((function () { return __awaiter(_this, void 0, void 0, function () {
-                                    var _a;
-                                    return __generator(this, function (_b) {
-                                        switch (_b.label) {
-                                            case 0:
-                                                _b.trys.push([0, 2, , 3]);
-                                                return [4 /*yield*/, conn.ssh.dispose()];
-                                            case 1:
-                                                _b.sent();
-                                                return [3 /*break*/, 3];
-                                            case 2:
-                                                _a = _b.sent();
-                                                return [3 /*break*/, 3];
-                                            case 3: return [2 /*return*/];
-                                        }
-                                    });
-                                }); })());
-                            };
-                            for (_b = 0, list_2 = list; _b < list_2.length; _b++) {
-                                conn = list_2[_b];
-                                _loop_3(conn);
-                            }
-                        }
-                        return [4 /*yield*/, Promise.all(closePromises)];
-                    case 1:
-                        _c.sent();
-                        this.connections.clear();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Get pool statistics
-     */
-    SSHConnectionPool.prototype.getStats = function () {
-        var now = Date.now();
-        var allConnections = [];
-        for (var _i = 0, _a = this.connections.values(); _i < _a.length; _i++) {
-            var list = _a[_i];
-            for (var _b = 0, list_3 = list; _b < list_3.length; _b++) {
-                var conn = list_3[_b];
-                allConnections.push({
-                    host: conn.host,
-                    port: conn.port,
-                    user: conn.user,
-                    lastUsed: new Date(conn.lastUsed),
-                    idleMs: now - conn.lastUsed,
-                    id: conn.id,
-                });
-            }
-        }
-        return {
-            totalConnections: allConnections.length,
-            connections: allConnections,
-        };
-    };
-    /**
-     * Check if a host has an active connection
-     */
-    SSHConnectionPool.prototype.isConnected = function (host, user, port) {
-        if (user === void 0) { user = 'root'; }
-        if (port === void 0) { port = 22; }
-        var key = this.getKey(host, port, user);
-        var list = this.connections.get(key);
-        return list !== undefined && list.length > 0;
-    };
-    return SSHConnectionPool;
-}());
-exports.SSHConnectionPool = SSHConnectionPool;
-// Global singleton instance
-var globalPool = null;
-/**
- * Get the global connection pool instance
- */
-function getSSHPool(config) {
-    if (!globalPool) {
-        globalPool = new SSHConnectionPool(config);
-    }
-    return globalPool;
-}
-/**
- * Close the global pool (for cleanup/shutdown)
- */
-function closeGlobalSSHPool() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!globalPool) return [3 /*break*/, 2];
-                    return [4 /*yield*/, globalPool.closeAll()];
-                case 1:
-                    _a.sent();
-                    globalPool = null;
-                    _a.label = 2;
-                case 2: return [2 /*return*/];
-            }
-        });
-    });
-}
-/**
- * Get active SSH connections (for monitoring)
- */
-function getActiveSSHConnections() {
-    if (!globalPool) {
-        return { totalConnections: 0, connections: [] };
-    }
-    return globalPool.getStats();
-}