@bytebase/dbhub 0.21.2 → 0.22.1

package/README.md

@@ -74,7 +74,7 @@ docker run --rm --init \
    --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
-**NPM:**
+**NPM:** (requires Node.js >= 22.5.0)
 
 ```bash
 npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
@@ -86,6 +86,14 @@ npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:p
 npx @bytebase/dbhub@latest --transport http --port 8080 --demo
 ```
 
+**Restrict to loopback (recommended for production):**
+
+```bash
+npx @bytebase/dbhub@latest --transport http --host 127.0.0.1 --port 8080 --demo
+```
+
+> The HTTP transport defaults to `--host 0.0.0.0`, exposing DBHub on every network interface. For production, bind to `127.0.0.1` and front DBHub with a reverse proxy (nginx/Caddy) or firewall — DBHub does not authenticate HTTP clients.
+
 See [Command-Line Options](https://dbhub.ai/config/command-line) for all available parameters.
 
 ### Multi-Database Setup
@@ -96,6 +104,8 @@ See [Multi-Database Configuration](https://dbhub.ai/config/toml) for complete se
 
 ## Development
 
+Requires Node.js >= 22.5.0 (DBHub uses the built-in `node:sqlite` module).
+
 ```bash
 # Install dependencies
 pnpm install

package/dist/{chunk-7D6RKVK2.js → chunk-MEBWJMLY.js}

@@ -701,6 +701,38 @@ function resolvePort() {
   }
   return { port: 8080, source: "default" };
 }
+function requireFlagValue(flag, args, example) {
+  const fail = () => {
+    console.error(`ERROR: --${flag} requires a value (e.g., --${flag}=${example}).`);
+    process.exit(1);
+  };
+  const rawArgs = process.argv.slice(2);
+  for (let i = 0; i < rawArgs.length; i++) {
+    const token = rawArgs[i];
+    if (token === `--${flag}`) {
+      const next = rawArgs[i + 1];
+      if (!next || next.startsWith("--")) fail();
+    } else if (token === `--${flag}=`) {
+      fail();
+    }
+  }
+  if (args[flag] === void 0) return void 0;
+  const value = args[flag].trim();
+  if (!value) fail();
+  return value;
+}
+function resolveHost() {
+  const args = parseCommandLineArgs();
+  const cliHost = requireFlagValue("host", args, "127.0.0.1");
+  if (cliHost !== void 0) {
+    return { host: cliHost, source: "command line argument" };
+  }
+  const envHost = process.env.DBHUB_HOST?.trim();
+  if (envHost) {
+    return { host: envHost, source: "environment variable" };
+  }
+  return { host: "0.0.0.0", source: "default" };
+}
 function redactDSN(dsn) {
   try {
     const url = new URL(dsn);
@@ -1132,12 +1164,45 @@ function validateSourceConfig(source, configPath) {
         `Configuration file ${configPath}: source '${source.id}' has sslmode but SQLite does not support SSL. Remove the sslmode field for SQLite sources.`
       );
     }
-    const validSslModes = ["disable", "require"];
+    const validSslModes = ["disable", "require", "verify-ca", "verify-full"];
     if (!validSslModes.includes(source.sslmode)) {
       throw new Error(
         `Configuration file ${configPath}: source '${source.id}' has invalid sslmode '${source.sslmode}'. Valid values: ${validSslModes.join(", ")}`
       );
     }
+    if ((source.sslmode === "verify-ca" || source.sslmode === "verify-full") && source.type !== "postgres") {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has sslmode '${source.sslmode}' which is only supported for PostgreSQL. Valid values for ${source.type}: disable, require`
+      );
+    }
+  }
+  if (source.sslrootcert !== void 0) {
+    if (source.sslmode !== "verify-ca" && source.sslmode !== "verify-full") {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has sslrootcert but sslmode is '${source.sslmode ?? "not set"}'. sslrootcert requires sslmode 'verify-ca' or 'verify-full'`
+      );
+    }
+    const expandedPath = expandHomeDir(source.sslrootcert);
+    let stats;
+    try {
+      stats = fs2.statSync(expandedPath);
+    } catch {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' sslrootcert file not found or not accessible: '${expandedPath}'`
+      );
+    }
+    if (!stats.isFile()) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' sslrootcert path is not a regular file: '${expandedPath}'`
+      );
+    }
+    try {
+      fs2.accessSync(expandedPath, fs2.constants.R_OK);
+    } catch {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' sslrootcert file is not readable: '${expandedPath}'`
+      );
+    }
   }
   if (source.authentication !== void 0) {
     if (source.type !== "sqlserver") {
@@ -1186,6 +1251,18 @@ function validateSourceConfig(source, configPath) {
       );
     }
   }
