@ebowwa/hetzner-mcp 1.1.0

package/src/index.js

@@ -0,0 +1,2034 @@
+"use strict";
+/**
+ * MCP - Model Context Protocol Server for Hetzner Infrastructure
+ * Exposes Hetzner VPS management, SSH sessions, tmux operations, and volume management as MCP tools
+ *
+ * This allows AI assistants (like Claude) to directly interact with
+ * Hetzner infrastructure for server management, SSH operations, and storage.
+ */
+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 });
+var index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+var stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+var types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+var node_path_1 = require("node:path");
+var node_os_1 = require("node:os");
+// Import business logic from com.hetzner.codespaces workspace
+var hetzner_1 = require("cheapspaces/workspace/src/lib/hetzner");
+// Local tmux session state tracking (in-memory, per host)
+// Tracks multiple named tmux sessions per host for different purposes
+// Key format: "sessionName" (full session name)
+// Value: { host, user, initialized, createdAt, windowName }
+var localTmuxSessions = new Map();
+// Get API token from CLI config
+function getTokenFromCLI() {
+    return __awaiter(this, void 0, void 0, function () {
+        var configPath, configFile, config, match, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 4, , 5]);
+                    configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".config", "hcloud", "cli.toml");
+                    configFile = Bun.file(configPath);
+                    return [4 /*yield*/, configFile.exists()];
+                case 1:
+                    if (!_a.sent()) return [3 /*break*/, 3];
+                    return [4 /*yield*/, configFile.text()];
+                case 2:
+                    config = _a.sent();
+                    match = config.match(/token\s*=\s*["']([^"']+)["']/);
+                    if (match && match[1]) {
+                        return [2 /*return*/, match[1]];
+                    }
+                    _a.label = 3;
+                case 3: return [3 /*break*/, 5];
+                case 4:
+                    e_1 = _a.sent();
+                    return [3 /*break*/, 5];
+                case 5: return [2 /*return*/, ""];
+            }
+        });
+    });
+}
+// Resolve API token: env var > CLI config
+function resolveApiToken() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (process.env.HETZNER_API_TOKEN) {
+                        return [2 /*return*/, process.env.HETZNER_API_TOKEN];
+                    }
+                    return [4 /*yield*/, getTokenFromCLI()];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+// Initialize Hetzner client
+var hetznerClient = null;
+// Initialize asynchronously
+function initializeClient() {
+    return __awaiter(this, void 0, void 0, function () {
+        var token;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, resolveApiToken()];
+                case 1:
+                    token = _a.sent();
+                    if (token) {
+                        try {
+                            hetznerClient = new hetzner_1.HetznerClient(token);
+                            console.error("[hetzner-mcp] Authenticated via ".concat(process.env.HETZNER_API_TOKEN ? "HETZNER_API_TOKEN" : "Hetzner CLI config"));
+                        }
+                        catch (e) {
+                            console.warn("[hetzner-mcp] Failed to initialize Hetzner client:", e);
+                        }
+                    }
+                    else {
+                        console.warn("[hetzner-mcp] Hetzner API token not configured - MCP running in limited mode");
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Create MCP server
+var server = new index_js_1.Server({
+    name: "hetzner-mcp",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, {
+                tools: [
+                    // Environment Management
+                    {
+                        name: "list_environments",
+                        description: "List all Hetzner VPS environments with their status, IPs, and metadata",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: "get_environment",
+                        description: "Get details of a specific environment by ID",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Environment ID (server ID)",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "create_environment",
+                        description: "Create a new Hetzner VPS environment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    description: "Server name",
+                                },
+                                serverType: {
+                                    type: "string",
+                                    description: "Server type (e.g., cax21, cpx21)",
+                                    default: "cax21",
+                                },
+                                location: {
+                                    type: "string",
+                                    description: "Datacenter location (e.g., nbg1, fsn1, hel1)",
+                                },
+                                sshKey: {
+                                    type: "string",
+                                    description: "SSH key name or public key to add to the server",
+                                },
+                                enablePassword: {
+                                    type: "boolean",
+                                    description: "Enable temporary password access via cloud-init (useful for initial setup)",
+                                    default: false,
+                                },
+                                userData: {
+                                    type: "string",
+                                    description: "Custom cloud-init user-data script (YAML format). Overrides enablePassword if both are set.",
+                                },
+                            },
+                            required: ["name"],
+                        },
+                    },
+                    {
+                        name: "start_environment",
+                        description: "Power on a stopped environment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Environment ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "stop_environment",
+                        description: "Power off an environment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Environment ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "delete_environment",
+                        description: "Delete an environment permanently",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Environment ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "get_resources",
+                        description: "Get real-time CPU, memory, and disk usage for an environment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Environment ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    // SSH Operations
+                    {
+                        name: "ssh_test",
+                        description: "Test SSH connectivity to an environment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                keyPath: {
+                                    type: "string",
+                                    description: "Path to SSH private key (optional)",
+                                },
+                                password: {
+                                    type: "string",
+                                    description: "SSH password (optional, for password authentication)",
+                                },
+                            },
+                            required: ["host"],
+                        },
+                    },
+                    {
+                        name: "create_ssh_key",
+                        description: "Create a new SSH key in Hetzner for server access",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    description: "SSH key name",
+                                },
+                                publicKey: {
+                                    type: "string",
+                                    description: "SSH public key content",
+                                },
+                            },
+                            required: ["name", "publicKey"],
+                        },
+                    },
+                    {
+                        name: "list_ssh_keys",
+                        description: "List all SSH keys in Hetzner",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: "exec_ssh",
+                        description: "Execute a command via SSH on a server using a persistent local tmux session (preserves shell state: working directory, environment variables, aliases, etc.). The first call creates a local tmux session with an SSH connection; subsequent calls reuse the existing connection for faster execution.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname",
+                                },
+                                command: {
+                                    type: "string",
+                                    description: "Command to execute",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                keyPath: {
+                                    type: "string",
+                                    description: "Path to SSH private key (optional, tries SSH agent if not provided)",
+                                },
+                                password: {
+                                    type: "string",
+                                    description: "SSH password (optional, for password authentication - requires sshpass on local machine)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Custom session name (e.g., 'dev', 'tests', 'monitoring'). If not provided, uses the default session for this host.",
+                                },
+                                paneIndex: {
+                                    type: "string",
+                                    description: "Pane index to send command to (default: '0'). Use '1', '2', etc. for additional panes created via split_pane.",
+                                    default: "0",
+                                },
+                                waitTime: {
+                                    type: "number",
+                                    description: "Time to wait after sending command (ms, default: 500)",
+                                    default: 500,
+                                },
+                                captureHistory: {
+                                    type: "boolean",
+                                    description: "Capture full pane history instead of just visible output (default: true)",
+                                    default: true,
+                                },
+                            },
+                            required: ["host", "command"],
+                        },
+                    },
+                    // tmux Operations
+                    {
+                        name: "list_tmux_sessions",
+                        description: "List all local tmux sessions managed by MCP. Returns all sessions, MCP sessions (filtered), tracked sessions (with host/user info), and resource usage.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: "kill_tmux_session",
+                        description: "Kill a local tmux session (closes the persistent SSH connection to the remote server)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name to kill (if not provided, kills the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "get_tmux_session_info",
+                        description: "Get detailed information about a local tmux session (exists, window count, etc.)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "attach_tmux_session",
+                        description: "Get tmux command to attach to a local tmux session interactively (for use in your local terminal - gives you direct shell access to the remote server)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "create_tmux_session",
+                        description: "Create a new named tmux session with an SSH connection to a server. Allows creating multiple sessions per host for different purposes (e.g., 'dev', 'tests', 'monitoring').",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Custom session name (e.g., 'dev', 'tests', 'monitoring'). If not provided, auto-generates based on host.",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                keyPath: {
+                                    type: "string",
+                                    description: "Path to SSH private key (optional, tries SSH agent if not provided)",
+                                },
+                                password: {
+                                    type: "string",
+                                    description: "SSH password (optional, for password authentication)",
+                                },
+                                initialCommand: {
+                                    type: "string",
+                                    description: "Optional command to run after SSH connection",
+                                },
+                                windowName: {
+                                    type: "string",
+                                    description: "Window name (default: 'ssh')",
+                                },
+                            },
+                            required: ["host"],
+                        },
+                    },
+                    {
+                        name: "split_pane",
+                        description: "Split a pane horizontally or vertically in a local tmux session for parallel work",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                direction: {
+                                    type: "string",
+                                    description: "Split direction: 'v' for vertical (top/bottom), 'h' for horizontal (left/right)",
+                                    enum: ["v", "h"],
+                                    default: "v",
+                                },
+                                command: {
+                                    type: "string",
+                                    description: "Optional command to run in the new pane",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "list_session_windows",
+                        description: "List all windows in a local tmux session",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "list_window_panes",
+                        description: "List all panes in a window of a local tmux session. Auto-detects the first window if windowIndex not provided.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                windowIndex: {
+                                    type: "string",
+                                    description: "Window index (e.g., '1', '2') or name. If not provided, uses the first window in the session.",
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                    {
+                        name: "switch_window",
+                        description: "Switch to a specific window in a local tmux session",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                windowIndex: {
+                                    type: "string",
+                                    description: "Target window index",
+                                },
+                            },
+                            required: ["windowIndex"],
+                        },
+                    },
+                    {
+                        name: "switch_pane",
+                        description: "Switch to a specific pane in a local tmux session window",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                paneIndex: {
+                                    type: "string",
+                                    description: "Target pane index (e.g., '0', '1', '0.1' for window.pane)",
+                                },
+                            },
+                            required: ["paneIndex"],
+                        },
+                    },
+                    {
+                        name: "rename_window",
+                        description: "Rename a window in a local tmux session",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                windowIndex: {
+                                    type: "string",
+                                    description: "Window index (default: 'ssh')",
+                                    default: "ssh",
+                                },
+                                newName: {
+                                    type: "string",
+                                    description: "New window name",
+                                },
+                            },
+                            required: ["newName"],
+                        },
+                    },
+                    {
+                        name: "kill_pane",
+                        description: "Kill a specific pane in a local tmux session",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "IP address or hostname (used to derive session name if sessionName not provided)",
+                                },
+                                sessionName: {
+                                    type: "string",
+                                    description: "Session name (if not provided, uses the default session for this host)",
+                                },
+                                user: {
+                                    type: "string",
+                                    description: "SSH user (default: root)",
+                                    default: "root",
+                                },
+                                paneIndex: {
+                                    type: "string",
+                                    description: "Pane index to kill",
+                                },
+                            },
+                            required: ["paneIndex"],
+                        },
+                    },
+                    // Volume Operations
+                    {
+                        name: "list_volumes",
+                        description: "List all Hetzner volumes with their status, size, and server attachment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    description: "Filter by volume name",
+                                },
+                                status: {
+                                    type: "string",
+                                    description: "Filter by status (creating, available, deleting)",
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: "get_volume",
+                        description: "Get details of a specific volume by ID",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Volume ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "create_volume",
+                        description: "Create a new Hetzner volume",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                name: {
+                                    type: "string",
+                                    description: "Volume name",
+                                },
+                                size: {
+                                    type: "number",
+                                    description: "Volume size in GB (10-10240)",
+                                },
+                                location: {
+                                    type: "string",
+                                    description: "Location name (e.g., nbg1, fsn1, hel1)",
+                                },
+                                serverId: {
+                                    type: "string",
+                                    description: "Server ID to attach volume to",
+                                },
+                                automount: {
+                                    type: "boolean",
+                                    description: "Automatically mount the volume (default: true)",
+                                },
+                                format: {
+                                    type: "string",
+                                    description: "File system format (ext4 or xfs)",
+                                    enum: ["ext4", "xfs"],
+                                },
+                            },
+                            required: ["name", "size"],
+                        },
+                    },
+                    {
+                        name: "delete_volume",
+                        description: "Delete a volume permanently",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Volume ID",
+                                },
+                            },
+                            required: ["id"],
+                        },
+                    },
+                    {
+                        name: "attach_volume",
+                        description: "Attach a volume to a server",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                volumeId: {
+                                    type: "string",
+                                    description: "Volume ID",
+                                },
+                                serverId: {
+                                    type: "string",
+                                    description: "Server ID",
+                                },
+                                automount: {
+                                    type: "boolean",
+                                    description: "Automatically mount the volume (default: true)",
+                                },
+                            },
+                            required: ["volumeId", "serverId"],
+                        },
+                    },
+                    {
+                        name: "detach_volume",
+                        description: "Detach a volume from a server",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                volumeId: {
+                                    type: "string",
+                                    description: "Volume ID",
+                                },
+                            },
+                            required: ["volumeId"],
+                        },
+                    },
+                    {
+                        name: "resize_volume",
+                        description: "Resize a volume (must be larger than current size)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                volumeId: {
+                                    type: "string",
+                                    description: "Volume ID",
+                                },
+                                size: {
+                                    type: "number",
+                                    description: "New size in GB (must be larger than current)",
+                                },
+                            },
+                            required: ["volumeId", "size"],
+                        },
+                    },
+                    {
+                        name: "calculate_volume_price",
+                        description: "Calculate pricing for a volume based on size",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                size: {
+                                    type: "number",
+                                    description: "Volume size in GB",
+                                },
+                            },
+                            required: ["size"],
+                        },
+                    },
+                    // Metadata
+                    {
+                        name: "list_server_types",
+                        description: "List all Hetzner server types with specs (cores, memory, disk, prices)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: "list_locations",
+                        description: "List all Hetzner datacenter locations",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                ],
+            }];
+    });
+}); });
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, name, args, _b, servers, environments, server_1, name_1, generateSeedBootstrap, userData, generatedPassword, cleanPassword, passwordSetup, seedLines, passwordLines, mergedLines, inRuncmd, runcmdIndex, _i, seedLines_1, line, _c, passwordLines_1, line, sshKeys, keyName, newKey, e_2, key, _d, _e, _f, _g, e_3, serverOptions, response, responseText, action, parseResources, execSSHParallel, getMetadata, server_2, metadata, keyPath, password, RESOURCE_COMMANDS, rawResults, resources, testSSHConnection, connected, sshKey, sshKeys, host, user, command, keyPath, password, waitTime_1, captureHistory, customSessionName, paneIndex, _h, generateLocalSessionName, isLocalTmuxInstalled, hasLocalSession, createLocalTmuxSSHSession, sendCommandToLocalSession, captureLocalPane, getLocalPaneHistory, tmuxInstalled, sessionName, sessionState, sessionExists, error_1, sent, output, _j, listLocalSessions, getLocalTmuxResourceUsage, sessions, mcpSessions, resources, trackedSessions, _k, _l, _m, name_2, state, _o, killLocalSession, generateLocalSessionName, host, user, sessionName, killed, _p, getDetailedLocalSessionInfo, generateLocalSessionName, host, user, sessionName, info, _q, generateLocalSessionName, hasLocalSession, host, user, customSessionName, sessionName, sessionExists, attachCmd, _r, generateLocalSessionName, isLocalTmuxInstalled, createLocalTmuxSSHSession, host, user, customSessionName, keyPath, password, initialCommand, windowName, tmuxInstalled, sessionName, result, effectiveWindowName, error_2, _s, generateLocalSessionName, splitLocalPane, host, user, customSessionName, direction, command, sessionName, sessionState, windowName, newPaneIndex, error_3, _t, generateLocalSessionName, listLocalSessionWindows, host, user, customSessionName, sessionName, windows, error_4, _u, generateLocalSessionName, listLocalWindowPanes, listLocalSessionWindows, host, user, customSessionName, windowIndex, sessionName, sessionState, windows, _v, panes, error_5, _w, generateLocalSessionName, switchLocalWindow, host, user, customSessionName, windowIndex, sessionName, switched, error_6, _x, generateLocalSessionName, switchLocalPane, host, user, customSessionName, paneIndex, sessionName, switched, error_7, _y, generateLocalSessionName, renameLocalWindow, host, user, customSessionName, windowIndex, newName, sessionName, renamed, sessionState, windows, error_8, _z, generateLocalSessionName, killLocalPane, host, user, customSessionName, paneIndex, sessionName, sessionState, windowName, killed, error_9, volumes, volume, name_3, size, result, action, action, action, action, VolumeOperations, price, serverTypes, locations, error_10;
+    var _0, _1;
+    var _2, _3, _4, _5, _6;
+    return __generator(this, function (_7) {
+        switch (_7.label) {
+            case 0:
+                _a = request.params, name = _a.name, args = _a.arguments;
+                _7.label = 1;
+            case 1:
+                _7.trys.push([1, 135, , 136]);
+                _b = name;
+                switch (_b) {
+                    case "list_environments": return [3 /*break*/, 2];
+                    case "get_environment": return [3 /*break*/, 4];
+                    case "create_environment": return [3 /*break*/, 6];
+                    case "start_environment": return [3 /*break*/, 20];
+                    case "stop_environment": return [3 /*break*/, 22];
+                    case "delete_environment": return [3 /*break*/, 24];
+                    case "get_resources": return [3 /*break*/, 26];
+                    case "ssh_test": return [3 /*break*/, 32];
+                    case "create_ssh_key": return [3 /*break*/, 35];
+                    case "list_ssh_keys": return [3 /*break*/, 37];
+                    case "exec_ssh": return [3 /*break*/, 39];
+                    case "list_tmux_sessions": return [3 /*break*/, 53];
+                    case "kill_tmux_session": return [3 /*break*/, 57];
+                    case "get_tmux_session_info": return [3 /*break*/, 60];
+                    case "attach_tmux_session": return [3 /*break*/, 63];
+                    case "create_tmux_session": return [3 /*break*/, 66];
+                    case "split_pane": return [3 /*break*/, 72];
+                    case "list_session_windows": return [3 /*break*/, 77];
+                    case "list_window_panes": return [3 /*break*/, 82];
+                    case "switch_window": return [3 /*break*/, 90];
+                    case "switch_pane": return [3 /*break*/, 95];
+                    case "rename_window": return [3 /*break*/, 100];
+                    case "kill_pane": return [3 /*break*/, 108];
+                    case "list_volumes": return [3 /*break*/, 113];
+                    case "get_volume": return [3 /*break*/, 115];
+                    case "create_volume": return [3 /*break*/, 117];
+                    case "delete_volume": return [3 /*break*/, 119];
+                    case "attach_volume": return [3 /*break*/, 121];
+                    case "detach_volume": return [3 /*break*/, 123];
+                    case "resize_volume": return [3 /*break*/, 125];
+                    case "calculate_volume_price": return [3 /*break*/, 127];
+                    case "list_server_types": return [3 /*break*/, 129];
+                    case "list_locations": return [3 /*break*/, 131];
+                }
+                return [3 /*break*/, 133];
+            case 2:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available. Please configure HETZNER_API_TOKEN.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.listServers()];
+            case 3:
+                servers = _7.sent();
+                environments = servers.map(function (server) {
+                    var _a, _b;
+                    return ({
+                        id: server.id.toString(),
+                        name: server.name,
+                        status: server.status,
+                        ipv4: ((_a = server.public_net.ipv4) === null || _a === void 0 ? void 0 : _a.ip) || null,
+                        ipv6: ((_b = server.public_net.ipv6) === null || _b === void 0 ? void 0 : _b.ip) || null,
+                        serverType: server.server_type.name,
+                        location: server.datacenter.location.name,
+                        created: server.created,
+                    });
+                });
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(environments, null, 2),
+                            }],
+                    }];
+            case 4:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.getServer(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 5:
+                server_1 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(server_1, null, 2),
+                            }],
+                    }];
+            case 6:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                name_1 = args === null || args === void 0 ? void 0 : args.name;
+                if (!name_1 || typeof name_1 !== "string") {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Error: name is required and must be a string",
+                                }],
+                            isError: true,
+                        }];
+                }
+                // Validate user-data format if provided
+                if ((args === null || args === void 0 ? void 0 : args.userData) && typeof args.userData === "string") {
+                    if (!args.userData.trim().startsWith("#cloud-config")) {
+                        return [2 /*return*/, {
+                                content: [{
+                                        type: "text",
+                                        text: "Error: userData must start with '#cloud-config'",
+                                    }],
+                                isError: true,
+                            }];
+                    }
+                }
+                return [4 /*yield*/, Promise.resolve().then(function () { return require("cheapspaces/workspace/src/lib/bootstrap/cloud-init"); })];
+            case 7:
+                generateSeedBootstrap = (_7.sent()).generateSeedBootstrap;
+                userData = generateSeedBootstrap();
+                generatedPassword = "";
+                // Override with custom userData if provided
+                if ((args === null || args === void 0 ? void 0 : args.userData) && typeof args.userData === "string") {
+                    userData = args.userData;
+                }
+                // Override with password mode if requested
+                else if ((args === null || args === void 0 ? void 0 : args.enablePassword) === true) {
+                    cleanPassword = Array.from({ length: 12 }, function () {
+                        return 'abcdefghijklmnopqrstuvwxyz0123456789'[Math.floor(Math.random() * 36)];
+                    }).join('');
+                    generatedPassword = cleanPassword;
+                    passwordSetup = "#cloud-config\nruncmd:\n  - sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config\n  - sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config\n  - systemctl restart ssh\n  - sh -c 'echo root:".concat(cleanPassword, " | chpasswd'\n  - sh -c 'echo ").concat(cleanPassword, " > /root/password.txt'\n  - chmod 600 /root/password.txt\n");
+                    seedLines = userData.split('\n');
+                    passwordLines = passwordSetup.split('\n');
+                    mergedLines = [];
+                    inRuncmd = false;
+                    runcmdIndex = -1;
+                    // Add seed bootstrap content until we hit runcmd
+                    for (_i = 0, seedLines_1 = seedLines; _i < seedLines_1.length; _i++) {
+                        line = seedLines_1[_i];
+                        if (line.startsWith('runcmd:')) {
+                            inRuncmd = true;
+                            runcmdIndex = mergedLines.length;
+                            mergedLines.push(line);
+                        }
+                        else if (inRuncmd && line.startsWith('  -')) {
+                            mergedLines.push(line);
+                        }
+                        else if (!inRuncmd) {
+                            mergedLines.push(line);
+                        }
+                        else if (inRuncmd && !line.startsWith('  -')) {
+                            // End of runcmd section
+                            inRuncmd = false;
+                        }
+                    }
+                    // Append password runcmd commands
+                    for (_c = 0, passwordLines_1 = passwordLines; _c < passwordLines_1.length; _c++) {
+                        line = passwordLines_1[_c];
+                        if (line.startsWith('runcmd:'))
+                            continue; // Skip header
+                        if (line.trim() === '' || line.startsWith('#'))
+                            continue; // Skip empty and comments
+                        if (line.startsWith('  -')) {
+                            mergedLines.splice(runcmdIndex + 1, 0, line);
+                            runcmdIndex++;
+                        }
+                    }
+                    userData = mergedLines.join('\n');
+                }
+                sshKeys = [];
+                if (!((args === null || args === void 0 ? void 0 : args.sshKey) && typeof args.sshKey === "string")) return [3 /*break*/, 18];
+                if (!args.sshKey.includes(" ")) return [3 /*break*/, 12];
+                _7.label = 8;
+            case 8:
+                _7.trys.push([8, 10, , 11]);
+                keyName = "mcp-key-".concat(Date.now());
+                return [4 /*yield*/, hetznerClient.ssh_keys.create({
+                        name: keyName,
+                        public_key: args.sshKey,
+                    })];
+            case 9:
+                newKey = _7.sent();
+                sshKeys = [newKey.id];
+                return [3 /*break*/, 11];
+            case 10:
+                e_2 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Error creating SSH key: ".concat(String(e_2)),
+                            }],
+                        isError: true,
+                    }];
+            case 11: return [3 /*break*/, 18];
+            case 12:
+                _7.trys.push([12, 17, , 18]);
+                return [4 /*yield*/, hetznerClient.ssh_keys.findByName(args.sshKey)];
+            case 13:
+                key = _7.sent();
+                if (!key) return [3 /*break*/, 14];
+                sshKeys = [key.id];
+                return [3 /*break*/, 16];
+            case 14:
+                _0 = {};
+                _1 = {
+                    type: "text"
+                };
+                _e = (_d = "Error: SSH key '".concat(args.sshKey, "' not found. Available keys:\n")).concat;
+                _g = (_f = JSON).stringify;
+                return [4 /*yield*/, hetznerClient.ssh_keys.list()];
+            case 15: return [2 /*return*/, (_0.content = [(_1.text = _e.apply(_d, [_g.apply(_f, [_7.sent(), null, 2])]),
+                        _1)],
+                    _0.isError = true,
+                    _0)];
+            case 16: return [3 /*break*/, 18];
+            case 17:
+                e_3 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Error looking up SSH key: ".concat(String(e_3)),
+                            }],
+                        isError: true,
+                    }];
+            case 18:
+                serverOptions = {
+                    name: name_1,
+                    server_type: typeof (args === null || args === void 0 ? void 0 : args.serverType) === "string" ? args.serverType : "cax21",
+                    ssh_keys: sshKeys,
+                    user_data: userData,
+                };
+                // Only add location if it's a valid string
+                if ((args === null || args === void 0 ? void 0 : args.location) && typeof args.location === "string") {
+                    serverOptions.location = args.location;
+                }
+                return [4 /*yield*/, hetznerClient.createServer(serverOptions)];
+            case 19:
+                response = _7.sent();
+                responseText = "";
+                // CRITICAL: Put password FIRST and make it VERY prominent
+                // The MCP tool layer seems to truncate responses after JSON, so password MUST come before
+                if (generatedPassword) {
+                    responseText += "========================================\n";
+                    responseText += "\uD83D\uDD11 TEMPORARY ROOT PASSWORD: ".concat(generatedPassword, "\n");
+                    responseText += "========================================\n";
+                    responseText += "SAVE THIS NOW - It will NOT be shown again!\n\n";
+                }
+                responseText += "Environment created:\n".concat(JSON.stringify(response.server, null, 2));
+                console.error("[MCP] Password generated for server ".concat(response.server.name, ": ").concat(generatedPassword));
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: responseText,
+                            }],
+                    }];
+            case 20:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.powerOn(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 21:
+                action = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Start action initiated: ".concat(action.id),
+                            }],
+                    }];
+            case 22:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.powerOff(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 23:
+                _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Environment stopped.",
+                            }],
+                    }];
+            case 24:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.deleteServer(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 25:
+                _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Environment deleted.",
+                            }],
+                    }];
+            case 26: return [4 /*yield*/, Promise.resolve().then(function () { return require("cheapspaces/workspace/src/lib/resources"); })];
+            case 27:
+                parseResources = (_7.sent()).parseResources;
+                return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 28:
+                execSSHParallel = (_7.sent()).execSSHParallel;
+                return [4 /*yield*/, Promise.resolve().then(function () { return require("cheapspaces/workspace/src/lib/metadata"); })];
+            case 29:
+                getMetadata = (_7.sent()).getMetadata;
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.getServer(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 30:
+                server_2 = _7.sent();
+                if (!((_2 = server_2 === null || server_2 === void 0 ? void 0 : server_2.public_net.ipv4) === null || _2 === void 0 ? void 0 : _2.ip)) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Server not found or no IP address.",
+                                }],
+                        }];
+                }
+                metadata = getMetadata(server_2.id.toString());
+                keyPath = metadata === null || metadata === void 0 ? void 0 : metadata.sshKeyPath;
+                password = metadata === null || metadata === void 0 ? void 0 : metadata.sshPassword;
+                RESOURCE_COMMANDS = {
+                    cpu: "top -bn1 | grep 'Cpu(s)' | awk '{print $2}' | cut -d'%' -f1",
+                    memory: "free | grep Mem | awk '{printf \"%.1f\", ($3/$2) * 100.0}'",
+                    disk: "df -h / | tail -1 | awk '{print $5}' | sed 's/%//'",
+                };
+                return [4 /*yield*/, execSSHParallel(RESOURCE_COMMANDS, __assign(__assign({ host: server_2.public_net.ipv4.ip, user: "root", timeout: 5 }, (keyPath && { keyPath: keyPath })), (password && { password: password })))];
+            case 31:
+                rawResults = _7.sent();
+                resources = parseResources(rawResults);
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(resources, null, 2),
+                            }],
+                    }];
+            case 32: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 33:
+                testSSHConnection = (_7.sent()).testSSHConnection;
+                return [4 /*yield*/, testSSHConnection({
+                        host: args === null || args === void 0 ? void 0 : args.host,
+                        user: (args === null || args === void 0 ? void 0 : args.user) || "root",
+                        port: 22,
+                        keyPath: args === null || args === void 0 ? void 0 : args.keyPath,
+                        password: args === null || args === void 0 ? void 0 : args.password,
+                    })];
+            case 34:
+                connected = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: connected ? "SSH connection successful." : "SSH connection failed.",
+                            }],
+                    }];
+            case 35:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.ssh_keys.create({
+                        name: args === null || args === void 0 ? void 0 : args.name,
+                        public_key: args === null || args === void 0 ? void 0 : args.publicKey,
+                    })];
+            case 36:
+                sshKey = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "SSH key created:\n".concat(JSON.stringify(sshKey, null, 2)),
+                            }],
+                    }];
+            case 37:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.ssh_keys.list()];
+            case 38:
+                sshKeys = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(sshKeys, null, 2),
+                            }],
+                    }];
+            case 39:
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                command = args === null || args === void 0 ? void 0 : args.command;
+                keyPath = args === null || args === void 0 ? void 0 : args.keyPath;
+                password = args === null || args === void 0 ? void 0 : args.password;
+                waitTime_1 = (_3 = args === null || args === void 0 ? void 0 : args.waitTime) !== null && _3 !== void 0 ? _3 : 500;
+                captureHistory = (_4 = args === null || args === void 0 ? void 0 : args.captureHistory) !== null && _4 !== void 0 ? _4 : true;
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                paneIndex = (_5 = args === null || args === void 0 ? void 0 : args.paneIndex) !== null && _5 !== void 0 ? _5 : "0";
+                return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 40:
+                _h = _7.sent(), generateLocalSessionName = _h.generateLocalSessionName, isLocalTmuxInstalled = _h.isLocalTmuxInstalled, hasLocalSession = _h.hasLocalSession, createLocalTmuxSSHSession = _h.createLocalTmuxSSHSession, sendCommandToLocalSession = _h.sendCommandToLocalSession, captureLocalPane = _h.captureLocalPane, getLocalPaneHistory = _h.getLocalPaneHistory;
+                return [4 /*yield*/, isLocalTmuxInstalled()];
+            case 41:
+                tmuxInstalled = _7.sent();
+                if (!tmuxInstalled) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Local tmux is not installed. Please install tmux on your local machine first.",
+                                }],
+                            isError: true,
+                        }];
+                }
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                // Track session state
+                if (!localTmuxSessions.has(sessionName)) {
+                    localTmuxSessions.set(sessionName, {
+                        host: host,
+                        user: user,
+                        initialized: false,
+                        createdAt: Date.now(),
+                        windowName: "ssh", // Default window name
+                    });
+                }
+                sessionState = localTmuxSessions.get(sessionName);
+                return [4 /*yield*/, hasLocalSession(sessionName)];
+            case 42:
+                sessionExists = _7.sent();
+                if (!(!sessionState.initialized || !sessionExists)) return [3 /*break*/, 46];
+                _7.label = 43;
+            case 43:
+                _7.trys.push([43, 45, , 46]);
+                return [4 /*yield*/, createLocalTmuxSSHSession(host, user, keyPath, password, { sessionName: sessionName })];
+            case 44:
+                _7.sent();
+                sessionState.initialized = true;
+                return [3 /*break*/, 46];
+            case 45:
+                error_1 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to create local tmux session '".concat(sessionName, "' for ").concat(user, "@").concat(host, ": ").concat(error_1 instanceof Error ? error_1.message : String(error_1)),
+                            }],
+                        isError: true,
+                    }];
+            case 46: return [4 /*yield*/, sendCommandToLocalSession(sessionName, command, paneIndex, sessionState.windowName)];
+            case 47:
+                sent = _7.sent();
+                if (!sent) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Failed to send command to local tmux session",
+                                }],
+                            isError: true,
+                        }];
+                }
+                // Wait for command to execute
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, waitTime_1); })];
+            case 48:
+                // Wait for command to execute
+                _7.sent();
+                output = void 0;
+                if (!captureHistory) return [3 /*break*/, 50];
+                return [4 /*yield*/, getLocalPaneHistory(sessionName, paneIndex, -1, sessionState.windowName)];
+            case 49:
+                output = _7.sent();
+                return [3 /*break*/, 52];
+            case 50: return [4 /*yield*/, captureLocalPane(sessionName, paneIndex, sessionState.windowName)];
+            case 51:
+                output = _7.sent();
+                _7.label = 52;
+            case 52: return [2 /*return*/, {
+                    content: [{
+                            type: "text",
+                            text: output || "Command executed (no output)",
+                        }],
+                }];
+            case 53: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 54:
+                _j = _7.sent(), listLocalSessions = _j.listLocalSessions, getLocalTmuxResourceUsage = _j.getLocalTmuxResourceUsage;
+                return [4 /*yield*/, listLocalSessions()];
+            case 55:
+                sessions = _7.sent();
+                mcpSessions = sessions.filter(function (s) { return s.startsWith("mcp-ssh"); });
+                return [4 /*yield*/, getLocalTmuxResourceUsage()];
+            case 56:
+                resources = _7.sent();
+                trackedSessions = [];
+                for (_k = 0, _l = localTmuxSessions.entries(); _k < _l.length; _k++) {
+                    _m = _l[_k], name_2 = _m[0], state = _m[1];
+                    if (sessions.includes(name_2)) {
+                        trackedSessions.push({
+                            sessionName: name_2,
+                            host: state.host,
+                            user: state.user,
+                            windowName: state.windowName,
+                            createdAt: state.createdAt,
+                        });
+                    }
+                }
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    allSessions: sessions,
+                                    mcpSessions: mcpSessions,
+                                    trackedSessions: trackedSessions,
+                                    resources: resources,
+                                    sessionType: "local",
+                                    description: "Local tmux sessions with persistent SSH connections",
+                                }, null, 2),
+                            }],
+                    }];
+            case 57: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 58:
+                _o = _7.sent(), killLocalSession = _o.killLocalSession, generateLocalSessionName = _o.generateLocalSessionName;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                sessionName = (args === null || args === void 0 ? void 0 : args.sessionName) || generateLocalSessionName(host, user);
+                return [4 /*yield*/, killLocalSession(sessionName)];
+            case 59:
+                killed = _7.sent();
+                // Clear from local state tracking (by session name directly)
+                localTmuxSessions.delete(sessionName);
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: killed
+                                    ? "Local tmux session '".concat(sessionName, "' killed.")
+                                    : "Failed to kill local tmux session '".concat(sessionName, "' or session not found."),
+                            }],
+                    }];
+            case 60: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 61:
+                _p = _7.sent(), getDetailedLocalSessionInfo = _p.getDetailedLocalSessionInfo, generateLocalSessionName = _p.generateLocalSessionName;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                sessionName = (args === null || args === void 0 ? void 0 : args.sessionName) || generateLocalSessionName(host, user);
+                return [4 /*yield*/, getDetailedLocalSessionInfo(sessionName)];
+            case 62:
+                info = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(__assign(__assign({}, info), { sessionType: "local", description: "Local tmux session with persistent SSH connection" }), null, 2),
+                            }],
+                    }];
+            case 63: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 64:
+                _q = _7.sent(), generateLocalSessionName = _q.generateLocalSessionName, hasLocalSession = _q.hasLocalSession;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                return [4 /*yield*/, hasLocalSession(sessionName)];
+            case 65:
+                sessionExists = _7.sent();
+                attachCmd = "tmux attach-session -t \"".concat(sessionName, "\"");
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "To attach to the local tmux session '".concat(sessionName, "', run:\n\n").concat(attachCmd, "\n\n") +
+                                    "Session exists: ".concat(sessionExists, "\n") +
+                                    "Note: This is a local tmux session with a persistent SSH connection to ".concat(user, "@").concat(host, "."),
+                            }],
+                    }];
+            case 66: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 67:
+                _r = _7.sent(), generateLocalSessionName = _r.generateLocalSessionName, isLocalTmuxInstalled = _r.isLocalTmuxInstalled, createLocalTmuxSSHSession = _r.createLocalTmuxSSHSession;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                keyPath = args === null || args === void 0 ? void 0 : args.keyPath;
+                password = args === null || args === void 0 ? void 0 : args.password;
+                initialCommand = args === null || args === void 0 ? void 0 : args.initialCommand;
+                windowName = args === null || args === void 0 ? void 0 : args.windowName;
+                return [4 /*yield*/, isLocalTmuxInstalled()];
+            case 68:
+                tmuxInstalled = _7.sent();
+                if (!tmuxInstalled) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Local tmux is not installed. Please install tmux on your local machine first.",
+                                }],
+                            isError: true,
+                        }];
+                }
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                _7.label = 69;
+            case 69:
+                _7.trys.push([69, 71, , 72]);
+                return [4 /*yield*/, createLocalTmuxSSHSession(host, user, keyPath, password, {
+                        sessionName: sessionName,
+                        initialCommand: initialCommand,
+                        windowName: windowName,
+                    })];
+            case 70:
+                result = _7.sent();
+                effectiveWindowName = windowName || "ssh";
+                localTmuxSessions.set(sessionName, {
+                    host: host,
+                    user: user,
+                    initialized: true,
+                    createdAt: Date.now(),
+                    windowName: effectiveWindowName,
+                });
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: result.newlyCreated
+                                    ? "Created new tmux session '".concat(sessionName, "' for ").concat(user, "@").concat(host, ".\n\nTo attach: tmux attach-session -t \"").concat(sessionName, "\"")
+                                    : "Tmux session '".concat(sessionName, "' already exists.\n\nTo attach: tmux attach-session -t \"").concat(sessionName, "\""),
+                            }],
+                    }];
+            case 71:
+                error_2 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to create tmux session: ".concat(error_2 instanceof Error ? error_2.message : String(error_2)),
+                            }],
+                        isError: true,
+                    }];
+            case 72: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 73:
+                _s = _7.sent(), generateLocalSessionName = _s.generateLocalSessionName, splitLocalPane = _s.splitLocalPane;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                direction = (args === null || args === void 0 ? void 0 : args.direction) || "v";
+                command = args === null || args === void 0 ? void 0 : args.command;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                sessionState = localTmuxSessions.get(sessionName);
+                windowName = sessionState === null || sessionState === void 0 ? void 0 : sessionState.windowName;
+                _7.label = 74;
+            case 74:
+                _7.trys.push([74, 76, , 77]);
+                return [4 /*yield*/, splitLocalPane(sessionName, direction, command, windowName)];
+            case 75:
+                newPaneIndex = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: newPaneIndex
+                                    ? "Pane split ".concat(direction === "v" ? "vertically" : "horizontally", " in session '").concat(sessionName, "'.\n\nUse exec_ssh with paneIndex to send commands to specific panes.")
+                                    : "Failed to split pane in session '".concat(sessionName, "'."),
+                            }],
+                    }];
+            case 76:
+                error_3 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to split pane: ".concat(error_3 instanceof Error ? error_3.message : String(error_3)),
+                            }],
+                        isError: true,
+                    }];
+            case 77: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 78:
+                _t = _7.sent(), generateLocalSessionName = _t.generateLocalSessionName, listLocalSessionWindows = _t.listLocalSessionWindows;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                _7.label = 79;
+            case 79:
+                _7.trys.push([79, 81, , 82]);
+                return [4 /*yield*/, listLocalSessionWindows(sessionName)];
+            case 80:
+                windows = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    session: sessionName,
+                                    windows: windows,
+                                    count: windows.length,
+                                }, null, 2),
+                            }],
+                    }];
+            case 81:
+                error_4 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to list windows: ".concat(error_4 instanceof Error ? error_4.message : String(error_4)),
+                            }],
+                        isError: true,
+                    }];
+            case 82: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 83:
+                _u = _7.sent(), generateLocalSessionName = _u.generateLocalSessionName, listLocalWindowPanes = _u.listLocalWindowPanes, listLocalSessionWindows = _u.listLocalSessionWindows;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                windowIndex = args === null || args === void 0 ? void 0 : args.windowIndex;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                if (!!windowIndex) return [3 /*break*/, 87];
+                sessionState = localTmuxSessions.get(sessionName);
+                if (!(sessionState === null || sessionState === void 0 ? void 0 : sessionState.windowName)) return [3 /*break*/, 84];
+                windowIndex = sessionState.windowName;
+                return [3 /*break*/, 87];
+            case 84:
+                _7.trys.push([84, 86, , 87]);
+                return [4 /*yield*/, listLocalSessionWindows(sessionName)];
+            case 85:
+                windows = _7.sent();
+                if (windows.length > 0) {
+                    windowIndex = windows[0].index; // Use numeric index
+                }
+                return [3 /*break*/, 87];
+            case 86:
+                _v = _7.sent();
+                windowIndex = "0"; // Fallback to 0
+                return [3 /*break*/, 87];
+            case 87:
+                _7.trys.push([87, 89, , 90]);
+                return [4 /*yield*/, listLocalWindowPanes(sessionName, windowIndex)];
+            case 88:
+                panes = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    session: sessionName,
+                                    window: windowIndex,
+                                    panes: panes,
+                                    count: panes.length,
+                                }, null, 2),
+                            }],
+                    }];
+            case 89:
+                error_5 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to list panes: ".concat(error_5 instanceof Error ? error_5.message : String(error_5)),
+                            }],
+                        isError: true,
+                    }];
+            case 90: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 91:
+                _w = _7.sent(), generateLocalSessionName = _w.generateLocalSessionName, switchLocalWindow = _w.switchLocalWindow;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                windowIndex = args === null || args === void 0 ? void 0 : args.windowIndex;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                _7.label = 92;
+            case 92:
+                _7.trys.push([92, 94, , 95]);
+                return [4 /*yield*/, switchLocalWindow(sessionName, windowIndex)];
+            case 93:
+                switched = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: switched
+                                    ? "Switched to window ".concat(windowIndex, " in session '").concat(sessionName, "'.")
+                                    : "Failed to switch to window ".concat(windowIndex, " in session '").concat(sessionName, "'."),
+                            }],
+                    }];
+            case 94:
+                error_6 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to switch window: ".concat(error_6 instanceof Error ? error_6.message : String(error_6)),
+                            }],
+                        isError: true,
+                    }];
+            case 95: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 96:
+                _x = _7.sent(), generateLocalSessionName = _x.generateLocalSessionName, switchLocalPane = _x.switchLocalPane;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                paneIndex = args === null || args === void 0 ? void 0 : args.paneIndex;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                _7.label = 97;
+            case 97:
+                _7.trys.push([97, 99, , 100]);
+                return [4 /*yield*/, switchLocalPane(sessionName, paneIndex)];
+            case 98:
+                switched = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: switched
+                                    ? "Switched to pane ".concat(paneIndex, " in session '").concat(sessionName, "'.")
+                                    : "Failed to switch to pane ".concat(paneIndex, " in session '").concat(sessionName, "'."),
+                            }],
+                    }];
+            case 99:
+                error_7 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to switch pane: ".concat(error_7 instanceof Error ? error_7.message : String(error_7)),
+                            }],
+                        isError: true,
+                    }];
+            case 100: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 101:
+                _y = _7.sent(), generateLocalSessionName = _y.generateLocalSessionName, renameLocalWindow = _y.renameLocalWindow;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                windowIndex = (args === null || args === void 0 ? void 0 : args.windowIndex) || "ssh";
+                newName = args === null || args === void 0 ? void 0 : args.newName;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                _7.label = 102;
+            case 102:
+                _7.trys.push([102, 107, , 108]);
+                return [4 /*yield*/, renameLocalWindow(sessionName, windowIndex, newName)];
+            case 103:
+                renamed = _7.sent();
+                if (!renamed) return [3 /*break*/, 106];
+                sessionState = localTmuxSessions.get(sessionName);
+                if (!sessionState) return [3 /*break*/, 106];
+                return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 104: return [4 /*yield*/, (_7.sent()).listLocalSessionWindows(sessionName)];
+            case 105:
+                windows = _7.sent();
+                if (windows.length > 0) {
+                    sessionState.windowName = newName;
+                }
+                _7.label = 106;
+            case 106: return [2 /*return*/, {
+                    content: [{
+                            type: "text",
+                            text: renamed
+                                ? "Renamed window ".concat(windowIndex, " to '").concat(newName, "' in session '").concat(sessionName, "'.")
+                                : "Failed to rename window in session '".concat(sessionName, "'."),
+                        }],
+                }];
+            case 107:
+                error_8 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to rename window: ".concat(error_8 instanceof Error ? error_8.message : String(error_8)),
+                            }],
+                        isError: true,
+                    }];
+            case 108: return [4 /*yield*/, Promise.resolve().then(function () { return require("@codespaces/terminal"); })];
+            case 109:
+                _z = _7.sent(), generateLocalSessionName = _z.generateLocalSessionName, killLocalPane = _z.killLocalPane;
+                host = args === null || args === void 0 ? void 0 : args.host;
+                user = (args === null || args === void 0 ? void 0 : args.user) || "root";
+                customSessionName = args === null || args === void 0 ? void 0 : args.sessionName;
+                paneIndex = args === null || args === void 0 ? void 0 : args.paneIndex;
+                sessionName = customSessionName || generateLocalSessionName(host, user);
+                sessionState = localTmuxSessions.get(sessionName);
+                windowName = sessionState === null || sessionState === void 0 ? void 0 : sessionState.windowName;
+                _7.label = 110;
+            case 110:
+                _7.trys.push([110, 112, , 113]);
+                return [4 /*yield*/, killLocalPane(sessionName, paneIndex, windowName)];
+            case 111:
+                killed = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: killed
+                                    ? "Killed pane ".concat(paneIndex, " in session '").concat(sessionName, "'.")
+                                    : "Failed to kill pane ".concat(paneIndex, " in session '").concat(sessionName, "'."),
+                            }],
+                    }];
+            case 112:
+                error_9 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Failed to kill pane: ".concat(error_9 instanceof Error ? error_9.message : String(error_9)),
+                            }],
+                        isError: true,
+                    }];
+            case 113:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.list({
+                        name: args === null || args === void 0 ? void 0 : args.name,
+                        status: args === null || args === void 0 ? void 0 : args.status,
+                    })];
+            case 114:
+                volumes = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(volumes, null, 2),
+                            }],
+                    }];
+            case 115:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.get(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 116:
+                volume = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(volume, null, 2),
+                            }],
+                    }];
+            case 117:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                name_3 = args === null || args === void 0 ? void 0 : args.name;
+                size = args === null || args === void 0 ? void 0 : args.size;
+                if (!name_3 || typeof name_3 !== "string") {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Error: name is required and must be a string",
+                                }],
+                            isError: true,
+                        }];
+                }
+                if (!size || typeof size !== "number") {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Error: size is required and must be a number",
+                                }],
+                            isError: true,
+                        }];
+                }
+                if (size < 10 || size > 10240) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Error: size must be between 10 and 10240 GB",
+                                }],
+                            isError: true,
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.create({
+                        name: name_3,
+                        size: size,
+                        location: args === null || args === void 0 ? void 0 : args.location,
+                        server: (args === null || args === void 0 ? void 0 : args.serverId) ? parseInt(args.serverId, 10) : undefined,
+                        automount: args === null || args === void 0 ? void 0 : args.automount,
+                        format: args === null || args === void 0 ? void 0 : args.format,
+                    })];
+            case 118:
+                result = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Volume created:\n".concat(JSON.stringify(result.volume, null, 2), "\n\nAction ID: ").concat(result.action.id),
+                            }],
+                    }];
+            case 119:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.delete(parseInt(args === null || args === void 0 ? void 0 : args.id))];
+            case 120:
+                action = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Volume deletion initiated. Action ID: ".concat(action.id),
+                            }],
+                    }];
+            case 121:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.attach(parseInt(args === null || args === void 0 ? void 0 : args.volumeId), parseInt(args === null || args === void 0 ? void 0 : args.serverId), (_6 = args === null || args === void 0 ? void 0 : args.automount) !== null && _6 !== void 0 ? _6 : true)];
+            case 122:
+                action = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Volume attachment initiated. Action ID: ".concat(action.id),
+                            }],
+                    }];
+            case 123:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.detach(parseInt(args === null || args === void 0 ? void 0 : args.volumeId))];
+            case 124:
+                action = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Volume detachment initiated. Action ID: ".concat(action.id),
+                            }],
+                    }];
+            case 125:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.volumes.resize(parseInt(args === null || args === void 0 ? void 0 : args.volumeId), args === null || args === void 0 ? void 0 : args.size)];
+            case 126:
+                action = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Volume resize initiated. Action ID: ".concat(action.id),
+                            }],
+                    }];
+            case 127: return [4 /*yield*/, Promise.resolve().then(function () { return require("cheapspaces/workspace/src/lib/hetzner/volumes"); })];
+            case 128:
+                VolumeOperations = (_7.sent()).VolumeOperations;
+                price = VolumeOperations.calculatePrice(args === null || args === void 0 ? void 0 : args.size);
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(price, null, 2),
+                            }],
+                    }];
+            case 129:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.pricing.listServerTypes()];
+            case 130:
+                serverTypes = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(serverTypes, null, 2),
+                            }],
+                    }];
+            case 131:
+                if (!hetznerClient) {
+                    return [2 /*return*/, {
+                            content: [{
+                                    type: "text",
+                                    text: "Hetzner client not available.",
+                                }],
+                        }];
+                }
+                return [4 /*yield*/, hetznerClient.pricing.listLocations()];
+            case 132:
+                locations = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(locations, null, 2),
+                            }],
+                    }];
+            case 133: return [2 /*return*/, {
+                    content: [{
+                            type: "text",
+                            text: "Unknown tool: ".concat(name),
+                        }],
+                    isError: true,
+                }];
+            case 134: return [3 /*break*/, 136];
+            case 135:
+                error_10 = _7.sent();
+                return [2 /*return*/, {
+                        content: [{
+                                type: "text",
+                                text: "Error: ".concat(String(error_10)),
+                            }],
+                        isError: true,
+                    }];
+            case 136: return [2 /*return*/];
+        }
+    });
+}); });
+// Start server
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var transport;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: 
+                // Initialize Hetzner client before starting server
+                return [4 /*yield*/, initializeClient()];
+                case 1:
+                    // Initialize Hetzner client before starting server
+                    _a.sent();
+                    transport = new stdio_js_1.StdioServerTransport();
+                    return [4 /*yield*/, server.connect(transport)];
+                case 2:
+                    _a.sent();
+                    console.error("Hetzner MCP server running on stdio");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main().catch(function (error) {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});