@ebowwa/terminal 0.3.0 → 0.3.1

package/src/client.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Core SSH client for executing commands on remote servers
+ * Uses persistent connection pool for efficient reuse
+ * Uses base64 encoding to avoid shell escaping issues
+ */
+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.execSSH = execSSH;
+var error_js_1 = require("./error.js");
+var ssh_1 = require("@ebowwa/codespaces-types/runtime/ssh");
+var pool_js_1 = require("./pool.js");
+/**
+ * Execute a command on a remote server via SSH
+ * Uses persistent connection pool for better performance
+ * @param command - Shell command to execute
+ * @param options - SSH connection options
+ * @returns Command output as string
+ */
+function execSSH(command, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var validatedCommand, validatedOptions, _a, host, _b, user, _c, timeout, _d, port, keyPath, password, pool, output, error_1;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    validatedCommand = ssh_1.SSHCommandSchema.safeParse(command);
+                    if (!validatedCommand.success) {
+                        throw new Error("Invalid SSH command: ".concat(validatedCommand.error.issues.map(function (i) { return i.message; }).join(', ')));
+                    }
+                    validatedOptions = ssh_1.SSHOptionsSchema.safeParse(options);
+                    if (!validatedOptions.success) {
+                        throw new Error("Invalid SSH options: ".concat(validatedOptions.error.issues.map(function (i) { return i.message; }).join(', ')));
+                    }
+                    _a = validatedOptions.data, host = _a.host, _b = _a.user, user = _b === void 0 ? "root" : _b, _c = _a.timeout, timeout = _c === void 0 ? 5 : _c, _d = _a.port, port = _d === void 0 ? 22 : _d, keyPath = _a.keyPath, password = _a.password;
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 3, , 4]);
+                    pool = (0, pool_js_1.getSSHPool)();
+                    return [4 /*yield*/, pool.exec(validatedCommand.data, {
+                            host: host,
+                            user: user,
+                            timeout: timeout,
+                            port: port,
+                            keyPath: keyPath,
+                            password: password,
+                        })];
+                case 2:
+                    output = _e.sent();
+                    return [2 /*return*/, output || "0"];
+                case 3:
+                    error_1 = _e.sent();
+                    throw new error_js_1.SSHError("SSH command failed: ".concat(validatedCommand.data), error_1);
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}

package/src/config.js