+  if (source.timezone !== void 0) {
+    if (source.type !== "mysql" && source.type !== "mariadb") {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has 'timezone' but it is only supported for MySQL and MariaDB sources.`
+      );
+    }
+    if (typeof source.timezone !== "string" || !/^(?:local|Z|[+-]\d\d:\d\d)$/.test(source.timezone)) {
+      throw new Error(
+        `Configuration file ${configPath}: source '${source.id}' has invalid timezone '${source.timezone}'. Must be "local", "Z" (UTC), or an offset like "+09:00".`
+      );
+    }
+  }
   if (source.readonly !== void 0) {
     throw new Error(
       `Configuration file ${configPath}: source '${source.id}' has 'readonly' field, but readonly must be configured per-tool, not per-source. Move 'readonly' to [[tools]] configuration instead.`
@@ -1203,6 +1280,9 @@ function processSourceConfigs(sources, configPath) {
     if (processed.ssh_key) {
       processed.ssh_key = expandHomeDir(processed.ssh_key);
     }
+    if (processed.sslrootcert) {
+      processed.sslrootcert = expandHomeDir(processed.sslrootcert);
+    }
     if (processed.type === "sqlite" && processed.database) {
       processed.database = expandHomeDir(processed.database);
     }
@@ -1228,6 +1308,18 @@ function processSourceConfigs(sources, configPath) {
           processed.user = connectionInfo.user;
         }
       }
+      try {
+        const url = new SafeURL(processed.dsn);
+        const dsnSslmode = url.getSearchParam("sslmode");
+        if (!processed.sslmode && dsnSslmode) {
+          processed.sslmode = dsnSslmode;
+        }
+        const dsnSslrootcert = url.getSearchParam("sslrootcert");
+        if (!processed.sslrootcert && dsnSslrootcert) {
+          processed.sslrootcert = dsnSslrootcert;
+        }
+      } catch {
+      }
     }
     return processed;
   });
@@ -1310,6 +1402,10 @@ function buildDSNFromSource(source) {
   if (source.sslmode && source.type !== "sqlite") {
     queryParams.push(`sslmode=${source.sslmode}`);
   }
+  if (source.sslrootcert && source.type === "postgres" && (source.sslmode === "verify-ca" || source.sslmode === "verify-full")) {
+    const expandedCertPath = expandHomeDir(source.sslrootcert);
+    queryParams.push(`sslrootcert=${encodeURIComponent(expandedCertPath)}`);
+  }
   if (queryParams.length > 0) {
     dsn += `?${queryParams.join("&")}`;
   }
@@ -1511,6 +1607,9 @@ var ConnectorManager = class {
     if (source.search_path) {
       config.searchPath = source.search_path;
     }
+    if (source.timezone) {
+      config.timezone = source.timezone;
+    }
     await connector.connect(actualDSN, source.init_script, config);
     this.connectors.set(sourceId, connector);
     if (!this.sourceIds.includes(sourceId)) {
@@ -1741,7 +1840,10 @@ var ConnectorManager = class {
       region: source.aws_region
     });
     const queryParams = new Map(parsed.searchParams);
-    queryParams.set("sslmode", "require");
+    const currentSslMode = queryParams.get("sslmode");
+    if (currentSslMode !== "verify-ca" && currentSslMode !== "verify-full") {
+      queryParams.set("sslmode", "require");
+    }
     const protocol = parsed.protocol.endsWith(":") ? parsed.protocol.slice(0, -1) : parsed.protocol;
     const encodedUser = encodeURIComponent(username);
     const encodedToken = encodeURIComponent(token);
@@ -2082,6 +2184,7 @@ export {
   isDemoMode,
   resolveTransport,
   resolvePort,
+  resolveHost,
   resolveSourceConfigs,
   BUILTIN_TOOL_EXECUTE_SQL,
   BUILTIN_TOOL_SEARCH_OBJECTS,

package/dist/index.js

@@ -8,11 +8,12 @@ import {
   isDemoMode,
   loadTomlConfig,
   mapArgumentsToArray,
+  resolveHost,
   resolvePort,
   resolveSourceConfigs,
   resolveTomlConfigPath,
   resolveTransport
-} from "./chunk-7D6RKVK2.js";
+} from "./chunk-MEBWJMLY.js";
 import {
   loadConnectors
 } from "./chunk-WVVMH6FJ.js";
@@ -33,6 +34,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import express from "express";
+import http from "http";
 import path from "path";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -281,7 +283,8 @@ function createExecuteSqlToolHandler(sourceId) {
       const responseData = {
         rows: result.rows,
         count: result.rowCount,
-        source_id: effectiveSourceId
+        source_id: effectiveSourceId,
+        ...result.messages && result.messages.length > 0 ? { messages: result.messages } : {}
       };
       return createToolSuccessResponse(responseData);
     } catch (error) {
@@ -307,7 +310,7 @@ function createExecuteSqlToolHandler(sourceId) {
 // src/tools/search-objects.ts
 import { z as z2 } from "zod";
 var searchDatabaseObjectsSchema = {
-  object_type: z2.enum(["schema", "table", "column", "procedure", "function", "index"]).describe("Object type to search"),
+  object_type: z2.enum(["schema", "table", "view", "column", "procedure", "function", "index"]).describe("Object type to search"),
   pattern: z2.string().optional().default("%").describe("LIKE pattern (% = any chars, _ = one char). Default: %"),
   schema: z2.string().optional().describe("Filter to schema"),
   table: z2.string().optional().describe("Filter to table (requires schema; column/index only)"),
@@ -451,6 +454,77 @@ async function searchTables(connector, pattern, schemaFilter, detailLevel, limit
   }
   return results;
 }
+async function searchViews(connector, pattern, schemaFilter, detailLevel, limit) {
+  const regex = likePatternToRegex(pattern);
+  const results = [];
+  let schemasToSearch;
+  if (schemaFilter) {
+    schemasToSearch = [schemaFilter];
+  } else {
+    schemasToSearch = await connector.getSchemas();
+  }
+  for (const schemaName of schemasToSearch) {
+    if (results.length >= limit) break;
+    try {
+      const views = await connector.getViews(schemaName);
+      const matched = views.filter((view) => regex.test(view));
+      for (const viewName of matched) {
+        if (results.length >= limit) break;
+        if (detailLevel === "names") {
+          results.push({
+            name: viewName,
+            schema: schemaName
+          });
+        } else if (detailLevel === "summary") {
+          try {
+            const columns = await connector.getTableSchema(viewName, schemaName);
+            const comment = await getTableComment(connector, viewName, schemaName);
+            results.push({
+              name: viewName,
+              schema: schemaName,
+              column_count: columns.length,
+              ...comment ? { comment } : {}
+            });
+          } catch (error) {
+            results.push({
+              name: viewName,
+              schema: schemaName,
+              column_count: null
+            });
+          }
+        } else {
+          try {
+            const columns = await connector.getTableSchema(viewName, schemaName);
+            const comment = await getTableComment(connector, viewName, schemaName);
+            results.push({
+              name: viewName,
+              schema: schemaName,
+              column_count: columns.length,
+              ...comment ? { comment } : {},
+              columns: columns.map((col) => ({
+                name: col.column_name,
+                type: col.data_type,
+                nullable: col.is_nullable === "YES",
+                default: col.column_default,
+                ...col.description ? { description: col.description } : {}
+              })),
+              indexes: []
+            });
+          } catch (error) {
+            results.push({
+              name: viewName,
+              schema: schemaName,
+              error: `Unable to fetch full details: ${error.message}`
+            });
+          }
+        }
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  return results;
+}
 async function searchColumns(connector, pattern, schemaFilter, tableFilter, detailLevel, limit) {
   const regex = likePatternToRegex(pattern);
   const results = [];
@@ -467,7 +541,11 @@ async function searchColumns(connector, pattern, schemaFilter, tableFilter, deta
       if (tableFilter) {
         tablesToSearch = [tableFilter];
       } else {
-        tablesToSearch = await connector.getTables(schemaName);
+        const [tables, views] = await Promise.all([
+          connector.getTables(schemaName),
+          Promise.resolve(connector.getViews(schemaName)).catch(() => [])
+        ]);
+        tablesToSearch = [...tables, ...views ?? []];
       }
       for (const tableName of tablesToSearch) {
         if (results.length >= limit) break;
@@ -649,6 +727,9 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
         case "table":
           results = await searchTables(connector, pattern, schema, detail_level, limit);
           break;
+        case "view":
+          results = await searchViews(connector, pattern, schema, detail_level, limit);
+          break;
         case "column":
           results = await searchColumns(connector, pattern, schema, table, detail_level, limit);
           break;
@@ -708,6 +789,11 @@ function normalizeSourceId(id) {
 }
 
 // src/utils/tool-metadata.ts
+function buildSourceDescriptionPrefix(description) {
+  const trimmed = description?.trim() ?? "";
+  if (!trimmed) return "";
+  return /[.!?:]$/.test(trimmed) ? `${trimmed} ` : `${trimmed}. `;
+}
 function zodToParameters(schema) {
   const parameters = [];
   for (const [key, zodType] of Object.entries(schema)) {
@@ -747,9 +833,10 @@ function getExecuteSqlMetadata(sourceId) {
   };
   const toolName = isSingleSource ? "execute_sql" : `execute_sql_${normalizeSourceId(sourceId)}`;
   const title = isSingleSource ? `Execute SQL (${dbType})` : `Execute SQL on ${sourceId} (${dbType})`;
+  const userDescPrefix = buildSourceDescriptionPrefix(sourceConfig.description);
   const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
   const maxRowsNote = executeOptions.maxRows ? ` (limited to ${executeOptions.maxRows} rows)` : "";
-  const description = isSingleSource ? `Execute SQL queries on the ${dbType} database${readonlyNote}${maxRowsNote}` : `Execute SQL queries on the '${sourceId}' ${dbType} database${readonlyNote}${maxRowsNote}`;
+  const description = isSingleSource ? `${userDescPrefix}Execute SQL queries on the ${dbType} database${readonlyNote}${maxRowsNote}` : `${userDescPrefix}Execute SQL queries on the '${sourceId}' ${dbType} database${readonlyNote}${maxRowsNote}`;
   const isReadonly = executeOptions.readonly === true;
   const annotations = {
     title,
@@ -776,7 +863,8 @@ function getSearchObjectsMetadata(sourceId) {
   const isSingleSource = sourceIds.length === 1;
   const toolName = isSingleSource ? "search_objects" : `search_objects_${normalizeSourceId(sourceId)}`;
   const title = isSingleSource ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
-  const description = isSingleSource ? `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the ${dbType} database` : `Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the '${sourceId}' ${dbType} database`;
+  const userDescPrefix = buildSourceDescriptionPrefix(sourceConfig.description);
+  const description = isSingleSource ? `${userDescPrefix}Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the ${dbType} database` : `${userDescPrefix}Search and list database objects (schemas, tables, columns, procedures, functions, indexes) on the '${sourceId}' ${dbType} database`;
   return {
     name: toolName,
     description,
@@ -1369,6 +1457,43 @@ Detected change in ${configPath}, reloading configuration...`);
   };
 }
 
