@mgsoftwarebv/mg-dashboard-mcp 6.6.0 → 6.6.2

package/dist/index.js

@@ -17,6 +17,10 @@ import { drizzle } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
 import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
+import { once } from 'events';
+import https from 'https';
+import { lookup } from 'dns/promises';
+import { connect } from 'tls';
 import { HeadObjectCommand, S3Client, ListObjectsV2Command, DeleteObjectsCommand, DeleteObjectCommand, CreateMultipartUploadCommand, UploadPartCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, PutObjectCommand, GetObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
 
 var __defProp = Object.defineProperty;
@@ -314,7 +318,7 @@ function rewriteUrl(originalUrl, localPort) {
   parsed.port = String(localPort);
   return parsed.toString();
 }
-async function connectSsh(opts) {
+async function connectSsh2(opts) {
   return await new Promise((resolve, reject) => {
     const conn = new Client();
     const onError = (err) => {
@@ -374,7 +378,7 @@ async function fetchRemoteEnvValue(options) {
   const privateKey = readFileSync(privateKeyPath);
   const keepaliveIntervalMs = options.keepaliveIntervalMs ?? 3e4;
   const envKey = options.envKey ?? "DATABASE_PRIMARY_URL";
-  const conn = await connectSsh({ host, port, username, privateKey, keepaliveIntervalMs });
+  const conn = await connectSsh2({ host, port, username, privateKey, keepaliveIntervalMs });
   try {
     const safePath = options.remoteEnvPath.replace(/'/g, "'\\''");
     const result = await execOverSsh(conn, `cat -- '${safePath}'`);
@@ -400,7 +404,7 @@ async function openDbSshTunnel(options) {
   const parsedDbUrl = new URL(options.databaseUrl);
   const remoteHost = parsedDbUrl.hostname;
   const remotePort = Number(parsedDbUrl.port || "5432");
-  const conn = await connectSsh({ host, port, username, privateKey, keepaliveIntervalMs });
+  const conn = await connectSsh2({ host, port, username, privateKey, keepaliveIntervalMs });
   conn.on("error", (err) => {
     console.error(`[mcp][db-ssh-tunnel] ssh connection error: ${err.message}`);
   });
@@ -1525,6 +1529,103 @@ async function handleRepoTool(name, args2, deps) {
       return { content: [{ type: "text", text: `Unknown repo tool: ${name}` }] };
   }
 }
+function connectSsh(opts) {
+  return new Promise((resolve, reject) => {
+    const client = new Client();
+    client.once("ready", () => resolve(client));
+    client.once("error", reject);
+    client.connect({
+      host: opts.hostname,
+      port: opts.port,
+      username: opts.username,
+      password: opts.password,
+      privateKey: opts.privateKey,
+      passphrase: opts.passphrase,
+      readyTimeout: opts.timeout ?? 3e4
+    });
+  });
+}
+function forwardOut(client, host, port) {
+  return new Promise((resolve, reject) => {
+    client.forwardOut("127.0.0.1", 0, host, port, (err, stream) => {
+      if (err) reject(err);
+      else resolve(stream);
+    });
+  });
+}
+async function fetchViaSshProxy(options) {
+  const parsedUrl = new URL(options.url);
+  if (parsedUrl.protocol !== "https:") {
+    throw new Error(`fetchViaSshProxy only supports https URLs, got ${parsedUrl.protocol}`);
+  }
+  const targetHost = parsedUrl.hostname;
+  const targetPort = parsedUrl.port ? Number(parsedUrl.port) : 443;
+  const method = options.method ?? "GET";
+  const body = options.body ?? "";
+  const headers = { ...options.headers };
+  if (body && !headers["Content-Length"]) {
+    headers["Content-Length"] = String(Buffer.byteLength(body));
+  }
+  headers.Host = parsedUrl.host;
+  const ssh = await connectSsh(options.proxy);
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  let timer;
+  try {
+    let connectHost = targetHost;
+    try {
+      const resolved = await lookup(targetHost, { family: 4 });
+      connectHost = resolved.address;
+    } catch {
+    }
+    const stream = await forwardOut(ssh, connectHost, targetPort);
+    const tlsSocket = connect({
+      socket: stream,
+      servername: targetHost,
+      ALPNProtocols: ["http/1.1"]
+    });
+    await Promise.race([
+      once(tlsSocket, "secureConnect"),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`mijn.host fetch via SSH proxy timed out after ${timeoutMs}ms`)),
+          timeoutMs
+        );
+      })
+    ]);
+    if (timer) clearTimeout(timer);
+    return await new Promise((resolve, reject) => {
+      const req = https.request(
+        {
+          createConnection: () => tlsSocket,
+          hostname: targetHost,
+          port: targetPort,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method,
+          headers,
+          agent: false
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(chunk));
+          res.on("end", () => {
+            resolve({
+              status: res.statusCode ?? 0,
+              statusText: res.statusMessage ?? "",
+              body: Buffer.concat(chunks).toString("utf8")
+            });
+          });
+          res.on("error", reject);
+        }
+      );
+      req.on("error", reject);
+      if (body) req.write(body);
+      req.end();
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+    ssh.end();
+  }
+}
 var args = process.argv.slice(2);
 function getArg2(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
@@ -1540,6 +1641,14 @@ var sshKeyPath = getArg2("ssh-key") || process.env.MG_DASHBOARD_SSH_KEY;
 var databaseUrl = getArg2("database-url") || process.env.DATABASE_PRIMARY_POOLER_URL || process.env.DATABASE_PRIMARY_URL;
 var encryptionKey = getArg2("encryption-key") || process.env.ENCRYPTION_KEY;
 var mijnhostApiKey = getArg2("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
+function isMijnhostViaSshProxyEnabled() {
+  const arg = getArg2("mijnhost-via-ssh-proxy");
+  if (arg === "false" || arg === "0") return false;
+  const env = process.env.MG_DASHBOARD_MIJNHOST_VIA_SSH_PROXY;
+  if (env === "0" || env === "false") return false;
+  return true;
+}
+var mijnhostViaSshProxy = isMijnhostViaSshProxyEnabled();
 var dbSshTunnel = getArg2("db-ssh-tunnel") || process.env.MG_DASHBOARD_DB_SSH_TUNNEL;
 var dbRemoteEnvFile = getArg2("db-remote-env-file") || process.env.MG_DASHBOARD_DB_REMOTE_ENV_FILE;
 var dbRemoteEnvKey = getArg2("db-remote-env-key") || process.env.MG_DASHBOARD_DB_REMOTE_ENV_KEY || "DATABASE_PRIMARY_URL";
@@ -1577,6 +1686,9 @@ if (dbSshTunnel) {
 process.env.DATABASE_PRIMARY_URL = databaseUrl;
 process.env.DATABASE_PRIMARY_POOLER_URL = databaseUrl;
 var db = getDb();
+if (mijnhostApiKey && mijnhostViaSshProxy) {
+  console.error("[mcp][mijnhost] Routing mijn.host API via SSH proxy");
+}
 var RateLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   maxAttempts;
@@ -3918,20 +4030,48 @@ function describeDnsCandidates(records, type, name, attemptedValue) {
 }
 async function mijnhostFetch(path, options = {}) {
   const key = requireMijnhostApiKey();
-  const res = await fetch(`${MIJNHOST_BASE_URL}${path}`, {
-    ...options,
-    headers: {
-      "API-Key": key,
-      "Accept": "application/json",
-      "Content-Type": "application/json",
-      "User-Agent": "mg-dashboard-mcp/6.6.0",
-      ...options.headers || {}
-    }
-  });
-  const json = await res.json();
+  const headers = {
+    "API-Key": key,
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+    "User-Agent": "mg-dashboard-mcp/6.6.2",
+    ...options.headers || {}
+  };
+  const method = options.method ?? "GET";
+  const requestBody = typeof options.body === "string" ? options.body : options.body != null ? String(options.body) : void 0;
+  let status;
+  let responseText;
+  if (mijnhostViaSshProxy) {
+    const proxy = await getProxyConnection();
+    const proxied = await fetchViaSshProxy({
+      proxy,
+      url: `${MIJNHOST_BASE_URL}${path}`,
+      method,
+      headers,
+      body: requestBody,
+      timeoutMs: 6e4
+    });
+    status = proxied.status;
+    responseText = proxied.body;
+  } else {
+    const res = await fetch(`${MIJNHOST_BASE_URL}${path}`, {
+      ...options,
+      headers
+    });
+    status = res.status;
+    responseText = await res.text();
+  }
+  let json;
+  try {
+    json = JSON.parse(responseText);
+  } catch {
+    throw new Error(
+      `mijn.host API returned non-JSON (${status}): ${responseText.slice(0, 300)}`
+    );
+  }
   const body = json;
-  if (!res.ok) {
-    throw new Error(body?.status_description || `mijn.host API error: ${res.status}`);
+  if (status < 200 || status >= 300) {
+    throw new Error(body?.status_description || `mijn.host API error: ${status}`);
   }
   return body;
 }