@mgsoftwarebv/mg-dashboard-mcp 3.1.1 → 3.3.0

package/dist/index.js

@@ -1,13 +1,216 @@
 #!/usr/bin/env node
+import { spawn } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { Client as Client$1 } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { createServer } from 'http';
-import { randomUUID, createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import { randomUUID, randomBytes, createHash, createCipheriv, createDecipheriv } from 'crypto';
 import { createClient } from '@supabase/supabase-js';
+import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
 import { Client } from 'ssh2';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/proxy-mode.ts
+var proxy_mode_exports = {};
+__export(proxy_mode_exports, {
+  runProxyMode: () => runProxyMode
+});
+function getArg(args2, name) {
+  return args2.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
+}
+function expandHome(path) {
+  if (!path.startsWith("~")) return path;
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return join(home, path.slice(1));
+}
+function resolvePubkeyPath(input) {
+  const candidate = expandHome(input);
+  let pubPath;
+  if (candidate.endsWith(".pub")) {
+    pubPath = candidate;
+  } else if (existsSync(`${candidate}.pub`)) {
+    pubPath = `${candidate}.pub`;
+  } else if (existsSync(candidate)) {
+    pubPath = candidate;
+  } else {
+    throw new Error(`SSH key file not found: ${candidate} (also tried ${candidate}.pub)`);
+  }
+  const pubText = readFileSync(pubPath, "utf8").trim();
+  if (!pubText) throw new Error(`SSH public-key file is empty: ${pubPath}`);
+  return { pubPath, pubText };
+}
+function runProcess(command, argv, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, argv, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      resolve({ stdout, stderr: stderr + String(err), code: -1 });
+    });
+    child.on("close", (code) => {
+      resolve({ stdout, stderr, code: code ?? -1 });
+    });
+    if (options.stdin !== void 0) {
+      child.stdin.write(options.stdin);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+function deriveAuthBaseUrl(proxyUrl2) {
+  const u = new URL(proxyUrl2);
+  return `${u.protocol}//${u.host}`;
+}
+async function performHandshake(proxyUrl2, pubPath, pubText) {
+  const base = deriveAuthBaseUrl(proxyUrl2);
+  const challengeRes = await fetch(`${base}/v1/auth/ssh/challenge`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: "{}"
+  });
+  if (!challengeRes.ok) {
+    const txt = await challengeRes.text().catch(() => "");
+    throw new Error(`Challenge request failed (${challengeRes.status}): ${txt}`);
+  }
+  const challenge = await challengeRes.json();
+  const sign = await runProcess(
+    "ssh-keygen",
+    ["-Y", "sign", "-f", pubPath, "-n", challenge.namespace, "-q"],
+    { stdin: challenge.nonce }
+  );
+  if (sign.code !== 0 || !sign.stdout.includes("BEGIN SSH SIGNATURE")) {
+    throw new Error(
+      `ssh-keygen sign failed (exit ${sign.code}). Make sure ssh-agent is running and has the matching private key loaded. stderr: ${sign.stderr.trim() || "(empty)"}`
+    );
+  }
+  const verifyRes = await fetch(`${base}/v1/auth/ssh/verify`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      challenge_id: challenge.challenge_id,
+      pubkey: pubText,
+      signature: sign.stdout
+    })
+  });
+  if (!verifyRes.ok) {
+    const txt = await verifyRes.text().catch(() => "");
+    throw new Error(`Verify request failed (${verifyRes.status}): ${txt}`);
+  }
+  const verified = await verifyRes.json();
+  return {
+    token: verified.token,
+    expiresAt: Date.now() + verified.expires_in_seconds * 1e3,
+    proxyKeyName: verified.proxy_key_name
+  };
+}
+async function runBridge(handshake, proxyUrl2, refresh) {
+  let currentToken = handshake.token;
+  const upstreamTransport = new StreamableHTTPClientTransport(new URL(proxyUrl2), {
+    requestInit: () => ({
+      headers: { Authorization: `Bearer ${currentToken}` }
+    })
+  });
+  const upstream = new Client$1({ name: "mg-dashboard-mcp-proxy-bridge", version: "1.0.0" });
+  const scheduleRefresh = (result) => {
+    const msUntilRefresh = Math.max(3e4, result.expiresAt - Date.now() - 12e4);
+    setTimeout(async () => {
+      try {
+        const fresh = await refresh();
+        currentToken = fresh.token;
+        console.error(`[Proxy] Token refreshed (key: ${fresh.proxyKeyName})`);
+        scheduleRefresh(fresh);
+      } catch (err) {
+        console.error(`[Proxy] Token refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+        setTimeout(() => scheduleRefresh({ ...result, expiresAt: Date.now() + 6e4 }), 3e4);
+      }
+    }, msUntilRefresh).unref();
+  };
+  scheduleRefresh(handshake);
+  const stdioServer = new Server(
+    { name: "mg-dashboard-mcp-proxy", version: "1.0.0" },
+    { capabilities: { tools: {}, prompts: {}, resources: {}, logging: {} } }
+  );
+  stdioServer.fallbackRequestHandler = async (request) => {
+    return await upstream.request(
+      request,
+      // We don't care about the schema check on the way through — let the
+      // upstream's actual response flow back unmodified.
+      void 0
+    );
+  };
+  stdioServer.fallbackNotificationHandler = async (notification) => {
+    await upstream.notification(notification);
+  };
+  await upstream.connect(upstreamTransport);
+  upstream.fallbackNotificationHandler = async (notification) => {
+    await stdioServer.notification(notification);
+  };
+  await stdioServer.connect(new StdioServerTransport());
+  console.error(`[Proxy] Bridge ready. Forwarding stdio \u2192 ${proxyUrl2}`);
+}
+async function runProxyMode(args2) {
+  const proxyUrl2 = getArg(args2, "proxy-url") || process.env.MG_DASHBOARD_PROXY_URL;
+  const sshKey = getArg(args2, "ssh-key") || process.env.MG_DASHBOARD_SSH_KEY;
+  if (!proxyUrl2) {
+    console.error("--proxy-url is required (or set MG_DASHBOARD_PROXY_URL)");
+    process.exit(1);
+  }
+  if (!sshKey) {
+    console.error("--ssh-key is required in proxy mode (or set MG_DASHBOARD_SSH_KEY)");
+    process.exit(1);
+  }
+  console.error(`[Proxy] Starting in proxy-bridge mode \u2192 ${proxyUrl2}`);
+  let resolved;
+  try {
+    resolved = resolvePubkeyPath(sshKey);
+  } catch (err) {
+    console.error(`[Proxy] ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const refresh = () => performHandshake(proxyUrl2, resolved.pubPath, resolved.pubText);
+  let handshake;
+  try {
+    handshake = await refresh();
+  } catch (err) {
+    console.error(`[Proxy] Handshake failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  console.error(`[Proxy] Authenticated as "${handshake.proxyKeyName}"`);
+  console.error(`[Proxy] Token valid for ${Math.floor((handshake.expiresAt - Date.now()) / 6e4)} min`);
+  try {
+    await runBridge(handshake, proxyUrl2, refresh);
+  } catch (err) {
+    console.error(`[Proxy] Bridge crashed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+var init_proxy_mode = __esm({
+  "src/proxy-mode.ts"() {
+  }
+});
+
 // src/trigger-tools.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "COMPLETED",
@@ -953,18 +1156,25 @@ LinkedIn: ${pageLinkedIn.join(", ")}`;
 
 // src/index.ts
 var args = process.argv.slice(2);
-function getArg(name) {
+function getArg2(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
 }
-var apiKey = getArg("api-key") || process.env.MG_DASHBOARD_API_KEY;
-var supabaseUrl = getArg("supabase-url") || process.env.SUPABASE_URL;
-var supabaseKey = getArg("supabase-key") || process.env.SUPABASE_SERVICE_ROLE_KEY;
-var encryptionKey = getArg("encryption-key") || process.env.ENCRYPTION_KEY;
-var mijnhostApiKey = getArg("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
+var proxyUrl = getArg2("proxy-url") || process.env.MG_DASHBOARD_PROXY_URL;
+if (proxyUrl) {
+  const { runProxyMode: runProxyMode2 } = await Promise.resolve().then(() => (init_proxy_mode(), proxy_mode_exports));
+  await runProxyMode2(args);
+  process.exit(0);
+}
+var apiKey = getArg2("api-key") || process.env.MG_DASHBOARD_API_KEY;
+var sshKeyPath = getArg2("ssh-key") || process.env.MG_DASHBOARD_SSH_KEY;
+var supabaseUrl = getArg2("supabase-url") || process.env.SUPABASE_URL;
+var supabaseKey = getArg2("supabase-key") || process.env.SUPABASE_SERVICE_ROLE_KEY;
+var encryptionKey = getArg2("encryption-key") || process.env.ENCRYPTION_KEY;
+var mijnhostApiKey = getArg2("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
 var httpMode = args.includes("--http");
-var httpPort = Number(getArg("port")) || 3100;
-if (!apiKey) {
-  console.error("API key is required. Use --api-key=dk_xxx or set MG_DASHBOARD_API_KEY");
+var httpPort = Number(getArg2("port")) || 3100;
+if (!apiKey && !sshKeyPath) {
+  console.error("Authentication required. Use --api-key=dk_xxx, --ssh-key=PATH (path to your SSH private or public key), or set MG_DASHBOARD_API_KEY / MG_DASHBOARD_SSH_KEY.");
   process.exit(1);
 }
 if (!supabaseUrl || !supabaseKey) {
@@ -1016,39 +1226,7 @@ var RateLimiter = class {
 var authRateLimiter = new RateLimiter(5, 15 * 60 * 1e3);
 setInterval(() => {
   authRateLimiter.cleanup();
-  toolRateLimiter.cleanup();
 }, 5 * 60 * 1e3).unref();
-var TOOL_RATE_CATEGORIES = {
-  "ssh-execute": "ssh",
-  "sftp-write": "sftp_write",
-  "sftp-delete": "sftp_write",
-  "sftp-list": "sftp_read",
-  "sftp-read": "sftp_read",
-  "db-query": "db",
-  "db-discover": "db",
-  "db-tables": "db",
-  "db-describe": "db"
-};
-var TOOL_RATE_LIMITS = {
-  ssh: { max: 120, windowMs: 60 * 60 * 1e3 },
-  sftp_write: { max: 60, windowMs: 60 * 60 * 1e3 },
-  sftp_read: { max: 200, windowMs: 60 * 60 * 1e3 },
-  db: { max: 200, windowMs: 60 * 60 * 1e3 },
-  default: { max: 300, windowMs: 60 * 60 * 1e3 }
-};
-var toolRateLimiter = new RateLimiter(300, 60 * 60 * 1e3);
-var toolRateBuckets = /* @__PURE__ */ new Map();
-function checkToolRateLimit(toolName) {
-  const category = TOOL_RATE_CATEGORIES[toolName] || "default";
-  const limits = TOOL_RATE_LIMITS[category] ?? TOOL_RATE_LIMITS.default;
-  let limiter = toolRateBuckets.get(category);
-  if (!limiter) {
-    limiter = new RateLimiter(limits.max, limits.windowMs);
-    toolRateBuckets.set(category, limiter);
-  }
-  const result = limiter.check(authContext?.apiKeyId || "unknown");
-  return { allowed: result.allowed, category, retryAfterMs: result.retryAfterMs };
-}
 var SENSITIVE_KEYS = /* @__PURE__ */ new Set(["password", "private_key", "passphrase", "secret", "token", "key", "api_key", "credentials"]);
 function redactSensitiveArgs(args2) {
   const redacted = {};
@@ -1081,161 +1259,6 @@ async function writeAuditLog(entry) {
     console.error("[Audit] Failed to write audit log:", err instanceof Error ? err.message : err);
   }
 }
-var TELEGRAM_API = "https://api.telegram.org/bot";
-var cachedTelegramConfig = null;
-async function getTelegramBotConfig() {
-  if (cachedTelegramConfig) return cachedTelegramConfig;
-  const { data, error } = await supabase.from("telegram_bot_config").select("bot_token_encrypted, chat_id, notifications_enabled").limit(1).maybeSingle();
-  if (error) {
-    console.error("[Telegram Config] Query error:", error.message);
-    return null;
-  }
-  if (!data?.bot_token_encrypted || !data?.chat_id) {
-    console.error("[Telegram Config] Missing bot_token or chat_id in telegram_bot_config table");
-    return null;
-  }
-  if (!data.notifications_enabled) {
-    console.error("[Telegram Config] Notifications disabled in telegram_bot_config");
-    return null;
-  }
-  try {
-    const token = decrypt(data.bot_token_encrypted);
-    cachedTelegramConfig = { botToken: token, chatId: data.chat_id };
-    console.error("[Telegram Config] Loaded successfully");
-    return cachedTelegramConfig;
-  } catch (err) {
-    console.error("[Telegram Config] Failed to decrypt bot token:", err instanceof Error ? err.message : err);
-    return null;
-  }
-}
-function escapeHtmlTg(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-async function sendTelegramMessage(token, chatId, text, replyMarkup) {
-  try {
-    const body = { chat_id: chatId, text, parse_mode: "HTML" };
-    if (replyMarkup) body.reply_markup = replyMarkup;
-    const res = await fetch(`${TELEGRAM_API}${token}/sendMessage`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    const result = await res.json();
-    return { ok: result.ok, messageId: result.result?.message_id };
-  } catch {
-    return { ok: false };
-  }
-}
-async function sendTelegramAlert(text) {
-  const config = await getTelegramBotConfig();
-  if (!config) return;
-  await sendTelegramMessage(config.botToken, config.chatId, text);
-}
-async function checkIpAllowlist(ipAddress) {
-  if (!authContext || !authContext.requireIpApproval) {
-    console.error(`[IP Check] Skipped (requireIpApproval=${authContext?.requireIpApproval})`);
-    return { allowed: true };
-  }
-  console.error(`[IP Check] Checking IP ${ipAddress} for key ${authContext.apiKeyId}`);
-  const { data: existing, error: lookupErr } = await supabase.from("mcp_ip_allowlist").select("id").eq("api_key_id", authContext.apiKeyId).eq("ip_address", ipAddress).maybeSingle();
-  if (lookupErr) {
-    console.error(`[IP Check] Allowlist lookup error: ${lookupErr.message}`);
-  }
-  if (existing) {
-    console.error(`[IP Check] IP ${ipAddress} found in allowlist`);
-    return { allowed: true };
-  }
-  console.error(`[IP Check] IP ${ipAddress} NOT in allowlist, requesting Telegram approval...`);
-  const tgConfig = await getTelegramBotConfig();
-  if (!tgConfig) {
-    console.error("[IP Check] BLOCKING: Unknown IP and no Telegram configured");
-    return { allowed: false, reason: "Unknown IP and no approval channel configured" };
-  }
-  let geoInfo = null;
-  try {
-    const geoRes = await fetch(`http://ip-api.com/json/${ipAddress}?fields=country,city,isp`);
-    if (geoRes.ok) geoInfo = await geoRes.json();
-  } catch {
-  }
-  const geoLabel = geoInfo ? `${geoInfo.city || "?"}, ${geoInfo.country || "?"} (${geoInfo.isp || "?"})` : "Onbekend";
-  const { data: request, error: insertErr } = await supabase.from("mcp_ip_approval_request").insert({
-    api_key_id: authContext.apiKeyId,
-    ip_address: ipAddress,
-    status: "pending",
-    geo_info: geoInfo
-  }).select("id").single();
-  if (insertErr || !request) {
-    console.error(`[IP Check] Failed to create approval request: ${insertErr?.message || "no data returned"}`);
-    return { allowed: false, reason: `Failed to create approval request: ${insertErr?.message || "unknown"}` };
-  }
-  console.error(`[IP Check] Created approval request ${request.id}`);
-  const message = [
-    `<b>MCP IP Approval</b>`,
-    ``,
-    `<b>IP:</b> <code>${escapeHtmlTg(ipAddress)}</code>`,
-    `<b>Locatie:</b> ${escapeHtmlTg(geoLabel)}`,
-    `<b>API Key:</b> ${escapeHtmlTg(authContext.apiKeyName)}`,
-    `<b>User:</b> ${escapeHtmlTg(authContext.userId)}`,
-    ``,
-    `<i>Onbekend IP probeert verbinding te maken met de MCP server.</i>`
-  ].join("\n");
-  const tgResult = await sendTelegramMessage(tgConfig.botToken, tgConfig.chatId, message, {
-    inline_keyboard: [
-      [
-        { text: "Goedkeuren", callback_data: `mcp_ip_approve:${request.id}` },
-        { text: "Weigeren", callback_data: `mcp_ip_deny:${request.id}` }
-      ]
-    ]
-  });
-  if (tgResult.messageId) {
-    await supabase.from("mcp_ip_approval_request").update({ telegram_message_id: tgResult.messageId }).eq("id", request.id);
-  }
-  console.error(`[IP Check] Waiting for Telegram approval for IP ${ipAddress}...`);
-  const deadline = Date.now() + 6e4;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 2e3));
-    const { data: check } = await supabase.from("mcp_ip_approval_request").select("status").eq("id", request.id).single();
-    if (check?.status === "approved") {
-      await supabase.from("mcp_ip_allowlist").insert({
-        api_key_id: authContext.apiKeyId,
-        ip_address: ipAddress,
-        label: geoLabel,
-        approved_by: "telegram"
-      });
-      console.error(`[IP Check] IP ${ipAddress} approved via Telegram`);
-      return { allowed: true };
-    }
-    if (check?.status === "denied") {
-      console.error(`[IP Check] IP ${ipAddress} denied via Telegram`);
-      return { allowed: false, reason: "IP denied via Telegram" };
-    }
-  }
-  await supabase.from("mcp_ip_approval_request").update({ status: "denied", resolved_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", request.id);
-  console.error(`[IP Check] IP ${ipAddress} approval timed out`);
-  return { allowed: false, reason: "Approval request timed out (60s)" };
-}
-var SESSION_TTL_MS = 8 * 60 * 60 * 1e3;
-var SESSION_MAX_ABSOLUTE_MS = 24 * 60 * 60 * 1e3;
-async function getOrCreateSession(ipAddress) {
-  if (!authContext) return { valid: false, reason: "Not authenticated" };
-  const now = /* @__PURE__ */ new Date();
-  const { data: existing } = await supabase.from("mcp_session").select("id, created_at, expires_at").eq("api_key_id", authContext.apiKeyId).eq("ip_address", ipAddress).gt("expires_at", now.toISOString()).order("created_at", { ascending: false }).limit(1).maybeSingle();
-  if (existing) {
-    const createdAt = new Date(existing.created_at).getTime();
-    if (now.getTime() - createdAt > SESSION_MAX_ABSOLUTE_MS) {
-      await supabase.from("mcp_session").delete().eq("id", existing.id);
-      return { valid: false, reason: "Session exceeded absolute TTL (24h)" };
-    }
-    await supabase.from("mcp_session").update({ last_activity_at: now.toISOString() }).eq("id", existing.id);
-    return { valid: true, sessionId: existing.id };
-  }
-  const { data: newSession } = await supabase.from("mcp_session").insert({
-    api_key_id: authContext.apiKeyId,
-    ip_address: ipAddress,
-    expires_at: new Date(now.getTime() + SESSION_TTL_MS).toISOString()
-  }).select("id").single();
-  return { valid: true, sessionId: newSession?.id };
-}
 var MODULE_KEYS = [
   "users",
   "ssh_servers",
@@ -1321,7 +1344,7 @@ async function validateApiKey(key) {
     console.error(`Rate limited: too many failed auth attempts. Retry in ${retryMin} minute(s).`);
     return null;
   }
-  const { data, error } = await supabase.from("dashboard_mcp_api_key").select("id, name, created_by, allowed_server_ids, is_active, expires_at, require_ip_approval").eq("api_key_hash", keyHash).eq("is_active", true).single();
+  const { data, error } = await supabase.from("dashboard_mcp_api_key").select("id, name, created_by, allowed_server_ids, is_active, expires_at").eq("api_key_hash", keyHash).eq("is_active", true).single();
   if (error || !data) {
     console.error(`API key not found or inactive (${rateCheck.remaining} attempts remaining)`);
     return null;
@@ -1352,8 +1375,182 @@ async function validateApiKey(key) {
     userId: data.created_by,
     allowedServerIds,
     permissions,
-    roleName,
-    requireIpApproval: data.require_ip_approval ?? true
+    roleName
+  };
+}
+function runProcess2(command, argv, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, argv, { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      resolve({ stdout, stderr: stderr + String(err), code: -1 });
+    });
+    child.on("close", (code) => {
+      resolve({ stdout, stderr, code: code ?? -1 });
+    });
+    if (options.stdin !== void 0) {
+      child.stdin.write(options.stdin);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+async function resolvePubkeyFile(input) {
+  const expand = (p) => p.startsWith("~") ? join(process.env.HOME || process.env.USERPROFILE || "", p.slice(1)) : p;
+  const candidate = expand(input);
+  let pubPath;
+  if (candidate.endsWith(".pub")) {
+    pubPath = candidate;
+  } else if (existsSync(`${candidate}.pub`)) {
+    pubPath = `${candidate}.pub`;
+  } else if (existsSync(candidate)) {
+    pubPath = candidate;
+  } else {
+    throw new Error(`SSH key file not found: ${candidate} (also tried ${candidate}.pub)`);
+  }
+  const pubText = (await readFile(pubPath, "utf8")).trim();
+  if (!pubText) {
+    throw new Error(`SSH public-key file is empty: ${pubPath}`);
+  }
+  return { pubPath, pubText };
+}
+function computeOpenSshFingerprint(pubkeyLine) {
+  const parts = pubkeyLine.trim().split(/\s+/);
+  if (parts.length < 2 || !parts[1]) {
+    throw new Error('Invalid SSH public-key line (expected "<type> <base64> [comment]")');
+  }
+  const bodyBytes = Buffer.from(parts[1], "base64");
+  const hash = createHash("sha256").update(bodyBytes).digest("base64").replace(/=+$/, "");
+  return `SHA256:${hash}`;
+}
+async function sshKeygenSign(pubkeyPath, challenge, namespace) {
+  const result = await runProcess2(
+    "ssh-keygen",
+    ["-Y", "sign", "-f", pubkeyPath, "-n", namespace, "-q"],
+    { stdin: challenge }
+  );
+  if (result.code !== 0) {
+    throw new Error(
+      `ssh-keygen sign failed (exit ${result.code}). Make sure ssh-agent is running and has the matching private key loaded (or that the private key is at the path next to the .pub file). stderr: ${result.stderr.trim() || "(empty)"}`
+    );
+  }
+  if (!result.stdout.includes("BEGIN SSH SIGNATURE")) {
+    throw new Error(`ssh-keygen sign produced no signature (stderr: ${result.stderr.trim() || "(empty)"})`);
+  }
+  return result.stdout;
+}
+async function sshKeygenVerify(pubkeyLine, signature, challenge, namespace) {
+  const dir = await mkdtemp(join(tmpdir(), "mcp-ssh-verify-"));
+  try {
+    const allowedSigners = `mcp@local ${pubkeyLine.trim()}
+`;
+    const allowedPath = join(dir, "allowed_signers");
+    const sigPath = join(dir, "sig");
+    await writeFile(allowedPath, allowedSigners, "utf8");
+    await writeFile(sigPath, signature, "utf8");
+    const result = await runProcess2(
+      "ssh-keygen",
+      ["-Y", "verify", "-f", allowedPath, "-I", "mcp@local", "-n", namespace, "-s", sigPath, "-q"],
+      { stdin: challenge }
+    );
+    return result.code === 0;
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function validateSshKey(pubkeyPathInput) {
+  let pubPath;
+  let pubText;
+  try {
+    const resolved = await resolvePubkeyFile(pubkeyPathInput);
+    pubPath = resolved.pubPath;
+    pubText = resolved.pubText;
+  } catch (err) {
+    console.error(`SSH key error: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  let fingerprint;
+  try {
+    fingerprint = computeOpenSshFingerprint(pubText);
+  } catch (err) {
+    console.error(`SSH key error: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  const rateCheck = authRateLimiter.check(fingerprint);
+  if (!rateCheck.allowed) {
+    const retryMin = Math.ceil(rateCheck.retryAfterMs / 6e4);
+    console.error(`Rate limited: too many failed SSH-key auth attempts. Retry in ${retryMin} minute(s).`);
+    return null;
+  }
+  const skipVerify = process.env.MG_DASHBOARD_SSH_SKIP_VERIFY === "1";
+  if (!skipVerify) {
+    try {
+      const challenge = randomBytes(32).toString("hex");
+      const signature = await sshKeygenSign(pubPath, challenge, "mg-dashboard-mcp");
+      const verified = await sshKeygenVerify(pubText, signature, challenge, "mg-dashboard-mcp");
+      if (!verified) {
+        console.error("SSH-key challenge verification failed (signature did not validate against the public key).");
+        return null;
+      }
+    } catch (err) {
+      console.error(`SSH-key challenge failed: ${err instanceof Error ? err.message : String(err)}`);
+      console.error("Tip: set MG_DASHBOARD_SSH_SKIP_VERIFY=1 to skip the challenge if you only need to print the fingerprint for enrollment.");
+      return null;
+    }
+  }
+  const { data: keyRow, error: keyErr } = await supabase.from("dashboard_mcp_ssh_key").select("id, name, api_key_id, is_active").eq("fingerprint_sha256", fingerprint).eq("is_active", true).maybeSingle();
+  if (keyErr || !keyRow) {
+    console.error(
+      `SSH key not registered (fingerprint ${fingerprint}; ${rateCheck.remaining} attempts remaining). Add it under MCP API Keys \u2192 SSH Keys in the dashboard.`
+    );
+    return null;
+  }
+  const { data: apiRow, error: apiErr } = await supabase.from("dashboard_mcp_api_key").select("id, name, created_by, allowed_server_ids, is_active, expires_at").eq("id", keyRow.api_key_id).eq("is_active", true).maybeSingle();
+  if (apiErr || !apiRow) {
+    console.error("SSH key is linked to an inactive or missing MCP API key entry.");
+    return null;
+  }
+  if (apiRow.expires_at && new Date(apiRow.expires_at) < /* @__PURE__ */ new Date()) {
+    console.error("Linked MCP API key entry has expired.");
+    return null;
+  }
+  const { data: userData, error: userError } = await supabase.from("user").select("permissions, role:role!role_id(name, default_permissions)").eq("id", apiRow.created_by).single();
+  if (userError || !userData) {
+    console.error(`User not found for SSH key creator: ${apiRow.created_by}`);
+    return null;
+  }
+  const roleName = userData.role?.name || "user";
+  const roleDefaults = userData.role?.default_permissions ?? {};
+  const userOverrides = userData.permissions ?? null;
+  const permissions = resolvePermissions(roleName, roleDefaults, userOverrides);
+  const allowedServerIds = intersectServerAccess(
+    apiRow.allowed_server_ids,
+    permissions.resources.ssh_servers
+  );
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  await Promise.all([
+    supabase.from("dashboard_mcp_ssh_key").update({ last_used_at: nowIso }).eq("id", keyRow.id),
+    supabase.from("dashboard_mcp_api_key").update({ last_used_at: nowIso }).eq("id", apiRow.id)
+  ]);
+  const moduleCount = MODULE_KEYS.filter((k) => permissions.modules[k]).length;
+  console.error(
+    `Authenticated via SSH key "${keyRow.name}" (fp ${fingerprint.slice(0, 24)}...) as user ${apiRow.created_by} (role: ${roleName}, modules: ${moduleCount}/${MODULE_KEYS.length})`
+  );
+  return {
+    apiKeyId: apiRow.id,
+    apiKeyName: `${apiRow.name || "Unknown"} (ssh: ${keyRow.name})`,
+    userId: apiRow.created_by,
+    allowedServerIds,
+    permissions,
+    roleName
   };
 }
 function assertServerAccess(serverId) {
@@ -2476,7 +2673,7 @@ var TOOLS = [
   // ----- Agent Reporting -----
   ...AGENT_TOOLS
 ];
-var MCP_VERSION = "3.0.6";
+var MCP_VERSION = "3.1.1";
 async function handleListTools() {
   if (!authContext) return { tools: TOOLS };
   const accessible = TOOLS.filter((tool) => {
@@ -2501,23 +2698,6 @@ async function handleCallTool(request) {
       }]
     };
   }
-  const rateResult = checkToolRateLimit(name);
-  if (!rateResult.allowed) {
-    const retryMin = Math.ceil(rateResult.retryAfterMs / 6e4);
-    void sendTelegramAlert(
-      `<b>MCP Rate Limit</b>
-
-Tool category <code>${escapeHtmlTg(rateResult.category)}</code> rate limited.
-Key: ${escapeHtmlTg(authContext.apiKeyName)}
-Retry in ${retryMin} min.`
-    );
-    return {
-      content: [{
-        type: "text",
-        text: `Rate limited: too many ${rateResult.category} calls. Retry in ${retryMin} minute(s).`
-      }]
-    };
-  }
   const startTime = Date.now();
   const serverId = a.serverId || a.server_id;
   const result = await executeToolCall(name, a);
@@ -2995,56 +3175,22 @@ function createMcpServer() {
   return s;
 }
 var server = createMcpServer();
-async function resolvePublicIp() {
-  const services = [
-    "https://api.ipify.org",
-    "https://ifconfig.me/ip",
-    "https://icanhazip.com"
-  ];
-  for (const url of services) {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), 5e3);
-      const res = await fetch(url, { signal: controller.signal });
-      clearTimeout(timer);
-      if (res.ok) {
-        const ip = (await res.text()).trim();
-        if (ip && /^[\d.:a-f]+$/i.test(ip)) {
-          console.error(`[IP Resolve] Got public IP: ${ip} (from ${url})`);
-          return ip;
-        }
-      }
-    } catch (err) {
-      console.error(`[IP Resolve] Failed ${url}: ${err instanceof Error ? err.message : err}`);
-    }
-  }
-  console.error("[IP Resolve] All services failed, returning unknown");
-  return "unknown";
-}
 async function main() {
   console.error("Starting MG Dashboard MCP Server...");
-  authContext = await validateApiKey(apiKey);
-  if (!authContext) {
-    console.error("API key validation failed");
-    process.exit(1);
-  }
-  console.error(`[Security] MCP v${MCP_VERSION} | Key: ${authContext.apiKeyName} | requireIpApproval: ${authContext.requireIpApproval}`);
-  if (authContext.requireIpApproval) {
-    console.error("[Security] IP approval enabled, resolving public IP...");
-    const publicIp = await resolvePublicIp();
-    console.error(`[Security] Public IP: ${publicIp}`);
-    const ipResult = await checkIpAllowlist(publicIp);
-    if (!ipResult.allowed) {
-      console.error(`[Security] BLOCKED \u2014 ${ipResult.reason}`);
-      console.error("[Security] MCP server will not start. Approve the IP via Telegram or add it manually in the dashboard.");
+  if (sshKeyPath) {
+    authContext = await validateSshKey(sshKeyPath);
+    if (!authContext) {
+      console.error("SSH-key authentication failed");
       process.exit(1);
     }
-    console.error("[Security] IP approved, creating session...");
-    await getOrCreateSession(publicIp);
-    console.error("[Security] Session created");
   } else {
-    console.error("[Security] IP approval disabled for this key");
+    authContext = await validateApiKey(apiKey);
+    if (!authContext) {
+      console.error("API key validation failed");
+      process.exit(1);
+    }
   }
+  console.error(`[Security] MCP v${MCP_VERSION} | Key: ${authContext.apiKeyName}`);
   const toolNames = TOOLS.map((t) => t.name).join(", ");
   if (httpMode) {
     console.error(`API key validated. Starting Streamable HTTP transport on port ${httpPort}...`);
@@ -3055,24 +3201,6 @@ async function main() {
     };
     const httpServer = createServer(async (req, res) => {
       const url = new URL(req.url ?? "/", `http://localhost:${httpPort}`);
-      const clientIp = (req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.headers["x-real-ip"] || req.socket.remoteAddress || "unknown").replace(/^::ffff:/, "");
-      if (authContext?.requireIpApproval) {
-        const { data: allowed } = await supabase.from("mcp_ip_allowlist").select("id").eq("api_key_id", authContext.apiKeyId).eq("ip_address", clientIp).maybeSingle();
-        if (!allowed) {
-          res.writeHead(403, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: `IP ${clientIp} not in allowlist. Approve via Telegram first.` }));
-          return;
-        }
-      }
-      if (authContext) {
-        const sessionResult = await getOrCreateSession(clientIp);
-        if (!sessionResult.valid) {
-          console.error(`[Session] Session expired: ${sessionResult.reason}`);
-          res.writeHead(401, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: `Session expired: ${sessionResult.reason}. Restart the MCP server to re-authenticate.` }));
-          return;
-        }
-      }
       const restToolName = REST_TOOL_MAP[url.pathname];
       if (restToolName && req.method === "POST") {
         if (!authContext) {