@bytebase/dbhub 0.11.0 → 0.11.2

package/README.md

@@ -217,6 +217,24 @@ postgres://user:password@localhost:5432/dbname
 
 DBHub supports connecting to databases through SSH tunnels, enabling secure access to databases in private networks or behind firewalls.
 
+#### Using SSH Config File (Recommended)
+
+DBHub can read SSH connection settings from your `~/.ssh/config` file. Simply use the host alias from your SSH config:
+
+```bash
+# If you have this in ~/.ssh/config:
+# Host mybastion
+#   HostName bastion.example.com
+#   User ubuntu
+#   IdentityFile ~/.ssh/id_rsa
+
+npx @bytebase/dbhub \
+  --dsn "postgres://dbuser:dbpass@database.internal:5432/mydb" \
+  --ssh-host mybastion
+```
+
+DBHub will automatically use the settings from your SSH config, including hostname, user, port, and identity file. If no identity file is specified in the config, DBHub will try common default locations (`~/.ssh/id_rsa`, `~/.ssh/id_ed25519`, etc.).
+
 #### SSH with Password Authentication
 
 ```bash

package/dist/index.js

@@ -1881,7 +1881,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import express from "express";
 import path3 from "path";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/utils/ssh-tunnel.ts
@@ -2031,6 +2031,103 @@ import dotenv from "dotenv";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
+import { homedir as homedir2 } from "os";
+
+// src/utils/ssh-config-parser.ts
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import SSHConfig from "ssh-config";
+var DEFAULT_SSH_KEYS = [
+  "~/.ssh/id_rsa",
+  "~/.ssh/id_ed25519",
+  "~/.ssh/id_ecdsa",
+  "~/.ssh/id_dsa"
+];
+function expandTilde(filePath) {
+  if (filePath.startsWith("~/")) {
+    return join(homedir(), filePath.substring(2));
+  }
+  return filePath;
+}
+function fileExists(filePath) {
+  try {
+    return existsSync(expandTilde(filePath));
+  } catch {
+    return false;
+  }
+}
+function findDefaultSSHKey() {
+  for (const keyPath of DEFAULT_SSH_KEYS) {
+    if (fileExists(keyPath)) {
+      return expandTilde(keyPath);
+    }
+  }
+  return void 0;
+}
+function parseSSHConfig(hostAlias, configPath) {
+  const sshConfigPath = configPath;
+  if (!existsSync(sshConfigPath)) {
+    return null;
+  }
+  try {
+    const configContent = readFileSync2(sshConfigPath, "utf8");
+    const config = SSHConfig.parse(configContent);
+    const hostConfig = config.compute(hostAlias);
+    if (!hostConfig || !hostConfig.HostName && !hostConfig.User) {
+      return null;
+    }
+    const sshConfig = {};
+    if (hostConfig.HostName) {
+      sshConfig.host = hostConfig.HostName;
+    } else {
+      sshConfig.host = hostAlias;
+    }
+    if (hostConfig.Port) {
+      sshConfig.port = parseInt(hostConfig.Port, 10);
+    }
+    if (hostConfig.User) {
+      sshConfig.username = hostConfig.User;
+    }
+    if (hostConfig.IdentityFile) {
+      const identityFile = Array.isArray(hostConfig.IdentityFile) ? hostConfig.IdentityFile[0] : hostConfig.IdentityFile;
+      const expandedPath = expandTilde(identityFile);
+      if (fileExists(expandedPath)) {
+        sshConfig.privateKey = expandedPath;
+      }
+    }
+    if (!sshConfig.privateKey) {
+      const defaultKey = findDefaultSSHKey();
+      if (defaultKey) {
+        sshConfig.privateKey = defaultKey;
+      }
+    }
+    if (hostConfig.ProxyJump || hostConfig.ProxyCommand) {
+      console.error("Warning: ProxyJump/ProxyCommand in SSH config is not yet supported by DBHub");
+    }
+    if (!sshConfig.host || !sshConfig.username) {
+      return null;
+    }
+    return sshConfig;
+  } catch (error) {
+    console.error(`Error parsing SSH config: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+function looksLikeSSHAlias(host) {
+  if (host.includes(".")) {
+    return false;
+  }
+  if (/^[\d:]+$/.test(host)) {
+    return false;
+  }
+  if (/^[0-9a-fA-F:]+$/.test(host) && host.includes(":")) {
+    return false;
+  }
+  return true;
+}
+
+// src/config/env.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 function parseCommandLineArgs() {
@@ -2151,15 +2248,27 @@ function resolveSSHConfig() {
   if (!hasSSHArgs) {
     return null;
   }
-  const config = {};
+  let config = {};
   let sources = [];
+  let sshConfigHost;
   if (args["ssh-host"]) {
+    sshConfigHost = args["ssh-host"];
     config.host = args["ssh-host"];
     sources.push("ssh-host from command line");
   } else if (process.env.SSH_HOST) {
+    sshConfigHost = process.env.SSH_HOST;
     config.host = process.env.SSH_HOST;
     sources.push("SSH_HOST from environment");
   }
+  if (sshConfigHost && looksLikeSSHAlias(sshConfigHost)) {
+    const sshConfigPath = path.join(homedir2(), ".ssh", "config");
+    console.error(`Attempting to parse SSH config for host '${sshConfigHost}' from: ${sshConfigPath}`);
+    const sshConfigData = parseSSHConfig(sshConfigHost, sshConfigPath);
+    if (sshConfigData) {
+      config = { ...sshConfigData };
+      sources.push(`SSH config for host '${sshConfigHost}'`);
+    }
+  }
   if (args["ssh-port"]) {
     config.port = parseInt(args["ssh-port"], 10);
     sources.push("ssh-port from command line");
@@ -2738,9 +2847,20 @@ var executeSqlSchema = {
 function splitSQLStatements(sql2) {
   return sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
 }
+function stripSQLComments(sql2) {
+  let cleaned = sql2.split("\n").map((line) => {
+    const commentIndex = line.indexOf("--");
+    return commentIndex >= 0 ? line.substring(0, commentIndex) : line;
+  }).join("\n");
+  cleaned = cleaned.replace(/\/\*[\s\S]*?\*\//g, " ");
+  return cleaned.trim();
+}
 function isReadOnlySQL(sql2, connectorType) {
-  const normalizedSQL = sql2.trim().toLowerCase();
-  const firstWord = normalizedSQL.split(/\s+/)[0];
+  const cleanedSQL = stripSQLComments(sql2).toLowerCase();
+  if (!cleanedSQL) {
+    return true;
+  }
+  const firstWord = cleanedSQL.split(/\s+/)[0];
   const keywordList = allowedKeywords[connectorType] || allowedKeywords.default || [];
   return keywordList.includes(firstWord);
 }
@@ -3197,7 +3317,7 @@ function registerPrompts(server) {
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = path3.dirname(__filename3);
 var packageJsonPath = path3.join(__dirname3, "..", "package.json");
-var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
 function generateBanner(version, modes = []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -25,6 +25,7 @@
     "mssql": "^11.0.1",
     "mysql2": "^3.13.0",
     "pg": "^8.13.3",
+    "ssh-config": "^5.0.3",
     "ssh2": "^1.16.0",
     "zod": "^3.24.2"
   },