@bytebase/dbhub 0.11.2 → 0.11.4

package/README.md

@@ -10,10 +10,18 @@
 </p>
 
 <p align="center">
-  <a href="https://cursor.com/install-mcp?name=dbhub&config=eyJjb21tYW5kIjoibnB4IEBieXRlYmFzZS9kYmh1YiIsImVudiI6eyJUUkFOU1BPUlQiOiJzdGRpbyIsIkRTTiI6InBvc3RncmVzOi8vdXNlcjpwYXNzd29yZEBsb2NhbGhvc3Q6NTQzMi9kYm5hbWU%2Fc3NsbW9kZT1kaXNhYmxlIiwiUkVBRE9OTFkiOiJ0cnVlIn19"><img src="https://cursor.com/deeplink/mcp-install-dark.svg" alt="Add dbhub MCP server to Cursor" height="32" /></a>
   <a href="https://discord.gg/BjEkZpsJzn"><img src="https://img.shields.io/badge/%20-Hang%20out%20on%20Discord-5865F2?style=for-the-badge&logo=discord&labelColor=EEEEEE" alt="Join our Discord" height="32" /></a>
 </p>
 
+<p>
+Add to Cursor by copying the below link to browser
+
+```text
+cursor://anysphere.cursor-deeplink/mcp/install?name=dbhub&config=eyJjb21tYW5kIjoibnB4IEBieXRlYmFzZS9kYmh1YiIsImVudiI6eyJUUkFOU1BPUlQiOiJzdGRpbyIsIkRTTiI6InBvc3RncmVzOi8vdXNlcjpwYXNzd29yZEBsb2NhbGhvc3Q6NTQzMi9kYm5hbWU%2Fc3NsbW9kZT1kaXNhYmxlIiwiUkVBRE9OTFkiOiJ0cnVlIn19
+```
+
+</p>
+
 DBHub is a universal database gateway implementing the Model Context Protocol (MCP) server interface. This gateway allows MCP-compatible clients to connect to and explore different databases.
 
 ```bash
@@ -35,12 +43,6 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
       MCP Clients           MCP Server             Databases
 ```
 
-## Demo HTTP Endpoint
-
-https://demo.dbhub.ai/message connects a [sample employee database](https://github.com/bytebase/employee-sample-database). You can point Cursor or MCP Inspector to it to see it in action.
-
-![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/mcp-inspector.webp)
-
 ## Supported Matrix
 
 ### Database Resources
@@ -93,6 +95,29 @@ docker run --rm --init \
    --demo
 ```
 
+**Docker Compose Setup:**
+
+If you're using Docker Compose for development, add DBHub to your `docker-compose.yml`:
+
+```yaml
+dbhub:
+  image: bytebase/dbhub:latest
+  container_name: dbhub
+  ports:
+    - "8080:8080"
+  environment:
+    - DBHUB_LOG_LEVEL=info
+  command:
+    - --transport
+    - http
+    - --port
+    - "8080"
+    - --dsn
+    - "postgres://user:password@database:5432/dbname"
+  depends_on:
+    - database
+```
+
 ### NPM
 
 ```bash
@@ -159,13 +184,88 @@ Check https://docs.anthropic.com/en/docs/claude-code/mcp
 
 ### Cursor
 
