@bytebase/dbhub 1.1.0 → 1.2.1

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-JYRRNC3E.js → registry-D2QVU6AG.js}

@@ -2,9 +2,9 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-GSSLHJB6.js";
+} from "./chunk-2DFLBX4D.js";
 import "./chunk-WVVMH6FJ.js";
-import "./chunk-JEZZN2YZ.js";
+import "./chunk-MF6LSVWK.js";
 export {
   ToolRegistry,
   getToolRegistry,

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

@@ -4,13 +4,13 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-6QETXS44.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
   splitSQLStatements
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-MF6LSVWK.js";
 
 // src/connectors/sqlite/suppress-experimental-warning.ts
 var installed = false;
@@ -334,17 +334,20 @@ var SQLiteConnector = class _SQLiteConnector {
         let processedStatement = statements[0];
         const trimmedStatement = statements[0].toLowerCase().trim();
         const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+        let probeApplied = false;
         if (options.maxRows) {
-          processedStatement = SQLRowLimiter.applyMaxRows(processedStatement, options.maxRows);
+          const rewrite = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
+            processedStatement,
+            options.maxRows
+          );
+          processedStatement = rewrite.sql;
+          probeApplied = rewrite.probeApplied;
         }
         if (isReadStatement) {
-          if (parameters && parameters.length > 0) {
-            const rows = this.prepare(processedStatement).all(...parameters);
-            return { rows, rowCount: rows.length };
-          } else {
-            const rows = this.prepare(processedStatement).all();
-            return { rows, rowCount: rows.length };
-          }
+          const rows = parameters && parameters.length > 0 ? this.prepare(processedStatement).all(...parameters) : this.prepare(processedStatement).all();
+          const resultSet = { sql: statements[0], rows, rowCount: rows.length };
+          SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
+          return { resultSets: [resultSet] };
         } else {
           let result;
           if (parameters && parameters.length > 0) {
@@ -352,7 +355,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 +373,28 @@ 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 { sql: processedStatement, probeApplied } = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
+            statement,
+            options.maxRows
+          );
+          const rows = this.prepare(processedStatement).all();
+          const resultSet = { sql: statement, rows, rowCount: rows.length };
+          SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
+          resultSets.push(resultSet);
         }
-        return { rows: allRows, rowCount: totalChanges + allRows.length };
+        return { resultSets };
       }
     } finally {
       if (options.readonly) {

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

@@ -3,7 +3,7 @@ import {
   sqlServerDynamicSqlPattern,
   sqlServerPassThroughKeywords,
   sqlServerPassThroughPattern
-} from "./chunk-EPOKWSFC.js";
+} from "./chunk-IQRBLAB4.js";
 import {
   isDriverNotInstalled
 } from "./chunk-WVVMH6FJ.js";
@@ -14,13 +14,14 @@ import {
 import {
   SQLRowLimiter,
   closeQuietly
-} from "./chunk-S2V6RZ3C.js";
+} from "./chunk-6QETXS44.js";
 import {
   ConnectorRegistry,
   SafeURL,
   obfuscateDSNPassword,
+  splitSQLStatements,
   stripCommentsAndStrings
-} from "./chunk-JEZZN2YZ.js";
+} from "./chunk-MF6LSVWK.js";
 
 // src/connectors/sqlserver/index.ts
 import sql from "mssql";