@@ -0,0 +1,490 @@
+"use strict";
+/**
+ * SSH Config Manager
+ *
+ * Manages ~/.ssh/config entries for easy node access.
+ * When a node is created, adds an alias so you can:
+ *   ssh node-<id>    or    ssh <name>
+ * Instead of:
+ *   ssh -i ~/.../key -o StrictHostKeyChecking=no root@167.235.236.8
+ */
+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.addSSHConfigEntry = addSSHConfigEntry;
+exports.removeSSHConfigEntry = removeSSHConfigEntry;
+exports.updateSSHConfigHost = updateSSHConfigHost;
+exports.listSSHConfigEntries = listSSHConfigEntries;
+exports.validateSSHConnection = validateSSHConnection;
+exports.ensureCorrectSSHKey = ensureCorrectSSHKey;
+exports.waitForSSHReady = waitForSSHReady;
+exports.syncNodesToSSHConfig = syncNodesToSSHConfig;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var child_process_1 = require("child_process");
+var util_1 = require("util");
+var execAsync = (0, util_1.promisify)(child_process_1.exec);
+var SSH_CONFIG_PATH = (0, path_1.join)(process.env.HOME || "~", ".ssh", "config");
+// Marker comments to identify our managed entries
+var BLOCK_START = "# >>> hetzner-codespaces managed";
+var BLOCK_END = "# <<< hetzner-codespaces managed";
+/**
+ * Resolve a path to absolute, handling relative paths
+ */
+function resolveKeyPath(keyPath) {
+    if ((0, path_1.isAbsolute)(keyPath)) {
+        return keyPath;
+    }
+    // Try to resolve relative to current working directory
+    var resolved = (0, path_1.resolve)(process.cwd(), keyPath);
+    // If file exists at resolved path, use it
+    if ((0, fs_1.existsSync)(resolved)) {
+        try {
+            return (0, fs_1.realpathSync)(resolved);
+        }
+        catch (_a) {
+            return resolved;
+        }
+    }
+    // Return as-is if we can't resolve it
+    return keyPath;
+}
+/**
+ * Read the current SSH config file
+ */
+function readSSHConfig() {
+    if (!(0, fs_1.existsSync)(SSH_CONFIG_PATH)) {
+        return "";
+    }
+    return (0, fs_1.readFileSync)(SSH_CONFIG_PATH, "utf-8");
+}
+/**
+ * Write to SSH config file, ensuring proper permissions
+ */
+function writeSSHConfig(content) {
+    var sshDir = (0, path_1.dirname)(SSH_CONFIG_PATH);
+    // Ensure ~/.ssh exists with correct permissions
+    if (!(0, fs_1.existsSync)(sshDir)) {
+        (0, fs_1.mkdirSync)(sshDir, { mode: 448, recursive: true });
+    }
+    (0, fs_1.writeFileSync)(SSH_CONFIG_PATH, content, { mode: 384 });
+}
+/**
+ * Extract our managed block from SSH config
+ */
+function extractManagedBlock(config) {
+    var startIdx = config.indexOf(BLOCK_START);
+    var endIdx = config.indexOf(BLOCK_END);
+    if (startIdx === -1 || endIdx === -1) {
+        return { before: config, managed: "", after: "" };
+    }
+    return {
+        before: config.substring(0, startIdx),
+        managed: config.substring(startIdx, endIdx + BLOCK_END.length + 1),
+        after: config.substring(endIdx + BLOCK_END.length + 1),
+    };
+}
+/**
+ * Parse managed block into entries
+ */
+function parseManagedEntries(managed) {
+    var entries = new Map();
+    // Match Host blocks within managed section
+    var hostRegex = /# node-id: (\S+)\nHost ([^\n]+)\n([\s\S]*?)(?=# node-id:|$)/g;
+    var match;
+    while ((match = hostRegex.exec(managed)) !== null) {
+        var id = match[1];
+        var hosts = match[2].trim();
+        var body = match[3];
+        // Parse body for HostName, User, IdentityFile, Port
+        var hostMatch = body.match(/HostName\s+(\S+)/);
+        var userMatch = body.match(/User\s+(\S+)/);
+        var keyMatch = body.match(/IdentityFile\s+(\S+)/);
+        var portMatch = body.match(/Port\s+(\d+)/);
+        if (hostMatch && keyMatch) {
+            entries.set(id, {
+                id: id,
+                name: hosts.split(/\s+/)[1] || hosts, // Second alias is usually the name
+                host: hostMatch[1],
+                user: (userMatch === null || userMatch === void 0 ? void 0 : userMatch[1]) || "root",
+                keyPath: keyMatch[1],
+                port: portMatch ? parseInt(portMatch[1]) : 22,
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Generate SSH config block for an entry
+ */
+function generateEntryBlock(entry) {
+    // Create aliases: node-<id> and <name> (sanitized)
+    var sanitizedName = entry.name.replace(/[^a-zA-Z0-9_-]/g, "-");
+    var aliases = "node-".concat(entry.id, " ").concat(sanitizedName);
+    // Resolve key path to absolute
+    var absoluteKeyPath = resolveKeyPath(entry.keyPath);
+    return "# node-id: ".concat(entry.id, "\nHost ").concat(aliases, "\n  HostName ").concat(entry.host, "\n  User ").concat(entry.user || "root", "\n  IdentityFile \"").concat(absoluteKeyPath, "\"\n  Port ").concat(entry.port || 22, "\n  StrictHostKeyChecking no\n  UserKnownHostsFile /dev/null\n  LogLevel ERROR\n  IdentitiesOnly yes\n\n");
+}
+/**
+ * Rebuild the managed block from entries
+ */
+function buildManagedBlock(entries) {
+    if (entries.size === 0) {
+        return "";
+    }
+    var block = "".concat(BLOCK_START, "\n");
+    block += "# Auto-generated SSH aliases for Hetzner nodes\n";
+    block += "# Do not edit manually - changes will be overwritten\n\n";
+    for (var _i = 0, _a = entries.values(); _i < _a.length; _i++) {
+        var entry = _a[_i];
+        block += generateEntryBlock(entry);
+    }
+    block += "".concat(BLOCK_END, "\n");
+    return block;
+}
+/**
+ * Add or update an SSH config entry for a node
+ */
+function addSSHConfigEntry(entry) {
+    var config = readSSHConfig();
+    var _a = extractManagedBlock(config), before = _a.before, managed = _a.managed, after = _a.after;
+    // Parse existing entries
+    var entries = parseManagedEntries(managed);
+    // Add/update entry
+    entries.set(entry.id, entry);
+    // Rebuild config
+    var newManaged = buildManagedBlock(entries);
+    var newConfig = before.trimEnd() + "\n\n" + newManaged + after.trimStart();
+    writeSSHConfig(newConfig);
+    console.log("[SSH Config] Added alias: ssh node-".concat(entry.id, " / ssh ").concat(entry.name.replace(/[^a-zA-Z0-9_-]/g, "-")));
+}
+/**
+ * Remove an SSH config entry for a node
+ */
+function removeSSHConfigEntry(id) {
+    var config = readSSHConfig();
+    var _a = extractManagedBlock(config), before = _a.before, managed = _a.managed, after = _a.after;
+    // Parse existing entries
+    var entries = parseManagedEntries(managed);
+    // Remove entry
+    if (!entries.has(id)) {
+        return; // Nothing to remove
+    }
+    entries.delete(id);
+    // Rebuild config
+    var newManaged = buildManagedBlock(entries);
+    var newConfig = before.trimEnd() + (newManaged ? "\n\n" + newManaged : "") + after.trimStart();
+    writeSSHConfig(newConfig);
+    console.log("[SSH Config] Removed alias for node-".concat(id));
+}
+/**
+ * Update IP address for an existing node (e.g., after rebuild)
+ */
+function updateSSHConfigHost(id, newHost) {
+    var config = readSSHConfig();
+    var _a = extractManagedBlock(config), before = _a.before, managed = _a.managed, after = _a.after;
+    // Parse existing entries
+    var entries = parseManagedEntries(managed);
+    // Update entry
+    var entry = entries.get(id);
+    if (!entry) {
+        console.warn("[SSH Config] No entry found for node-".concat(id));
+        return;
+    }
+    entry.host = newHost;
+    entries.set(id, entry);
+    // Rebuild config
+    var newManaged = buildManagedBlock(entries);
+    var newConfig = before.trimEnd() + "\n\n" + newManaged + after.trimStart();
+    writeSSHConfig(newConfig);
+    console.log("[SSH Config] Updated node-".concat(id, " host to ").concat(newHost));
+}
+/**
+ * List all managed SSH config entries
+ */
+function listSSHConfigEntries() {
+    var config = readSSHConfig();
+    var managed = extractManagedBlock(config).managed;
+    var entries = parseManagedEntries(managed);
+    return Array.from(entries.values());
+}
+/**
+ * Validate SSH connection works with the configured key
+ * Returns true if connection succeeds, throws on failure with diagnostic info
+ */
+function validateSSHConnection(host_1, keyPath_1) {
+    return __awaiter(this, arguments, void 0, function (host, keyPath, user, timeoutSeconds) {
+        var cmd, stdout, error_1, diagnostics, agentKeys, _a;
+        if (user === void 0) { user = "root"; }
+        if (timeoutSeconds === void 0) { timeoutSeconds = 10; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 7]);
+                    cmd = [
+                        "ssh",
+                        "-o", "StrictHostKeyChecking=no",
+                        "-o", "UserKnownHostsFile=/dev/null",
+                        "-o",
+                        "ConnectTimeout=".concat(timeoutSeconds),
+                        "-o", "IdentitiesOnly=yes", // Only use specified key, not ssh-agent
+                        "-o", "BatchMode=yes", // Fail instead of prompting for password
+                        "-i", keyPath,
+                        "".concat(user, "@").concat(host),
+                        "echo CONNECTION_OK"
+                    ].join(" ");
+                    return [4 /*yield*/, execAsync(cmd, { timeout: (timeoutSeconds + 5) * 1000 })];
+                case 1:
+                    stdout = (_b.sent()).stdout;
+                    if (stdout.includes("CONNECTION_OK")) {
+                        return [2 /*return*/, { success: true }];
+                    }
+                    return [2 /*return*/, {
+                            success: false,
+                            error: "Connection established but test command failed",
+                            diagnostics: stdout
+                        }];
+                case 2:
+                    error_1 = _b.sent();
+                    diagnostics = "";
+                    // Check if key file exists
+                    if (!(0, fs_1.existsSync)(keyPath)) {
+                        diagnostics += "Key file missing: ".concat(keyPath, "\n");
+                    }
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, execAsync("ssh-add -l 2>&1")];
+                case 4:
+                    agentKeys = (_b.sent()).stdout;
+                    diagnostics += "ssh-agent keys:\n".concat(agentKeys, "\n");
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _b.sent();
+                    diagnostics += "ssh-agent: no keys loaded\n";
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/, {
+                        success: false,
+                        error: error_1.message || String(error_1),
+                        diagnostics: diagnostics,
+                    }];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Ensure SSH key is loaded correctly and agent doesn't interfere
+ * Clears wrong keys from agent and adds the correct one
+ */
+function ensureCorrectSSHKey(keyPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ourFingerprint, ourFp, agentList, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 6, , 7]);
+                    return [4 /*yield*/, execAsync("ssh-keygen -lf \"".concat(keyPath, ".pub\""))];
+                case 1:
+                    ourFingerprint = (_a.sent()).stdout;
+                    ourFp = ourFingerprint.split(/\s+/)[1];
+                    return [4 /*yield*/, execAsync("ssh-add -l 2>&1").catch(function () { return ({ stdout: "" }); })];
+                case 2:
+                    agentList = (_a.sent()).stdout;
+                    if (!!agentList.includes(ourFp)) return [3 /*break*/, 5];
+                    // Clear agent and add our key
+                    return [4 /*yield*/, execAsync("ssh-add -D 2>/dev/null").catch(function () { })];
+                case 3:
+                    // Clear agent and add our key
+                    _a.sent();
+                    return [4 /*yield*/, execAsync("ssh-add \"".concat(keyPath, "\""))];
+                case 4:
+                    _a.sent();
+                    console.log("[SSH] Added key to ssh-agent: ".concat(keyPath));
+                    _a.label = 5;
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    error_2 = _a.sent();
+                    // Non-fatal - we can still use the key file directly
+                    console.warn("[SSH] Could not configure ssh-agent: ".concat(error_2));
+                    return [3 /*break*/, 7];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Wait for SSH to become ready on a new server
+ * Polls until connection succeeds or timeout
+ */
+function waitForSSHReady(host_1, keyPath_1) {
+    return __awaiter(this, arguments, void 0, function (host, keyPath, options) {
+        var _a, user, _b, maxAttempts, _c, intervalMs, onAttempt, attempt, result;
+        var _d;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _a = options.user, user = _a === void 0 ? "root" : _a, _b = options.maxAttempts, maxAttempts = _b === void 0 ? 30 : _b, _c = options.intervalMs, intervalMs = _c === void 0 ? 5000 : _c, onAttempt = options.onAttempt;
+                    attempt = 1;
+                    _e.label = 1;
+                case 1:
+                    if (!(attempt <= maxAttempts)) return [3 /*break*/, 5];
+                    onAttempt === null || onAttempt === void 0 ? void 0 : onAttempt(attempt, maxAttempts);
+                    return [4 /*yield*/, validateSSHConnection(host, keyPath, user, 5)];
+                case 2:
+                    result = _e.sent();
+                    if (result.success) {
+                        return [2 /*return*/, { success: true, attempts: attempt }];
+                    }
+                    // Check for fatal errors (not just "connection refused")
+                    if ((_d = result.error) === null || _d === void 0 ? void 0 : _d.includes("Permission denied")) {
+                        // Key mismatch - won't resolve by waiting
+                        return [2 /*return*/, {
+                                success: false,
+                                attempts: attempt,
+                                error: "SSH key rejected: ".concat(result.error, "\n").concat(result.diagnostics || ""),
+                            }];
+                    }
+                    if (!(attempt < maxAttempts)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, intervalMs); })];
+                case 3:
+                    _e.sent();
+                    _e.label = 4;
+                case 4:
+                    attempt++;
+                    return [3 /*break*/, 1];
+                case 5: return [2 /*return*/, {
+                        success: false,
+                        attempts: maxAttempts,
+                        error: "SSH not ready after ".concat(maxAttempts, " attempts (").concat((maxAttempts * intervalMs) / 1000, "s)"),
+                    }];
+            }
+        });
+    });
+}
+/**
+ * Sync all existing Hetzner nodes to SSH config
+ * Call this to add aliases for nodes created before this feature
+ */
+function syncNodesToSSHConfig(nodes_1) {
+    return __awaiter(this, arguments, void 0, function (nodes, options) {
+        var _a, validateSSH, onProgress, results, existingEntries, existingIds, _loop_1, _i, nodes_2, node;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = options.validateSSH, validateSSH = _a === void 0 ? false : _a, onProgress = options.onProgress;
+                    results = [];
+                    existingEntries = listSSHConfigEntries();
+                    existingIds = new Set(existingEntries.map(function (e) { return e.id; }));
+                    _loop_1 = function (node) {
+                        var result, existing, sshResult, error_3;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    result = {
+                                        id: node.id,
+                                        name: node.name,
+                                        ip: node.ip,
+                                        status: "added",
+                                    };
+                                    _c.label = 1;
+                                case 1:
+                                    _c.trys.push([1, 4, , 5]);
+                                    // Check if already exists
+                                    if (existingIds.has(node.id)) {
+                                        existing = existingEntries.find(function (e) { return e.id === node.id; });
+                                        if ((existing === null || existing === void 0 ? void 0 : existing.host) === node.ip) {
+                                            result.status = "skipped";
+                                        }
+                                        else {
+                                            // IP changed, update it
+                                            updateSSHConfigHost(node.id, node.ip);
+                                            result.status = "updated";
+                                        }
+                                    }
+                                    else {
+                                        // Add new entry
+                                        addSSHConfigEntry({
+                                            id: node.id,
+                                            name: node.name,
+                                            host: node.ip,
+                                            user: "root",
+                                            keyPath: node.keyPath,
+                                        });
+                                        result.status = "added";
+                                    }
+                                    if (!(validateSSH && result.status !== "skipped")) return [3 /*break*/, 3];
+                                    return [4 /*yield*/, validateSSHConnection(node.ip, node.keyPath)];
+                                case 2:
+                                    sshResult = _c.sent();
+                                    result.sshReady = sshResult.success;
+                                    if (!sshResult.success) {
+                                        result.error = sshResult.error;
+                                    }
+                                    _c.label = 3;
+                                case 3: return [3 /*break*/, 5];
+                                case 4:
+                                    error_3 = _c.sent();
+                                    result.status = "error";
+                                    result.error = String(error_3);
+                                    return [3 /*break*/, 5];
+                                case 5:
+                                    results.push(result);
+                                    onProgress === null || onProgress === void 0 ? void 0 : onProgress(result);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _i = 0, nodes_2 = nodes;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < nodes_2.length)) return [3 /*break*/, 4];
+                    node = nodes_2[_i];
+                    return [5 /*yield**/, _loop_1(node)];
+                case 2:
+                    _b.sent();
+                    _b.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, results];
+            }
+        });
+    });
+}

package/src/error.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * SSH error class
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHError = void 0;
+var SSHError = /** @class */ (function (_super) {
+    __extends(SSHError, _super);
+    function SSHError(message, cause) {
+        var _this = _super.call(this, message) || this;
+        _this.cause = cause;
+        _this.name = "SSHError";
+        return _this;
+    }
+    return SSHError;
+}(Error));
+exports.SSHError = SSHError;