@bytebase/dbhub 0.22.6 → 0.24.0

package/dist/{sqlserver-47APXMSF.js → sqlserver-LHWZ7WOP.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-D2BIPC7V.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,13 +475,16 @@ 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());
+      return this.explainQuery(afterNoise.slice("explain".length).trim(), options.readonly);
     }
     try {
       let processedSQL = sqlQuery;
       if (options.maxRows) {
         processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
       }
+      if (options.readonly) {
+        return await this.executeReadOnly(processedSQL, parameters);
+      }
       const request = this.connection.request();
       const messages = [];
       request.on(
@@ -525,6 +541,122 @@ var _SQLServerConnector = class _SQLServerConnector {
       throw new Error(`Failed to execute query: ${error.message}`);
     }
   }
+  /**
+   * 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 (sqlServerDynamicSqlPattern.test(cleaned)) {
+      throw new Error(
+        `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);
+    const messages = [];
+    request.on(
+      "info",
+      (info) => {
+        messages.push({
+          text: info.message,
+          severity: info.class !== void 0 ? String(info.class) : void 0,
+          code: info.number,
+          line: info.lineNumber
+        });
+      }
+    );
+    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;
+    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 {
+        await transaction.rollback();
+      } catch (rollbackError) {
+        if (!queryFailed) {
+          throw new Error(
+            `Read-only rollback failed \u2014 data may have been modified: ${rollbackError.message}`
+          );
+        }
+      }
+    }
+    return {
+      rows: result.recordset || [],
+      rowCount: result.rowsAffected[0] || 0,
+      ...messages.length > 0 ? { messages } : {}
+    };
+  }
   /**
    * Return the estimated execution plan for a query using SHOWPLAN_XML.
    *
@@ -539,11 +671,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) {
     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");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.22.6",
+  "version": "0.24.0",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
@@ -21,6 +21,8 @@
     "build": "pnpm run generate:api-types && tsup && cd frontend && pnpm run build",
     "build:backend": "pnpm run generate:api-types && tsup",
     "build:frontend": "cd frontend && pnpm run build",
+    "build:mcpb": "pnpm run build:backend && node scripts/build-mcpb.mjs",
+    "test:mcpb": "node scripts/smoke-test-mcpb.mjs",
     "start": "node dist/index.js",
     "dev": "concurrently --kill-others \"pnpm run dev:backend\" \"pnpm run dev:frontend\"",
     "dev:backend": "NODE_ENV=development tsx src/index.ts --transport=http",
@@ -58,6 +60,7 @@
     "pg": "^8.13.3"
   },
   "devDependencies": {
+    "@anthropic-ai/mcpb": "^2.1.2",
     "@testcontainers/mariadb": "^11.0.3",
     "@testcontainers/mssqlserver": "^11.0.3",
     "@testcontainers/mysql": "^11.0.3",