@ebowwa/terminal 0.2.0 → 0.2.1

package/src/tmux-manager.js

@@ -0,0 +1,1026 @@
+"use strict";
+/**
+ * Multi-Node Tmux Session Manager
+ * Provides unified management of tmux sessions across multiple VPS nodes
+ * Supports batch operations, session tracking, and parallel execution
+ */
+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.TmuxSessionManager = void 0;
+exports.getTmuxManager = getTmuxManager;
+exports.resetTmuxManager = resetTmuxManager;
+var tmux_js_1 = require("./tmux.js");
+/**
+ * Multi-Node Tmux Session Manager
+ * Manages tmux sessions across multiple VPS nodes
+ */
+var TmuxSessionManager = /** @class */ (function () {
+    function TmuxSessionManager() {
+        this.nodes = new Map();
+        this.sessionCache = new Map();
+        this.cacheTimeout = 30000; // 30 seconds
+        this.lastCacheUpdate = new Map();
+    }
+    /**
+     * Add or update a node in the manager
+     */
+    TmuxSessionManager.prototype.addNode = function (node) {
+        this.nodes.set(node.id, __assign({}, node));
+        // Invalidate cache for this node
+        this.sessionCache.delete(node.id);
+        this.lastCacheUpdate.delete(node.id);
+    };
+    /**
+     * Remove a node from the manager
+     */
+    TmuxSessionManager.prototype.removeNode = function (nodeId) {
+        this.nodes.delete(nodeId);
+        this.sessionCache.delete(nodeId);
+        this.lastCacheUpdate.delete(nodeId);
+    };
+    /**
+     * Get a node by ID
+     */
+    TmuxSessionManager.prototype.getNode = function (nodeId) {
+        return this.nodes.get(nodeId);
+    };
+    /**
+     * Get all nodes
+     */
+    TmuxSessionManager.prototype.getAllNodes = function () {
+        return Array.from(this.nodes.values());
+    };
+    /**
+     * Get nodes by tag
+     */
+    TmuxSessionManager.prototype.getNodesByTag = function (tag) {
+        return this.getAllNodes().filter(function (node) { var _a; return (_a = node.tags) === null || _a === void 0 ? void 0 : _a.includes(tag); });
+    };
+    /**
+     * Get active nodes (running and reachable)
+     */
+    TmuxSessionManager.prototype.getActiveNodes = function () {
+        return this.getAllNodes().filter(function (node) { return node.status === "running"; });
+    };
+    /**
+     * Get SSH options for a node
+     */
+    TmuxSessionManager.prototype.getSSHOptions = function (node) {
+        return {
+            host: node.ip,
+            user: node.user,
+            port: node.port,
+            keyPath: node.keyPath,
+            timeout: 30,
+        };
+    };
+    /**
+     * Invalidate session cache for a node or all nodes
+     */
+    TmuxSessionManager.prototype.invalidateCache = function (nodeId) {
+        if (nodeId) {
+            this.sessionCache.delete(nodeId);
+            this.lastCacheUpdate.delete(nodeId);
+        }
+        else {
+            this.sessionCache.clear();
+            this.lastCacheUpdate.clear();
+        }
+    };
+    /**
+     * Check if cache is valid for a node
+     */
+    TmuxSessionManager.prototype.isCacheValid = function (nodeId) {
+        var lastUpdate = this.lastCacheUpdate.get(nodeId);
+        if (!lastUpdate)
+            return false;
+        return Date.now() - lastUpdate < this.cacheTimeout;
+    };
+    /**
+     * Create a new tmux session on a node
+     */
+    TmuxSessionManager.prototype.createSession = function (nodeId_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, options) {
+            var node, sshOpts, tmuxCheck, sessionName, exists, createCmd, getSSHPool, pool, error_1;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node) {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " not found") }];
+                        }
+                        if (node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " is not running") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 10, , 11]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.ensureTmux)(sshOpts)];
+                    case 2:
+                        tmuxCheck = _a.sent();
+                        if (!tmuxCheck.success) {
+                            return [2 /*return*/, { success: false, error: tmuxCheck.message }];
+                        }
+                        sessionName = options.sessionName || (0, tmux_js_1.generateSessionName)(node.ip, node.user);
+                        return [4 /*yield*/, (0, tmux_js_1.hasTmuxSession)(sessionName, sshOpts)];
+                    case 3:
+                        exists = _a.sent();
+                        if (exists) {
+                            return [2 /*return*/, { success: true, sessionName: sessionName }];
+                        }
+                        createCmd = options.initialCommand
+                            ? "tmux new-session -d -s \"".concat(sessionName, "\" -n \"main\" \"").concat(options.initialCommand, "\"")
+                            : "tmux new-session -d -s \"".concat(sessionName, "\" -n \"main\"");
+                        return [4 /*yield*/, Promise.resolve().then(function () { return require("./pool.js"); })];
+                    case 4:
+                        getSSHPool = (_a.sent()).getSSHPool;
+                        pool = getSSHPool();
+                        return [4 /*yield*/, pool.exec(createCmd, sshOpts)];
+                    case 5:
+                        _a.sent();
+                        if (!options.cwd) return [3 /*break*/, 7];
+                        return [4 /*yield*/, pool.exec("tmux set-option -t \"".concat(sessionName, "\" default-path \"").concat(options.cwd, "\""), sshOpts)];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7:
+                        if (!options.layout) return [3 /*break*/, 9];
+                        return [4 /*yield*/, pool.exec("tmux select-layout -t \"".concat(sessionName, "\" ").concat(options.layout), sshOpts)];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9:
+                        // Invalidate cache
+                        this.invalidateCache(nodeId);
+                        return [2 /*return*/, { success: true, sessionName: sessionName }];
+                    case 10:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_1 instanceof Error ? error_1.message : String(error_1),
+                            }];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Attach to a tmux session on a node (returns SSH command args)
+     */
+    TmuxSessionManager.prototype.attachSession = function (nodeId, sessionName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, result, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node) {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " not found") }];
+                        }
+                        if (node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " is not running") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, (0, tmux_js_1.createOrAttachTmuxSession)(node.ip, node.user, node.keyPath, { sessionName: sessionName })];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                sshArgs: result.sshArgs,
+                                sessionName: result.sessionName,
+                            }];
+                    case 3:
+                        error_2 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_2 instanceof Error ? error_2.message : String(error_2),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * List all sessions across nodes
+     */
+    TmuxSessionManager.prototype.listSessions = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var nodes, allSessions, _loop_1, this_1, _i, nodes_1, node;
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nodes = options.nodeIds
+                            ? options.nodeIds.map(function (id) { return _this.getNode(id); }).filter(Boolean)
+                            : options.tags
+                                ? options.tags.flatMap(function (tag) { return _this.getNodesByTag(tag); })
+                                : this.getActiveNodes();
+                        allSessions = [];
+                        _loop_1 = function (node) {
+                            var sshOpts_1, sessionNames, sessions, _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        if (node.status !== "running")
+                                            return [2 /*return*/, "continue"];
+                                        // Use cache if valid
+                                        if (this_1.isCacheValid(node.id) && this_1.sessionCache.has(node.id)) {
+                                            allSessions.push.apply(allSessions, this_1.sessionCache.get(node.id));
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        _c.label = 1;
+                                    case 1:
+                                        _c.trys.push([1, 4, , 5]);
+                                        sshOpts_1 = this_1.getSSHOptions(node);
+                                        return [4 /*yield*/, (0, tmux_js_1.listTmuxSessions)(sshOpts_1)];
+                                    case 2:
+                                        sessionNames = _c.sent();
+                                        return [4 /*yield*/, Promise.all(sessionNames.map(function (name) { return __awaiter(_this, void 0, void 0, function () {
+                                                var info;
+                                                var _a;
+                                                return __generator(this, function (_b) {
+                                                    switch (_b.label) {
+                                                        case 0: return [4 /*yield*/, (0, tmux_js_1.getTmuxSessionInfo)(name, sshOpts_1)];
+                                                        case 1:
+                                                            info = _b.sent();
+                                                            return [2 /*return*/, {
+                                                                    name: name,
+                                                                    nodeId: node.id,
+                                                                    windows: info === null || info === void 0 ? void 0 : info.windows,
+                                                                    panes: info === null || info === void 0 ? void 0 : info.panes,
+                                                                    exists: (_a = info === null || info === void 0 ? void 0 : info.exists) !== null && _a !== void 0 ? _a : true,
+                                                                }];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 3:
+                                        sessions = _c.sent();
+                                        // Update cache
+                                        this_1.sessionCache.set(node.id, sessions);
+                                        this_1.lastCacheUpdate.set(node.id, Date.now());
+                                        allSessions.push.apply(allSessions, sessions);
+                                        return [3 /*break*/, 5];
+                                    case 4:
+                                        _b = _c.sent();
+                                        return [2 /*return*/, "continue"];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _i = 0, nodes_1 = nodes;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < nodes_1.length)) return [3 /*break*/, 4];
+                        node = nodes_1[_i];
+                        return [5 /*yield**/, _loop_1(node)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, allSessions];
+                }
+            });
+        });
+    };
+    /**
+     * Get detailed session information
+     */
+    TmuxSessionManager.prototype.getDetailedSession = function (nodeId, sessionName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, info, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, null];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.getDetailedSessionInfo)(sessionName, sshOpts)];
+                    case 2:
+                        info = _b.sent();
+                        if (!info || !info.exists) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, {
+                                name: sessionName,
+                                nodeId: node.id,
+                                exists: true,
+                                windows: info.windows,
+                            }];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Kill a session on a node
+     */
+    TmuxSessionManager.prototype.killSession = function (nodeId, sessionName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, killed, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node) {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " not found") }];
+                        }
+                        if (node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: "Node ".concat(nodeId, " is not running") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.killTmuxSession)(sessionName, sshOpts)];
+                    case 2:
+                        killed = _a.sent();
+                        // Invalidate cache
+                        this.invalidateCache(nodeId);
+                        return [2 /*return*/, { success: killed }];
+                    case 3:
+                        error_3 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_3 instanceof Error ? error_3.message : String(error_3),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send a command to a specific session on a node
+     */
+    TmuxSessionManager.prototype.sendCommand = function (nodeId_1, sessionName_1, command_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, sessionName, command, paneIndex) {
+            var node, sshOpts, result, error_4;
+            if (paneIndex === void 0) { paneIndex = "0"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.sendCommandToPane)(sessionName, command, paneIndex, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, { success: result }];
+                    case 3:
+                        error_4 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_4 instanceof Error ? error_4.message : String(error_4),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send command to multiple nodes (batch operation)
+     */
+    TmuxSessionManager.prototype.sendCommandToNodes = function (nodeIds_1, sessionName_1, command_1) {
+        return __awaiter(this, arguments, void 0, function (nodeIds, sessionName, command, options) {
+            var _a, parallel, _b, continueOnError, _c, paneIndex, _d, timeout, nodes, results, successful, failed, executeCommand, resultsArray, _i, nodes_2, node, result, error_5;
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = options.parallel, parallel = _a === void 0 ? true : _a, _b = options.continueOnError, continueOnError = _b === void 0 ? true : _b, _c = options.paneIndex, paneIndex = _c === void 0 ? "0" : _c, _d = options.timeout, timeout = _d === void 0 ? 30 : _d;
+                        nodes = nodeIds.map(function (id) { return _this.getNode(id); }).filter(Boolean);
+                        results = [];
+                        successful = 0;
+                        failed = 0;
+                        executeCommand = function (node) { return __awaiter(_this, void 0, void 0, function () {
+                            var sshOpts, result, error_6;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (node.status !== "running") {
+                                            failed++;
+                                            return [2 /*return*/, {
+                                                    nodeId: node.id,
+                                                    nodeName: node.name,
+                                                    success: false,
+                                                    error: "Node is ".concat(node.status),
+                                                }];
+                                        }
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        sshOpts = __assign(__assign({}, this.getSSHOptions(node)), { timeout: timeout });
+                                        return [4 /*yield*/, (0, tmux_js_1.sendCommandToPane)(sessionName, command, paneIndex, sshOpts)];
+                                    case 2:
+                                        result = _a.sent();
+                                        if (result) {
+                                            successful++;
+                                            return [2 /*return*/, {
+                                                    nodeId: node.id,
+                                                    nodeName: node.name,
+                                                    success: true,
+                                                }];
+                                        }
+                                        else {
+                                            failed++;
+                                            return [2 /*return*/, {
+                                                    nodeId: node.id,
+                                                    nodeName: node.name,
+                                                    success: false,
+                                                    error: "Failed to send command",
+                                                }];
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        error_6 = _a.sent();
+                                        failed++;
+                                        return [2 /*return*/, {
+                                                nodeId: node.id,
+                                                nodeName: node.name,
+                                                success: false,
+                                                error: error_6 instanceof Error ? error_6.message : String(error_6),
+                                            }];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        if (!parallel) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.allSettled(nodes.map(executeCommand))];
+                    case 1:
+                        resultsArray = _e.sent();
+                        resultsArray.forEach(function (result) {
+                            if (result.status === "fulfilled") {
+                                results.push(result.value);
+                            }
+                            else {
+                                results.push({
+                                    nodeId: "unknown",
+                                    nodeName: "unknown",
+                                    success: false,
+                                    error: String(result.reason),
+                                });
+                            }
+                        });
+                        return [3 /*break*/, 8];
+                    case 2:
+                        _i = 0, nodes_2 = nodes;
+                        _e.label = 3;
+                    case 3:
+                        if (!(_i < nodes_2.length)) return [3 /*break*/, 8];
+                        node = nodes_2[_i];
+                        _e.label = 4;
+                    case 4:
+                        _e.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, executeCommand(node)];
+                    case 5:
+                        result = _e.sent();
+                        results.push(result);
+                        if (!result.success && !continueOnError) {
+                            return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        error_5 = _e.sent();
+                        failed++;
+                        results.push({
+                            nodeId: node.id,
+                            nodeName: node.name,
+                            success: false,
+                            error: error_5 instanceof Error ? error_5.message : String(error_5),
+                        });
+                        if (!continueOnError) {
+                            return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 7];
+                    case 7:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 8: return [2 /*return*/, {
+                            total: nodes.length,
+                            successful: successful,
+                            failed: failed,
+                            results: results,
+                        }];
+                }
+            });
+        });
+    };
+    /**
+     * Split a pane in a session
+     */
+    TmuxSessionManager.prototype.splitPaneOnNode = function (nodeId_1, sessionName_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, sessionName, direction, command, windowIndex) {
+            var node, sshOpts, result, error_7;
+            if (direction === void 0) { direction = "v"; }
+            if (command === void 0) { command = null; }
+            if (windowIndex === void 0) { windowIndex = "0"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.splitPane)(sessionName, direction, command, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                success: result !== null,
+                                newPaneIndex: result || undefined,
+                            }];
+                    case 3:
+                        error_7 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_7 instanceof Error ? error_7.message : String(error_7),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Capture pane output from a session
+     */
+    TmuxSessionManager.prototype.capturePaneOutput = function (nodeId_1, sessionName_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, sessionName, paneIndex) {
+            var node, sshOpts, output, error_8;
+            if (paneIndex === void 0) { paneIndex = "0"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.capturePane)(sessionName, paneIndex, sshOpts)];
+                    case 2:
+                        output = _a.sent();
+                        return [2 /*return*/, {
+                                success: output !== null,
+                                output: output || undefined,
+                            }];
+                    case 3:
+                        error_8 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_8 instanceof Error ? error_8.message : String(error_8),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get pane history (scrollback buffer)
+     */
+    TmuxSessionManager.prototype.getPaneHistory = function (nodeId_1, sessionName_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, sessionName, paneIndex, lines) {
+            var node, sshOpts, history_1, error_9;
+            if (paneIndex === void 0) { paneIndex = "0"; }
+            if (lines === void 0) { lines = -1; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.getPaneHistory)(sessionName, paneIndex, lines, sshOpts)];
+                    case 2:
+                        history_1 = _a.sent();
+                        return [2 /*return*/, {
+                                success: history_1 !== null,
+                                history: history_1 || undefined,
+                            }];
+                    case 3:
+                        error_9 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_9 instanceof Error ? error_9.message : String(error_9),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * List windows in a session
+     */
+    TmuxSessionManager.prototype.listWindows = function (nodeId, sessionName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, windows, error_10;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.listSessionWindows)(sessionName, sshOpts)];
+                    case 2:
+                        windows = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                windows: windows,
+                            }];
+                    case 3:
+                        error_10 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_10 instanceof Error ? error_10.message : String(error_10),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * List panes in a window
+     */
+    TmuxSessionManager.prototype.listPanes = function (nodeId_1, sessionName_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, sessionName, windowIndex) {
+            var node, sshOpts, panes, error_11;
+            if (windowIndex === void 0) { windowIndex = "0"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.listWindowPanes)(sessionName, windowIndex, sshOpts)];
+                    case 2:
+                        panes = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                panes: panes,
+                            }];
+                    case 3:
+                        error_11 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_11 instanceof Error ? error_11.message : String(error_11),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Switch to a different window in a session
+     */
+    TmuxSessionManager.prototype.switchToWindow = function (nodeId, sessionName, windowIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, result, error_12;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.switchWindow)(sessionName, windowIndex, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, { success: result }];
+                    case 3:
+                        error_12 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_12 instanceof Error ? error_12.message : String(error_12),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Switch to a different pane in a session
+     */
+    TmuxSessionManager.prototype.switchToPane = function (nodeId, sessionName, paneIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, result, error_13;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.switchPane)(sessionName, paneIndex, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, { success: result }];
+                    case 3:
+                        error_13 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_13 instanceof Error ? error_13.message : String(error_13),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Rename a window in a session
+     */
+    TmuxSessionManager.prototype.renameWindowInSession = function (nodeId, sessionName, windowIndex, newName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, result, error_14;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.renameWindow)(sessionName, windowIndex, newName, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, { success: result }];
+                    case 3:
+                        error_14 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_14 instanceof Error ? error_14.message : String(error_14),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Kill a pane in a session
+     */
+    TmuxSessionManager.prototype.killPaneInSession = function (nodeId, sessionName, paneIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, result, error_15;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.killPane)(sessionName, paneIndex, sshOpts)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, { success: result }];
+                    case 3:
+                        error_15 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_15 instanceof Error ? error_15.message : String(error_15),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Cleanup old sessions on a node
+     */
+    TmuxSessionManager.prototype.cleanupOldSessions = function (nodeId_1) {
+        return __awaiter(this, arguments, void 0, function (nodeId, ageLimitMs) {
+            var node, sshOpts, result, error_16;
+            if (ageLimitMs === void 0) { ageLimitMs = 30 * 24 * 60 * 60 * 1000; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.cleanupOldTmuxSessions)(sshOpts, { sessionAgeLimit: ageLimitMs })];
+                    case 2:
+                        result = _a.sent();
+                        // Invalidate cache
+                        this.invalidateCache(nodeId);
+                        return [2 /*return*/, {
+                                success: true,
+                                cleaned: result.cleaned,
+                                errors: result.errors,
+                            }];
+                    case 3:
+                        error_16 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_16 instanceof Error ? error_16.message : String(error_16),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get resource usage for sessions on a node
+     */
+    TmuxSessionManager.prototype.getResourceUsage = function (nodeId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, sshOpts, usage, error_17;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.getNode(nodeId);
+                        if (!node || node.status !== "running") {
+                            return [2 /*return*/, { success: false, error: node ? "Node ".concat(nodeId, " is not running") : "Node ".concat(nodeId, " not found") }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        sshOpts = this.getSSHOptions(node);
+                        return [4 /*yield*/, (0, tmux_js_1.getTmuxResourceUsage)(sshOpts)];
+                    case 2:
+                        usage = _a.sent();
+                        return [2 /*return*/, {
+                                success: usage !== null,
+                                usage: usage || undefined,
+                            }];
+                    case 3:
+                        error_17 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_17 instanceof Error ? error_17.message : String(error_17),
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get summary statistics across all nodes
+     */
+    TmuxSessionManager.prototype.getSummary = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodes, sessions, totalMemoryUsageMB, nodesWithSessions, _i, sessions_1, session, _a, nodes_3, node, usage;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        nodes = this.getActiveNodes();
+                        return [4 /*yield*/, this.listSessions()];
+                    case 1:
+                        sessions = _b.sent();
+                        totalMemoryUsageMB = 0;
+                        nodesWithSessions = new Set();
+                        // Group sessions by node
+                        for (_i = 0, sessions_1 = sessions; _i < sessions_1.length; _i++) {
+                            session = sessions_1[_i];
+                            nodesWithSessions.add(session.nodeId);
+                        }
+                        _a = 0, nodes_3 = nodes;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_a < nodes_3.length)) return [3 /*break*/, 5];
+                        node = nodes_3[_a];
+                        return [4 /*yield*/, this.getResourceUsage(node.id)];
+                    case 3:
+                        usage = _b.sent();
+                        if (usage.success && usage.usage) {
+                            totalMemoryUsageMB += usage.usage.estimatedMemoryMB;
+                        }
+                        _b.label = 4;
+                    case 4:
+                        _a++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, {
+                            totalNodes: this.nodes.size,
+                            activeNodes: nodes.length,
+                            totalSessions: sessions.length,
+                            totalMemoryUsageMB: totalMemoryUsageMB,
+                            nodesWithSessions: nodesWithSessions.size,
+                        }];
+                }
+            });
+        });
+    };
+    return TmuxSessionManager;
+}());
+exports.TmuxSessionManager = TmuxSessionManager;
+/**
+ * Global singleton instance
+ */
+var globalManager = null;
+/**
+ * Get the global tmux session manager instance
+ */
+function getTmuxManager() {
+    if (!globalManager) {
+        globalManager = new TmuxSessionManager();
+    }
+    return globalManager;
+}
+/**
+ * Reset the global manager (for testing)
+ */
+function resetTmuxManager() {
+    globalManager = null;
+}