@bytebase/dbhub 0.2.3 → 0.3.1

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/resources/images/logo-full.svg" width="50%">
+  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/logo-full.webp" width="50%">
 </picture>
 </a>
 </p>
@@ -20,7 +20,7 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |      Clients     |    |              |    |                  |
  |                  |    |              +--->+     MySQL        |
  |                  |    |              |    |                  |
- |                  |    |              +--->+  Other Databases |
+ |                  |    |              +--->+    MariaDB       |
  |                  |    |              |    |                  |
  +------------------+    +--------------+    +------------------+
       MCP Clients           MCP Server             Databases
@@ -36,28 +36,28 @@ https://demo.dbhub.ai/sse connects a [sample employee database](https://github.c
 
 ### Database Resources
 
-| Resource Name               | URI Format                                             | PostgreSQL | MySQL | 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 | 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}` |     ✅     |  ✅   |   ✅    |     ✅     |   ❌   |
 
 ### Database Tools
 
-| Tool            | Command Name      | PostgreSQL | MySQL | SQL Server | SQLite |
-| --------------- | ----------------- | :--------: | :---: | :--------: | :----: |
-| Execute Query   | `run_query`       |     ✅     |  ✅   |     ✅     |   ✅   |
-| List Connectors | `list_connectors` |     ✅     |  ✅   |     ✅     |   ✅   |
+| Tool            | Command Name      | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| --------------- | ----------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Execute Query   | `run_query`       |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| List Connectors | `list_connectors` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ### Prompt Capabilities
 
-| Prompt              | Command Name   | PostgreSQL | MySQL | SQL Server | SQLite |
-| ------------------- | -------------- | :--------: | :---: | :--------: | :----: |
-| Generate SQL        | `generate_sql` |     ✅     |  ✅   |     ✅     |   ✅   |
-| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |     ✅     |   ✅   |
+| Prompt              | Command Name   | PostgreSQL | MySQL | MariaDB | SQL Server | SQLite |
+| ------------------- | -------------- | :--------: | :---: | :-----: | :--------: | ------ |
+| Generate SQL        | `generate_sql` |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
+| Explain DB Elements | `explain_db`   |     ✅     |  ✅   |   ✅    |     ✅     | ✅     |
 
 ## Installation
 
@@ -156,7 +156,7 @@ npx @bytebase/dbhub --transport sse --port 8080 --demo
 You can use DBHub in demo mode with a sample employee database for testing:
 
 ```bash
-pnpm dev --demo
+npx @bytebase/dbhub  --demo
 ```
 
 For real databases, a Database Source Name (DSN) is required. You can provide this in several ways:
@@ -164,14 +164,14 @@ For real databases, a Database Source Name (DSN) is required. You can provide th
 - **Command line argument** (highest priority):
 
   ```bash
-  pnpm dev --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+  npx @bytebase/dbhub  --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
   ```
 
 - **Environment variable** (second priority):
 
   ```bash
   export DSN="postgres://user:password@localhost:5432/dbname?sslmode=disable"