+// src/utils/cross-origin.ts
+var INVALID_HOST_CHARS = /[\s/\\@?#]/;
+function validateOrigin(originHeader, hostHeader) {
+  if (originHeader === void 0) return { ok: true };
+  const trimmedOrigin = originHeader.trim();
+  if (!trimmedOrigin) {
+    return { ok: false, status: 400, message: "Malformed Origin header" };
+  }
+  const trimmedHost = (hostHeader ?? "").trim();
+  if (!trimmedHost || INVALID_HOST_CHARS.test(trimmedHost)) {
+    return { ok: false, status: 400, message: "Malformed Host header" };
+  }
+  let originHostname;
+  try {
+    originHostname = new URL(trimmedOrigin).hostname.toLowerCase();
+  } catch {
+    return { ok: false, status: 400, message: "Malformed Origin header" };
+  }
+  let hostname;
+  try {
+    hostname = new URL(`http://${trimmedHost}`).hostname.toLowerCase();
+  } catch {
+    return { ok: false, status: 400, message: "Malformed Host header" };
+  }
+  if (!hostname) {
+    return { ok: false, status: 400, message: "Malformed Host header" };
+  }
+  if (originHostname !== hostname) {
+    return {
+      ok: false,
+      status: 403,
+      message: "Origin does not match Host header"
+    };
+  }
+  return { ok: true };
+}
+
 // src/server.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
@@ -1421,7 +1546,7 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-Y755MTUO.js");
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-FZPB5LRL.js");
     initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -1441,6 +1566,7 @@ See documentation for more details on configuring database connections.
     };
     const transportData = resolveTransport();
     const port = transportData.type === "http" ? resolvePort().port : null;
