@bytebase/dbhub 0.23.0 → 1.0.0

package/dist/{sqlserver-65AGCEJX.js → sqlserver-COKW7RIK.js}

@@ -1,9 +1,16 @@
+import {
+  sqlServerDynamicSqlKeywords,
+  sqlServerDynamicSqlPattern,
+  sqlServerPassThroughKeywords,
+  sqlServerPassThroughPattern
+} from "./chunk-JO7YQPBQ.js";
 import {
   isDriverNotInstalled
 } from "./chunk-WVVMH6FJ.js";
 import {
-  SQLRowLimiter
-} from "./chunk-BXXHWEQS.js";
+  SQLRowLimiter,
+  closeQuietly
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -156,8 +163,14 @@ var _SQLServerConnector = class _SQLServerConnector {
       if (!this.config.options) {
         this.config.options = {};
       }
-      this.connection = await new sql.ConnectionPool(this.config).connect();
+      this.connection = new sql.ConnectionPool(this.config);
+      await this.connection.connect();
     } catch (error) {
+      if (this.connection) {
+        const connection = this.connection;
+        this.connection = void 0;
+        await closeQuietly(() => connection.close());
+      }
       throw error;
     }
   }
@@ -462,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());
+      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;
@@ -486,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,
@@ -529,30 +514,88 @@ var _SQLServerConnector = class _SQLServerConnector {
     }
   }
   /**
-   * Execute a query inside a transaction that always rolls back, preventing
-   * any modifications from persisting. SQL Server has no native READ ONLY
-   * transaction mode, so this is the defense-in-depth backstop behind the
-   * keyword classifier.
+   * 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.
    *
-   * Because the rollback guard is application-level (not engine-enforced),
-   * we reject dangerous keywords in the stripped SQL before opening the
-   * transaction:
-   * - COMMIT/ROLLBACK: would end the outer transaction, letting writes persist
-   * - EXEC/EXECUTE/sp_executesql/xp_cmdshell: dynamic SQL can carry hidden
-   *   COMMIT/ROLLBACK inside string literals that stripCommentsAndStrings removes
+   * Works for `batch` as well as `query`: node-mssql prepends the matching
+   * DECLARE/SET statements when the request is a batch.
    */
-  async executeReadOnly(processedSQL, parameters) {
-    const cleaned = stripCommentsAndStrings(processedSQL, "sqlserver").toLowerCase();
-    if (/\b(?:commit|rollback)\b/.test(cleaned)) {
+  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.
+   *
+   * - Dynamic SQL (sqlServerDynamicSqlKeywords): can carry hidden COMMIT/ROLLBACK
+   *   inside string literals that stripCommentsAndStrings removes
+   * - Pass-through data sources (sqlServerPassThroughKeywords): execute on a
+   *   remote or ad-hoc source, so a local rollback never reaches them
+   * - COMMIT/ROLLBACK, when `transactionControl` is set: would end the wrapping
+   *   transaction, letting writes persist. Only meaningful for the transaction
+   *   path; the EXPLAIN path opens no transaction of its own.
+   *
+   * Both keyword lists are imported from the read-only classifier rather than
+   * redeclared, so the classifier and these backstops cannot drift apart.
+   *
+   * Note the COMMIT/ROLLBACK check is SQL Server-only by design. MySQL/MariaDB
+   * wrap batches in a transaction too, but there `commit`, `prepare` and
+   * `execute` are absent from their allow-lists in allowedKeywords, and
+   * execute-sql.ts requires every split statement to pass the classifier — so a
+   * transaction-control statement can never reach their backstop.
+   */
+  assertNoReadOnlyEscapes(sqlText, { transactionControl = false } = {}) {
+    const cleaned = stripCommentsAndStrings(sqlText, "sqlserver").toLowerCase();
+    if (transactionControl && /\b(?:commit|rollback)\b/.test(cleaned)) {
       throw new Error(
         "Read-only mode: transaction control statements (COMMIT, ROLLBACK) are not allowed"
       );
     }
-    if (/\b(?:exec|execute|sp_executesql|xp_cmdshell)\b/.test(cleaned)) {
+    if (sqlServerDynamicSqlPattern.test(cleaned)) {
       throw new Error(
-        "Read-only mode: dynamic SQL execution (EXEC, EXECUTE, sp_executesql, xp_cmdshell) is not allowed"
+        `Read-only mode: dynamic SQL execution (${sqlServerDynamicSqlKeywords.map((k) => k.toUpperCase()).join(", ")}) is not allowed`
       );
     }
+    if (sqlServerPassThroughPattern.test(cleaned)) {
+      throw new Error(
+        `Read-only mode: pass-through data sources (${sqlServerPassThroughKeywords.map((k) => k.toUpperCase()).join(", ")}) are not allowed`
+      );
+    }
+  }
+  /**
+   * Execute a query inside a transaction that always rolls back, preventing
+   * any modifications from persisting. SQL Server has no native READ ONLY
+   * transaction mode, so this is the defense-in-depth backstop behind the
+   * keyword classifier.
+   *
+   * Dangerous constructs are rejected before the transaction opens; see
+   * assertNoReadOnlyEscapes.
+   */
+  async executeReadOnly(processedSQL, parameters) {
+    this.assertNoReadOnlyEscapes(processedSQL, { transactionControl: true });
     const transaction = new sql.Transaction(this.connection);
     await transaction.begin();
     const request = new sql.Request(transaction);
@@ -568,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 {
@@ -633,11 +650,14 @@ 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) {
+  async explainQuery(innerQuery, readonly, parameters) {
     const cleaned = stripCommentsAndStrings(innerQuery, "sqlserver").trim();
     if (!cleaned) {
       throw new Error("EXPLAIN requires a statement to analyze");
     }
+    if (readonly) {
+      this.assertNoReadOnlyEscapes(innerQuery);
+    }
     if (/\bset\s+showplan/i.test(cleaned)) {
       throw new Error("EXPLAIN does not support SET SHOWPLAN statements");
     }
@@ -651,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 {
@@ -664,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.
@@ -672,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.23.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",