@bytebase/dbhub 0.0.6 → 0.0.7

package/README.md

@@ -1,7 +1,7 @@
 <p align="center">
 <a href="https://dbhub.ai/" target="_blank">
 <picture>
-  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/assets/logo-full.svg" width="50%">
+  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/logo-full.svg" width="50%">
 </picture>
 </a>
 </p>
@@ -14,14 +14,16 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |  Claude Desktop  +--->+              +--->+    PostgreSQL    |
  |                  |    |              |    |                  |
- |      Cursor      +--->+    DBHub     +--->+      MySQL       |
+ |      Cursor      +--->+    DBHub     +--->+    SQL Server    |
  |                  |    |              |    |                  |
  |     Other MCP    +--->+              +--->+     SQLite       |
  |      Clients     |    |              |    |                  |
- |                  |    |              +--->+     DuckDB       |
+ |                  |    |              +--->+     MySQL        |
  |                  |    |              |    |                  |
+ |                  |    |              +--->+     DuckDB       |
+ |                  |    |              |    |      (soon)      |
  |                  |    |              +--->+  Other Databases |
- |                  |    |              |    |                  |
+ |                  |    |              |    |     (coming)     |
  +------------------+    +--------------+    +------------------+
       MCP Clients           MCP Server             Databases
 ```
@@ -38,6 +40,7 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
 ### Docker
 
 ```bash
+# PostgreSQL example
 docker run --rm --init \
    --name dbhub \
    --publish 8080:8080 \
@@ -45,12 +48,37 @@ docker run --rm --init \
    --transport sse \
    --port 8080 \
    --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+
+# SQLite in-memory example
+docker run --rm --init \
+   --name dbhub \
+   --publish 8080:8080 \
+   bytebase/dbhub \
+   --transport sse \
+   --port 8080 \
+   --dsn "sqlite::memory:"
+
+# MySQL example
+docker run --rm --init \
+   --name dbhub \
+   --publish 8080:8080 \
+   bytebase/dbhub \
+   --transport sse \
+   --port 8080 \
+   --dsn "mysql://user:password@localhost:3306/dbname"
 ```
 
 ### NPM
 
 ```bash
+# PostgreSQL example
 npx @bytebase/dbhub --transport sse --port 8080 --dsn "postgres://user:password@localhost:5432/dbname"
+
+# SQLite example
+npx @bytebase/dbhub --transport sse --port 8080 --dsn "sqlite:///path/to/database.db"
+
+# MySQL example
+npx @bytebase/dbhub --transport sse --port 8080 --dsn "mysql://user:password@localhost:3306/dbname"
 ```
 
 ## Usage
@@ -79,6 +107,17 @@ Database Source Name (DSN) is required to connect to your database. You can prov
   DSN=postgres://user:password@localhost:5432/dbname?sslmode=disable
   ```
 
+### Supported DSN formats
+
+DBHub supports the following database connection string formats:
+
+| Database   | DSN Format                                                | Example                                                 |
+|------------|-----------------------------------------------------------|--------------------------------------------------------|
+| PostgreSQL | `postgres://[user]:[password]@[host]:[port]/[database]`   | `postgres://user:password@localhost:5432/dbname?sslmode=disable` |
+| SQLite     | `sqlite:///[path/to/file]` or `sqlite::memory:`           | `sqlite:///path/to/database.db` or `sqlite::memory:`  |
+| SQL Server | `sqlserver://[user]:[password]@[host]:[port]/[database]`  | `sqlserver://user:password@localhost:1433/dbname`      |
+| MySQL      | `mysql://[user]:[password]@[host]:[port]/[database]`      | `mysql://user:password@localhost:3306/dbname`          |
+
 ### Transport
 
 - **stdio** (default) - for direct integration with tools like Claude Desktop:
@@ -102,17 +141,17 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 
 ### Claude Desktop
 