+    const host = transportData.type === "http" ? resolveHost().host : null;
     const activeModes = [];
     const modeDescriptions = [];
     const isDemo = isDemoMode();
@@ -1466,19 +1592,12 @@ See documentation for more details on configuring database connections.
       app.use(express.json());
       app.use((req, res, next) => {
         const origin = req.headers.origin;
-        if (origin) {
-          const host = (req.headers.host ?? "").split(":")[0].toLowerCase();
-          try {
-            const originHost = new URL(origin).hostname.toLowerCase();
-            if (originHost !== host) {
-              return res.status(403).json({
-                error: "Forbidden",
-                message: "Origin does not match Host header (DNS rebinding protection)"
-              });
-            }
-          } catch {
-            return res.status(400).json({ error: "Bad Request", message: "Malformed Origin header" });
-          }
+        const result = validateOrigin(origin, req.headers.host);
+        if (!result.ok) {
+          return res.status(result.status).json({
+            error: result.status === 400 ? "Bad Request" : "Forbidden",
+            message: result.message
+          });
         }
         res.header("Access-Control-Allow-Origin", origin || "http://localhost");
         res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -1526,16 +1645,28 @@ See documentation for more details on configuring database connections.
           res.sendFile(path.join(frontendPath, "index.html"));
         });
       }
