@bytebase/dbhub 1.0.0 → 1.2.0

package/dist/public/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>DBHub - Minimal Database MCP Server</title>
-    <script type="module" crossorigin src="/assets/index-DBYlgGks.js"></script>
+    <script type="module" crossorigin src="/assets/index-DOZ5HOZ9.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BJ-1UrcV.css">
   </head>
   <body>

package/dist/{registry-ZU6ZFNQ2.js → registry-XMEJF7WW.js}

@@ -2,9 +2,9 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-MQR6VX5F.js";
+} from "./chunk-CUBIR72I.js";
 import "./chunk-WVVMH6FJ.js";
-import "./chunk-JEZZN2YZ.js";
+import "./chunk-WIQ4DWGY.js";
 export {
   ToolRegistry,
   getToolRegistry,

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

@@ -4,13 +4,13 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-RSB7DPO2.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
   splitSQLStatements
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-WIQ4DWGY.js";
 
 // src/connectors/sqlite/suppress-experimental-warning.ts
 var installed = false;
@@ -340,10 +340,10 @@ var SQLiteConnector = class _SQLiteConnector {
         if (isReadStatement) {
           if (parameters && parameters.length > 0) {
             const rows = this.prepare(processedStatement).all(...parameters);
-            return { rows, rowCount: rows.length };
+            return { resultSets: [{ sql: statements[0], rows, rowCount: rows.length }] };
           } else {
             const rows = this.prepare(processedStatement).all();
-            return { rows, rowCount: rows.length };
+            return { resultSets: [{ sql: statements[0], rows, rowCount: rows.length }] };
           }
         } else {
           let result;
@@ -352,7 +352,9 @@ var SQLiteConnector = class _SQLiteConnector {
           } else {
             result = this.prepare(processedStatement).run();
           }
-          return { rows: [], rowCount: Number(result.changes) };
+          return {
+            resultSets: [{ sql: statements[0], rows: [], rowCount: Number(result.changes) }]
+          };
         }
       } else {
         if (parameters && parameters.length > 0) {
@@ -368,24 +370,23 @@ var SQLiteConnector = class _SQLiteConnector {
             writeStatements.push(statement);
           }
         }
-        let totalChanges = 0;
+        const resultSets = [];
         for (const statement of writeStatements) {
           if (options.readonly) {
             this.db.exec("PRAGMA query_only = ON");
           }
           const result = this.prepare(statement).run();
-          totalChanges += Number(result.changes);
+          resultSets.push({ sql: statement, rows: [], rowCount: Number(result.changes) });
         }
-        let allRows = [];
-        for (let statement of readStatements) {
+        for (const statement of readStatements) {
           if (options.readonly) {
             this.db.exec("PRAGMA query_only = ON");
           }
-          statement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
-          const result = this.prepare(statement).all();
-          allRows.push(...result);
+          const processedStatement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+          const rows = this.prepare(processedStatement).all();
+          resultSets.push({ sql: statement, rows, rowCount: rows.length });
         }
-        return { rows: allRows, rowCount: totalChanges + allRows.length };
+        return { resultSets };
       }
     } finally {
       if (options.readonly) {

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

@@ -3,20 +3,25 @@ import {
   sqlServerDynamicSqlPattern,
   sqlServerPassThroughKeywords,
   sqlServerPassThroughPattern
-} from "./chunk-JO7YQPBQ.js";
+} from "./chunk-PBN2UXB5.js";
 import {
   isDriverNotInstalled
 } from "./chunk-WVVMH6FJ.js";
+import {
+  computeHitRatioPct,
+  toNullableNumber
+} from "./chunk-FU2ZJE4E.js";
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-RSB7DPO2.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
+  splitSQLStatements,
   stripCommentsAndStrings
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-WIQ4DWGY.js";
 
 // src/connectors/sqlserver/index.ts
 import sql from "mssql";
@@ -372,6 +377,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");
@@ -485,8 +565,9 @@ var _SQLServerConnector = class _SQLServerConnector {
       if (options.maxRows) {
         processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
       }
+      const isSingleStatement = splitSQLStatements(processedSQL, "sqlserver").length === 1;
       if (options.readonly) {
-        return await this.executeReadOnly(processedSQL, parameters);
+        return await this.executeReadOnly(processedSQL, parameters, isSingleStatement);
       }
       const request = this.connection.request();
       const messages = [];
@@ -505,14 +586,57 @@ var _SQLServerConnector = class _SQLServerConnector {
       _SQLServerConnector.bindParameters(request, parameters);
       const result = await request.query(processedSQL);
       return {
-        rows: result.recordset || [],
-        rowCount: result.rowsAffected[0] || 0,
+        resultSets: _SQLServerConnector.buildResultSets(
+          result.recordsets,
+          result.rowsAffected,
+          isSingleStatement ? processedSQL : void 0
+        ),
         ...messages.length > 0 ? { messages } : {}
       };
     } catch (error) {
       throw new Error(`Failed to execute query: ${error.message}`);
     }
   }
+  /**
+   * Builds one result set per SELECT-producing statement in the batch, plus
+   * (if any) a trailing result set summarizing the write-only statements.
+   *
+   * node-mssql only pushes a `recordsets` entry for statements that produce
+   * columns (SELECT); INSERT/UPDATE/DELETE statements in the same batch
+   * contribute to `rowsAffected` only, with no way to recover which
+   * `rowsAffected` entry belongs to which statement from the driver's final
+   * arrays (`recordsets`/`rowsAffected` aren't index-aligned - see the
+   * tedious `doneHandler`, which always pushes to `rowsAffected` but only
+   * conditionally to `recordsets`). So a batch of pure writes collapses to a
+   * single summed result set, and a batch mixing writes with selects gets
+   * one result set per select plus one trailing "writes" set for the rest -
+   * not a truly per-statement breakdown, but no read statement's rows are
+   * ever merged with another's, which is what mattered for #380.
+   *
+   * `sourceSql`, when given, is attributed to the single resulting set - it
+   * must be omitted (pass `undefined`) unless the caller has already
+   * confirmed the batch is unambiguously one statement, since for a genuine
+   * multi-statement batch there's no reliable way to say which source
+   * statement a given recordset (or the trailing writes set) came from.
+   */
+  static buildResultSets(recordsets, rowsAffected, sourceSql) {
+    const sets = (recordsets ?? []).map((recordset) => {
+      const rows = recordset ?? [];
+      return { rows, rowCount: rows.length };
+    });
+    const totalAffected = (rowsAffected ?? []).reduce((total, count) => total + (count ?? 0), 0);
+    const accountedFor = sets.reduce((total, set) => total + set.rowCount, 0);
+    const writesOnly = totalAffected - accountedFor;
+    if (sets.length === 0) {
+      sets.push({ rows: [], rowCount: totalAffected });
+    } else if (writesOnly > 0) {
+      sets.push({ rows: [], rowCount: writesOnly });
+    }
+    if (sets.length === 1 && sourceSql !== void 0) {
+      sets[0].sql = sourceSql;
+    }
+    return sets;
+  }
   /**
    * Bind positional parameters as @p1, @p2, ... inferring the SQL Server type
    * from each JavaScript value. Shared by every execution path so they cannot
@@ -594,7 +718,7 @@ var _SQLServerConnector = class _SQLServerConnector {
    * Dangerous constructs are rejected before the transaction opens; see
    * assertNoReadOnlyEscapes.
    */
-  async executeReadOnly(processedSQL, parameters) {
+  async executeReadOnly(processedSQL, parameters, isSingleStatement) {
     this.assertNoReadOnlyEscapes(processedSQL, { transactionControl: true });
     const transaction = new sql.Transaction(this.connection);
     await transaction.begin();
@@ -631,8 +755,11 @@ var _SQLServerConnector = class _SQLServerConnector {
       }
     }
     return {
-      rows: result.recordset || [],
-      rowCount: result.rowsAffected[0] || 0,
+      resultSets: _SQLServerConnector.buildResultSets(
+        result.recordsets,
+        result.rowsAffected,
+        isSingleStatement ? processedSQL : void 0
+      ),
       ...messages.length > 0 ? { messages } : {}
     };
   }
@@ -677,8 +804,12 @@ var _SQLServerConnector = class _SQLServerConnector {
       const planRow = planResult.recordset?.[0];
       const planXml = planRow ? Object.values(planRow)[0] : null;
       return {
-        rows: planXml != null ? [{ plan: planXml }] : [],
-        rowCount: planXml != null ? 1 : 0
+        resultSets: [
+          {
+            rows: planXml != null ? [{ plan: planXml }] : [],
+            rowCount: planXml != null ? 1 : 0
+          }
+        ]
       };
     } catch (error) {
       throw new Error(`Failed to explain query: ${error.message}`);
@@ -799,8 +930,12 @@ var _SQLServerConnector = class _SQLServerConnector {
       }
       const planXml = _SQLServerConnector.extractPlanXml(planResult);
       return {
-        rows: planXml != null ? [{ plan: planXml }] : [],
-        rowCount: planXml != null ? 1 : 0
+        resultSets: [
+          {
+            rows: planXml != null ? [{ plan: planXml }] : [],
+            rowCount: planXml != null ? 1 : 0
+          }
+        ]
       };
     } catch (error) {
       throw new Error(`Failed to explain analyze query: ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
@@ -33,7 +33,9 @@
     "test:unit": "vitest run --project unit",
     "test:watch": "vitest",
     "test:integration": "vitest run --project integration",
-    "test:build": "node scripts/smoke-test-build.mjs"
+    "test:build": "node scripts/smoke-test-build.mjs",
+    "sync-version": "node scripts/sync-version.mjs",
+    "version": "pnpm run sync-version && git add plugin/.claude-plugin/plugin.json plugin/.mcp.json server.json"
   },
   "engines": {
     "node": ">=22.5.0"

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
-};