-![claude-desktop](https://raw.githubusercontent.com/bytebase/dbhub/main/assets/claude-desktop.webp)
+![claude-desktop](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/claude-desktop.webp)
 
 - Claude Desktop only supports `stdio` transport https://github.com/orgs/modelcontextprotocol/discussions/16
 
 #### Docker
 
 ```json
-// claude_desktop_config.json
+// claude_desktop_config.json - PostgreSQL example
 {
   "mcpServers": {
-    "dbhub": {
+    "dbhub-postgres": {
       "command": "docker",
       "args": [
         "run",
@@ -130,13 +169,34 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 }
 ```
 
+```json
+// claude_desktop_config.json - SQLite example (in-memory)
+{
+  "mcpServers": {
+    "dbhub-sqlite": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        "sqlite::memory:"
+      ]
+    }
+  }
+}
+```
+
 #### NPX
 
 ```json
-// claude_desktop_config.json
+// claude_desktop_config.json - PostgreSQL example
 {
   "mcpServers": {
-    "dbhub": {
+    "dbhub-postgres": {
       "command": "npx",
       "args": [
         "-y",
@@ -151,6 +211,44 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 }
 ```
 
+```json
+// claude_desktop_config.json - SQLite example
+{
+  "mcpServers": {
+    "dbhub-sqlite": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        "sqlite:///path/to/database.db"
+      ]
+    }
+  }
+}
+```
+
+```json
+// claude_desktop_config.json - MySQL example
+{
+  "mcpServers": {
+    "dbhub-mysql": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        "mysql://user:password@localhost:3306/dbname"
+      ]
+    }
+  }
+}
+```
+
 ## Development
 
 1. Install dependencies:
@@ -176,7 +274,17 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 #### stdio
 
 ```bash
+# PostgreSQL example
 TRANSPORT=stdio DSN="postgres://user:password@localhost:5432/dbname?sslmode=disable" npx @modelcontextprotocol/inspector node /path/to/dbhub/dist/index.js
+
+# SQLite example
+TRANSPORT=stdio DSN="sqlite:///path/to/database.db" npx @modelcontextprotocol/inspector node /path/to/dbhub/dist/index.js
+
+# SQLite in-memory example  
+TRANSPORT=stdio DSN="sqlite::memory:" npx @modelcontextprotocol/inspector node /path/to/dbhub/dist/index.js
+
+# MySQL example
+TRANSPORT=stdio DSN="mysql://user:password@localhost:3306/dbname" npx @modelcontextprotocol/inspector node /path/to/dbhub/dist/index.js
 ```
 
 #### SSE
@@ -191,4 +299,4 @@ npx @modelcontextprotocol/inspector
 
 Connect to the DBHub server `/sse` endpoint
 
-![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/assets/mcp-inspector.webp)
+![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/mcp-inspector.webp)

package/dist/connectors/mysql/index.js

@@ -0,0 +1,169 @@
+import mysql from 'mysql2/promise';
+import { ConnectorRegistry } from '../interface.js';
+/**
+ * MySQL DSN Parser
+ * Handles DSN strings like: mysql://user:password@localhost:3306/dbname
+ */
+class MySQLDSNParser {
+    parse(dsn) {
+        // Basic validation
+        if (!this.isValidDSN(dsn)) {
+            throw new Error(`Invalid MySQL DSN: ${dsn}`);
+        }
+        try {
+            const url = new URL(dsn);
+            const config = {
+                host: url.hostname,
+                port: url.port ? parseInt(url.port) : 3306,
+                database: url.pathname.substring(1), // Remove leading '/'
+                user: url.username,
+                password: url.password,
+            };
+            // Handle query parameters
+            url.searchParams.forEach((value, key) => {
+                if (key === 'ssl') {
+                    config.ssl = value === 'true' ? {} : undefined;
+                }
+                // Add other parameters as needed
+            });
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getSampleDSN() {
+        return 'mysql://root:password@localhost:3306/mysql';
+    }
+    isValidDSN(dsn) {
+        try {
+            const url = new URL(dsn);
+            return url.protocol === 'mysql:';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+/**
+ * MySQL Connector Implementation
+ */
+export class MySQLConnector {
+    constructor() {
+        this.id = 'mysql';
+        this.name = 'MySQL';
+        this.dsnParser = new MySQLDSNParser();
+        this.pool = null;
+    }
+    async connect(dsn) {
+        try {
+            const config = this.dsnParser.parse(dsn);
+            this.pool = mysql.createPool(config);
+            // Test the connection
+            const [rows] = await this.pool.query('SELECT 1');
+            console.error("Successfully connected to MySQL database");
+        }
+        catch (err) {
+            console.error("Failed to connect to MySQL database:", err);
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async getTables() {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            // Get all tables from the current database
+            const [rows] = await this.pool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE()
+        ORDER BY table_name
+      `);
+            return rows.map(row => row.table_name);
+        }
+        catch (error) {
+            console.error("Error getting tables:", error);
+            throw error;
+        }
+    }
+    async tableExists(tableName) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            const [rows] = await this.pool.query(`
+        SELECT COUNT(*) as count
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE() 
+        AND table_name = ?
+      `, [tableName]);
+            return rows[0].count > 0;
+        }
+        catch (error) {
+            console.error("Error checking if table exists:", error);
+            throw error;
+        }
+    }
+    async getTableSchema(tableName) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            // Get table columns
+            const [rows] = await this.pool.query(`
+        SELECT 
+          column_name, 
+          data_type, 
+          is_nullable,
+          column_default
+        FROM information_schema.columns
+        WHERE table_schema = DATABASE()
+        AND table_name = ?
+        ORDER BY ordinal_position
+      `, [tableName]);
+            return rows;
+        }
+        catch (error) {
+            console.error("Error getting table schema:", error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        const safetyCheck = this.validateQuery(query);
+        if (!safetyCheck.isValid) {
+            throw new Error(safetyCheck.message || "Query validation failed");
+        }
+        try {
+            const [rows, fields] = await this.pool.query(query);
+            return { rows, fields };
+        }
+        catch (error) {
+            console.error("Error executing query:", error);
+            throw error;
+        }
+    }
+    validateQuery(query) {
+        // Basic check to prevent non-SELECT queries
+        const normalizedQuery = query.trim().toLowerCase();
+        if (!normalizedQuery.startsWith('select')) {
+            return {
+                isValid: false,
+                message: "Only SELECT queries are allowed for security reasons."
+            };
+        }
+        return { isValid: true };
+    }
+}
+// Create and register the connector
+const mysqlConnector = new MySQLConnector();
+ConnectorRegistry.register(mysqlConnector);

package/dist/connectors/sqlite/index.js

@@ -1,12 +1,13 @@
 /**
- * SQLite Connector Implementation (Template)
+ * SQLite Connector Implementation
  *
- * This is a template showing how to implement a new database connector.
+ * Implements SQLite database connectivity for DBHub
  * To use this connector:
- * 1. Install the required dependencies: npm install sqlite3
- * 2. Implement the methods below
- * 3. Set DSN=sqlite:///path/to/database.db in your .env file
+ * 1. Set DSN=sqlite:///path/to/database.db in your .env file
+ * 2. Or set DB_CONNECTOR_TYPE=sqlite for default in-memory database
  */
+import { ConnectorRegistry } from '../interface.js';
+import sqlite3 from 'sqlite3';
 /**
  * SQLite DSN Parser
  * Handles DSN strings like:
@@ -63,129 +64,117 @@ export class SQLiteConnector {
         this.id = 'sqlite';
         this.name = 'SQLite';
         this.dsnParser = new SQLiteDSNParser();
-        this.dbPath = null;
+        this.db = null;
+        this.dbPath = ':memory:'; // Default to in-memory database
     }
     async connect(dsn) {
         const config = this.dsnParser.parse(dsn);
         this.dbPath = config.dbPath;
-        // Example implementation (requires sqlite3 package)
-        /*
         return new Promise((resolve, reject) => {
-          const sqlite3 = require('sqlite3').verbose();
-          this.db = new sqlite3.Database(this.dbPath, (err) => {
-            if (err) {
-              console.error("Failed to connect to SQLite database:", err);
-              reject(err);
-            } else {
-              console.error("Successfully connected to SQLite database");
-              resolve();
-            }
-          });
+            this.db = new sqlite3.Database(this.dbPath, (err) => {
+                if (err) {
+                    console.error("Failed to connect to SQLite database:", err);
+                    reject(err);
+                }
+                else {
+                    // Can't use console.log here because it will break the stdio transport
+                    console.error("Successfully connected to SQLite database");
+                    resolve();
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async disconnect() {
         // Close the SQLite connection
-        /*
         if (this.db) {
-          return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-              if (err) {
-                reject(err);
-              } else {
-                this.db = null;
-                resolve();
-              }
+            return new Promise((resolve, reject) => {
+                this.db.close((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        this.db = null;
+                        resolve();
+                    }
+                });
             });
-          });
         }
-        */
-        throw new Error('SQLite connector not implemented yet');
+        return Promise.resolve();
     }
     async getTables() {
-        // Get all tables from SQLite
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.all(
-            `SELECT name FROM sqlite_master
-             WHERE type='table' AND name NOT LIKE 'sqlite_%'
-             ORDER BY name`,
-            (err, rows) => {
-              if (err) {
-                reject(err);
-              } else {
-                resolve(rows.map(row => row.name));
-              }
-            }
-          );
+            this.db.all(`SELECT name FROM sqlite_master 
+         WHERE type='table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rows.map(row => row.name));
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async tableExists(tableName) {
-        // Check if a table exists in SQLite
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.get(
-            `SELECT name FROM sqlite_master
-             WHERE type='table' AND name = ?`,
-            [tableName],
-            (err, row) => {
-              if (err) {
-                reject(err);
-              } else {
-                resolve(!!row);
-              }
-            }
-          );
+            this.db.get(`SELECT name FROM sqlite_master 
+         WHERE type='table' AND name = ?`, [tableName], (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(!!row);
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async getTableSchema(tableName) {
-        // Get schema for a specific table
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.all(
-            `PRAGMA table_info(${tableName})`,
-            (err, rows) => {
-              if (err) {
-                reject(err);
-              } else {
-                // Convert SQLite schema format to our standard TableColumn format
-                const columns = rows.map(row => ({
-                  column_name: row.name,
-                  data_type: row.type,
-                  is_nullable: row.notnull ? 'NO' : 'YES',
-                  column_default: row.dflt_value
-                }));
-                resolve(columns);
-              }
-            }
-          );
+            this.db.all(`PRAGMA table_info(${tableName})`, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // Convert SQLite schema format to our standard TableColumn format
+                    const columns = rows.map(row => ({
+                        column_name: row.name,
+                        data_type: row.type,
+                        is_nullable: row.notnull === 0 ? 'YES' : 'NO', // In SQLite, 0 means nullable
+                        column_default: row.dflt_value
+                    }));
+                    resolve(columns);
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async executeQuery(query) {
-        // Execute a query against SQLite
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
+        // Validate query for safety
         const safetyCheck = this.validateQuery(query);
         if (!safetyCheck.isValid) {
             throw new Error(safetyCheck.message || "Query validation failed");
         }
-        /*
         return new Promise((resolve, reject) => {
-          this.db.all(query, (err, rows) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve({ rows });
-            }
-          });
+            this.db.all(query, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve({ rows });
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     validateQuery(query) {
         // Basic check to prevent non-SELECT queries
@@ -199,6 +188,6 @@ export class SQLiteConnector {
         return { isValid: true };
     }
 }
-// To enable this connector, uncomment the following lines and install sqlite3:
-// const sqliteConnector = new SQLiteConnector();
-// ConnectorRegistry.register(sqliteConnector);
+// Register the SQLite connector
+const sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);

package/dist/index.js

@@ -2,7 +2,8 @@
 // Import connector modules to register them
 import './connectors/postgres/index.js'; // Register PostgreSQL connector
 import './connectors/sqlserver/index.js'; // Register SQL Server connector
-// import './connectors/sqlite/index.js';  // Uncomment to enable SQLite
+import './connectors/sqlite/index.js'; // SQLite connector
+import './connectors/mysql/index.js'; // MySQL connector
 // Import main function from server.ts
 import { main } from './server.js';
 /**

package/dist/prompts/index.js

@@ -5,7 +5,7 @@ import { dbExplainerPromptHandler, dbExplainerSchema } from './db-explainer.js';
  */
 export function registerPrompts(server) {
     // Register SQL Generator prompt
-    server.prompt("generate-sql", "Generate SQL queries from natural language descriptions", sqlGeneratorSchema, sqlGeneratorPromptHandler);
+    server.prompt("generate_sql", "Generate SQL queries from natural language descriptions", sqlGeneratorSchema, sqlGeneratorPromptHandler);
     // Register Database Explainer prompt
-    server.prompt("explain-db", "Get explanations about database tables, columns, and structures", dbExplainerSchema, dbExplainerPromptHandler);
+    server.prompt("explain_db", "Get explanations about database tables, columns, and structures", dbExplainerSchema, dbExplainerPromptHandler);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -17,10 +17,13 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
+    "@types/sqlite3": "^5.1.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "mssql": "^11.0.1",
+    "mysql2": "^3.13.0",
     "pg": "^8.13.3",
+    "sqlite3": "^5.1.7",
     "zod": "^3.24.2"
   },
   "devDependencies": {