@bytebase/dbhub 0.24.0 → 1.1.0

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

@@ -3,14 +3,18 @@ import {
   sqlServerDynamicSqlPattern,
   sqlServerPassThroughKeywords,
   sqlServerPassThroughPattern
-} from "./chunk-JO7YQPBQ.js";
+} from "./chunk-EPOKWSFC.js";
 import {
   isDriverNotInstalled
 } from "./chunk-WVVMH6FJ.js";
+import {
+  computeHitRatioPct,
+  toNullableNumber
+} from "./chunk-FU2ZJE4E.js";
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-D2BIPC7V.js";
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -372,6 +376,81 @@ var _SQLServerConnector = class _SQLServerConnector {
       return null;
     }
   }
+  async getHealthCheck() {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    const notes = [];
+    const result = {};
+    try {
+      const [connResult, maxConnResult] = await Promise.all([
+        this.connection.request().query(`
+          SELECT
+            COUNT(*) AS total,
+            SUM(CASE WHEN r.session_id IS NOT NULL THEN 1 ELSE 0 END) AS active,
+            SUM(CASE WHEN r.session_id IS NULL THEN 1 ELSE 0 END) AS idle,
+            SUM(CASE WHEN r.session_id IS NULL AND t.session_id IS NOT NULL THEN 1 ELSE 0 END) AS idle_in_transaction,
+            MAX(CASE WHEN r.session_id IS NULL AND t.session_id IS NOT NULL
+                  THEN DATEDIFF(SECOND, s.last_request_end_time, SYSDATETIME()) ELSE NULL END) AS longest_idle_in_transaction_seconds,
+            MAX(CASE WHEN r.session_id IS NOT NULL
+                  THEN DATEDIFF(SECOND, r.start_time, SYSDATETIME()) ELSE NULL END) AS longest_active_query_seconds
+          FROM sys.dm_exec_sessions s
+          LEFT JOIN sys.dm_exec_requests r ON r.session_id = s.session_id
+          LEFT JOIN (SELECT DISTINCT session_id FROM sys.dm_tran_session_transactions) t ON t.session_id = s.session_id
+          WHERE s.is_user_process = 1 AND s.session_id <> @@SPID
+        `),
+        this.connection.request().query(`
+          SELECT CAST(value_in_use AS INT) AS max_connections
+          FROM sys.configurations
+          WHERE name = 'user connections'
+        `)
+      ]);
+      const conn = connResult.recordset[0];
+      const maxConnections = maxConnResult.recordset.length > 0 && maxConnResult.recordset[0].max_connections > 0 ? maxConnResult.recordset[0].max_connections : null;
+      result.connections = {
+        total: conn.total ?? 0,
+        active: conn.active ?? 0,
+        idle: conn.idle ?? 0,
+        idleInTransaction: conn.idle_in_transaction ?? 0,
+        // SQL Server has no equivalent of Postgres's "idle in transaction
+        // (aborted)" state - a failed statement doesn't leave the session's
+        // transaction in a distinct aborted-but-open state the way Postgres does.
+        maxConnections,
+        longestIdleInTransactionSeconds: toNullableNumber(conn.longest_idle_in_transaction_seconds),
+        longestActiveQuerySeconds: toNullableNumber(conn.longest_active_query_seconds)
+      };
+    } catch {
+      notes.push(
+        "Connection pool metrics unavailable: connecting user lacks the VIEW SERVER STATE permission (VIEW DATABASE STATE on Azure SQL Database)."
+      );
+    }
+    try {
+      const bufferResult = await this.connection.request().query(`
+        SELECT counter_name, CAST(cntr_value AS BIGINT) AS cntr_value
+        FROM sys.dm_os_performance_counters
+        WHERE object_name LIKE '%Buffer Manager%'
+          AND counter_name IN ('Page lookups/sec', 'Page reads/sec')
+      `);
+      const counters = Object.fromEntries(
+        bufferResult.recordset.map((row) => [row.counter_name.trim(), Number(row.cntr_value)])
+      );
+      const pageLookups = counters["Page lookups/sec"] ?? 0;
+      const pageReads = counters["Page reads/sec"] ?? 0;
+      result.bufferCache = {
+        hitRatioPct: computeHitRatioPct(pageLookups, pageReads),
+        blocksHit: pageLookups - pageReads,
+        blocksRead: pageReads
+      };
+    } catch {
+      notes.push(
+        "Buffer cache metrics unavailable: connecting user lacks the VIEW SERVER STATE permission (VIEW DATABASE STATE on Azure SQL Database)."
+      );
+    }
+    if (notes.length > 0) {
+      result.notes = notes;
+    }
+    return result;
+  }
   async getStoredProcedures(schema, routineType) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