-      app.listen(port, "0.0.0.0", () => {
+      const httpServer = http.createServer(app);
+      httpServer.on("error", (err) => {
+        const displayHost = host.includes(":") ? `[${host}]` : host;
+        console.error(`Failed to bind HTTP server to ${displayHost}:${port}: ${err.message}`);
+        process.exit(1);
+      });
+      httpServer.listen(port, host, () => {
+        const address = httpServer.address();
+        const boundHost = typeof address === "object" && address ? address.address : host;
+        const boundPort = typeof address === "object" && address ? address.port : port;
+        const displayHost = boundHost.includes(":") ? `[${boundHost}]` : boundHost;
+        const userHost = boundHost === "0.0.0.0" || boundHost === "::" ? "localhost" : displayHost;
+        console.error(`HTTP server listening on ${displayHost}:${boundPort}`);
         if (process.env.NODE_ENV === "development") {
           console.error("Development mode detected!");
           console.error("   Workbench dev server (with HMR): http://localhost:5173");
-          console.error("   Backend API: http://localhost:8080");
+          console.error(`   Backend API: http://localhost:${boundPort}`);
           console.error("");
         } else {
-          console.error(`Workbench at http://localhost:${port}/`);
+          console.error(`Workbench at http://${userHost}:${boundPort}/`);
         }
-        console.error(`MCP server endpoint at http://localhost:${port}/mcp`);
+        console.error(`MCP server endpoint at http://${userHost}:${boundPort}/mcp`);
       });
     } else {
       const server = createServer();
@@ -1563,11 +1694,11 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-4PCNQDGV.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-YV3KVJ3B.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-FSCLCRIH.js"), name: "SQLite", driver: "better-sqlite3" },
-  { load: () => import("./mysql-M4INQQ46.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-4IBCPIEV.js"), name: "MariaDB", driver: "mariadb" }
+  { load: () => import("./postgres-EKVOBAH6.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-5E7DSDVX.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-2GBIF3MQ.js"), name: "SQLite", driver: "node:sqlite" },
+  { load: () => import("./mysql-NCKXNVZJ.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-DVQM4MMM.js"), name: "MariaDB", driver: "mariadb" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);

package/dist/{mariadb-4IBCPIEV.js → mariadb-DVQM4MMM.js}

@@ -46,6 +46,10 @@ Expected: ${expectedFormat}`
         },
         ...queryTimeoutSeconds !== void 0 && {
           queryTimeout: queryTimeoutSeconds * 1e3
+        },
+        // Controls how the driver interprets DATETIME values ("Z", "local", or "±HH:MM").
+        ...config?.timezone !== void 0 && {
+          timezone: config.timezone
         }
       };
       url.forEachSearchParam((value, key) => {
@@ -138,9 +142,10 @@ var MariaDBConnector = class _MariaDBConnector {
       const queryParams = schema ? [schema] : [];
       const rows = await this.pool.query(
         `
-        SELECT TABLE_NAME 
-        FROM INFORMATION_SCHEMA.TABLES 
+        SELECT TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
         ${schemaClause}
+        AND TABLE_TYPE = 'BASE TABLE'
         ORDER BY TABLE_NAME
       `,
         queryParams
@@ -151,6 +156,29 @@ var MariaDBConnector = class _MariaDBConnector {
       throw error;
     }
   }
+  async getViews(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const rows = await this.pool.query(
+        `
+        SELECT TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_TYPE = 'VIEW'
+        ORDER BY TABLE_NAME
+      `,
+        queryParams
+      );
+      return rows.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      console.error("Error getting views:", error);
+      throw error;
+    }
+  }
   async tableExists(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");

package/dist/{mysql-M4INQQ46.js → mysql-NCKXNVZJ.js}

@@ -20,6 +20,7 @@ import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
   async parse(dsn, config) {
     const connectionTimeoutSeconds = config?.connectionTimeoutSeconds;
+    const timezone = config?.timezone;
     if (!this.isValidDSN(dsn)) {
       const obfuscatedDSN = obfuscateDSNPassword(dsn);
       const expectedFormat = this.getSampleDSN();
@@ -57,6 +58,9 @@ Expected: ${expectedFormat}`
       if (connectionTimeoutSeconds !== void 0) {
         config2.connectTimeout = connectionTimeoutSeconds * 1e3;
       }
+      if (timezone !== void 0) {
+        config2.timezone = timezone;
+      }
       if (url.password && url.password.includes("X-Amz-Credential")) {
         config2.authPlugins = {
           mysql_clear_password: () => () => {
@@ -144,9 +148,10 @@ var MySQLConnector = class _MySQLConnector {
       const queryParams = schema ? [schema] : [];
       const [rows] = await this.pool.query(
         `
-        SELECT TABLE_NAME 
-        FROM INFORMATION_SCHEMA.TABLES 
+        SELECT TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
         ${schemaClause}
+        AND TABLE_TYPE = 'BASE TABLE'
         ORDER BY TABLE_NAME
       `,
         queryParams
@@ -157,6 +162,29 @@ var MySQLConnector = class _MySQLConnector {
       throw error;
     }
   }
+  async getViews(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE TABLE_SCHEMA = ?" : "WHERE TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const [rows] = await this.pool.query(
+        `
+        SELECT TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
+        ${schemaClause}
+        AND TABLE_TYPE = 'VIEW'
+        ORDER BY TABLE_NAME
+      `,
+        queryParams
+      );
+      return rows.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      console.error("Error getting views:", error);
+      throw error;
+    }
+  }
   async tableExists(tableName, schema) {
     if (!this.pool) {
       throw new Error("Not connected to database");

package/dist/{postgres-4PCNQDGV.js → postgres-EKVOBAH6.js}

@@ -12,7 +12,20 @@ import {
 } from "./chunk-C7WEAPX4.js";
 
 // src/connectors/postgres/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
 import pg from "pg";
+
+// src/connectors/postgres/failed-to-read-certificate.ts
+var FailedToReadCertificate = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FailedToReadCertificate";
+  }
+};
+
+// src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
   async parse(dsn, config) {
@@ -37,17 +50,38 @@ Expected: ${expectedFormat}`
         user: url.username,
         password: url.password
       };
+      let sslmode;
+      let sslrootcert;
       url.forEachSearchParam((value, key) => {
         if (key === "sslmode") {
-          if (value === "disable") {
-            poolConfig.ssl = false;
-          } else if (value === "require") {
-            poolConfig.ssl = { rejectUnauthorized: false };
-          } else {
-            poolConfig.ssl = true;
-          }
+          sslmode = value;
+        } else if (key === "sslrootcert") {
+          sslrootcert = value;
         }
       });
+      if (sslmode === "disable") {
+        poolConfig.ssl = false;
+      } else if (sslmode === "require") {
+        poolConfig.ssl = { rejectUnauthorized: false };
+      } else if (sslmode === "verify-ca" || sslmode === "verify-full") {
+        const sslConfig = { rejectUnauthorized: true };
+        if (sslmode === "verify-ca") {
+          sslConfig.checkServerIdentity = () => void 0;
+        }
+        if (sslrootcert) {
+          const certPath = sslrootcert.startsWith("~/") ? path.join(os.homedir(), sslrootcert.slice(2)) : sslrootcert;
+          try {
+            sslConfig.ca = await fs.promises.readFile(certPath, "utf-8");
+          } catch (err) {
+            throw new FailedToReadCertificate(
+              `Failed to read SSL root certificate at '${certPath}': ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        poolConfig.ssl = sslConfig;
+      } else if (sslmode !== void 0) {
+        poolConfig.ssl = true;
+      }
       if (connectionTimeoutSeconds !== void 0) {
         poolConfig.connectionTimeoutMillis = connectionTimeoutSeconds * 1e3;
       }
@@ -56,8 +90,13 @@ Expected: ${expectedFormat}`
       }
       return poolConfig;
     } catch (error) {
+      if (error instanceof FailedToReadCertificate) {
+        throw error;
+      }
+      const originalError = error instanceof Error ? error : new Error(String(error));
       throw new Error(
-        `Failed to parse PostgreSQL DSN: ${error instanceof Error ? error.message : String(error)}`
+        `Failed to parse PostgreSQL DSN: ${originalError.message}`,
+        { cause: originalError }
       );
     }
   }
@@ -145,9 +184,32 @@ var PostgresConnector = class _PostgresConnector {
       const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT table_name 
-        FROM information_schema.tables 
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
+        ORDER BY table_name
+      `,
+        [schemaToUse]
+      );
+      return result.rows.map((row) => row.table_name);
+    } finally {
+      client.release();
+    }
+  }
+  async getViews(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const client = await this.pool.connect();
+    try {
+      const schemaToUse = schema || this.defaultSchema;
+      const result = await client.query(
+        `
+        SELECT table_name
+        FROM information_schema.tables
         WHERE table_schema = $1
+        AND table_type = 'VIEW'
         ORDER BY table_name
       `,
         [schemaToUse]
@@ -167,8 +229,8 @@ var PostgresConnector = class _PostgresConnector {
       const result = await client.query(
         `
         SELECT EXISTS (
-          SELECT FROM information_schema.tables 
-          WHERE table_schema = $1 
+          SELECT FROM information_schema.tables
+          WHERE table_schema = $1
           AND table_name = $2
         )
       `,
@@ -188,18 +250,18 @@ var PostgresConnector = class _PostgresConnector {
       const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
+        SELECT
           i.relname as index_name,
           array_agg(a.attname) as column_names,
           ix.indisunique as is_unique,
           ix.indisprimary as is_primary
-        FROM 
+        FROM
           pg_class t,
           pg_class i,
           pg_index ix,
           pg_attribute a,
           pg_namespace ns
-        WHERE 
+        WHERE
           t.oid = ix.indrelid
           AND i.oid = ix.indexrelid
           AND a.attrelid = t.oid
@@ -208,11 +270,11 @@ var PostgresConnector = class _PostgresConnector {
           AND t.relname = $1
           AND ns.oid = t.relnamespace
           AND ns.nspname = $2
-        GROUP BY 
-          i.relname, 
+        GROUP BY
+          i.relname,
           ix.indisunique,
           ix.indisprimary
-        ORDER BY 
+        ORDER BY
           i.relname
       `,
         [tableName, schemaToUse]
@@ -353,7 +415,7 @@ var PostgresConnector = class _PostgresConnector {
       const schemaToUse = schema || this.defaultSchema;
       const result = await client.query(
         `
-        SELECT 
+        SELECT
           routine_name as procedure_name,
           routine_type,
           CASE WHEN routine_type = 'PROCEDURE' THEN 'procedure' ELSE 'function' END as procedure_type,
@@ -362,8 +424,8 @@ var PostgresConnector = class _PostgresConnector {
           routine_definition as definition,
           (
             SELECT string_agg(
-              parameter_name || ' ' || 
-              parameter_mode || ' ' || 
+              parameter_name || ' ' ||
+              parameter_mode || ' ' ||
               data_type,
               ', '
             )

package/dist/{registry-Y755MTUO.js → registry-FZPB5LRL.js}

@@ -2,7 +2,7 @@ import {
   ToolRegistry,
   getToolRegistry,
   initializeToolRegistry
-} from "./chunk-7D6RKVK2.js";
+} from "./chunk-MEBWJMLY.js";
 import "./chunk-WVVMH6FJ.js";
 import "./chunk-C7WEAPX4.js";
 export {

package/dist/{sqlite-FSCLCRIH.js → sqlite-2GBIF3MQ.js}

@@ -11,8 +11,24 @@ import {
   splitSQLStatements
 } from "./chunk-C7WEAPX4.js";
 
+// src/connectors/sqlite/suppress-experimental-warning.ts
+var installed = false;
+function suppressSqliteExperimentalWarning() {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  const originalEmitWarning = process.emitWarning.bind(process);
+  process.emitWarning = (warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning?.message;
+    if (message && message.includes("SQLite is an experimental feature")) {
+      return;
+    }
+    return originalEmitWarning(warning, ...args);
+  };
+}
+
 // src/connectors/sqlite/index.ts
-import Database from "better-sqlite3";
 var SQLiteDSNParser = class {
   async parse(dsn, config) {
     if (!this.isValidDSN(dsn)) {
@@ -73,6 +89,42 @@ var SQLiteConnector = class _SQLiteConnector {
   clone() {
     return new _SQLiteConnector();
   }
+  /**
+   * Prepare a user-facing query statement with BigInt reads enabled, so 64-bit
+   * integer values in the result rows keep full precision.
+   *
+   * better-sqlite3 exposed this connection-wide via `defaultSafeIntegers(true)`;
+   * `node:sqlite` only offers it per-statement via `setReadBigInts`. This is for
+   * `executeSQL` only — schema introspection reads small integer flags and uses
+   * `queryAll`/`queryOne` (plain numbers) so comparisons like `=== 1` work.
+   */
+  prepare(sql) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    const statement = this.db.prepare(sql);
+    statement.setReadBigInts(true);
+    return statement;
+  }
+  /**
+   * Run an introspection query and return all rows. Integers come back as plain
+   * numbers (no `setReadBigInts`), which is what the schema-reading callers need
+   * for boolean flag comparisons. node:sqlite types `.all()` as a generic record
+   * array, so the result is cast to the caller's expected row shape.
+   */
+  queryAll(sql, ...params) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return this.db.prepare(sql).all(...params);
+  }
+  /** Run an introspection query and return a single row (or undefined). */
+  queryOne(sql, ...params) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    return this.db.prepare(sql).get(...params);
+  }
   /**
    * Connect to SQLite database
    * Note: SQLite does not support connection timeouts as it's a local file-based database.
@@ -82,12 +134,18 @@ var SQLiteConnector = class _SQLiteConnector {
     const parsedConfig = await this.dsnParser.parse(dsn, config);
     this.dbPath = parsedConfig.dbPath;
     try {
-      const dbOptions = {};
+      suppressSqliteExperimentalWarning();
+      const { DatabaseSync } = await import("node:sqlite");
+      const dbOptions = {
+        // node:sqlite enables foreign key constraints by default, whereas
+        // better-sqlite3 (and SQLite's own default) leaves them off. Preserve
+        // the historical behavior; callers can opt in via `PRAGMA foreign_keys = ON`.
+        enableForeignKeyConstraints: false
+      };
       if (config?.readonly && this.dbPath !== ":memory:") {
-        dbOptions.readonly = true;
+        dbOptions.readOnly = true;
       }
-      this.db = new Database(this.dbPath, dbOptions);
-      this.db.defaultSafeIntegers(true);
+      this.db = new DatabaseSync(this.dbPath, dbOptions);
       if (initScript) {
         this.db.exec(initScript);
       }
@@ -99,7 +157,8 @@ var SQLiteConnector = class _SQLiteConnector {
   async disconnect() {
     if (this.db) {
       try {
-        if (!this.db.inTransaction) {
+        const inTransaction = this.db.isTransaction;
+        if (!inTransaction) {
           this.db.close();
         } else {
           try {
@@ -127,13 +186,26 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const rows = this.db.prepare(
-        `
-        SELECT name FROM sqlite_master 
+      const rows = this.queryAll(`
+        SELECT name FROM sqlite_master
         WHERE type='table' AND name NOT LIKE 'sqlite_%'
         ORDER BY name
-      `
-      ).all();
+      `);
+      return rows.map((row) => row.name);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getViews(schema) {
+    if (!this.db) {
+      throw new Error("Not connected to SQLite database");
+    }
+    try {
+      const rows = this.queryAll(`
+        SELECT name FROM sqlite_master
+        WHERE type='view' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `);
       return rows.map((row) => row.name);
     } catch (error) {
       throw error;
@@ -144,12 +216,13 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const row = this.db.prepare(
+      const row = this.queryOne(
         `
-        SELECT name FROM sqlite_master 
+        SELECT name FROM sqlite_master
         WHERE type='table' AND name = ?
-      `
-      ).get(tableName);
+      `,
+        tableName
+      );
       return !!row;
     } catch (error) {
       throw error;
@@ -160,28 +233,33 @@ var SQLiteConnector = class _SQLiteConnector {
       throw new Error("Not connected to SQLite database");
     }
     try {
-      const indexInfoRows = this.db.prepare(
+      const indexInfoRows = this.queryAll(
         `
-        SELECT 
+        SELECT
           name as index_name,
           0 as is_unique
-        FROM sqlite_master 
-        WHERE type = 'index' 
+        FROM sqlite_master
+        WHERE type = 'index'
         AND tbl_name = ?
-      `
-      ).all(tableName);
+      `,
+        tableName
+      );
       const quotedTableName = quoteIdentifier(tableName, "sqlite");
-      const indexListRows = this.db.prepare(`PRAGMA index_list(${quotedTableName})`).all();
+      const indexListRows = this.queryAll(
+        `PRAGMA index_list(${quotedTableName})`
+      );
       const indexUniqueMap = /* @__PURE__ */ new Map();
       for (const indexListRow of indexListRows) {
         indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
       }
-      const tableInfo = this.db.prepare(`PRAGMA table_info(${quotedTableName})`).all();
+      const tableInfo = this.queryAll(`PRAGMA table_info(${quotedTableName})`);
       const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
       const results = [];
       for (const indexInfo of indexInfoRows) {
         const quotedIndexName = quoteIdentifier(indexInfo.index_name, "sqlite");
-        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${quotedIndexName})`).all();
+        const indexDetailRows = this.queryAll(
+          `PRAGMA index_info(${quotedIndexName})`
+        );
         const columnNames = indexDetailRows.map((row) => row.name);
         results.push({
           index_name: indexInfo.index_name,
@@ -209,7 +287,7 @@ var SQLiteConnector = class _SQLiteConnector {
     }
     try {
       const quotedTableName = quoteIdentifier(tableName, "sqlite");
-      const rows = this.db.prepare(`PRAGMA table_info(${quotedTableName})`).all();
+      const rows = this.queryAll(`PRAGMA table_info(${quotedTableName})`);
       const columns = rows.map((row) => ({
         column_name: row.name,
         data_type: row.type,
@@ -253,7 +331,7 @@ var SQLiteConnector = class _SQLiteConnector {
         if (isReadStatement) {
           if (parameters && parameters.length > 0) {
             try {
-              const rows = this.db.prepare(processedStatement).all(...parameters);
+              const rows = this.prepare(processedStatement).all(...parameters);
               return { rows, rowCount: rows.length };
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
@@ -262,14 +340,14 @@ var SQLiteConnector = class _SQLiteConnector {
               throw error;
             }
           } else {
-            const rows = this.db.prepare(processedStatement).all();
+            const rows = this.prepare(processedStatement).all();
             return { rows, rowCount: rows.length };
           }
         } else {
           let result;
           if (parameters && parameters.length > 0) {
             try {
-              result = this.db.prepare(processedStatement).run(...parameters);
+              result = this.prepare(processedStatement).run(...parameters);
             } catch (error) {
               console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
               console.error(`[SQLite executeSQL] SQL: ${processedStatement}`);
@@ -277,9 +355,9 @@ var SQLiteConnector = class _SQLiteConnector {
               throw error;
             }
           } else {
-            result = this.db.prepare(processedStatement).run();
+            result = this.prepare(processedStatement).run();
           }
-          return { rows: [], rowCount: result.changes };
+          return { rows: [], rowCount: Number(result.changes) };
         }
       } else {
         if (parameters && parameters.length > 0) {
@@ -297,13 +375,13 @@ var SQLiteConnector = class _SQLiteConnector {
         }
         let totalChanges = 0;
         for (const statement of writeStatements) {
-          const result = this.db.prepare(statement).run();
-          totalChanges += result.changes;
+          const result = this.prepare(statement).run();
+          totalChanges += Number(result.changes);
         }
         let allRows = [];
         for (let statement of readStatements) {
           statement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
-          const result = this.db.prepare(statement).all();
+          const result = this.prepare(statement).all();
           allRows.push(...result);
         }
         return { rows: allRows, rowCount: totalChanges + allRows.length };

package/dist/{sqlserver-YV3KVJ3B.js → sqlserver-5E7DSDVX.js}

@@ -192,6 +192,7 @@ var SQLServerConnector = class _SQLServerConnector {
           SELECT TABLE_NAME
           FROM INFORMATION_SCHEMA.TABLES
           WHERE TABLE_SCHEMA = @schema
+          AND TABLE_TYPE = 'BASE TABLE'
           ORDER BY TABLE_NAME
       `;
       const result = await request.query(query);
@@ -200,6 +201,26 @@ var SQLServerConnector = class _SQLServerConnector {
       throw new Error(`Failed to get tables: ${error.message}`);
     }
   }
+  async getViews(schema) {
+    if (!this.connection) {
+      throw new Error("Not connected to SQL Server database");
+    }
+    try {
+      const schemaToUse = schema || "dbo";
+      const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
+      const query = `
+          SELECT TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = @schema
+          AND TABLE_TYPE = 'VIEW'
+          ORDER BY TABLE_NAME
+      `;
+      const result = await request.query(query);
+      return result.recordset.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      throw new Error(`Failed to get views: ${error.message}`);
+    }
+  }
   async tableExists(tableName, schema) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
@@ -442,6 +463,19 @@ var SQLServerConnector = class _SQLServerConnector {
         processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sqlQuery, options.maxRows);
       }
       const request = this.connection.request();
+      const messages = [];
+      request.on(
+        "info",
+        (info) => {
+          messages.push({
+            text: info.message,
+            // SQL Server reports severity as a numeric class; info messages are < 10.
+            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}`;
@@ -477,7 +511,8 @@ var SQLServerConnector = class _SQLServerConnector {
       }
       return {
         rows: result.recordset || [],
-        rowCount: result.rowsAffected[0] || 0
+        rowCount: result.rowsAffected[0] || 0,
+        ...messages.length > 0 ? { messages } : {}
       };
     } catch (error) {
       throw new Error(`Failed to execute query: ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.21.2",
+  "version": "0.22.1",
   "mcpName": "io.github.bytebase/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {
@@ -34,8 +34,9 @@
     "test:build": "node scripts/smoke-test-build.mjs"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.5.0"
   },
+  "packageManager": "pnpm@10.17.1",
   "keywords": [],
   "author": "",
   "license": "MIT",
@@ -51,7 +52,6 @@
   "optionalDependencies": {
     "@aws-sdk/rds-signer": "^3.1001.0",
     "@azure/identity": "^4.8.0",
-    "better-sqlite3": "^11.9.0",
     "mariadb": "^3.4.0",
     "mssql": "^11.0.1",
     "mysql2": "^3.13.0",
@@ -62,7 +62,6 @@
     "@testcontainers/mssqlserver": "^11.0.3",
     "@testcontainers/mysql": "^11.0.3",
     "@testcontainers/postgresql": "^11.0.3",
-    "@types/better-sqlite3": "^7.6.12",
     "@types/express": "^4.17.21",
     "@types/mssql": "^9.1.7",
     "@types/node": "^22.13.10",