@bytebase/dbhub 0.8.4 → 0.9.0

package/README.md

@@ -24,8 +24,6 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |  Cursor          +--->+    DBHub     +--->+    SQL Server    |
  |                  |    |              |    |                  |
- |  Other Clients   +--->+              +--->+    SQLite        |
- |                  |    |              |    |                  |
  |                  |    |              +--->+    MySQL         |
  |                  |    |              |    |                  |
  |                  |    |              +--->+    MariaDB       |
@@ -44,27 +42,27 @@ https://demo.dbhub.ai/message connects a [sample employee database](https://gith
 
 ### Database Resources
 
-| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
-| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: | :----: |
-| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
-| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
-| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
-| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |   ✅   |
-| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
-| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
+| Resource Name               | URI Format                                             | PostgreSQL | MySQL | MariaDB | SQL Server |
+| --------------------------- | ------------------------------------------------------ | :--------: | :---: | :-----: | :--------: |
+| schemas                     | `db://schemas`                                         |     ✅     |  ✅   |   ✅    |     ✅     |
+| tables_in_schema            | `db://schemas/{schemaName}/tables`                     |     ✅     |  ✅   |   ✅    |     ✅     |
+| table_structure_in_schema   | `db://schemas/{schemaName}/tables/{tableName}`         |     ✅     |  ✅   |   ✅    |     ✅     |
+| indexes_in_table            | `db://schemas/{schemaName}/tables/{tableName}/indexes` |     ✅     |  ✅   |   ✅    |     ✅     |
+| procedures_in_schema        | `db://schemas/{schemaName}/procedures`                 |     ✅     |  ✅   |   ✅    |     ✅     |
+| procedure_details_in_schema | `db://schemas/{schemaName}/procedures/{procedureName}` |     ✅     |  ✅   |   ✅    |     ✅     |
 
 ### Database Tools
 
-| Tool        | Command Name  | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
-| ----------- | ------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: | ------ |
-| Execute SQL | `execute_sql` | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Tool        | Command Name  | Description                                                         | PostgreSQL | MySQL | MariaDB | SQL Server |
+| ----------- | ------------- | ------------------------------------------------------------------- | :--------: | :---: | :-----: | :--------: |
+| Execute SQL | `execute_sql` | Execute single or multiple SQL statements (separated by semicolons) |     ✅     |  ✅   |   ✅    |     ✅     |
 
 ### Prompt Capabilities
 
-| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
-| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ |
-| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
-| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server |
+| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: |
+| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     |
+| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     |
 
 ## Installation
 
@@ -81,16 +79,6 @@ docker run --rm --init \
    --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
-```bash
-# Demo mode with sample employee database
-docker run --rm --init \
-   --name dbhub \
-   --publish 8080:8080 \
-   bytebase/dbhub \
-   --transport http \
-   --port 8080 \
-   --demo
-```
 
 
 ### NPM
@@ -100,12 +88,6 @@ docker run --rm --init \
 npx @bytebase/dbhub --transport http --port 8080 --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
-```bash
-# Demo mode with sample employee database
-npx @bytebase/dbhub --transport http --port 8080 --demo
-```
-
-> Note: The demo mode includes a bundled SQLite sample "employee" database with tables for employees, departments, salaries, and more.
 
 ### Claude Desktop
 
@@ -142,10 +124,6 @@ npx @bytebase/dbhub --transport http --port 8080 --demo
         "postgres://user:password@localhost:5432/dbname?sslmode=disable"
       ]
     },