@@ -475,7 +554,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 +581,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 +592,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 +690,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 +729,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 +750,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 +765,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 +944,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.1.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",

package/dist/chunk-DUCNPMNW.js

@@ -1,113 +0,0 @@
-import {
-  obfuscateDSNPassword
-} from "./chunk-JEZZN2YZ.js";
-
-// src/utils/dsn-database.ts
-var MissingDatabaseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MissingDatabaseError";
-  }
-};
-function requireDatabaseInDSN(database, dsn, label) {
-  if (database) {
-    return;
-  }
-  throw new MissingDatabaseError(
-    `${label} DSN must name a database.
-Provided: ${obfuscateDSNPassword(dsn)}
-Add the database to the DSN, e.g. ...:3306/mydb
-To work with several databases, define one [[sources]] entry per database in a TOML config file: https://dbhub.ai/config/toml`
-  );
-}
-
-// src/utils/multi-statement-result-parser.ts
-function isMetadataObject(element) {
-  if (!element || typeof element !== "object" || Array.isArray(element)) {
-    return false;
-  }
-  return "affectedRows" in element || "insertId" in element || "fieldCount" in element || "warningStatus" in element;
-}
-function isMultiStatementResult(results) {
-  if (!Array.isArray(results) || results.length === 0) {
-    return false;
-  }
-  const firstElement = results[0];
-  return isMetadataObject(firstElement) || Array.isArray(firstElement);
-}
-function extractRowsFromMultiStatement(results) {
-  if (!Array.isArray(results)) {
-    return [];
-  }
-  const allRows = [];
-  for (const result of results) {
-    if (Array.isArray(result)) {
-      allRows.push(...result);
-    }
-  }
-  return allRows;
-}
-function extractAffectedRows(results) {
-  if (isMetadataObject(results)) {
-    return results.affectedRows || 0;
-  }
-  if (!Array.isArray(results)) {
-    return 0;
-  }
-  if (isMultiStatementResult(results)) {
-    let totalAffected = 0;
-    for (const result of results) {
-      if (isMetadataObject(result)) {
-        totalAffected += result.affectedRows || 0;
-      } else if (Array.isArray(result)) {
-        totalAffected += result.length;
-      }
-    }
-    return totalAffected;
-  }
-  return results.length;
-}
-function parseQueryResults(results) {
-  if (!Array.isArray(results)) {
-    return [];
-  }
-  if (isMultiStatementResult(results)) {
-    return extractRowsFromMultiStatement(results);
-  }
-  return results;
-}
-
-// src/utils/readonly-transaction.ts
-async function withReadOnlyTransaction(conn, readonly, supportsReadOnlyTransaction, execute) {
-  if (!readonly) {
-    return execute();
-  }
-  try {
-    await conn.query(
-      supportsReadOnlyTransaction ? "START TRANSACTION READ ONLY" : "START TRANSACTION"
-    );
-    const result = await execute();
-    await conn.query(supportsReadOnlyTransaction ? "COMMIT" : "ROLLBACK");
-    return result;
-  } catch (error) {
-    try {
-      await conn.query("ROLLBACK");
-    } catch {
-    }
-    throw error;
-  }
-}
-
-// src/utils/server-flavor.ts
-function isTiDBVersion(version) {
-  return typeof version === "string" && /tidb/i.test(version);
-}
-
-export {
-  MissingDatabaseError,
-  requireDatabaseInDSN,
-  extractAffectedRows,
-  parseQueryResults,
-  withReadOnlyTransaction,
-  isTiDBVersion
-};