@bytebase/dbhub 0.24.0 → 1.0.0

package/README.md

@@ -84,6 +84,10 @@ npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:p
 
 Download `dbhub-<version>.mcpb` from the [latest release](https://github.com/bytebase/dbhub/releases/latest) and install it in any [MCPB-compatible client](https://github.com/modelcontextprotocol/mcpb) — Claude Desktop (double-click, or drag into Settings → Extensions), Claude Code, or MCP for Windows — then enter your database connection string. The bundle runs locally over stdio, is **read-only by design** (writes are rejected and the database session is set to read-only at the engine level), and needs no remote endpoint or OAuth setup — ideal for giving non-technical teammates curated, read-only database access. Pair it with a least-privilege, read-only database account. See the [MCP Bundle guide](https://dbhub.ai/mcpb) for details and for packaging your own bundle.
 
+**Claude Code Plugin:**
+
+For Claude Code, the [DBHub plugin](https://dbhub.ai/claude-code-plugin) registers the MCP server with one install command — Claude Code prompts for your connection string and stores it in secure storage — and adds `/dbhub:setup` and `/dbhub:explore` skills. Read-only by design, like the MCP Bundle.
+
 **Demo Mode:**
 
 ```bash
@@ -99,6 +103,8 @@ npx @bytebase/dbhub@latest --transport http --host 127.0.0.1 --port 8080 --demo
 > The HTTP transport defaults to `--host 0.0.0.0`, exposing DBHub on every network interface. For production, bind to `127.0.0.1` and front DBHub with a reverse proxy (nginx/Caddy) or firewall — DBHub does not authenticate HTTP clients.
 >
 > The HTTP transport also has built-in DNS-rebinding protection: it only accepts requests whose `Host` is loopback, this machine's own hostname/IPs, or a name you allow via [`--allowed-hosts`](https://dbhub.ai/config/command-line#allowed-hosts). If a client behind a reverse proxy or custom DNS name gets a `403`, add that hostname with `--allowed-hosts`.
+>
+> DBHub serves both MCP protocol eras on the same `/mcp` endpoint: the stateless **2026-07-28** revision (cacheable `tools/list`, no session state — safe behind round-robin load balancers) and the 2025-era Streamable HTTP protocol for older clients. 2026-era clients send the standard `Mcp-Method` / `Mcp-Name` headers on every request, so a fronting gateway or WAF can route and rate-limit `execute_sql` separately from `search_objects` without parsing JSON bodies.
 
 See [Command-Line Options](https://dbhub.ai/config/command-line) for all available parameters.
 

package/dist/{chunk-D2BIPC7V.js → chunk-S2V6RZ3C.js}

@@ -66,7 +66,8 @@ var SQLRowLimiter = class {
       const trimmed = sql.trim();
       const hasSemicolon = trimmed.endsWith(";");
       const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
-      return `${sqlWithoutSemicolon} LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+      return `${sqlWithoutSemicolon}
+LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
     }
   }
   /**
@@ -107,7 +108,8 @@ var SQLRowLimiter = class {
       const trimmed = sql.trim();
       const hasSemicolon = trimmed.endsWith(";");
       const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
-      return `SELECT * FROM (${sqlWithoutSemicolon}) AS subq LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+      return `SELECT * FROM (${sqlWithoutSemicolon}
+) AS subq LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
     }
     return this.applyLimitToQuery(sql, maxRows);
   }

package/dist/index.js

@@ -18,7 +18,9 @@ import {
 } from "./chunk-MQR6VX5F.js";
 import {
   allowedKeywords,
-  isReadOnlySQL
+  isReadOnlySQL,
+  sqlServerDynamicSqlPattern,
+  sqlServerPassThroughPattern
 } from "./chunk-JO7YQPBQ.js";
 import {
   loadConnectors
@@ -31,13 +33,14 @@ import {
   getDatabaseTypeFromDSN,
   getDefaultPortForType,
   parseConnectionInfoFromDSN,
-  splitSQLStatements
+  splitSQLStatements,
+  stripCommentsAndStrings
 } from "./chunk-JEZZN2YZ.js";
 
 // src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { toNodeHandler } from "@modelcontextprotocol/node";
 import express from "express";
 import http from "http";
 import path from "path";
@@ -98,6 +101,52 @@ function createToolSuccessResponse(data, meta = {}) {
   };
 }
 
+// src/utils/sql-access-policy.ts
+var CLASS_SEVERITY = {
+  read: 0,
+  dml: 1,
+  ddl: 2,
+  admin: 3,
+  unknown: 4
+};
+var ddlPattern = /\b(?:create|alter|drop|truncate|rename)\b/i;
+var dmlPattern = /\b(?:insert|update|delete|merge|replace\s+(?:(?:low_priority|delayed)\s+)?into)\b/i;
+var grantRevokePattern = /\b(?:grant|revoke)\b/i;
+function isAdminStatement(stripped, connectorType) {
+  if (grantRevokePattern.test(stripped)) return true;
+  return connectorType === "sqlserver" && (sqlServerDynamicSqlPattern.test(stripped) || sqlServerPassThroughPattern.test(stripped));
+}
+function policyFromReadonly(readonly) {
+  const write = readonly === true ? "deny" : "allow";
+  return { read: "allow", dml: write, ddl: write, admin: write, unknown: write };
+}
+function isReadOnlyPolicy(policy) {
+  return policy.dml === "deny" && policy.ddl === "deny" && policy.admin === "deny" && policy.unknown === "deny";
+}
+function classifyStatement(sql, connectorType) {
+  if (isReadOnlySQL(sql, connectorType)) {
+    return "read";
+  }
+  const stripped = stripCommentsAndStrings(sql, connectorType);
+  if (isAdminStatement(stripped, connectorType)) return "admin";
+  if (ddlPattern.test(stripped)) return "ddl";
+  if (dmlPattern.test(stripped)) return "dml";
+  return "unknown";
+}
+function classifySQL(sql, connectorType) {
+  let strictest = "read";
+  for (const statement of splitSQLStatements(sql, connectorType)) {
+    const cls = classifyStatement(statement, connectorType);
+    if (CLASS_SEVERITY[cls] > CLASS_SEVERITY[strictest]) {
+      strictest = cls;
+    }
+  }
+  return strictest;
+}
+function sqlVerdict(policy, sql, connectorType) {
+  return policy[classifySQL(sql, connectorType)];
+}
+
 // src/requests/store.ts
 var RequestStore = class {
   constructor() {
@@ -149,8 +198,8 @@ var RequestStore = class {
 var requestStore = new RequestStore();
 
 // src/utils/client-identifier.ts
-function getClientIdentifier(extra) {
-  const userAgent = extra?.requestInfo?.headers?.["user-agent"];
+function getClientIdentifier(ctx) {
+  const userAgent = ctx?.http?.req?.headers.get("user-agent");
   if (userAgent) {
     return userAgent;
   }
@@ -196,10 +245,7 @@ function tryClassifyConnectionError(error, rawSourceId, displaySourceId) {
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
 };
-function areAllStatementsReadOnly(sql, connectorType) {
-  const statements = splitSQLStatements(sql, connectorType);
-  return statements.every((statement) => isReadOnlySQL(statement, connectorType));
-}
+var executeSqlInputSchema = z.object(executeSqlSchema);
 function createExecuteSqlToolHandler(sourceId) {
   return async (args, extra) => {
     const { sql } = args;
@@ -214,14 +260,14 @@ function createExecuteSqlToolHandler(sourceId) {
       const actualSourceId = connector.getId();
       const registry = getToolRegistry();
       const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, actualSourceId);
-      const isReadonly = toolConfig?.readonly === true;
-      if (isReadonly && !areAllStatementsReadOnly(sql, connector.id)) {
+      const policy = policyFromReadonly(toolConfig?.readonly);
+      if (sqlVerdict(policy, sql, connector.id) === "deny") {
         errorMessage = `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
       const executeOptions = {
-        readonly: toolConfig?.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig?.max_rows
       };
       result = await connector.executeSQL(sql, executeOptions);
@@ -264,6 +310,7 @@ var searchDatabaseObjectsSchema = {
   detail_level: z2.enum(["names", "summary", "full"]).default("names").describe("Detail: names (minimal), summary (metadata), full (all)"),
   limit: z2.number().int().positive().max(1e3).default(100).describe("Max results")
 };
+var searchDatabaseObjectsInputSchema = z2.object(searchDatabaseObjectsSchema);
 function likePatternToRegex(pattern) {
   const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
   return new RegExp(`^${escaped}$`, "i");
@@ -795,7 +842,7 @@ function getExecuteSqlMetadata(sourceId) {
   const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
   const maxRowsNote = executeOptions.maxRows ? ` (limited to ${executeOptions.maxRows} rows)` : "";
   const description = isSingleSource ? `${userDescPrefix}Execute SQL queries on the ${dbType} database${readonlyNote}${maxRowsNote}` : `${userDescPrefix}Execute SQL queries on the '${sourceId}' ${dbType} database${readonlyNote}${maxRowsNote}`;
-  const isReadonly = executeOptions.readonly === true;
+  const isReadonly = isReadOnlyPolicy(policyFromReadonly(executeOptions.readonly));
   const annotations = {
     title,
     readOnlyHint: isReadonly,
@@ -971,9 +1018,17 @@ function buildZodSchemaFromParameters(parameters) {
   }
   return schemaShape;
 }
+var customToolInputSchemas = /* @__PURE__ */ new WeakMap();
+function getCustomToolInputSchema(toolConfig) {
+  let schema = customToolInputSchemas.get(toolConfig);
+  if (!schema) {
+    schema = z4.object(buildZodSchemaFromParameters(toolConfig.parameters));
+    customToolInputSchemas.set(toolConfig, schema);
+  }
+  return schema;
+}
 function createCustomToolHandler(toolConfig) {
-  const zodSchemaShape = buildZodSchemaFromParameters(toolConfig.parameters);
-  const zodSchema = z4.object(zodSchemaShape);
+  const zodSchema = getCustomToolInputSchema(toolConfig);
   return async (args, extra) => {
     const startTime = Date.now();
     let success = true;
@@ -983,12 +1038,12 @@ function createCustomToolHandler(toolConfig) {
       const validatedArgs = zodSchema.parse(args);
       await ConnectorManager.ensureConnected(toolConfig.source);
       const connector = ConnectorManager.getCurrentConnector(toolConfig.source);
+      const policy = policyFromReadonly(toolConfig.readonly);
       const executeOptions = {
-        readonly: toolConfig.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig.max_rows
       };
-      const isReadonly = executeOptions.readonly === true;
-      if (isReadonly && !isReadOnlySQL(toolConfig.statement, connector.id)) {
+      if (sqlVerdict(policy, toolConfig.statement, connector.id) === "deny") {
         errorMessage = createReadonlyViolationMessage(toolConfig.name, toolConfig.source, connector.id);
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
@@ -1065,7 +1120,7 @@ function registerExecuteSqlTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: metadata.schema,
+      inputSchema: executeSqlInputSchema,
       annotations: metadata.annotations
     },
     createExecuteSqlToolHandler(sourceId)
@@ -1077,7 +1132,7 @@ function registerSearchObjectsTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: searchDatabaseObjectsSchema,
+      inputSchema: searchDatabaseObjectsInputSchema,
       annotations: {
         title: metadata.title,
         readOnlyHint: true,
@@ -1092,13 +1147,12 @@ function registerSearchObjectsTool(server, sourceId) {
 function registerCustomTool(server, sourceId, toolConfig) {
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
   const dbType = sourceConfig.type;
-  const isReadOnly = isReadOnlySQL(toolConfig.statement, dbType);
-  const zodSchema = buildZodSchemaFromParameters(toolConfig.parameters);
+  const isReadOnly = classifySQL(toolConfig.statement, dbType) === "read";
   server.registerTool(
     toolConfig.name,
     {
       description: toolConfig.description,
-      inputSchema: zodSchema,
+      inputSchema: getCustomToolInputSchema(toolConfig),
       annotations: {
         title: `${toolConfig.name} (${dbType})`,
         readOnlyHint: isReadOnly,
@@ -1538,6 +1592,8 @@ var packageJsonPath = path.join(__dirname, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
+var TOOLS_LIST_CACHE_TTL_MS = 3e5;
+var logMcpError = (scope) => (error) => console.error(`MCP ${scope} error:`, error);
 function generateBanner(version, modes = []) {
   const modeText = modes.length > 0 ? ` [${modes.join(" | ")}]` : "";
   return `
@@ -1594,10 +1650,18 @@ See documentation for more details on configuring database connections.
       initialTools: sourceConfigsData.tools
     });
     const createServer = () => {
-      const server = new McpServer({
-        name: SERVER_NAME,
-        version: SERVER_VERSION
-      });
+      const server = new McpServer(
+        {
+          name: SERVER_NAME,
+          version: SERVER_VERSION
+        },
+        {
+          // `private` keeps caching client-side (no shared/proxy caches).
+          cacheHints: {
+            "tools/list": { ttlMs: TOOLS_LIST_CACHE_TTL_MS, cacheScope: "private" }
+          }
+        }
+      );
       registerTools(server);
       return server;
     };
@@ -1639,7 +1703,7 @@ See documentation for more details on configuring database connections.
         }
         res.header("Access-Control-Allow-Origin", origin || "http://localhost");
         res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, MCP-Protocol-Version, Mcp-Method, Mcp-Name");
         res.header("Access-Control-Allow-Credentials", "true");
         if (req.method === "OPTIONS") {
           return res.sendStatus(200);
@@ -1654,29 +1718,10 @@ See documentation for more details on configuring database connections.
       app.get("/api/sources", listSources);
       app.get("/api/sources/:sourceId", getSource);
       app.get("/api/requests", listRequests);
-      app.get("/mcp", (req, res) => {
-        res.status(405).json({
-          error: "Method Not Allowed",
-          message: "SSE streaming is not supported in stateless mode. Use POST requests with JSON responses."
-        });
-      });
-      app.post("/mcp", async (req, res) => {
-        try {
-          const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: void 0,
-            // Disable session management for stateless mode
-            enableJsonResponse: true
-            // Use JSON responses (SSE not supported in stateless mode)
-          });
-          const server = createServer();
-          await server.connect(transport);
-          await transport.handleRequest(req, res, req.body);
-        } catch (error) {
-          console.error("Error handling request:", error);
-          if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error" });
-          }
-        }
+      const mcpHandler = createMcpHandler(createServer, { onerror: logMcpError("handler") });
+      const mcpNodeHandler = toNodeHandler(mcpHandler, { onerror: logMcpError("adapter") });
+      app.all("/mcp", (req, res) => {
+        void mcpNodeHandler(req, res, req.body);
       });
       if (process.env.NODE_ENV !== "development") {
         app.get("*", (req, res) => {
@@ -1712,16 +1757,14 @@ See documentation for more details on configuring database connections.
         console.error(`MCP server endpoint at http://${userHost}:${boundPort}/mcp`);
       });
     } else {
-      const server = createServer();
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
+      const stdioHandle = serveStdio(createServer, { onerror: logMcpError("stdio") });
       console.error("MCP server running on stdio");
       let isShuttingDown = false;
       const shutdown = async () => {
         if (isShuttingDown) return;
         isShuttingDown = true;
         console.error("Shutting down...");
-        await transport.close();
+        await stdioHandle.close();
         await connectorManager.disconnect();
         process.exit(0);
       };
@@ -1737,11 +1780,11 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-ZQFXCBYA.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-LHWZ7WOP.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-JH5CNV5E.js"), name: "SQLite", driver: "node:sqlite" },
-  { load: () => import("./mysql-MHIZK2UY.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-VZMU7LYA.js"), name: "MariaDB", driver: "mariadb" }
+  { load: () => import("./postgres-YAYHDXVD.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-COKW7RIK.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-5M7SDAQZ.js"), name: "SQLite", driver: "node:sqlite" },
+  { load: () => import("./mysql-CDUKJMNN.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-72C2BNCG.js"), name: "MariaDB", driver: "mariadb" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);

package/dist/{mariadb-VZMU7LYA.js → mariadb-72C2BNCG.js}

@@ -12,7 +12,7 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -509,14 +509,7 @@ var MariaDBConnector = class _MariaDBConnector {
           }
           let results;
           if (parameters && parameters.length > 0) {
-            try {
-              results = await conn.query(processedSQL, parameters);
-            } catch (error) {
-              console.error(`[MariaDB executeSQL] ERROR: ${error.message}`);
-              console.error(`[MariaDB executeSQL] SQL: ${processedSQL}`);
-              console.error(`[MariaDB executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-              throw error;
-            }
+            results = await conn.query(processedSQL, parameters);
           } else {
             results = await conn.query(processedSQL);
           }
@@ -525,9 +518,6 @@ var MariaDBConnector = class _MariaDBConnector {
           return { rows, rowCount };
         }
       );
-    } catch (error) {
-      console.error("Error executing query:", error);
-      throw error;
     } finally {
       conn.release();
     }

package/dist/{mysql-MHIZK2UY.js → mysql-CDUKJMNN.js}

@@ -12,7 +12,7 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -514,14 +514,7 @@ var MySQLConnector = class _MySQLConnector {
           }
           let results;
           if (parameters && parameters.length > 0) {
-            try {
-              results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs }, parameters);
-            } catch (error) {
-              console.error(`[MySQL executeSQL] ERROR: ${error.message}`);
-              console.error(`[MySQL executeSQL] SQL: ${processedSQL}`);
-              console.error(`[MySQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-              throw error;
-            }
+            results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs }, parameters);
           } else {
             results = await conn.query({ sql: processedSQL, timeout: this.queryTimeoutMs });
           }
@@ -531,9 +524,6 @@ var MySQLConnector = class _MySQLConnector {
           return { rows, rowCount };
         }
       );
-    } catch (error) {
-      console.error("Error executing query:", error);
-      throw error;
     } finally {
       conn.release();
     }

package/dist/{postgres-ZQFXCBYA.js → postgres-YAYHDXVD.js}

@@ -4,7 +4,7 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -508,24 +508,12 @@ var PostgresConnector = class _PostgresConnector {
               await client.query("ROLLBACK");
             } catch {
             }
-            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
-            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
-            if (parameters && parameters.length > 0) {
-              console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-            }
             throw error;
           }
         }
         let result;
         if (parameters && parameters.length > 0) {
-          try {
-            result = await client.query(processedStatement, parameters);
-          } catch (error) {
-            console.error(`[PostgreSQL executeSQL] ERROR: ${error.message}`);
-            console.error(`[PostgreSQL executeSQL] SQL: ${processedStatement}`);
-            console.error(`[PostgreSQL executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-            throw error;
-          }
+          result = await client.query(processedStatement, parameters);
         } else {
           result = await client.query(processedStatement);
         }

package/dist/{sqlite-JH5CNV5E.js → sqlite-5M7SDAQZ.js}

@@ -4,7 +4,7 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -339,15 +339,8 @@ var SQLiteConnector = class _SQLiteConnector {
         }
         if (isReadStatement) {
           if (parameters && parameters.length > 0) {
-            try {
-              const rows = this.prepare(processedStatement).all(...parameters);
-              return { rows, rowCount: rows.length };
-            } catch (error) {
-              console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
-              console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
-              console.error(`[SQLite executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-              throw error;
-            }
+            const rows = this.prepare(processedStatement).all(...parameters);
+            return { rows, rowCount: rows.length };
           } else {
             const rows = this.prepare(processedStatement).all();
             return { rows, rowCount: rows.length };
@@ -355,14 +348,7 @@ var SQLiteConnector = class _SQLiteConnector {
         } else {
           let result;
           if (parameters && parameters.length > 0) {
-            try {
-              result = this.prepare(processedStatement).run(...parameters);
-            } catch (error) {
-              console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
-              console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
-              console.error(`[SQLite executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-              throw error;
-            }
+            result = this.prepare(processedStatement).run(...parameters);
           } else {
             result = this.prepare(processedStatement).run();
           }

package/dist/{sqlserver-LHWZ7WOP.js → sqlserver-COKW7RIK.js}

@@ -10,7 +10,7 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -475,7 +475,10 @@ var _SQLServerConnector = class _SQLServerConnector {
       sqlQuery.match(_SQLServerConnector.LEADING_NOISE)[0].length
     );
     if (/^explain\b/i.test(afterNoise)) {
-      return this.explainQuery(afterNoise.slice("explain".length).trim(), options.readonly);
+      const { analyze, query } = _SQLServerConnector.parseExplainPrefix(
+        afterNoise.slice("explain".length).trim()
+      );
+      return analyze ? this.explainAnalyzeQuery(query, options, parameters) : this.explainQuery(query, options.readonly, parameters);
     }
     try {
       let processedSQL = sqlQuery;
@@ -499,39 +502,8 @@ var _SQLServerConnector = class _SQLServerConnector {
           });
         }
       );
-      if (parameters && parameters.length > 0) {
-        parameters.forEach((param, index) => {
-          const paramName = `p${index + 1}`;
-          if (typeof param === "string") {
-            request.input(paramName, sql.VarChar, param);
-          } else if (typeof param === "number") {
-            if (Number.isInteger(param)) {
-              request.input(paramName, sql.Int, param);
-            } else {
-              request.input(paramName, sql.Float, param);
-            }
-          } else if (typeof param === "boolean") {
-            request.input(paramName, sql.Bit, param);
-          } else if (param === null || param === void 0) {
-            request.input(paramName, sql.VarChar, param);
-          } else if (Array.isArray(param)) {
-            request.input(paramName, sql.VarChar, JSON.stringify(param));
-          } else {
-            request.input(paramName, sql.VarChar, JSON.stringify(param));
-          }
-        });
-      }
-      let result;
-      try {
-        result = await request.query(processedSQL);
-      } catch (error) {
-        if (parameters && parameters.length > 0) {
-          console.error(`[SQL Server executeSQL] ERROR: ${error.message}`);
-          console.error(`[SQL Server executeSQL] SQL: ${processedSQL}`);
-          console.error(`[SQL Server executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-        }
-        throw error;
-      }
+      _SQLServerConnector.bindParameters(request, parameters);
+      const result = await request.query(processedSQL);
       return {
         rows: result.recordset || [],
         rowCount: result.rowsAffected[0] || 0,
@@ -541,6 +513,39 @@ var _SQLServerConnector = class _SQLServerConnector {
       throw new Error(`Failed to execute query: ${error.message}`);
     }
   }
+  /**
+   * Bind positional parameters as @p1, @p2, ... inferring the SQL Server type
+   * from each JavaScript value. Shared by every execution path so they cannot
+   * drift in how a given value is typed.
+   *
+   * Works for `batch` as well as `query`: node-mssql prepends the matching
+   * DECLARE/SET statements when the request is a batch.
+   */
+  static bindParameters(request, parameters) {
+    if (!parameters || parameters.length === 0) {
+      return;
+    }
+    parameters.forEach((param, index) => {
+      const paramName = `p${index + 1}`;
+      if (typeof param === "string") {
+        request.input(paramName, sql.VarChar, param);
+      } else if (typeof param === "number") {
+        if (Number.isInteger(param)) {
+          request.input(paramName, sql.Int, param);
+        } else {
+          request.input(paramName, sql.Float, param);
+        }
+      } else if (typeof param === "boolean") {
+        request.input(paramName, sql.Bit, param);
+      } else if (param === null || param === void 0) {
+        request.input(paramName, sql.VarChar, param);
+      } else if (Array.isArray(param)) {
+        request.input(paramName, sql.VarChar, JSON.stringify(param));
+      } else {
+        request.input(paramName, sql.VarChar, JSON.stringify(param));
+      }
+    });
+  }
   /**
    * Reject the constructs that escape SQL Server's read-only guards, for use by
    * both read-only execution paths.
@@ -606,39 +611,13 @@ var _SQLServerConnector = class _SQLServerConnector {
         });
       }
     );
-    if (parameters && parameters.length > 0) {
-      parameters.forEach((param, index) => {
-        const paramName = `p${index + 1}`;
-        if (typeof param === "string") {
-          request.input(paramName, sql.VarChar, param);
-        } else if (typeof param === "number") {
-          if (Number.isInteger(param)) {
-            request.input(paramName, sql.Int, param);
-          } else {
-            request.input(paramName, sql.Float, param);
-          }
-        } else if (typeof param === "boolean") {
-          request.input(paramName, sql.Bit, param);
-        } else if (param === null || param === void 0) {
-          request.input(paramName, sql.VarChar, param);
-        } else if (Array.isArray(param)) {
-          request.input(paramName, sql.VarChar, JSON.stringify(param));
-        } else {
-          request.input(paramName, sql.VarChar, JSON.stringify(param));
-        }
-      });
-    }
+    _SQLServerConnector.bindParameters(request, parameters);
     let result;
     let queryFailed = false;
     try {
       result = await request.query(processedSQL);
     } catch (error) {
       queryFailed = true;
-      console.error(`[SQL Server executeReadOnly] ERROR: ${error.message}`);
-      console.error(`[SQL Server executeReadOnly] SQL: ${processedSQL}`);
-      if (parameters && parameters.length > 0) {
-        console.error(`[SQL Server executeReadOnly] Parameters: ${JSON.stringify(parameters)}`);
-      }
       throw error;
     } finally {
       try {
@@ -671,7 +650,7 @@ var _SQLServerConnector = class _SQLServerConnector {
    * off the shared pool, so a concurrent query can never land on a connection
    * with SHOWPLAN enabled (which would return a plan instead of its results).
    */
-  async explainQuery(innerQuery, readonly) {
+  async explainQuery(innerQuery, readonly, parameters) {
     const cleaned = stripCommentsAndStrings(innerQuery, "sqlserver").trim();
     if (!cleaned) {
       throw new Error("EXPLAIN requires a statement to analyze");
@@ -692,7 +671,9 @@ var _SQLServerConnector = class _SQLServerConnector {
     try {
       await explainPool.connect();
       await explainPool.request().batch("SET SHOWPLAN_XML ON");
-      const planResult = await explainPool.request().batch(innerQuery);
+      const planRequest = explainPool.request();
+      _SQLServerConnector.bindParameters(planRequest, parameters);
+      const planResult = await planRequest.batch(innerQuery);
       const planRow = planResult.recordset?.[0];
       const planXml = planRow ? Object.values(planRow)[0] : null;
       return {
@@ -705,6 +686,177 @@ var _SQLServerConnector = class _SQLServerConnector {
       await explainPool.close();
     }
   }
+  /**
+   * Splits the modifiers between EXPLAIN and its statement, covering the same
+   * forms the read-only classifier recognises (see utils/allowed-keywords.ts):
+   * `ANALYZE`, `ANALYZE VERBOSE`, `(ANALYZE)`, `(ANALYZE, BUFFERS)`,
+   * `(ANALYZE false)`.
+   *
+   * Only ANALYZE carries a meaning here — it selects STATISTICS XML over
+   * SHOWPLAN_XML. The rest are PostgreSQL planner knobs with no SQL Server
+   * counterpart, so they are refused by name: silently dropping an option would
+   * quietly hand back something other than what was asked for.
+   */
+  static parseExplainPrefix(afterExplain) {
+    if (afterExplain.startsWith("(")) {
+      const close = afterExplain.indexOf(")");
+      if (close < 0) {
+        throw new Error("EXPLAIN option list is missing its closing ')'");
+      }
+      let analyze = false;
+      for (const part of afterExplain.slice(1, close).split(",")) {
+        const token = part.trim();
+        if (!token) continue;
+        const parsed = _SQLServerConnector.EXPLAIN_OPTION.exec(token);
+        if (!parsed) {
+          throw new Error(
+            `EXPLAIN option '${token}' is not supported on SQL Server \u2014 only ANALYZE is.`
+          );
+        }
+        const name = parsed[1];
+        if (!/^analyze$/i.test(name)) {
+          throw new Error(
+            `EXPLAIN option '${name}' is not supported on SQL Server \u2014 only ANALYZE is.`
+          );
+        }
+        const value = parsed[2];
+        if (value === void 0 || _SQLServerConnector.EXPLAIN_ON.test(value)) {
+          analyze = true;
+        } else if (_SQLServerConnector.EXPLAIN_OFF.test(value)) {
+          analyze = false;
+        } else {
+          throw new Error(`EXPLAIN option 'ANALYZE' expects a boolean, got '${value}'.`);
+        }
+      }
+      return { analyze, query: afterExplain.slice(close + 1).trim() };
+    }
+    const analyzeKeyword = /^analyze\b/i.exec(afterExplain);
+    if (!analyzeKeyword) {
+      return { analyze: false, query: afterExplain };
+    }
+    const rest = afterExplain.slice(analyzeKeyword[0].length).trim();
+    const disabled = _SQLServerConnector.EXPLAIN_BARE_DISABLED.exec(rest);
+    if (disabled) {
+      return { analyze: false, query: rest.slice(disabled[0].length).trim() };
+    }
+    const trailing = /^([A-Za-z_]+)\b/.exec(rest);
+    if (trailing && /^verbose$/i.test(trailing[1])) {
+      throw new Error(
+        "EXPLAIN option 'VERBOSE' is not supported on SQL Server \u2014 only ANALYZE is."
+      );
+    }
+    return { analyze: true, query: rest };
+  }
+  /**
+   * Run a statement under SET STATISTICS XML and return its *actual* execution
+   * plan — the Postgres `EXPLAIN ANALYZE` contract.
+   *
+   * SHOWPLAN_XML (plain EXPLAIN) compiles without executing, so its plan carries
+   * only estimates. STATISTICS XML runs the statement, so the plan reports real
+   * row counts and execution counts. The flip side is that this path is *not*
+   * inherently read-only the way explainQuery is, so under `options.readonly` the
+   * statement runs inside a transaction that always rolls back.
+   *
+   * The dedicated single-connection pool serves the same purpose as in
+   * explainQuery: the STATISTICS XML session toggle must never leak onto a
+   * shared pool connection, where a concurrent query would inherit it.
+   */
+  async explainAnalyzeQuery(innerQuery, options, parameters) {
+    const cleaned = stripCommentsAndStrings(innerQuery, "sqlserver").trim();
+    if (!cleaned) {
+      throw new Error("EXPLAIN ANALYZE requires a statement to analyze");
+    }
+    if (/\bset\s+statistics\b/i.test(cleaned)) {
+      throw new Error("EXPLAIN ANALYZE does not support SET STATISTICS statements");
+    }
+    if (/\bset\s+showplan\b/i.test(cleaned)) {
+      throw new Error("EXPLAIN ANALYZE does not support SET SHOWPLAN statements");
+    }
+    if (options.readonly) {
+      this.assertNoReadOnlyEscapes(innerQuery, { transactionControl: true });
+    }
+    if (!this.config) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    const explainPool = new sql.ConnectionPool({
+      ...this.config,
+      pool: { ...this.config.pool, max: 1, min: 1 }
+    });
+    try {
+      await explainPool.connect();
+      await explainPool.request().batch("SET STATISTICS XML ON");
+      let planResult;
+      if (options.readonly) {
+        planResult = await _SQLServerConnector.batchRolledBack(
+          explainPool,
+          innerQuery,
+          parameters
+        );
+      } else {
+        const planRequest = explainPool.request();
+        _SQLServerConnector.bindParameters(planRequest, parameters);
+        planResult = await planRequest.batch(innerQuery);
+      }
+      const planXml = _SQLServerConnector.extractPlanXml(planResult);
+      return {
+        rows: planXml != null ? [{ plan: planXml }] : [],
+        rowCount: planXml != null ? 1 : 0
+      };
+    } catch (error) {
+      throw new Error(`Failed to explain analyze query: ${error.message}`);
+    } finally {
+      await explainPool.close();
+    }
+  }
+  /**
+   * Run a batch inside a transaction that is always rolled back, so EXPLAIN
+   * ANALYZE can report a real plan without letting the statement's writes stick.
+   */
+  static async batchRolledBack(pool, innerQuery, parameters) {
+    const transaction = new sql.Transaction(pool);
+    await transaction.begin();
+    let queryFailed = false;
+    try {
+      const request = new sql.Request(transaction);
+      _SQLServerConnector.bindParameters(request, parameters);
+      return await request.batch(innerQuery);
+    } catch (error) {
+      queryFailed = true;
+      throw error;
+    } finally {
+      try {
+        await transaction.rollback();
+      } catch (rollbackError) {
+        if (!queryFailed) {
+          throw new Error(
+            `Read-only rollback failed \u2014 data may have been modified: ${rollbackError.message}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Pull the ShowPlanXML document out of a STATISTICS XML result.
+   *
+   * STATISTICS XML interleaves each statement's plan with that statement's own
+   * result sets, so the plan sits at no fixed index — and `recordset` (singular)
+   * would hand back the statement's data instead. Scan from the end for the
+   * first single-column row holding a plan document.
+   */
+  static extractPlanXml(result) {
+    const recordsets = result.recordsets ?? [];
+    for (let i = recordsets.length - 1; i >= 0; i--) {
+      const firstRow = recordsets[i]?.[0];
+      if (!firstRow) continue;
+      const values = Object.values(firstRow);
+      if (values.length !== 1) continue;
+      const value = values[0];
+      if (typeof value === "string" && value.includes("<ShowPlanXML")) {
+        return value;
+      }
+    }
+    return null;
+  }
 };
 /**
  * Leading whitespace and SQL comments to skip before looking for a keyword.
@@ -713,6 +865,17 @@ var _SQLServerConnector = class _SQLServerConnector {
  * comment passes validation but reaches the server untranslated.
  */
 _SQLServerConnector.LEADING_NOISE = /^(?:\s+|--[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)*/;
+/** Boolean spellings PostgreSQL accepts for an EXPLAIN option. */
+_SQLServerConnector.EXPLAIN_ON = /^(?:true|on|1)$/i;
+_SQLServerConnector.EXPLAIN_OFF = /^(?:false|off|0)$/i;
+/**
+ * One option inside `EXPLAIN (...)`: a name, then optionally a value written
+ * either space-separated as PostgreSQL spells it (`ANALYZE false`) or with an
+ * equals sign, which the read-only classifier also accepts (`ANALYZE = 0`).
+ */
+_SQLServerConnector.EXPLAIN_OPTION = /^([A-Za-z_]+)(?:(?:\s*=\s*|\s+)(\S+))?$/;
+/** A disabling boolean directly after a bare `EXPLAIN ANALYZE`. */
+_SQLServerConnector.EXPLAIN_BARE_DISABLED = /^(?:=\s*)?(?:false|off|0)\b/i;
 var SQLServerConnector = _SQLServerConnector;
 var sqlServerConnector = new SQLServerConnector();
 ConnectorRegistry.register(sqlServerConnector);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.24.0",
+  "version": "1.0.0",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
@@ -44,12 +44,13 @@
   "license": "MIT",
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "ssh-config": "^5.0.3",
     "ssh2": "^1.16.0",
-    "zod": "^3.24.2"
+    "zod": "^4.2.0"
   },
   "optionalDependencies": {
     "@aws-sdk/rds-signer": "^3.1001.0",
@@ -61,6 +62,7 @@
   },
   "devDependencies": {
     "@anthropic-ai/mcpb": "^2.1.2",
+    "@modelcontextprotocol/client": "^2.0.0",
     "@testcontainers/mariadb": "^11.0.3",
     "@testcontainers/mssqlserver": "^11.0.3",
     "@testcontainers/mysql": "^11.0.3",