-  pnpm dev
+  npx @bytebase/dbhub
   ```
 
 - **Environment file** (third priority):
@@ -188,10 +188,19 @@ DBHub supports the following database connection string formats:
 
 | Database   | DSN Format                                               | Example                                                          |
 | ---------- | -------------------------------------------------------- | ---------------------------------------------------------------- |
+| MySQL      | `mysql://[user]:[password]@[host]:[port]/[database]`     | `mysql://user:password@localhost:3306/dbname`                    |
+| MariaDB    | `mariadb://[user]:[password]@[host]:[port]/[database]`   | `mariadb://user:password@localhost:3306/dbname`                  |
 | 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`                    |
+| 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
+
+Extra query parameters:
+
+#### authentication
+
+- `authentication=azure-active-directory-access-token`. Only applicable when running from Azure. See [DefaultAzureCredential](https://learn.microsoft.com/en-us/azure/developer/javascript/sdk/authentication/credential-chains#use-defaultazurecredential-for-flexibility).
 
 ### Transport
 
@@ -257,3 +266,7 @@ npx @modelcontextprotocol/inspector
 ```
 
 Connect to the DBHub server `/sse` endpoint
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=bytebase/dbhub&type=Date)](https://www.star-history.com/#bytebase/dbhub&Date)

package/dist/index.js

@@ -60,7 +60,7 @@ var ConnectorRegistry = _ConnectorRegistry;
 // src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
-  parse(dsn) {
+  async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
       throw new Error(`Invalid PostgreSQL DSN: ${dsn}`);
     }
@@ -72,7 +72,7 @@ var PostgresDSNParser = class {
         database: url.pathname.substring(1),
         // Remove leading '/'
         user: url.username,
-        password: url.password
+        password: url.password ? decodeURIComponent(url.password) : ""
       };
       url.searchParams.forEach((value, key) => {
         if (key === "sslmode") {
@@ -105,7 +105,7 @@ var PostgresConnector = class {
   }
   async connect(dsn) {
     try {
-      const config = this.dsnParser.parse(dsn);
+      const config = await this.dsnParser.parse(dsn);
       this.pool = new Pool(config);
       const client = await this.pool.connect();
       console.error("Successfully connected to PostgreSQL database");
@@ -363,8 +363,9 @@ ConnectorRegistry.register(postgresConnector);
 
 // src/connectors/sqlserver/index.ts
 import sql from "mssql";
+import { DefaultAzureCredential } from "@azure/identity";
 var SQLServerDSNParser = class {
-  parse(dsn) {
+  async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
       throw new Error("Invalid SQL Server DSN format. Expected: sqlserver://username:password@host:port/database");
     }
@@ -373,7 +374,7 @@ var SQLServerDSNParser = class {
     const port = url.port ? parseInt(url.port, 10) : 1433;
     const database = url.pathname.substring(1);
     const user = url.username;
-    const password = url.password;
+    const password = url.password ? decodeURIComponent(url.password) : "";
     const options = {};
     for (const [key, value] of url.searchParams.entries()) {
       if (key === "encrypt") {
@@ -384,9 +385,11 @@ var SQLServerDSNParser = class {
         options.connectTimeout = parseInt(value, 10);
       } else if (key === "requestTimeout") {
         options.requestTimeout = parseInt(value, 10);
+      } else if (key === "authentication") {
+        options.authentication = value;
       }
     }
-    return {
+    const config = {
       user,
       password,
       server: host,
@@ -401,6 +404,22 @@ var SQLServerDSNParser = class {
         requestTimeout: options.requestTimeout ?? 15e3
       }
     };
+    if (options.authentication === "azure-active-directory-access-token") {
+      try {
+        const credential = new DefaultAzureCredential();
+        const token = await credential.getToken("https://database.windows.net/");
+        config.authentication = {
+          type: "azure-active-directory-access-token",
+          options: {
+            token: token.token
+          }
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to get Azure AD token: ${errorMessage}`);
+      }
+    }
+    return config;
   }
   getSampleDSN() {
     return "sqlserver://username:password@localhost:1433/database?encrypt=true";
@@ -422,7 +441,7 @@ var SQLServerConnector = class {
   }
   async connect(dsn) {
     try {
-      this.config = this.dsnParser.parse(dsn);
+      this.config = await this.dsnParser.parse(dsn);
       if (!this.config.options) {
         this.config.options = {};
       }
@@ -443,9 +462,9 @@ var SQLServerConnector = class {
     }
     try {
       const result = await this.connection.request().query(`
-        SELECT SCHEMA_NAME 
-        FROM INFORMATION_SCHEMA.SCHEMATA 
-        ORDER BY SCHEMA_NAME
+          SELECT SCHEMA_NAME
+          FROM INFORMATION_SCHEMA.SCHEMATA
+          ORDER BY SCHEMA_NAME
       `);
       return result.recordset.map((row) => row.SCHEMA_NAME);
     } catch (error) {
@@ -460,10 +479,10 @@ var SQLServerConnector = class {
       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
-        ORDER BY TABLE_NAME
+          SELECT TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = @schema
+          ORDER BY TABLE_NAME
       `;
       const result = await request.query(query);
       return result.recordset.map((row) => row.TABLE_NAME);
@@ -479,10 +498,10 @@ var SQLServerConnector = class {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
       const query = `
-        SELECT COUNT(*) as count
-        FROM INFORMATION_SCHEMA.TABLES
-        WHERE TABLE_NAME = @tableName
-        AND TABLE_SCHEMA = @schema
+          SELECT COUNT(*) as count
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_NAME = @tableName
+            AND TABLE_SCHEMA = @schema
       `;
       const result = await request.query(query);
       return result.recordset[0].count > 0;
@@ -498,28 +517,24 @@ var SQLServerConnector = class {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
       const query = `
-        SELECT 
-          i.name AS index_name,
-          i.is_unique,
-          i.is_primary_key,
-          c.name AS column_name,
-          ic.key_ordinal
-        FROM 
-          sys.indexes i
-        INNER JOIN 
-          sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
-        INNER JOIN 
-          sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
-        INNER JOIN 
-          sys.tables t ON i.object_id = t.object_id
-        INNER JOIN 
-          sys.schemas s ON t.schema_id = s.schema_id
-        WHERE 
-          t.name = @tableName
-          AND s.name = @schema
-        ORDER BY 
-          i.name, 
-          ic.key_ordinal
+          SELECT i.name AS index_name,
+                 i.is_unique,
+                 i.is_primary_key,
+                 c.name AS column_name,
+                 ic.key_ordinal
+          FROM sys.indexes i
+                   INNER JOIN
+               sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+                   INNER JOIN
+               sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+                   INNER JOIN
+               sys.tables t ON i.object_id = t.object_id
+                   INNER JOIN
+               sys.schemas s ON t.schema_id = s.schema_id
+          WHERE t.name = @tableName
+            AND s.name = @schema
+          ORDER BY i.name,
+                   ic.key_ordinal
       `;
       const result = await request.query(query);
       const indexMap = /* @__PURE__ */ new Map();
@@ -560,15 +575,14 @@ var SQLServerConnector = class {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("tableName", sql.VarChar, tableName).input("schema", sql.VarChar, schemaToUse);
       const query = `
-        SELECT 
-          COLUMN_NAME as column_name,
-          DATA_TYPE as data_type,
-          IS_NULLABLE as is_nullable,
-          COLUMN_DEFAULT as column_default
-        FROM INFORMATION_SCHEMA.COLUMNS
-        WHERE TABLE_NAME = @tableName
-        AND TABLE_SCHEMA = @schema
-        ORDER BY ORDINAL_POSITION
+          SELECT COLUMN_NAME as    column_name,
+                 DATA_TYPE as      data_type,
+                 IS_NULLABLE as    is_nullable,
+                 COLUMN_DEFAULT as column_default
+          FROM INFORMATION_SCHEMA.COLUMNS
+          WHERE TABLE_NAME = @tableName
+            AND TABLE_SCHEMA = @schema
+          ORDER BY ORDINAL_POSITION
       `;
       const result = await request.query(query);
       return result.recordset;
@@ -584,11 +598,11 @@ var SQLServerConnector = class {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("schema", sql.VarChar, schemaToUse);
       const query = `
-        SELECT ROUTINE_NAME
-        FROM INFORMATION_SCHEMA.ROUTINES
-        WHERE ROUTINE_SCHEMA = @schema
-        AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')
-        ORDER BY ROUTINE_NAME
+          SELECT ROUTINE_NAME
+          FROM INFORMATION_SCHEMA.ROUTINES
+          WHERE ROUTINE_SCHEMA = @schema
+            AND (ROUTINE_TYPE = 'PROCEDURE' OR ROUTINE_TYPE = 'FUNCTION')
+          ORDER BY ROUTINE_NAME
       `;
       const result = await request.query(query);
       return result.recordset.map((row) => row.ROUTINE_NAME);
@@ -604,13 +618,12 @@ var SQLServerConnector = class {
       const schemaToUse = schema || "dbo";
       const request = this.connection.request().input("procedureName", sql.VarChar, procedureName).input("schema", sql.VarChar, schemaToUse);
       const routineQuery = `
-        SELECT 
-          ROUTINE_NAME as procedure_name,
-          ROUTINE_TYPE,
-          DATA_TYPE as return_data_type
-        FROM INFORMATION_SCHEMA.ROUTINES
-        WHERE ROUTINE_NAME = @procedureName
-        AND ROUTINE_SCHEMA = @schema
+          SELECT ROUTINE_NAME as procedure_name,
+                 ROUTINE_TYPE,
+                 DATA_TYPE    as return_data_type
+          FROM INFORMATION_SCHEMA.ROUTINES
+          WHERE ROUTINE_NAME = @procedureName
+            AND ROUTINE_SCHEMA = @schema
       `;
       const routineResult = await request.query(routineQuery);
       if (routineResult.recordset.length === 0) {
@@ -618,16 +631,15 @@ var SQLServerConnector = class {
       }
       const routine = routineResult.recordset[0];
       const parameterQuery = `
-        SELECT 
-          PARAMETER_NAME,
-          PARAMETER_MODE,
-          DATA_TYPE,
-          CHARACTER_MAXIMUM_LENGTH,
-          ORDINAL_POSITION
-        FROM INFORMATION_SCHEMA.PARAMETERS
-        WHERE SPECIFIC_NAME = @procedureName
-        AND SPECIFIC_SCHEMA = @schema
-        ORDER BY ORDINAL_POSITION
+          SELECT PARAMETER_NAME,
+                 PARAMETER_MODE,
+                 DATA_TYPE,
+                 CHARACTER_MAXIMUM_LENGTH,
+                 ORDINAL_POSITION
+          FROM INFORMATION_SCHEMA.PARAMETERS
+          WHERE SPECIFIC_NAME = @procedureName
+            AND SPECIFIC_SCHEMA = @schema
+          ORDER BY ORDINAL_POSITION
       `;
       const parameterResult = await request.query(parameterQuery);
       let parameterList = "";
@@ -638,12 +650,12 @@ var SQLServerConnector = class {
         }).join(", ");
       }
       const definitionQuery = `
-        SELECT definition 
-        FROM sys.sql_modules sm
-        JOIN sys.objects o ON sm.object_id = o.object_id
-        JOIN sys.schemas s ON o.schema_id = s.schema_id
-        WHERE o.name = @procedureName
-        AND s.name = @schema
+          SELECT definition
+          FROM sys.sql_modules sm
+                   JOIN sys.objects o ON sm.object_id = o.object_id
+                   JOIN sys.schemas s ON o.schema_id = s.schema_id
+          WHERE o.name = @procedureName
+            AND s.name = @schema
       `;
       const definitionResult = await request.query(definitionQuery);
       let definition = void 0;
@@ -701,7 +713,7 @@ ConnectorRegistry.register(sqlServerConnector);
 // src/connectors/sqlite/index.ts
 import Database from "better-sqlite3";
 var SQLiteDSNParser = class {
-  parse(dsn) {
+  async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
       throw new Error(`Invalid SQLite DSN: ${dsn}`);
     }
@@ -744,7 +756,7 @@ var SQLiteConnector = class {
   }
   // Default to in-memory database
   async connect(dsn, initScript) {
-    const config = this.dsnParser.parse(dsn);
+    const config = await this.dsnParser.parse(dsn);
     this.dbPath = config.dbPath;
     try {
       this.db = new Database(this.dbPath);
@@ -908,7 +920,7 @@ ConnectorRegistry.register(sqliteConnector);
 // src/connectors/mysql/index.ts
 import mysql from "mysql2/promise";
 var MySQLDSNParser = class {
-  parse(dsn) {
+  async parse(dsn) {
     if (!this.isValidDSN(dsn)) {
       throw new Error(`Invalid MySQL DSN: ${dsn}`);
     }
@@ -920,7 +932,7 @@ var MySQLDSNParser = class {
         database: url.pathname.substring(1),
         // Remove leading '/'
         user: url.username,
-        password: url.password
+        password: url.password ? decodeURIComponent(url.password) : ""
       };
       url.searchParams.forEach((value, key) => {
         if (key === "ssl") {
@@ -953,7 +965,7 @@ var MySQLConnector = class {
   }
   async connect(dsn) {
     try {
-      const config = this.dsnParser.parse(dsn);
+      const config = await this.dsnParser.parse(dsn);
       this.pool = mysql.createPool(config);
       const [rows] = await this.pool.query("SELECT 1");
       console.error("Successfully connected to MySQL database");
@@ -1247,6 +1259,348 @@ var MySQLConnector = class {
 var mysqlConnector = new MySQLConnector();
 ConnectorRegistry.register(mysqlConnector);
 
+// src/connectors/mariadb/index.ts
+import mariadb from "mariadb";
+var MariadbDSNParser = class {
+  async parse(dsn) {
+    if (!this.isValidDSN(dsn)) {
+      throw new Error(`Invalid MariaDB 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),
+        user: url.username,
+        password: decodeURIComponent(url.password)
+      };
+      url.searchParams.forEach((value, key) => {
+        if (key === "ssl") {
+          config.ssl = value === "true" ? {} : void 0;
+        }
+      });
+      return config;
+    } catch (error) {
+      throw new Error(`Failed to parse MariaDB DSN: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getSampleDSN() {
+    return "mariadb://root:password@localhost:3306/db";
+  }
+  isValidDSN(dsn) {
+    try {
+      const url = new URL(dsn);
+      return url.protocol === "mariadb:";
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var MariaDBConnector = class {
+  constructor() {
+    this.id = "mariadb";
+    this.name = "MariaDB";
+    this.dsnParser = new MariadbDSNParser();
+    this.pool = null;
+  }
+  async connect(dsn) {
+    try {
+      const config = await this.dsnParser.parse(dsn);
+      this.pool = mariadb.createPool(config);
+      console.error("Testing connection to MariaDB...");
+      const [rows] = await this.pool.query("SELECT 1");
+      console.error("Successfully connected to MariaDB database");
+    } catch (err) {
+      console.error("Failed to connect to MariaDB database:", err);
+      throw err;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getSchemas() {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const [rows] = await this.pool.query(`
+        SELECT SCHEMA_NAME 
+        FROM INFORMATION_SCHEMA.SCHEMATA
+        ORDER BY SCHEMA_NAME
+      `);
+      return rows.map((row) => row.SCHEMA_NAME);
+    } catch (error) {
+      console.error("Error getting schemas:", error);
+      throw error;
+    }
+  }
+  async getTables(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}
+        ORDER BY TABLE_NAME
+      `, queryParams);
+      return rows.map((row) => row.TABLE_NAME);
+    } catch (error) {
+      console.error("Error getting tables:", error);
+      throw error;
+    }
+  }
+  async tableExists(tableName, 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, tableName] : [tableName];
+      const [rows] = await this.pool.query(`
+        SELECT COUNT(*) AS COUNT
+        FROM INFORMATION_SCHEMA.TABLES 
+        ${schemaClause} 
+        AND TABLE_NAME = ?
+      `, queryParams);
+      return rows[0].COUNT > 0;
+    } catch (error) {
+      console.error("Error checking if table exists:", error);
+      throw error;
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "TABLE_SCHEMA = ?" : "TABLE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, tableName] : [tableName];
+      const [indexRows] = await this.pool.query(`
+        SELECT 
+          INDEX_NAME,
+          COLUMN_NAME,
+          NON_UNIQUE,
+          SEQ_IN_INDEX
+        FROM 
+          INFORMATION_SCHEMA.STATISTICS 
+        WHERE 
+          ${schemaClause}
+          AND TABLE_NAME = ? 
+        ORDER BY 
+          INDEX_NAME, 
+          SEQ_IN_INDEX
+      `, queryParams);
+      const indexMap = /* @__PURE__ */ new Map();
+      for (const row of indexRows) {
+        const indexName = row.INDEX_NAME;
+        const columnName = row.COLUMN_NAME;
+        const isUnique = row.NON_UNIQUE === 0;
+        const isPrimary = indexName === "PRIMARY";
+        if (!indexMap.has(indexName)) {
+          indexMap.set(indexName, {
+            columns: [],
+            is_unique: isUnique,
+            is_primary: isPrimary
+          });
+        }
+        const indexInfo = indexMap.get(indexName);
+        indexInfo.columns.push(columnName);
+      }
+      const results = [];
+      indexMap.forEach((indexInfo, indexName) => {
+        results.push({
+          index_name: indexName,
+          column_names: indexInfo.columns,
+          is_unique: indexInfo.is_unique,
+          is_primary: indexInfo.is_primary
+        });
+      });
+      return results;
+    } catch (error) {
+      console.error("Error getting table indexes:", error);
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, 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, tableName] : [tableName];
+      const [rows] = await this.pool.query(`
+        SELECT 
+          COLUMN_NAME as column_name, 
+          DATA_TYPE as data_type, 
+          IS_NULLABLE as is_nullable,
+          COLUMN_DEFAULT as column_default
+        FROM INFORMATION_SCHEMA.COLUMNS
+        ${schemaClause}
+        AND TABLE_NAME = ?
+        ORDER BY ORDINAL_POSITION
+      `, queryParams);
+      return rows;
+    } catch (error) {
+      console.error("Error getting table schema:", error);
+      throw error;
+    }
+  }
+  async getStoredProcedures(schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE ROUTINE_SCHEMA = ?" : "WHERE ROUTINE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema] : [];
+      const [rows] = await this.pool.query(`
+        SELECT ROUTINE_NAME
+        FROM INFORMATION_SCHEMA.ROUTINES
+        ${schemaClause}
+        ORDER BY ROUTINE_NAME
+      `, queryParams);
+      return rows.map((row) => row.ROUTINE_NAME);
+    } catch (error) {
+      console.error("Error getting stored procedures:", error);
+      throw error;
+    }
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      const schemaClause = schema ? "WHERE r.ROUTINE_SCHEMA = ?" : "WHERE r.ROUTINE_SCHEMA = DATABASE()";
+      const queryParams = schema ? [schema, procedureName] : [procedureName];
+      const [rows] = await this.pool.query(`
+        SELECT 
+          r.ROUTINE_NAME AS procedure_name,
+          CASE 
+            WHEN r.ROUTINE_TYPE = 'PROCEDURE' THEN 'procedure'
+            ELSE 'function'
+          END AS procedure_type,
+          LOWER(r.ROUTINE_TYPE) AS routine_type,
+          r.ROUTINE_DEFINITION,
+          r.DTD_IDENTIFIER AS return_type,
+          (
+            SELECT GROUP_CONCAT(
+              CONCAT(p.PARAMETER_NAME, ' ', p.PARAMETER_MODE, ' ', p.DATA_TYPE)
+              ORDER BY p.ORDINAL_POSITION
+              SEPARATOR ', '
+            )
+            FROM INFORMATION_SCHEMA.PARAMETERS p
+            WHERE p.SPECIFIC_SCHEMA = r.ROUTINE_SCHEMA
+            AND p.SPECIFIC_NAME = r.ROUTINE_NAME
+            AND p.PARAMETER_NAME IS NOT NULL
+          ) AS parameter_list
+        FROM INFORMATION_SCHEMA.ROUTINES r
+        ${schemaClause}
+        AND r.ROUTINE_NAME = ?
+      `, queryParams);
+      if (rows.length === 0) {
+        const schemaName = schema || "current schema";
+        throw new Error(`Stored procedure '${procedureName}' not found in ${schemaName}`);
+      }
+      const procedure = rows[0];
+      let definition = procedure.ROUTINE_DEFINITION;
+      try {
+        const schemaValue = schema || await this.getCurrentSchema();
+        if (procedure.procedure_type === "procedure") {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE PROCEDURE ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Procedure"];
+            }
+          } catch (err) {
+            console.error(`Error getting procedure definition with SHOW CREATE: ${err}`);
+          }
+        } else {
+          try {
+            const [defRows] = await this.pool.query(`
+              SHOW CREATE FUNCTION ${schemaValue}.${procedureName}
+            `);
+            if (defRows && defRows.length > 0) {
+              definition = defRows[0]["Create Function"];
+            }
+          } catch (innerErr) {
+            console.error(`Error getting function definition with SHOW CREATE: ${innerErr}`);
+          }
+        }
+        if (!definition) {
+          const [bodyRows] = await this.pool.query(`
+            SELECT ROUTINE_DEFINITION, ROUTINE_BODY 
+            FROM INFORMATION_SCHEMA.ROUTINES
+            WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ?
+          `, [schemaValue, procedureName]);
+          if (bodyRows && bodyRows.length > 0) {
+            if (bodyRows[0].ROUTINE_DEFINITION) {
+              definition = bodyRows[0].ROUTINE_DEFINITION;
+            } else if (bodyRows[0].ROUTINE_BODY) {
+              definition = bodyRows[0].ROUTINE_BODY;
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error getting procedure/function details: ${error}`);
+      }
+      return {
+        procedure_name: procedure.procedure_name,
+        procedure_type: procedure.procedure_type,
+        language: "sql",
+        // MariaDB procedures are generally in SQL
+        parameter_list: procedure.parameter_list || "",
+        return_type: procedure.routine_type === "function" ? procedure.return_type : void 0,
+        definition: definition || void 0
+      };
+    } catch (error) {
+      console.error("Error getting stored procedure detail:", error);
+      throw error;
+    }
+  }
+  // Helper method to get current schema (database) name
+  async getCurrentSchema() {
+    const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
+    return rows[0].DB;
+  }
+  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) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery.startsWith("select")) {
+      return {
+        isValid: false,
+        message: "Only SELECT queries are allowed for security reasons."
+      };
+    }
+    return { isValid: true };
+  }
+};
+var mariadbConnector = new MariaDBConnector();
+ConnectorRegistry.register(mariadbConnector);
+
 // src/server.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
@@ -1437,6 +1791,17 @@ function resolvePort() {
   }
   return { port: 8080, source: "default" };
 }
+function redactDSN(dsn) {
+  try {
+    const url = new URL(dsn);
+    if (url.password) {
+      url.password = "*******";
+    }
+    return url.toString();
+  } catch (error) {
+    return dsn.replace(/\/\/([^:]+):([^@]+)@/, "//$1:***@");
+  }
+}
 
 // src/config/demo-loader.ts
 import fs2 from "fs";
@@ -1875,11 +2240,13 @@ async function listConnectorsToolHandler(_args, _extra) {
 function registerTools(server) {
   server.tool(
     "run_query",
+    "Run a SQL query on the current database",
     runQuerySchema,
     runQueryToolHandler
   );
   server.tool(
     "list_connectors",
+    "List all available database connectors",
     {},
     listConnectorsToolHandler
   );
@@ -2336,7 +2703,7 @@ See documentation for more details on configuring database connections.
     registerTools(server);
     registerPrompts(server);
     const connectorManager = new ConnectorManager();
-    console.error(`Connecting with DSN: ${dsnData.dsn}`);
+    console.error(`Connecting with DSN: ${redactDSN(dsnData.dsn)}`);
     console.error(`DSN source: ${dsnData.source}`);
     if (dsnData.isDemo) {
       console.error("Running in demo mode with sample employee database");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -16,11 +16,13 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@azure/identity": "^4.8.0",
     "@modelcontextprotocol/sdk": "^1.6.1",
     "better-sqlite3": "^11.9.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "mssql": "^11.0.1",
+    "mariadb": "^3.4.0",
     "mysql2": "^3.13.0",
     "pg": "^8.13.3",
     "zod": "^3.24.2"