-[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=dbhub&config=eyJjb21tYW5kIjoibnB4IEBieXRlYmFzZS9kYmh1YiIsImVudiI6eyJUUkFOU1BPUlQiOiJzdGRpbyIsIkRTTiI6InBvc3RncmVzOi8vdXNlcjpwYXNzd29yZEBsb2NhbGhvc3Q6NTQzMi9kYm5hbWU%2Fc3NsbW9kZT1kaXNhYmxlIiwiUkVBRE9OTFkiOiJ0cnVlIn19)
+<p>
+Add to Cursor by copying the below link to browser
+
+```text
+cursor://anysphere.cursor-deeplink/mcp/install?name=dbhub&config=eyJjb21tYW5kIjoibnB4IEBieXRlYmFzZS9kYmh1YiIsImVudiI6eyJUUkFOU1BPUlQiOiJzdGRpbyIsIkRTTiI6InBvc3RncmVzOi8vdXNlcjpwYXNzd29yZEBsb2NhbGhvc3Q6NTQzMi9kYm5hbWU%2Fc3NsbW9kZT1kaXNhYmxlIiwiUkVBRE9OTFkiOiJ0cnVlIn19
+```
+
+</p>
 
 ![cursor](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/cursor.webp)
 
 - Cursor supports both `stdio` and `http`.
 - Follow [Cursor MCP guide](https://docs.cursor.com/context/model-context-protocol) and make sure to use [Agent](https://docs.cursor.com/chat/agent) mode.
 
+### VSCode + Copilot
+
+Check https://code.visualstudio.com/docs/copilot/customization/mcp-servers
+
+VSCode with GitHub Copilot can connect to DBHub via both `stdio` and `http` transports. This enables AI agents to interact with your development database through a secure interface.
+
+- VSCode supports both `stdio` and `http` transports
+- Configure MCP server in `.vscode/mcp.json`:
+
+**Stdio Transport:**
+
+```json
+{
+  "servers": {
+    "dbhub": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        "postgres://user:password@localhost:5432/dbname"
+      ]
+    }
+  },
+  "inputs": []
+}
+```
+
+**HTTP Transport:**
+
+```json
+{
+  "servers": {
+    "dbhub": {
+      "url": "http://localhost:8080/message",
+      "type": "http"
+    }
+  },
+  "inputs": []
+}
+```
+
+**Copilot Instructions:**
+
+You can provide Copilot with context by creating `.github/copilot-instructions.md`:
+
+```markdown
+## Database Access
+
+This project provides an MCP server (DBHub) for secure SQL access to the development database.
+
+AI agents can execute SQL queries. In read-only mode (recommended for production):
+
+- `SELECT * FROM users LIMIT 5;`
+- `SHOW TABLES;`
+- `DESCRIBE table_name;`
+
+In read-write mode (development/testing):
+
+- `INSERT INTO users (name, email) VALUES ('John', 'john@example.com');`
+- `UPDATE users SET status = 'active' WHERE id = 1;`
+- `CREATE TABLE test_table (id INT PRIMARY KEY);`
+
+Use `--readonly` flag to restrict to read-only operations for safety.
+```
+
 ## Usage
 
 ### Read-only Mode
@@ -181,6 +281,18 @@ In read-only mode, only [readonly SQL operations](https://github.com/bytebase/db
 
 This provides an additional layer of security when connecting to production databases.
 
+### Row Limiting
+
+You can limit the number of rows returned from SELECT queries using the `--max-rows` parameter. This helps prevent accidentally retrieving too much data from large tables:
+
+```bash
+# Limit SELECT queries to return at most 1000 rows
+npx @bytebase/dbhub --dsn "postgres://user:password@localhost:5432/dbname" --max-rows 1000
+```
+
+- Row limiting is only applied to SELECT statements, not INSERT/UPDATE/DELETE
+- If your query already has a `LIMIT` or `TOP` clause, DBHub uses the smaller value
+
 ### SSL Connections
 
 You can specify the SSL mode using the `sslmode` parameter in your DSN string:
@@ -287,9 +399,14 @@ 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`)
+> If your user/password contains special characters, you have two options:
+>
+> 1. Escape them in the DSN (e.g. `pass#word` should be escaped as `pass%23word`)
+> 2. Use the individual database parameters method below (recommended)
 
-For real databases, a Database Source Name (DSN) is required. You can provide this in several ways:
+For real databases, you can configure the database connection in two ways:
+
+#### Method 1: Database Source Name (DSN)
 
 - **Command line argument** (highest priority):
 
@@ -311,6 +428,45 @@ For real databases, a Database Source Name (DSN) is required. You can provide th
   DSN=postgres://user:password@localhost:5432/dbname?sslmode=disable
   ```
 
+#### Method 2: Individual Database Parameters
+
+If your password contains special characters that would break URL parsing, use individual environment variables instead:
+
+- **Environment variables**:
+
+  ```bash
+  export DB_TYPE=postgres
+  export DB_HOST=localhost
+  export DB_PORT=5432
+  export DB_USER=myuser
+  export DB_PASSWORD='my@complex:password/with#special&chars'
+  export DB_NAME=mydatabase
+  npx @bytebase/dbhub
+  ```
+
+- **Environment file**:
+  ```
+  DB_TYPE=postgres
+  DB_HOST=localhost
+  DB_PORT=5432
+  DB_USER=myuser
+  DB_PASSWORD=my@complex:password/with#special&chars
+  DB_NAME=mydatabase
+  ```
+
+**Supported DB_TYPE values**: `postgres`, `mysql`, `mariadb`, `sqlserver`, `sqlite`
+
+**Default ports** (when DB_PORT is omitted):
+
+- PostgreSQL: `5432`
+- MySQL/MariaDB: `3306`
+- SQL Server: `1433`
+
+**For SQLite**: Only `DB_TYPE=sqlite` and `DB_NAME=/path/to/database.db` are required.
+
+> [!TIP]
+> Use the individual parameter method when your password contains special characters like `@`, `:`, `/`, `#`, `&`, `=` that would break DSN parsing.
+
 > [!WARNING]
 > When running in Docker, use `host.docker.internal` instead of `localhost` to connect to databases running on your host machine. For example: `mysql://user:password@host.docker.internal:3306/dbname`
 
@@ -347,19 +503,26 @@ 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`                      |
-| ssh-host       | `SSH_HOST`           | SSH server hostname for tunnel connection                        | N/A                          |
-| ssh-port       | `SSH_PORT`           | SSH server port                                                  | `22`                         |
-| ssh-user       | `SSH_USER`           | SSH username                                                     | N/A                          |
-| ssh-password   | `SSH_PASSWORD`       | SSH password (for password authentication)                       | N/A                          |
-| ssh-key        | `SSH_KEY`            | Path to SSH private key file                                     | N/A                          |
-| ssh-passphrase | `SSH_PASSPHRASE`     | Passphrase for SSH private key                                   | N/A                          |
+| Option         | Environment Variable | Description                                                           | Default                      |
+| -------------- | -------------------- | --------------------------------------------------------------------- | ---------------------------- |
+| dsn            | `DSN`                | Database connection string                                            | Required if not in demo mode |
+| N/A            | `DB_TYPE`            | Database type: `postgres`, `mysql`, `mariadb`, `sqlserver`, `sqlite`  | N/A                          |
+| N/A            | `DB_HOST`            | Database server hostname (not needed for SQLite)                      | N/A                          |
+| N/A            | `DB_PORT`            | Database server port (uses default if omitted, not needed for SQLite) | N/A                          |
+| N/A            | `DB_USER`            | Database username (not needed for SQLite)                             | N/A                          |
+| N/A            | `DB_PASSWORD`        | Database password (not needed for SQLite)                             | N/A                          |
+| N/A            | `DB_NAME`            | Database name or SQLite file path                                     | N/A                          |
+| 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`                      |
+| max-rows       | N/A                  | Limit the number of rows returned from SELECT queries                 | No limit                     |
+| demo           | N/A                  | Run in demo mode with sample employee database                        | `false`                      |
+| ssh-host       | `SSH_HOST`           | SSH server hostname for tunnel connection                             | N/A                          |
+| ssh-port       | `SSH_PORT`           | SSH server port                                                       | `22`                         |
+| ssh-user       | `SSH_USER`           | SSH username                                                          | N/A                          |
+| ssh-password   | `SSH_PASSWORD`       | SSH password (for password authentication)                            | N/A                          |
+| ssh-key        | `SSH_KEY`            | Path to SSH private key file                                          | N/A                          |
+| ssh-passphrase | `SSH_PASSPHRASE`     | Passphrase for SSH private key                                        | N/A                          |
 
 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.
 
@@ -483,6 +646,8 @@ The project includes pre-commit hooks to run tests automatically before each com
 
 ### Debug with [MCP Inspector](https://github.com/modelcontextprotocol/inspector)
 
+![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/mcp-inspector.webp)
+
 #### stdio
 
 ```bash

package/dist/index.js

@@ -185,6 +185,97 @@ function obfuscateDSNPassword(dsn) {
   }
 }
 
+// src/utils/sql-row-limiter.ts
+var SQLRowLimiter = class {
+  /**
+   * Check if a SQL statement is a SELECT query that can benefit from row limiting
+   * Only handles SELECT queries
+   */
+  static isSelectQuery(sql2) {
+    const trimmed = sql2.trim().toLowerCase();
+    return trimmed.startsWith("select");
+  }
+  /**
+   * Check if a SQL statement already has a LIMIT clause
+   */
+  static hasLimitClause(sql2) {
+    const limitRegex = /\blimit\s+\d+/i;
+    return limitRegex.test(sql2);
+  }
+  /**
+   * Check if a SQL statement already has a TOP clause (SQL Server)
+   */
+  static hasTopClause(sql2) {
+    const topRegex = /\bselect\s+top\s+\d+/i;
+    return topRegex.test(sql2);
+  }
+  /**
+   * Extract existing LIMIT value from SQL if present
+   */
+  static extractLimitValue(sql2) {
+    const limitMatch = sql2.match(/\blimit\s+(\d+)/i);
+    if (limitMatch) {
+      return parseInt(limitMatch[1], 10);
+    }
+    return null;
+  }
+  /**
+   * Extract existing TOP value from SQL if present (SQL Server)
+   */
+  static extractTopValue(sql2) {
+    const topMatch = sql2.match(/\bselect\s+top\s+(\d+)/i);
+    if (topMatch) {
+      return parseInt(topMatch[1], 10);
+    }
+    return null;
+  }
+  /**
+   * Add or modify LIMIT clause in a SQL statement
+   */
+  static applyLimitToQuery(sql2, maxRows) {
+    const existingLimit = this.extractLimitValue(sql2);
+    if (existingLimit !== null) {
+      const effectiveLimit = Math.min(existingLimit, maxRows);
+      return sql2.replace(/\blimit\s+\d+/i, `LIMIT ${effectiveLimit}`);
+    } else {
+      const trimmed = sql2.trim();
+      const hasSemicolon = trimmed.endsWith(";");
+      const sqlWithoutSemicolon = hasSemicolon ? trimmed.slice(0, -1) : trimmed;
+      return `${sqlWithoutSemicolon} LIMIT ${maxRows}${hasSemicolon ? ";" : ""}`;
+    }
+  }
+  /**
+   * Add or modify TOP clause in a SQL statement (SQL Server)
+   */
+  static applyTopToQuery(sql2, maxRows) {
+    const existingTop = this.extractTopValue(sql2);
+    if (existingTop !== null) {
+      const effectiveTop = Math.min(existingTop, maxRows);
+      return sql2.replace(/\bselect\s+top\s+\d+/i, `SELECT TOP ${effectiveTop}`);
+    } else {
+      return sql2.replace(/\bselect\s+/i, `SELECT TOP ${maxRows} `);
+    }
+  }
+  /**
+   * Apply maxRows limit to a SELECT query only
+   */
+  static applyMaxRows(sql2, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql2)) {
+      return sql2;
+    }
+    return this.applyLimitToQuery(sql2, maxRows);
+  }
+  /**
+   * Apply maxRows limit to a SELECT query using SQL Server TOP syntax
+   */
+  static applyMaxRowsForSQLServer(sql2, maxRows) {
+    if (!maxRows || !this.isSelectQuery(sql2)) {
+      return sql2;
+    }
+    return this.applyTopToQuery(sql2, maxRows);
+  }
+};
+
 // src/connectors/postgres/index.ts
 var { Pool } = pg;
 var PostgresDSNParser = class {
@@ -494,7 +585,7 @@ var PostgresConnector = class {
       client.release();
     }
   }
-  async executeSQL(sql2) {
+  async executeSQL(sql2, options) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
@@ -502,13 +593,15 @@ var PostgresConnector = class {
     try {
       const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
       if (statements.length === 1) {
-        return await client.query(statements[0]);
+        const processedStatement = SQLRowLimiter.applyMaxRows(statements[0], options.maxRows);
+        return await client.query(processedStatement);
       } else {
         let allRows = [];
         await client.query("BEGIN");
         try {
-          for (const statement of statements) {
-            const result = await client.query(statement);
+          for (let statement of statements) {
+            const processedStatement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+            const result = await client.query(processedStatement);
             if (result.rows && result.rows.length > 0) {
               allRows.push(...result.rows);
             }
@@ -858,12 +951,16 @@ var SQLServerConnector = class {
       throw new Error(`Failed to get stored procedure details: ${error.message}`);
     }
   }
-  async executeSQL(sql2) {
+  async executeSQL(sql2, options) {
     if (!this.connection) {
       throw new Error("Not connected to SQL Server database");
     }
     try {
-      const result = await this.connection.request().query(sql2);
+      let processedSQL = sql2;
+      if (options.maxRows) {
+        processedSQL = SQLRowLimiter.applyMaxRowsForSQLServer(sql2, options.maxRows);
+      }
+      const result = await this.connection.request().query(processedSQL);
       return {
         rows: result.recordset || [],
         fields: result.recordset && result.recordset.length > 0 ? Object.keys(result.recordset[0]).map((key) => ({
@@ -949,10 +1046,19 @@ var SQLiteConnector = class {
   async disconnect() {
     if (this.db) {
       try {
-        this.db.close();
+        if (!this.db.inTransaction) {
+          this.db.close();
+        } else {
+          try {
+            this.db.exec("ROLLBACK");
+          } catch (rollbackError) {
+          }
+          this.db.close();
+        }
         this.db = null;
       } catch (error) {
-        throw error;
+        console.error("Error during SQLite disconnect:", error);
+        this.db = null;
       }
     }
     return Promise.resolve();
@@ -1074,20 +1180,24 @@ var SQLiteConnector = class {
       "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
     );
   }
-  async executeSQL(sql2) {
+  async executeSQL(sql2, options) {
     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) {
+        let processedStatement = statements[0];
         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 (options.maxRows) {
+          processedStatement = SQLRowLimiter.applyMaxRows(processedStatement, options.maxRows);
+        }
         if (isReadStatement) {
-          const rows = this.db.prepare(statements[0]).all();
+          const rows = this.db.prepare(processedStatement).all();
           return { rows };
         } else {
-          this.db.prepare(statements[0]).run();
+          this.db.prepare(processedStatement).run();
           return { rows: [] };
         }
       } else {
@@ -1105,7 +1215,8 @@ var SQLiteConnector = class {
           this.db.exec(writeStatements.join("; "));
         }
         let allRows = [];
-        for (const statement of readStatements) {
+        for (let statement of readStatements) {
+          statement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
           const result = this.db.prepare(statement).all();
           allRows.push(...result);
         }
@@ -1467,18 +1578,29 @@ var MySQLConnector = class {
     const [rows] = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeSQL(sql2) {
+  async executeSQL(sql2, options) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
-      const results = await this.pool.query(sql2);
+      let processedSQL = sql2;
+      if (options.maxRows) {
+        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const processedStatements = statements.map(
+          (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
+        );
+        processedSQL = processedStatements.join("; ");
+        if (sql2.trim().endsWith(";")) {
+          processedSQL += ";";
+        }
+      }
+      const results = await this.pool.query(processedSQL);
       const [firstResult] = results;
-      if (Array.isArray(firstResult) && firstResult.length > 0 && Array.isArray(firstResult[0]) && firstResult[0].length === 2) {
+      if (Array.isArray(firstResult) && firstResult.length > 0 && Array.isArray(firstResult[0])) {
         let allRows = [];
-        for (const [rows, _fields] of firstResult) {
-          if (Array.isArray(rows)) {
-            allRows.push(...rows);
+        for (const result of firstResult) {
+          if (Array.isArray(result)) {
+            allRows.push(...result);
           }
         }
         return { rows: allRows };
@@ -1845,12 +1967,23 @@ var MariaDBConnector = class {
     const rows = await this.pool.query("SELECT DATABASE() AS DB");
     return rows[0].DB;
   }
-  async executeSQL(sql2) {
+  async executeSQL(sql2, options) {
     if (!this.pool) {
       throw new Error("Not connected to database");
     }
     try {
-      const results = await this.pool.query(sql2);
+      let processedSQL = sql2;
+      if (options.maxRows) {
+        const statements = sql2.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+        const processedStatements = statements.map(
+          (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
+        );
+        processedSQL = processedStatements.join("; ");
+        if (sql2.trim().endsWith(";")) {
+          processedSQL += ";";
+        }
+      }
+      const results = await this.pool.query(processedSQL);
       if (Array.isArray(results)) {
         if (results.length > 0 && Array.isArray(results[0]) && results[0].length > 0) {
           let allRows = [];
@@ -2186,6 +2319,62 @@ function isReadOnlyMode() {
   }
   return false;
 }
+function buildDSNFromEnvParams() {
+  const dbType = process.env.DB_TYPE;
+  const dbHost = process.env.DB_HOST;
+  const dbUser = process.env.DB_USER;
+  const dbPassword = process.env.DB_PASSWORD;
+  const dbName = process.env.DB_NAME;
+  const dbPort = process.env.DB_PORT;
+  if (dbType?.toLowerCase() === "sqlite") {
+    if (!dbName) {
+      return null;
+    }
+  } else {
+    if (!dbType || !dbHost || !dbUser || !dbPassword || !dbName) {
+      return null;
+    }
+  }
+  const supportedTypes = ["postgres", "postgresql", "mysql", "mariadb", "sqlserver", "sqlite"];
+  if (!supportedTypes.includes(dbType.toLowerCase())) {
+    throw new Error(`Unsupported DB_TYPE: ${dbType}. Supported types: ${supportedTypes.join(", ")}`);
+  }
+  let port = dbPort;
+  if (!port) {
+    switch (dbType.toLowerCase()) {
+      case "postgres":
+      case "postgresql":
+        port = "5432";
+        break;
+      case "mysql":
+      case "mariadb":
+        port = "3306";
+        break;
+      case "sqlserver":
+        port = "1433";
+        break;
+      case "sqlite":
+        return {
+          dsn: `sqlite:///${dbName}`,
+          source: "individual environment variables"
+        };
+      default:
+        throw new Error(`Unknown database type for port determination: ${dbType}`);
+    }
+  }
+  const user = dbUser;
+  const password = dbPassword;
+  const dbNameStr = dbName;
+  const encodedUser = encodeURIComponent(user);
+  const encodedPassword = encodeURIComponent(password);
+  const encodedDbName = encodeURIComponent(dbNameStr);
+  const protocol = dbType.toLowerCase() === "postgresql" ? "postgres" : dbType.toLowerCase();
+  const dsn = `${protocol}://${encodedUser}:${encodedPassword}@${dbHost}:${port}/${encodedDbName}`;
+  return {
+    dsn,
+    source: "individual environment variables"
+  };
+}
 function resolveDSN() {
   const args = parseCommandLineArgs();
   if (isDemoMode()) {
@@ -2201,10 +2390,23 @@ function resolveDSN() {
   if (process.env.DSN) {
     return { dsn: process.env.DSN, source: "environment variable" };
   }
+  const envParamsResult = buildDSNFromEnvParams();
+  if (envParamsResult) {
+    return envParamsResult;
+  }
   const loadedEnvFile = loadEnvFiles();
   if (loadedEnvFile && process.env.DSN) {
     return { dsn: process.env.DSN, source: `${loadedEnvFile} file` };
   }
+  if (loadedEnvFile) {
+    const envFileParamsResult = buildDSNFromEnvParams();
+    if (envFileParamsResult) {
+      return {
+        dsn: envFileParamsResult.dsn,
+        source: `${loadedEnvFile} file (individual parameters)`
+      };
+    }
+  }
   return null;
 }
 function resolveTransport() {
@@ -2219,6 +2421,17 @@ function resolveTransport() {
   }
   return { type: "stdio", source: "default" };
 }
+function resolveMaxRows() {
+  const args = parseCommandLineArgs();
+  if (args["max-rows"]) {
+    const maxRows = parseInt(args["max-rows"], 10);
+    if (isNaN(maxRows) || maxRows <= 0) {
+      throw new Error(`Invalid --max-rows value: ${args["max-rows"]}. Must be a positive integer.`);
+    }
+    return { maxRows, source: "command line argument" };
+  }
+  return null;
+}
 function resolvePort() {
   const args = parseCommandLineArgs();
   if (args.port) {
@@ -2330,9 +2543,15 @@ var ConnectorManager = class {
     this.connected = false;
     this.sshTunnel = null;
     this.originalDSN = null;
+    this.maxRows = null;
     if (!managerInstance) {
       managerInstance = this;
     }
+    const maxRowsData = resolveMaxRows();
+    if (maxRowsData) {
+      this.maxRows = maxRowsData.maxRows;
+      console.error(`Max rows limit: ${this.maxRows} (from ${maxRowsData.source})`);
+    }
   }
   /**
    * Initialize and connect to the database using a DSN
@@ -2428,6 +2647,26 @@ var ConnectorManager = class {
     }
     return managerInstance.getConnector();
   }
+  /**
+   * Get execute options for SQL execution
+   */
+  getExecuteOptions() {
+    const options = {};
+    if (this.maxRows !== null) {
+      options.maxRows = this.maxRows;
+    }
+    return options;
+  }
+  /**
+   * Get the current execute options
+   * This is used by tool handlers
+   */
+  static getCurrentExecuteOptions() {
+    if (!managerInstance) {
+      throw new Error("ConnectorManager not initialized");
+    }
+    return managerInstance.getExecuteOptions();
+  }
   /**
    * Get default port for a database based on DSN protocol
    */
@@ -2870,6 +3109,7 @@ function areAllStatementsReadOnly(sql2, connectorType) {
 }
 async function executeSqlToolHandler({ sql: sql2 }, _extra) {
   const connector = ConnectorManager.getCurrentConnector();
+  const executeOptions = ConnectorManager.getCurrentExecuteOptions();
   try {
     if (isReadOnlyMode() && !areAllStatementsReadOnly(sql2, connector.id)) {
       return createToolErrorResponse(
@@ -2877,7 +3117,7 @@ async function executeSqlToolHandler({ sql: sql2 }, _extra) {
         "READONLY_VIOLATION"
       );
     }
-    const result = await connector.executeSQL(sql2);
+    const result = await connector.executeSQL(sql2, executeOptions);
     const responseData = {
       rows: result.rows,
       count: result.rows.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",