@ebowwa/hetzner-mcp 1.1.0

package/dist/index.js

@@ -0,0 +1,1928 @@
+#!/usr/bin/env node
+/**
+ * @mcp/hetzner - Hetzner VPS Management MCP Server
+ *
+ * Full-featured Hetzner Cloud integration with:
+ * - Server management (list, create, delete, power operations)
+ * - SSH/tmux session management via @ebowwa/terminal
+ * - Advanced tmux operations (windows, panes, split, switch)
+ * - File operations (SCP upload/download)
+ * - Volume operations (create, delete, attach, detach, resize)
+ * - Resource monitoring (CPU, memory, disk, GPU, network)
+ * - SSH key management
+ * - Action monitoring
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { HetznerClient, generateSeedBootstrap, VolumeOperations } from "./lib/hetzner/index.js";
+import { execSSH } from "./lib/terminal/client.js";
+import { testSSHConnection, } from "./lib/terminal/exec.js";
+import { parseResources } from "./lib/resources.js";
+import { createOrAttachTmuxSession, killTmuxSession, listTmuxSessions, sendCommandToPane, capturePane, splitPane, cleanupOldTmuxSessions, listSessionWindows, listWindowPanes, switchWindow, switchPane, renameWindow, killPane, } from "./lib/terminal/tmux.js";
+import { scpUpload, scpDownload, } from "./lib/terminal/scp.js";
+import { listFiles, previewFile, } from "./lib/terminal/files.js";
+// ==============
+// Resource Commands
+//=============
+const RESOURCE_COMMANDS = {
+    cpu: "top -bn1 | grep 'Cpu(s)' | awk '{print $2}' | cut -d'%' -f1",
+    memory: "free | awk '/^Mem:/ {printf \"%.1f %.1f %.1f\", $3/$2*100, $3/1024, $2/1024}'",
+    disk: "df -h / | awk 'NR==2 {printf \"%s %s %s\", $5, $3, $2}'",
+    gpu: "nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,noheader,nounits 2>/dev/null || echo 'NOGPU'",
+    loadavg: "cat /proc/loadavg | awk '{print $1}'",
+    processes: "ps aux | wc -l",
+    connections: "netstat -an 2>/dev/null | grep ESTABLISHED | wc -l || ss -an 2>/dev/null | grep ESTAB | wc -l",
+    ports: "netstat -tuln 2>/dev/null | grep LISTEN | wc -l || ss -tuln 2>/dev/null | grep LISTEN | wc -l",
+};
+import { homedir } from "os";
+import { join } from "path";
+async function getTokenFromCLI() {
+    try {
+        const configPath = join(homedir(), ".config", "hcloud", "cli.toml");
+        // @ts-ignore - Bun.file is available
+        const configFile = Bun.file(configPath);
+        if (await configFile.exists()) {
+            const config = await configFile.text();
+            const match = config.match(/token\s*=\s*["']([^"']+)["']/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return "";
+}
+// Initialize client
+let hetznerClient = null;
+async function getHetznerClient() {
+    if (!hetznerClient) {
+        const token = process.env.HETZNER_API_TOKEN || await getTokenFromCLI();
+        if (!token) {
+            throw new Error("HETZNER_API_TOKEN not configured. Set environment variable or run `hcloud context create`.");
+        }
+        hetznerClient = new HetznerClient(token);
+    }
+    return hetznerClient;
+}
+// ==============
+// MCP Server
+//=============
+const server = new Server({
+    name: "@mcp/hetzner",
+    version: "1.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            // Server Management
+            {
+                name: "list_servers",
+                description: "List all Hetzner servers with their status, IPs, and details",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            description: "Filter by server status (running, stopped, initializing, etc.)",
+                            enum: ["running", "stopped", "initializing", "starting", "stopping"],
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_server",
+                description: "Get detailed information about a specific server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID or name",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "get_server_types",
+                description: "List available Hetzner server types with pricing",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_datacenters",
+                description: "List Hetzner datacenters and locations",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_locations",
+                description: "List available Hetzner locations",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "get_ssh_keys",
+                description: "List SSH keys registered in Hetzner",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "create_server",
+                description: "Create a new Hetzner server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Server name",
+                        },
+                        server_type: {
+                            type: "string",
+                            description: "Server type (e.g., cx22.medium)",
+                        },
+                        image: {
+                            type: "string",
+                            description: "Image ID or name",
+                        },
+                        location: {
+                            type: "string",
+                            description: "Location (e.g., nbg1, fsn1)",
+                        },
+                        ssh_keys: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "SSH key IDs or fingerprints",
+                        },
+                        user_data: {
+                            type: "string",
+                            description: "Cloud-init user data (must start with #cloud-config)",
+                        },
+                        start_after_create: {
+                            type: "boolean",
+                            description: "Start server after creation (default: true)",
+                        },
+                    },
+                    required: ["name", "server_type", "image", "location"],
+                },
+            },
+            {
+                name: "create_server_hardened",
+                description: "Create a new Hetzner server with security hardening (SSH keys only, fail2ban, UFW firewall, kernel hardening). Uses cloud-init to apply security at first boot.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Server name",
+                        },
+                        server_type: {
+                            type: "string",
+                            description: "Server type (e.g., cx22.medium)",
+                        },
+                        image: {
+                            type: "string",
+                            description: "Image ID or name (Ubuntu 24.04 recommended)",
+                        },
+                        location: {
+                            type: "string",
+                            description: "Location (e.g., nbg1, fsn1)",
+                        },
+                        ssh_keys: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "SSH key IDs or fingerprints (required - password auth disabled)",
+                        },
+                        enable_security: {
+                            type: "boolean",
+                            description: "Enable security hardening (default: true)",
+                        },
+                        allow_http: {
+                            type: "boolean",
+                            description: "Allow HTTP port 80 (default: false)",
+                        },
+                        allow_https: {
+                            type: "boolean",
+                            description: "Allow HTTPS port 443 (default: false)",
+                        },
+                        start_after_create: {
+                            type: "boolean",
+                            description: "Start server after creation (default: true)",
+                        },
+                    },
+                    required: ["name", "server_type", "image", "location", "ssh_keys"],
+                },
+            },
+            {
+                name: "delete_server",
+                description: "Delete a Hetzner server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "power_on",
+                description: "Power on a stopped server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "power_off",
+                description: "Power off a running server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "reboot",
+                description: "Reboot a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            {
+                name: "get_actions",
+                description: "Get recent actions for a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: {
+                            type: "string",
+                            description: "Server ID",
+                        },
+                    },
+                    required: ["id"],
+                },
+            },
+            // SSH Operations
+            {
+                name: "ssh_exec",
+                description: "Execute a command on a server via SSH",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        command: {
+                            type: "string",
+                            description: "Command to execute",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                        port: {
+                            type: "number",
+                            description: "SSH port (default: 22)",
+                        },
+                    },
+                    required: ["host", "command"],
+                },
+            },
+            {
+                name: "ssh_test",
+                description: "Test SSH connection to a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                        port: {
+                            type: "number",
+                            description: "SSH port (default: 22)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "ssh_exec_parallel",
+                description: "Execute a command on multiple servers in parallel",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        hosts: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of server IPs/hostnames",
+                        },
+                        command: {
+                            type: "string",
+                            description: "Command to execute",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["hosts", "command"],
+                },
+            },
+            // Tmux Operations
+            {
+                name: "tmux_create_or_attach",
+                description: "Create or attach to a tmux session on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name (auto-generated if not provided)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "tmux_list",
+                description: "List tmux sessions on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "tmux_kill",
+                description: "Kill a tmux session on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName"],
+                },
+            },
+            {
+                name: "tmux_send_command",
+                description: "Send a command to a tmux session pane",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        command: {
+                            type: "string",
+                            description: "Command to send",
+                        },
+                        paneIndex: {
+                            type: "string",
+                            description: "Pane index (default: 0)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName", "command"],
+                },
+            },
+            {
+                name: "tmux_capture",
+                description: "Capture output from a tmux pane",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        paneIndex: {
+                            type: "string",
+                            description: "Pane index (default: 0)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName"],
+                },
+            },
+            {
+                name: "tmux_cleanup",
+                description: "Clean up old tmux sessions on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        ageLimit: {
+                            type: "number",
+                            description: "Age limit in days (default: 30)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "tmux_list_windows",
+                description: "List all windows in a tmux session",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName"],
+                },
+            },
+            {
+                name: "tmux_list_panes",
+                description: "List all panes in a tmux window",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index (default: 0)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName"],
+                },
+            },
+            {
+                name: "tmux_split_pane",
+                description: "Split a tmux pane (creates a new pane in current window)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index (default: 0)",
+                        },
+                        paneIndex: {
+                            type: "string",
+                            description: "Pane index to split (default: 0)",
+                        },
+                        direction: {
+                            type: "string",
+                            description: "Split direction: 'h' for horizontal, 'v' for vertical (default: 'h')",
+                            enum: ["h", "v"],
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName"],
+                },
+            },
+            {
+                name: "tmux_kill_pane",
+                description: "Kill a specific tmux pane",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index (default: 0)",
+                        },
+                        paneIndex: {
+                            type: "string",
+                            description: "Pane index to kill (required)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName", "paneIndex"],
+                },
+            },
+            {
+                name: "tmux_switch_window",
+                description: "Switch to a different window in a tmux session",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index to switch to",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName", "windowIndex"],
+                },
+            },
+            {
+                name: "tmux_switch_pane",
+                description: "Switch focus to a different pane in the current window",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index (default: 0)",
+                        },
+                        paneIndex: {
+                            type: "string",
+                            description: "Pane index to switch to",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName", "paneIndex"],
+                },
+            },
+            {
+                name: "tmux_rename_window",
+                description: "Rename a tmux window",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        sessionName: {
+                            type: "string",
+                            description: "Session name",
+                        },
+                        windowIndex: {
+                            type: "string",
+                            description: "Window index (default: 0)",
+                        },
+                        newName: {
+                            type: "string",
+                            description: "New window name",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "sessionName", "newName"],
+                },
+            },
+            // File Operations
+            {
+                name: "scp_upload",
+                description: "Upload a file to a server via SCP",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        source: {
+                            type: "string",
+                            description: "Local file path",
+                        },
+                        destination: {
+                            type: "string",
+                            description: "Remote file path",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "source", "destination"],
+                },
+            },
+            {
+                name: "scp_download",
+                description: "Download a file from a server via SCP",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        source: {
+                            type: "string",
+                            description: "Remote file path",
+                        },
+                        destination: {
+                            type: "string",
+                            description: "Local file path",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "source", "destination"],
+                },
+            },
+            {
+                name: "file_list",
+                description: "List files in a directory on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        path: {
+                            type: "string",
+                            description: "Directory path (default: current directory)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "file_preview",
+                description: "Preview a file on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        path: {
+                            type: "string",
+                            description: "File path",
+                        },
+                        lines: {
+                            type: "number",
+                            description: "Number of lines to preview (default: 100)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host", "path"],
+                },
+            },
+            // Security Verification Tools
+            {
+                name: "check_bootstrap_status",
+                description: "Check if bootstrap/security hardening completed on a server",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "check_security_status",
+                description: "Check comprehensive security status (firewall, fail2ban, SSH, kernel)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "get_ssh_logs",
+                description: "Get recent SSH connection logs and authentication events",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        lines: {
+                            type: "number",
+                            description: "Number of log lines to show (default: 20)",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "check_fail2ban",
+                description: "Check fail2ban status, banned IPs, and failed login attempts",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            {
+                name: "check_server_health",
+                description: "Get real-time server health metrics (CPU, memory, connections)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+            // Volume Management
+            {
+                name: "list_volumes",
+                description: "List all Hetzner volumes with their status, size, and server attachments",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Filter by volume name",
+                        },
+                        status: {
+                            type: "string",
+                            description: "Filter by volume status",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_volume",
+                description: "Get detailed information about a specific volume",
+                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",
+                        },
+                        server: {
+                            type: "string",
+                            description: "Server ID to attach volume to (optional)",
+                        },
+                        location: {
+                            type: "string",
+                            description: "Location (e.g., nbg1, fsn1)",
+                        },
+                        automount: {
+                            type: "boolean",
+                            description: "Automatically mount the volume (default: true)",
+                        },
+                        format: {
+                            type: "string",
+                            description: "File system format (e.g., ext4)",
+                        },
+                    },
+                    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 (can only increase 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"],
+                },
+            },
+            // Resource Monitoring
+            {
+                name: "get_resources",
+                description: "Get real-time CPU, memory, disk, GPU, network, and system metrics for a server via SSH",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        host: {
+                            type: "string",
+                            description: "Server IP or hostname",
+                        },
+                        user: {
+                            type: "string",
+                            description: "SSH user (default: root)",
+                        },
+                        keyPath: {
+                            type: "string",
+                            description: "Path to SSH private key (optional, uses default if not provided)",
+                        },
+                        password: {
+                            type: "string",
+                            description: "SSH password (optional, for password authentication)",
+                        },
+                        commands: {
+                            type: "array",
+                            description: "Resource commands to run (default: all). Options: cpu, memory, disk, gpu, network, loadavg, processes, connections, ports",
+                            items: {
+                                type: "string",
+                            },
+                        },
+                    },
+                    required: ["host"],
+                },
+            },
+        ],
+    };
+});
+// Helper to get SSH options
+function getSSHOpts(host, user = "root", port = 22) {
+    return {
+        host,
+        user,
+        port,
+        timeout: 30,
+        keyPath: `${process.env.HOME}/.ssh/id_ed25519`,
+    };
+}
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const hetzner = await getHetznerClient();
+        switch (name) {
+            // Server Management
+            case "list_servers": {
+                const servers = await hetzner.listServers();
+                // Filter by status if provided
+                const status = args?.status;
+                const filtered = status ? servers.filter((s) => s.status === status) : servers;
+                const lines = [
+                    `Hetzner Servers (${filtered.length} total)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const server of filtered) {
+                    const status = server.status;
+                    const name = server.name;
+                    const id = server.id;
+                    const ipv4 = server.public_net?.ipv4?.ip || "no IP";
+                    const location = server.datacenter?.location?.name || "unknown";
+                    lines.push(`${name} (${status})`);
+                    lines.push(`  ID: ${id}`);
+                    lines.push(`  IP: ${ipv4}`);
+                    lines.push(`  Location: ${location}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_server": {
+                const id = args.id;
+                const server = await hetzner.getServer(Number(id));
+                const lines = [
+                    `Server: ${server.name}`,
+                    "=".repeat(50),
+                    "",
+                    `ID: ${server.id}`,
+                    `Status: ${server.status}`,
+                    `Type: ${server.server_type?.name}`,
+                    `Image: ${server.image?.name} (${server.image?.description || ""})`,
+                    `Created: ${server.created}`,
+                    "",
+                    `Network:`,
+                    `  IPv4: ${server.public_net?.ipv4?.ip || "none"}`,
+                    `  IPv6: ${server.public_net?.ipv6?.ip || "none"}`,
+                    "",
+                    `Datacenter: ${server.datacenter?.description}`,
+                    `Location: ${server.datacenter?.location?.city}, ${server.datacenter?.location?.country}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_server_types": {
+                const types = await hetzner.pricing.listServerTypes();
+                const lines = [
+                    `Hetzner Server Types (${types.length} available)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const type of types.slice(0, 20)) {
+                    const cores = type.cores;
+                    const memory = type.memory;
+                    const disk = type.disk;
+                    const deprecated = type.deprecated ? " (deprecated)" : "";
+                    const price = type.prices?.[0]?.price_monthly?.gross || "N/A";
+                    lines.push(`${type.name}${deprecated}`);
+                    lines.push(`  Cores: ${cores}, Memory: ${memory}MB, Disk: ${disk}GB`);
+                    lines.push(`  Price: €${price}/month`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_datacenters": {
+                const dcs = await hetzner.pricing.listDatacenters();
+                const lines = [
+                    `Hetzner Datacenters (${dcs.length} total)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const dc of dcs) {
+                    lines.push(`${dc.description}`);
+                    lines.push(`  ID: ${dc.id}`);
+                    lines.push(`  Location: ${dc.location?.city}, ${dc.location?.country}`);
+                    lines.push(`  Supported Server Types: ${dc.supported_server_types?.length || 0}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_locations": {
+                const locations = await hetzner.pricing.listLocations();
+                const lines = [
+                    `Hetzner Locations (${locations.length} total)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const loc of locations) {
+                    lines.push(`${loc.name} (${loc.city}, ${loc.country})`);
+                    lines.push(`  ID: ${loc.id}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_ssh_keys": {
+                const keys = await hetzner.ssh_keys.list();
+                const lines = [
+                    `SSH Keys (${keys.length} total)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const key of keys) {
+                    lines.push(`${key.name}`);
+                    lines.push(`  ID: ${key.id}`);
+                    lines.push(`  Fingerprint: ${key.fingerprint}`);
+                    lines.push(`  Created: ${key.created}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "create_server": {
+                const params = args;
+                const data = await hetzner.createServer({
+                    name: params.name,
+                    server_type: params.server_type,
+                    image: params.image,
+                    location: params.location,
+                    ssh_keys: params.ssh_keys,
+                    user_data: params.user_data,
+                    start_after_create: params.start_after_create ?? true,
+                });
+                const server = data.server;
+                const nextActions = data.next_actions || [];
+                const lines = [
+                    `Server creation initiated`,
+                    "=".repeat(50),
+                    "",
+                    `ID: ${server.id}`,
+                    `Name: ${server.name}`,
+                    `Status: ${server.status}`,
+                    "",
+                    `Next Actions:`,
+                ];
+                for (const action of nextActions) {
+                    lines.push(`  - ${action.command} (progress: ${action.progress}%)`);
+                }
+                lines.push("");
+                lines.push(`Use 'get_actions ${server.id}' to track progress.`);
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "create_server_hardened": {
+                const params = args;
+                // Generate cloud-init with security hardening
+                const cloudInit = generateSeedBootstrap({
+                    enableSecurity: params.enable_security !== false,
+                });
+                const data = await hetzner.createServer({
+                    name: params.name,
+                    server_type: params.server_type,
+                    image: params.image,
+                    location: params.location,
+                    ssh_keys: params.ssh_keys,
+                    user_data: cloudInit,
+                    start_after_create: params.start_after_create ?? true,
+                });
+                const server = data.server;
+                const nextActions = data.next_actions || [];
+                const lines = [
+                    `🔒 Hardened server creation initiated`,
+                    "=".repeat(50),
+                    "",
+                    `ID: ${server.id}`,
+                    `Name: ${server.name}`,
+                    `Status: ${server.status}`,
+                    "",
+                    `Security Features:`,
+                    params.enable_security !== false ? `  ✓ SSH key-only authentication (no passwords)` : `  ✗ Security disabled`,
+                    params.enable_security !== false ? `  ✓ Fail2ban (3 failures → 1hr ban)` : ``,
+                    params.enable_security !== false ? `  ✓ UFW Firewall (default deny incoming)` : ``,
+                    params.enable_security !== false ? `  ✓ Kernel hardening` : ``,
+                    params.enable_security !== false ? `  ✓ SSH health monitoring` : ``,
+                    "",
+                    `Next Actions:`,
+                ];
+                for (const action of nextActions) {
+                    lines.push(`  - ${action.command} (progress: ${action.progress}%)`);
+                }
+                lines.push("");
+                lines.push(`Server will be secured at first boot via cloud-init.`);
+                lines.push(`Use 'get_actions ${server.id}' to track progress.`);
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "delete_server": {
+                const id = args.id;
+                await hetzner.deleteServer(Number(id));
+                return {
+                    content: [{ type: "text", text: `Server ${id} deletion initiated.` }],
+                };
+            }
+            case "power_on": {
+                const id = args.id;
+                const action = await hetzner.powerOn(Number(id));
+                return {
+                    content: [{ type: "text", text: `Power on initiated for ${id}\nAction ID: ${action.id}` }],
+                };
+            }
+            case "power_off": {
+                const id = args.id;
+                const action = await hetzner.powerOff(Number(id));
+                return {
+                    content: [{ type: "text", text: `Power off initiated for ${id}\nAction ID: ${action.id}` }],
+                };
+            }
+            case "reboot": {
+                const id = args.id;
+                const action = await hetzner.reboot(Number(id));
+                return {
+                    content: [{ type: "text", text: `Reboot initiated for ${id}\nAction ID: ${action.id}` }],
+                };
+            }
+            case "get_actions": {
+                const id = args.id;
+                const actions = await hetzner.actions.list({ server_id: Number(id) });
+                const lines = [
+                    `Actions for ${id} (${actions.length} recent)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const action of actions.slice(0, 10)) {
+                    const status = action.status;
+                    const command = action.command;
+                    const started = action.started;
+                    const finished = action.finished;
+                    lines.push(`${command} (${status})`);
+                    lines.push(`  ID: ${action.id}`);
+                    lines.push(`  Started: ${started}`);
+                    if (finished)
+                        lines.push(`  Finished: ${finished}`);
+                    if (action.error)
+                        lines.push(`  Error: ${action.error}`);
+                    lines.push(`  Progress: ${action.progress}%`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            // SSH Operations
+            case "ssh_exec": {
+                const { host, command, user = "root", port = 22 } = args;
+                const sshOpts = getSSHOpts(host, user, port);
+                const result = await execSSH(command, sshOpts);
+                return {
+                    content: [{ type: "text", text: result || "Command executed" }],
+                };
+            }
+            case "ssh_test": {
+                const { host, user = "root", port = 22 } = args;
+                const sshOpts = getSSHOpts(host, user, port);
+                const result = await testSSHConnection(sshOpts);
+                return {
+                    content: [{ type: "text", text: result ? "SSH connection successful" : "SSH connection failed" }],
+                };
+            }
+            case "ssh_exec_parallel": {
+                const { hosts, command, user = "root" } = args;
+                // Execute command on all hosts in parallel using Promise.all
+                const results = {};
+                await Promise.all(hosts.map(async (host) => {
+                    const sshOpts = getSSHOpts(host, user);
+                    try {
+                        results[host] = await execSSH(command, sshOpts);
+                    }
+                    catch (error) {
+                        results[host] = `Error: ${error.message}`;
+                    }
+                }));
+                const lines = ["Parallel SSH Execution Results", "=".repeat(50), ""];
+                for (const [host, output] of Object.entries(results)) {
+                    const status = output && !output.startsWith("Error:") ? "SUCCESS" : "FAILED";
+                    lines.push(`${host}: ${status}`);
+                    if (output)
+                        lines.push(`  ${output}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            // Tmux Operations
+            case "tmux_create_or_attach": {
+                const { host, sessionName, user = "root" } = args;
+                // Note: sessionName parameter is not currently supported by @ebowwa/terminal
+                // The function generates session name automatically from host and user
+                const result = await createOrAttachTmuxSession(host, user, undefined, {});
+                return {
+                    content: [{ type: "text", text: result.sessionName ? `Session: ${result.sessionName}\nSSH: ssh ${result.sshArgs.join(" ")}` : "Failed to create session" }],
+                };
+            }
+            case "tmux_list": {
+                const { host, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const sessions = await listTmuxSessions(sshOpts);
+                const lines = [`Tmux sessions on ${host}:`, ...sessions.map((s) => `  - ${s}`), ""];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "tmux_kill": {
+                const { host, sessionName, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const killed = await killTmuxSession(sessionName, sshOpts);
+                return {
+                    content: [{ type: "text", text: killed ? `Session '${sessionName}' killed` : `Failed to kill session '${sessionName}'` }],
+                };
+            }
+            case "tmux_send_command": {
+                const { host, sessionName, command, paneIndex = "0", user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const sent = await sendCommandToPane(sessionName, command, paneIndex, sshOpts);
+                return {
+                    content: [{ type: "text", text: sent ? "Command sent" : "Failed to send command" }],
+                };
+            }
+            case "tmux_capture": {
+                const { host, sessionName, paneIndex = "0", user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const output = await capturePane(sessionName, paneIndex, sshOpts);
+                return {
+                    content: [{ type: "text", text: output || "No output captured" }],
+                };
+            }
+            case "tmux_cleanup": {
+                const { host, ageLimit = 30, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const ageMs = ageLimit * 24 * 60 * 60 * 1000;
+                const result = await cleanupOldTmuxSessions(sshOpts, { sessionAgeLimit: ageMs });
+                const lines = [
+                    `Cleanup on ${host}:`,
+                    `  Cleaned: ${result.cleaned} sessions`,
+                    result.errors?.length ? `  Errors: ${result.errors.join(", ")}` : "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "tmux_list_windows": {
+                const { host, sessionName, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const windows = await listSessionWindows(sessionName, sshOpts);
+                const lines = [
+                    `Windows in session '${sessionName}' on ${host}:`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const win of windows) {
+                    lines.push(`Window ${win.index}: ${win.name}${win.active ? " (active)" : ""}`);
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "tmux_list_panes": {
+                const { host, sessionName, windowIndex = "0", user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const panes = await listWindowPanes(sessionName, windowIndex, sshOpts);
+                const lines = [
+                    `Panes in window ${windowIndex} of '${sessionName}' on ${host}:`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const pane of panes) {
+                    lines.push(`Pane ${pane.index}: PID ${pane.pid}${pane.active ? " (active)" : ""}`);
+                    lines.push(`  Path: ${pane.currentPath || "none"}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "tmux_split_pane": {
+                const { host, sessionName, windowIndex = "0", paneIndex = "0", direction = "h", user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                await splitPane(sessionName, direction, null, sshOpts);
+                return {
+                    content: [{ type: "text", text: `Split pane in window ${windowIndex} of session '${sessionName}' (${direction === "h" ? "horizontal" : "vertical"})` }],
+                };
+            }
+            case "tmux_kill_pane": {
+                const { host, sessionName, paneIndex, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                await killPane(sessionName, paneIndex, sshOpts);
+                return {
+                    content: [{ type: "text", text: `Killed pane ${paneIndex} in session '${sessionName}'` }],
+                };
+            }
+            case "tmux_switch_window": {
+                const { host, sessionName, windowIndex, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                await switchWindow(sessionName, windowIndex, sshOpts);
+                return {
+                    content: [{ type: "text", text: `Switched to window ${windowIndex} in session '${sessionName}'` }],
+                };
+            }
+            case "tmux_switch_pane": {
+                const { host, sessionName, paneIndex, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                await switchPane(sessionName, paneIndex, sshOpts);
+                return {
+                    content: [{ type: "text", text: `Switched to pane ${paneIndex} in session '${sessionName}'` }],
+                };
+            }
+            case "tmux_rename_window": {
+                const { host, sessionName, windowIndex = "0", newName, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                await renameWindow(sessionName, windowIndex, newName, sshOpts);
+                return {
+                    content: [{ type: "text", text: `Renamed window ${windowIndex} to '${newName}' in session '${sessionName}'` }],
+                };
+            }
+            // File Operations
+            case "scp_upload": {
+                const { host, source, destination, user = "root" } = args;
+                await scpUpload({ host, source, destination, user, timeout: 30 });
+                return {
+                    content: [{ type: "text", text: `Uploaded ${source} to ${host}:${destination}` }],
+                };
+            }
+            case "scp_download": {
+                const { host, source, destination, user = "root" } = args;
+                await scpDownload({ host, source, destination, user, timeout: 30 });
+                return {
+                    content: [{ type: "text", text: `Downloaded ${host}:${source} to ${destination}` }],
+                };
+            }
+            case "file_list": {
+                const { host, path = ".", user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const files = await listFiles(path === "." ? undefined : path, sshOpts);
+                const lines = [
+                    `Files in ${path || "."} on ${host}:`,
+                    "=".repeat(50),
+                    ...files.map(f => `${f.type}: ${f.path} (${f.size || 0} bytes)`),
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "file_preview": {
+                const { host, path, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const preview = await previewFile(path, sshOpts);
+                return {
+                    content: [{ type: "text", text: preview.content || preview.error || "Could not preview file" }],
+                };
+            }
+            // Security Verification Tools
+            case "check_bootstrap_status": {
+                const { host, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const status = await execSSH("cat /root/.bootstrap-status 2>/dev/null || echo 'No bootstrap status file'", sshOpts);
+                const lines = [
+                    `📋 Bootstrap Status for ${host}`,
+                    "=".repeat(50),
+                    "",
+                    status,
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "check_security_status": {
+                const { host, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const commands = [
+                    'echo "=== UFW Firewall ==="',
+                    'ufw status verbose',
+                    'echo ""',
+                    'echo "=== Fail2ban ==="',
+                    'systemctl status fail2ban --no-pager | head -3',
+                    'fail2ban-client status sshd 2>/dev/null | grep -E "(Status|banned|IP)"',
+                    'echo ""',
+                    'echo "=== SSH Hardening ==="',
+                    'sshd -T 2>/dev/null | grep -E "(PasswordAuth|PermitRootLogin|MaxStartups)"',
+                    'echo ""',
+                    'echo "=== Kernel Hardening ==="',
+                    'sysctl -n net.ipv4.conf.all.rp_filter net.ipv4.tcp_syncookies kernel.randomize_va_space 2>/dev/null',
+                ];
+                const results = await execSSH(commands.join(" && "), sshOpts);
+                const lines = [
+                    `🔒 Security Status for ${host}`,
+                    "=".repeat(50),
+                    "",
+                    results,
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_ssh_logs": {
+                const { host, lines = 20, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const logs = await execSSH(`journalctl -u ssh --no-pager -n ${lines} | grep -E "(Accepted|Failed|Postponed|session)"`, sshOpts);
+                const output = logs.trim() || "No recent SSH logs";
+                const text = [
+                    `📝 SSH Logs for ${host} (last ${lines} entries)`,
+                    "=".repeat(50),
+                    "",
+                    output,
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: text.join("\n") }],
+                };
+            }
+            case "check_fail2ban": {
+                const { host, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const results = await execSSH(`
+          echo "=== Fail2ban Status ==="
+          systemctl is-active fail2ban
+          echo ""
+          echo "=== SSH Jail Status ==="
+          fail2ban-client status sshd
+          echo ""
+          echo "=== Failed Logins (last hour) ==="
+          journalctl -u ssh --since "1 hour ago" --no-pager | grep -c "Failed" || echo "0"
+        `, sshOpts);
+                const text = [
+                    `🚫 Fail2ban Status for ${host}`,
+                    "=".repeat(50),
+                    "",
+                    results,
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: text.join("\n") }],
+                };
+            }
+            case "check_server_health": {
+                const { host, user = "root" } = args;
+                const sshOpts = getSSHOpts(host, user);
+                const health = await execSSH("cat /var/log/sshd-health.json 2>/dev/null || echo 'No health data yet'", sshOpts);
+                const lines = [
+                    `💓 Server Health for ${host}`,
+                    "=".repeat(50),
+                    "",
+                    health,
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            // Volume Management
+            case "list_volumes": {
+                const volumes = await hetzner.volumes.list({
+                    name: args?.name,
+                    status: args?.status,
+                });
+                const lines = [
+                    `💾 Hetzner Volumes (${volumes.length} total)`,
+                    "=".repeat(50),
+                    "",
+                ];
+                for (const volume of volumes) {
+                    const status = volume.status;
+                    const name = volume.name;
+                    const id = volume.id;
+                    const size = volume.size;
+                    const server = volume.server || "not attached";
+                    const location = volume.location?.name || "unknown";
+                    lines.push(`${name} (${status})`);
+                    lines.push(`  ID: ${id}`);
+                    lines.push(`  Size: ${size} GB`);
+                    lines.push(`  Server: ${server}`);
+                    lines.push(`  Location: ${location}`);
+                    lines.push("");
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_volume": {
+                const id = parseInt(args.id);
+                const volume = await hetzner.volumes.get(id);
+                const lines = [
+                    `💾 Volume: ${volume.name}`,
+                    "=".repeat(50),
+                    "",
+                    `ID: ${volume.id}`,
+                    `Status: ${volume.status}`,
+                    `Size: ${volume.size} GB`,
+                    `Location: ${volume.location?.name || "unknown"}`,
+                    `Server: ${volume.server || "not attached"}`,
+                    `Format: ${volume.format || "not formatted"}`,
+                    `Automount: ${volume.automount ? "yes" : "no"}`,
+                    `Protection: ${volume.protection?.delete ? "enabled" : "disabled"}`,
+                    `Labels: ${JSON.stringify(volume.labels || {})}`,
+                    "",
+                    `Created: ${volume.created}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "create_volume": {
+                const { name, size, server, location, automount, format } = args;
+                const result = await hetzner.volumes.create({
+                    name,
+                    size,
+                    server: server ? parseInt(server) : undefined,
+                    location,
+                    automount: automount ?? true,
+                    format,
+                });
+                const lines = [
+                    "✅ Volume created successfully",
+                    "=".repeat(50),
+                    "",
+                    `Name: ${result.volume.name}`,
+                    `ID: ${result.volume.id}`,
+                    `Size: ${result.volume.size} GB`,
+                    `Status: ${result.volume.status}`,
+                    "",
+                    "Action:",
+                    `  ID: ${result.action.id}`,
+                    `  Status: ${result.action.status}`,
+                    `  Command: ${result.action.command}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "delete_volume": {
+                const id = parseInt(args.id);
+                const action = await hetzner.volumes.delete(id);
+                const lines = [
+                    "🗑️ Volume deletion initiated",
+                    "=".repeat(50),
+                    "",
+                    `Action ID: ${action.id}`,
+                    `Status: ${action.status}`,
+                    `Resource: ${action.resources?.[0]?.id || "unknown"}`,
+                    `Resource Type: ${action.resources?.[0]?.type || "unknown"}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "attach_volume": {
+                const { volumeId, serverId, automount } = args;
+                const action = await hetzner.volumes.attach(parseInt(volumeId), parseInt(serverId), automount ?? true);
+                const lines = [
+                    "🔌 Volume attachment initiated",
+                    "=".repeat(50),
+                    "",
+                    `Action ID: ${action.id}`,
+                    `Status: ${action.status}`,
+                    `Volume ID: ${action.resources?.[0]?.id || volumeId}`,
+                    `Server ID: ${action.resources?.[1]?.id || serverId}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "detach_volume": {
+                const volumeId = parseInt(args.volumeId);
+                const action = await hetzner.volumes.detach(volumeId);
+                const lines = [
+                    "🔌 Volume detachment initiated",
+                    "=".repeat(50),
+                    "",
+                    `Action ID: ${action.id}`,
+                    `Status: ${action.status}`,
+                    `Volume ID: ${action.resources?.[0]?.id || volumeId.toString()}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "resize_volume": {
+                const { volumeId, size } = args;
+                const action = await hetzner.volumes.resize(parseInt(volumeId), size);
+                const lines = [
+                    "📏 Volume resize initiated",
+                    "=".repeat(50),
+                    "",
+                    `Action ID: ${action.id}`,
+                    `Status: ${action.status}`,
+                    `Volume ID: ${action.resources?.[0]?.id || volumeId}`,
+                    `New Size: ${size} GB`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "calculate_volume_price": {
+                const size = args.size;
+                const price = VolumeOperations.calculatePrice(size);
+                const lines = [
+                    `💰 Volume Pricing (${size} GB)`,
+                    "=".repeat(50),
+                    "",
+                    `Monthly: €${price.monthly}/month`,
+                    `Hourly: €${price.hourly}/hour`,
+                    `Currency: ${price.currency}`,
+                    "",
+                    `Price per GB: €0.008/month`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            // Resource Monitoring
+            case "get_resources": {
+                const { host, user = "root", keyPath, password, commands } = args;
+                // Default to all commands if none specified
+                const allCommands = Object.keys(RESOURCE_COMMANDS);
+                const commandsToRun = commands || allCommands;
+                // Build command object with only requested commands
+                const selectedCommands = {};
+                for (const cmd of commandsToRun) {
+                    if (cmd in RESOURCE_COMMANDS) {
+                        selectedCommands[cmd] = RESOURCE_COMMANDS[cmd];
+                    }
+                }
+                const sshOpts = {
+                    host,
+                    user,
+                    timeout: 10,
+                    ...(keyPath && { keyPath }),
+                    ...(password && { password }),
+                };
+                // Execute commands in parallel using Promise.all
+                const rawResults = {};
+                await Promise.all(Object.entries(selectedCommands).map(async ([name, command]) => {
+                    try {
+                        rawResults[name] = await execSSH(command, sshOpts);
+                    }
+                    catch {
+                        rawResults[name] = "";
+                    }
+                }));
+                const resources = parseResources(rawResults);
+                const lines = [
+                    `📊 Resources for ${host}`,
+                    "=".repeat(50),
+                    "",
+                    `CPU: ${resources.cpuPercent}%`,
+                    `Memory: ${resources.memoryPercent}% (${resources.memoryUsed} / ${resources.memoryTotal})`,
+                    `Disk: ${resources.diskPercent}% (${resources.diskUsed} / ${resources.diskTotal})`,
+                    ...(resources.gpuPercent !== undefined ? [`GPU: ${resources.gpuPercent}% (${resources.gpuMemoryUsed} / ${resources.gpuMemoryTotal})`] : []),
+                    ...(resources.loadavg ? [`Load: ${resources.loadavg}`] : []),
+                    ...(resources.processes ? [`Processes: ${resources.processes}`] : []),
+                    ...(resources.connections ? [`Connections: ${resources.connections}`] : []),
+                    ...(resources.ports ? [`Ports: ${resources.ports}`] : []),
+                    "",
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown tool: ${name}`,
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const token = process.env.HETZNER_API_TOKEN || await getTokenFromCLI();
+    if (token) {
+        hetznerClient = new HetznerClient(token);
+        console.error("[@mcp/hetzner] Authenticated via", process.env.HETZNER_API_TOKEN ? "HETZNER_API_TOKEN" : "Hetzner CLI config");
+    }
+    else {
+        console.warn("[@mcp/hetzner] HETZNER_API_TOKEN not configured - MCP will run in limited mode");
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[@mcp/hetzner] Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map