-    "dbhub-demo": {
-      "command": "npx",
-      "args": ["-y", "@bytebase/dbhub", "--transport", "stdio", "--demo"]
-    }
   }
 }
 ```
@@ -171,7 +149,6 @@ You can specify the SSL mode using the `sslmode` parameter in your DSN string:
 | MySQL      |        ✅         |        ✅         |    Certificate verification    |
 | MariaDB    |        ✅         |        ✅         |    Certificate verification    |
 | SQL Server |        ✅         |        ✅         |    Certificate verification    |
-| SQLite     |        ❌         |        ❌         |        N/A (file-based)        |
 
 **SSL Mode Options:**
 
@@ -208,12 +185,6 @@ This provides an additional layer of security when connecting to production data
 
 ### Configure your database connection
 
-You can use DBHub in demo mode with a sample employee database for testing:
-
-```bash
-npx @bytebase/dbhub  --demo
-```
-
 > [!WARNING]
 > If your user/password contains special characters, you need to escape them first. (e.g. `pass#word` should be escaped as `pass%23word`)
 
@@ -250,7 +221,6 @@ DBHub supports the following database connection string formats:
 | MariaDB    | `mariadb://[user]:[password]@[host]:[port]/[database]`    | `mariadb://user:password@localhost:3306/dbname?sslmode=disable`                                                |
 | PostgreSQL | `postgres://[user]:[password]@[host]:[port]/[database]`   | `postgres://user:password@localhost:5432/dbname?sslmode=disable`                                               |
 | SQL Server | `sqlserver://[user]:[password]@[host]:[port]/[database]`  | `sqlserver://user:password@localhost:1433/dbname?sslmode=disable`                                              |
-| SQLite     | `sqlite:///[path/to/file]` or `sqlite:///:memory:`        | `sqlite:///path/to/database.db`, `sqlite:C:/Users/YourName/data/database.db (windows)` or `sqlite:///:memory:` |
 
 
 #### SQL Server
@@ -276,15 +246,13 @@ Extra query parameters:
 
 ### Command line options
 
-| Option    | Environment Variable | Description                                                      | Default                      |
-| --------- | -------------------- | ---------------------------------------------------------------- | ---------------------------- |
-| dsn       | `DSN`                | Database connection string                                       | Required if not in demo mode |
-| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                                | `stdio`                      |
-| port      | `PORT`               | HTTP server port (only applicable when using `--transport=http`) | `8080`                       |
-| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                   | `false`                      |
-| demo      | N/A                  | Run in demo mode with sample employee database                   | `false`                      |
+| Option    | Environment Variable | Description                                                      | Default  |
+| --------- | -------------------- | ---------------------------------------------------------------- | -------- |
+| dsn       | `DSN`                | Database connection string                                       | Required |
+| transport | `TRANSPORT`          | Transport mode: `stdio` or `http`                                | `stdio`  |
+| port      | `PORT`               | HTTP server port (only applicable when using `--transport=http`) | `8080`   |
+| readonly  | `READONLY`           | Restrict SQL execution to read-only operations                   | `false`  |
 