@@ -561,11 +562,24 @@ var _SQLServerConnector = class _SQLServerConnector {
     }
     try {
       let processedSQL = sqlQuery;
+      let probeApplied = false;
       if (options.maxRows) {
-        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
+        const rewrite = SQLRowLimiter.applyMaxRowsForSQLServerWithTruncationProbe(
+          sqlQuery,
+          options.maxRows
+        );
+        processedSQL = rewrite.sql;
+        probeApplied = rewrite.probeApplied;
       }
+      const isSingleStatement = splitSQLStatements(processedSQL, "sqlserver").length === 1;
       if (options.readonly) {
-        return await this.executeReadOnly(processedSQL, parameters);
+        return await this.executeReadOnly(
+          processedSQL,
+          parameters,
+          isSingleStatement ? sqlQuery : void 0,
+          options.maxRows,
+          probeApplied
+        );
       }
       const request = this.connection.request();
       const messages = [];
@@ -583,15 +597,62 @@ var _SQLServerConnector = class _SQLServerConnector {
       );
       _SQLServerConnector.bindParameters(request, parameters);
       const result = await request.query(processedSQL);
+      const resultSets = _SQLServerConnector.buildResultSets(
+        result.recordsets,
+        result.rowsAffected,
+        isSingleStatement ? sqlQuery : void 0
+      );
+      if (resultSets.length > 0) {
+        SQLRowLimiter.flagTruncation(resultSets[0], options.maxRows, probeApplied);
+      }
       return {
-        rows: result.recordset || [],
-        rowCount: result.rowsAffected[0] || 0,
+        resultSets,
         ...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
@@ -673,7 +734,7 @@ var _SQLServerConnector = class _SQLServerConnector {
    * Dangerous constructs are rejected before the transaction opens; see
    * assertNoReadOnlyEscapes.
    */
-  async executeReadOnly(processedSQL, parameters) {
+  async executeReadOnly(processedSQL, parameters, sourceSql, maxRows, probeApplied) {
     this.assertNoReadOnlyEscapes(processedSQL, { transactionControl: true });
     const transaction = new sql.Transaction(this.connection);
     await transaction.begin();
@@ -709,9 +770,16 @@ var _SQLServerConnector = class _SQLServerConnector {
         }
       }
     }
+    const resultSets = _SQLServerConnector.buildResultSets(
+      result.recordsets,
+      result.rowsAffected,
+      sourceSql
+    );
+    if (resultSets.length > 0) {
+      SQLRowLimiter.flagTruncation(resultSets[0], maxRows, probeApplied);
+    }
     return {
-      rows: result.recordset || [],
-      rowCount: result.rowsAffected[0] || 0,
+      resultSets,
       ...messages.length > 0 ? { messages } : {}
     };
   }
@@ -756,8 +824,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}`);
@@ -878,8 +950,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.1.0",
+  "version": "1.2.1",
   "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"
@@ -53,6 +55,7 @@
     "zod": "^4.2.0"
   },
   "optionalDependencies": {
+    "@aws-sdk/credential-providers": "^3.1001.0",
     "@aws-sdk/rds-signer": "^3.1001.0",
     "@azure/identity": "^4.8.0",
     "mariadb": "^3.4.0",

package/dist/chunk-S2V6RZ3C.js

@@ -1,138 +0,0 @@
-import {
-  stripCommentsAndStrings
-} from "./chunk-JEZZN2YZ.js";
-
-// src/utils/sql-row-limiter.ts
-var SQLRowLimiter = class {
-  /**
-   * Check if a SQL statement is a SELECT query that can benefit from row limiting
-   * Only handles SELECT queries
-   */
-  static isSelectQuery(sql) {
-    const trimmed = sql.trim().toLowerCase();
-    return trimmed.startsWith("select");
-  }
-  /**
-   * Check if a SQL statement already has a LIMIT clause.
-   * Strips comments and string literals first to avoid false positives.
-   */
-  static hasLimitClause(sql) {
-    const cleanedSQL = stripCommentsAndStrings(sql);
-    const limitRegex = /\blimit\s+(?:\d+|\$\d+|\?|@p\d+)/i;
-    return limitRegex.test(cleanedSQL);
-  }
-  /**
-   * Check if a SQL statement already has a TOP clause (SQL Server).
-   * Strips comments and string literals first to avoid false positives.
-   */
-  static hasTopClause(sql) {
-    const cleanedSQL = stripCommentsAndStrings(sql);
-    const topRegex = /\bselect\s+top\s+\d+/i;
-    return topRegex.test(cleanedSQL);
-  }
-  /**
-   * Extract existing LIMIT value from SQL if present.
-   * Strips comments and string literals first to avoid false positives.
-   */
-  static extractLimitValue(sql) {
-    const cleanedSQL = stripCommentsAndStrings(sql);
-    const limitMatch = cleanedSQL.match(/\blimit\s+(\d+)/i);
-    if (limitMatch) {
-      return parseInt(limitMatch[1], 10);
-    }
-    return null;
-  }
-  /**
-   * Extract existing TOP value from SQL if present (SQL Server).
-   * Strips comments and string literals first to avoid false positives.
-   */
-  static extractTopValue(sql) {
-    const cleanedSQL = stripCommentsAndStrings(sql);
-    const topMatch = cleanedSQL.match(/\bselect\s+top\s+(\d+)/i);
-    if (topMatch) {
-      return parseInt(topMatch[1], 10);
-    }
-    return null;
-  }
-  /**
-   * Add or modify LIMIT clause in a SQL statement
-   */
-  static applyLimitToQuery(sql, maxRows) {
-    const existingLimit = this.extractLimitValue(sql);
-    if (existingLimit !== null) {
-      const effectiveLimit = Math.min(existingLimit, maxRows);
-      return sql.replace(/\blimit\s+\d+/i, `LIMIT ${effectiveLimit}`);
-    } else {
-      const trimmed = sql.trim();
-      const hasSemicolon = trimmed.endsWith(";");
-      const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
-      return `${sqlWithoutSemicolon}
-LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
-    }
-  }
-  /**
-   * Add or modify TOP clause in a SQL statement (SQL Server)
-   */
-  static applyTopToQuery(sql, maxRows) {
-    const existingTop = this.extractTopValue(sql);
-    if (existingTop !== null) {
-      const effectiveTop = Math.min(existingTop, maxRows);
-      return sql.replace(/\bselect\s+top\s+\d+/i, `SELECT TOP ${effectiveTop}`);
-    } else {
-      return sql.replace(/\bselect\s+/i, `SELECT TOP ${maxRows} `);
-    }
-  }
-  /**
-   * Check if a LIMIT clause uses a parameter placeholder (not a literal number).
-   * Strips comments and string literals first to avoid false positives.
-   */
-  static hasParameterizedLimit(sql) {
-    const cleanedSQL = stripCommentsAndStrings(sql);
-    const parameterizedLimitRegex = /\blimit\s+(?:\$\d+|\?|@p\d+)/i;
-    return parameterizedLimitRegex.test(cleanedSQL);
-  }
-  /**
-   * Apply maxRows limit to a SELECT query only
-   *
-   * This method is used by PostgreSQL, MySQL, MariaDB, and SQLite connectors which all support
-   * the LIMIT clause syntax. SQL Server uses applyMaxRowsForSQLServer() instead with TOP syntax.
-   *
-   * For parameterized LIMIT clauses (e.g., LIMIT $1 or LIMIT ?), we wrap the query in a subquery
-   * to enforce max_rows as a hard cap, since the parameter value is not known until runtime.
-   */
-  static applyMaxRows(sql, maxRows) {
-    if (!maxRows || !this.isSelectQuery(sql)) {
-      return sql;
-    }
-    if (this.hasParameterizedLimit(sql)) {
-      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 this.applyLimitToQuery(sql, maxRows);
-  }
-  /**
-   * Apply maxRows limit to a SELECT query using SQL Server TOP syntax
-   */
-  static applyMaxRowsForSQLServer(sql, maxRows) {
-    if (!maxRows || !this.isSelectQuery(sql)) {
-      return sql;
-    }
-    return this.applyTopToQuery(sql, maxRows);
-  }
-};
-
-// src/utils/resource-cleanup.ts
-async function closeQuietly(close) {
-  try {
-    await close();
-  } catch {
-  }
-}
-
-export {
-  SQLRowLimiter,
-  closeQuietly
-};