-The demo mode uses an in-memory SQLite database loaded with the [sample employee database](https://github.com/bytebase/dbhub/tree/main/resources/employee-sqlite) that includes tables for employees, departments, titles, salaries, department employees, and department managers. The sample database includes SQL scripts for table creation, data loading, and testing.
 
 ## Development
 
@@ -342,8 +310,6 @@ pnpm test src/connectors/__tests__/mysql.integration.test.ts
 pnpm test src/connectors/__tests__/mariadb.integration.test.ts
 # Run only SQL Server integration tests
 pnpm test src/connectors/__tests__/sqlserver.integration.test.ts
-# Run only SQLite integration tests
-pnpm test src/connectors/__tests__/sqlite.integration.test.ts
 # Run JSON RPC integration tests
 pnpm test src/__tests__/json-rpc-integration.test.ts
 ```

package/dist/index.js

@@ -159,9 +159,6 @@ function obfuscateDSNPassword(dsn) {
       return dsn;
     }
     const protocol = protocolMatch[1];
-    if (protocol === "sqlite") {
-      return dsn;
-    }
     const protocolPart = dsn.split("://")[1];
     if (!protocolPart) {
       return dsn;
@@ -879,246 +876,6 @@ var SQLServerConnector = class {
 var sqlServerConnector = new SQLServerConnector();
 ConnectorRegistry.register(sqlServerConnector);
 
-// src/connectors/sqlite/index.ts
-import Database from "better-sqlite3";
-var SQLiteDSNParser = class {
-  async parse(dsn) {
-    if (!this.isValidDSN(dsn)) {
-      const obfuscatedDSN = obfuscateDSNPassword(dsn);
-      const expectedFormat = this.getSampleDSN();
-      throw new Error(
-        `Invalid SQLite DSN format.
-Provided: ${obfuscatedDSN}
-Expected: ${expectedFormat}`
-      );
-    }
-    try {
-      const url = new SafeURL(dsn);
-      let dbPath;
-      if (url.hostname === "" && url.pathname === "/:memory:") {
-        dbPath = ":memory:";
-      } else {
-        if (url.pathname.startsWith("//")) {
-          dbPath = url.pathname.substring(2);
-        } else {
-          dbPath = url.pathname;
-        }
-      }
-      return { dbPath };
-    } catch (error) {
-      throw new Error(
-        `Failed to parse SQLite DSN: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  getSampleDSN() {
-    return "sqlite:///path/to/database.db";
-  }
-  isValidDSN(dsn) {
-    try {
-      return dsn.startsWith("sqlite://");
-    } catch (error) {
-      return false;
-    }
-  }
-};
-var SQLiteConnector = class {
-  constructor() {
-    this.id = "sqlite";
-    this.name = "SQLite";
-    this.dsnParser = new SQLiteDSNParser();
-    this.db = null;
-    this.dbPath = ":memory:";
-  }
-  // Default to in-memory database
-  async connect(dsn, initScript) {
-    const config = await this.dsnParser.parse(dsn);
-    this.dbPath = config.dbPath;
-    try {
-      this.db = new Database(this.dbPath);
-      console.error("Successfully connected to SQLite database");
-      if (initScript) {
-        this.db.exec(initScript);
-        console.error("Successfully initialized database with script");
-      }
-    } catch (error) {
-      console.error("Failed to connect to SQLite database:", error);
-      throw error;
-    }
-  }
-  async disconnect() {
-    if (this.db) {
-      try {
-        this.db.close();
-        this.db = null;
-      } catch (error) {
-        throw error;
-      }
-    }
-    return Promise.resolve();
-  }
-  async getSchemas() {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    return ["main"];
-  }
-  async getTables(schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    try {
-      const rows = this.db.prepare(
-        `
-        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 tableExists(tableName, schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    try {
-      const row = this.db.prepare(
-        `
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name = ?
-      `
-      ).get(tableName);
-      return !!row;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getTableIndexes(tableName, schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    try {
-      const indexInfoRows = this.db.prepare(
-        `
-        SELECT 
-          name as index_name,
-          0 as is_unique
-        FROM sqlite_master 
-        WHERE type = 'index' 
-        AND tbl_name = ?
-      `
-      ).all(tableName);
-      const indexListRows = this.db.prepare(`PRAGMA index_list(${tableName})`).all();
-      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(${tableName})`).all();
-      const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
-      const results = [];
-      for (const indexInfo of indexInfoRows) {
-        const indexDetailRows = this.db.prepare(`PRAGMA index_info(${indexInfo.index_name})`).all();
-        const columnNames = indexDetailRows.map((row) => row.name);
-        results.push({
-          index_name: indexInfo.index_name,
-          column_names: columnNames,
-          is_unique: indexUniqueMap.get(indexInfo.index_name) || false,
-          is_primary: false
-        });
-      }
-      if (pkColumns.length > 0) {
-        results.push({
-          index_name: "PRIMARY",
-          column_names: pkColumns,
-          is_unique: true,
-          is_primary: true
-        });
-      }
-      return results;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getTableSchema(tableName, schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    try {
-      const rows = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
-      const columns = rows.map((row) => ({
-        column_name: row.name,
-        data_type: row.type,
-        // In SQLite, primary key columns are automatically NOT NULL even if notnull=0
-        is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
-        column_default: row.dflt_value
-      }));
-      return columns;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getStoredProcedures(schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    return [];
-  }
-  async getStoredProcedureDetail(procedureName, schema) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    throw new Error(
-      "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
-    );
-  }
-  async executeSQL(sql2) {
-    if (!this.db) {
-      throw new Error("Not connected to SQLite database");
-    }
-    try {
-      const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
-      if (statements.length === 1) {
-        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"));
-        if (isReadStatement) {
-          const rows = this.db.prepare(statements[0]).all();
-          return { rows };
-        } else {
-          this.db.prepare(statements[0]).run();
-          return { rows: [] };
-        }
-      } else {
-        const readStatements = [];
-        const writeStatements = [];
-        for (const statement of statements) {
-          const trimmedStatement = statement.toLowerCase().trim();
-          if (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"))) {
-            readStatements.push(statement);
-          } else {
-            writeStatements.push(statement);
-          }
-        }
-        if (writeStatements.length > 0) {
-          this.db.exec(writeStatements.join("; "));
-        }
-        let allRows = [];
-        for (const statement of readStatements) {
-          const result = this.db.prepare(statement).all();
-          allRows.push(...result);
-        }
-        return { rows: allRows };
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
-};
-var sqliteConnector = new SQLiteConnector();
-ConnectorRegistry.register(sqliteConnector);
-
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
@@ -1880,9 +1637,9 @@ import { McpServer as McpServer2 } 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 path3 from "path";
+import path2 from "path";
 import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/connectors/manager.ts
 var managerInstance = null;
@@ -2016,10 +1773,6 @@ function loadEnvFiles() {
   }
   return null;
 }
-function isDemoMode() {
-  const args = parseCommandLineArgs();
-  return args.demo === "true";
-}
 function isReadOnlyMode() {
   const args = parseCommandLineArgs();
   if (args.readonly !== void 0) {
@@ -2032,13 +1785,6 @@ function isReadOnlyMode() {
 }
 function resolveDSN() {
   const args = parseCommandLineArgs();
-  if (isDemoMode()) {
-    return {
-      dsn: "sqlite:///:memory:",
-      source: "demo mode",
-      isDemo: true
-    };
-  }
   if (args.dsn) {
     return { dsn: args.dsn, source: "command line argument" };
   }
@@ -2087,45 +1833,6 @@ function redactDSN(dsn) {
   }
 }
 
-// src/config/demo-loader.ts
-import fs2 from "fs";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var DEMO_DATA_DIR;
-var projectRootPath = path2.join(__dirname2, "..", "..", "..");
-var projectResourcesPath = path2.join(projectRootPath, "resources", "employee-sqlite");
-var distPath = path2.join(__dirname2, "resources", "employee-sqlite");
-if (fs2.existsSync(projectResourcesPath)) {
-  DEMO_DATA_DIR = projectResourcesPath;
-} else if (fs2.existsSync(distPath)) {
-  DEMO_DATA_DIR = distPath;
-} else {
-  DEMO_DATA_DIR = path2.join(process.cwd(), "resources", "employee-sqlite");
-  if (!fs2.existsSync(DEMO_DATA_DIR)) {
-    throw new Error(`Could not find employee-sqlite resources in any of the expected locations: 
-      - ${projectResourcesPath}
-      - ${distPath}
-      - ${DEMO_DATA_DIR}`);
-  }
-}
-function loadSqlFile(fileName) {
-  const filePath = path2.join(DEMO_DATA_DIR, fileName);
-  return fs2.readFileSync(filePath, "utf8");
-}
-function getSqliteInMemorySetupSql() {
-  let sql2 = loadSqlFile("employee.sql");
-  const readRegex = /\.read\s+([a-zA-Z0-9_]+\.sql)/g;
-  let match;
-  while ((match = readRegex.exec(sql2)) !== null) {
-    const includePath = match[1];
-    const includeContent = loadSqlFile(includePath);
-    sql2 = sql2.replace(match[0], includeContent);
-  }
-  return sql2;
-}
-
 // src/resources/index.ts
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -2478,7 +2185,6 @@ var allowedKeywords = {
   postgres: ["select", "with", "explain", "analyze", "show"],
   mysql: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
   mariadb: ["select", "with", "explain", "analyze", "show", "describe", "desc"],
-  sqlite: ["select", "with", "explain", "analyze", "pragma"],
   sqlserver: ["select", "with", "explain", "showplan"]
 };
 
@@ -2546,9 +2252,6 @@ async function sqlGeneratorPromptHandler({
       case "postgres":
         sqlDialect = "postgres";
         break;
-      case "sqlite":
-        sqlDialect = "sqlite";
-        break;
       case "mysql":
         sqlDialect = "mysql";
         break;
@@ -2609,11 +2312,6 @@ ${accessibleSchemas.map(
           "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
           "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
         ],
-        sqlite: [
-          "SELECT * FROM users WHERE created_at > datetime('now', '-1 day')",
-          "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
-          "SELECT product_name, price FROM products WHERE price > (SELECT AVG(price) FROM products)"
-        ],
         mysql: [
           "SELECT * FROM users WHERE created_at > NOW() - INTERVAL 1 DAY",
           "SELECT u.name, COUNT(o.id) FROM users u JOIN orders o ON u.id = o.user_id GROUP BY u.name HAVING COUNT(o.id) > 5",
@@ -2945,9 +2643,9 @@ function registerPrompts(server) {
 }
 
 // src/server.ts
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path3.dirname(__filename3);
-var packageJsonPath = path3.join(__dirname3, "..", "package.json");
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var packageJsonPath = path2.join(__dirname2, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
@@ -2974,8 +2672,7 @@ async function main() {
 ERROR: Database connection string (DSN) is required.
 Please provide the DSN in one of these ways (in order of priority):
 
-1. Use demo mode: --demo (uses in-memory SQLite with sample employee database)
-2. Command line argument: --dsn="your-connection-string"
+1. Command line argument: --dsn="your-connection-string"
 3. Environment variable: export DSN="your-connection-string"
 4. .env file: DSN=your-connection-string
 
@@ -2999,22 +2696,13 @@ See documentation for more details on configuring database connections.
     const connectorManager = new ConnectorManager();
     console.error(`Connecting with DSN: ${redactDSN(dsnData.dsn)}`);
     console.error(`DSN source: ${dsnData.source}`);
-    if (dsnData.isDemo) {
-      const initScript = getSqliteInMemorySetupSql();
-      await connectorManager.connectWithDSN(dsnData.dsn, initScript);
-    } else {
-      await connectorManager.connectWithDSN(dsnData.dsn);
-    }
+    await connectorManager.connectWithDSN(dsnData.dsn);
     const transportData = resolveTransport();
     console.error(`Using transport: ${transportData.type}`);
     console.error(`Transport source: ${transportData.source}`);
     const readonly = isReadOnlyMode();
     const activeModes = [];
     const modeDescriptions = [];
-    if (dsnData.isDemo) {
-      activeModes.push("DEMO");
-      modeDescriptions.push("using sample employee database");
-    }
     if (readonly) {
       activeModes.push("READ-ONLY");
       modeDescriptions.push("only read only queries allowed");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -18,7 +18,6 @@
   "dependencies": {
     "@azure/identity": "^4.8.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "better-sqlite3": "^11.9.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "mariadb": "^3.4.0",
@@ -32,7 +31,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",
@@ -61,7 +59,7 @@
     "src/**/*"
   ],
   "lint-staged": {
-    "*.{js,ts}": "vitest related --run"
+    "*.{js,ts}": "pnpm run test:pre-commit"
   },
   "scripts": {
     "build": "tsup",
@@ -71,6 +69,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:integration": "vitest run --testNamePattern='Integration Tests'",
+    "test:pre-commit": "vitest related --run --exclude '**/sqlserver.integration.test.ts'",
     "pre-commit": "lint-staged"
   }
 }