@dbx-app/mcp-server 0.4.3 → 0.4.5

package/README.md

@@ -92,7 +92,7 @@ See the [DBX CLI README](../cli/README.md) for command details.
 
 ## SQL Safety
 
-`dbx_execute_query` is read-only by default. To allow write statements such as `INSERT` or `UPDATE`, set:
+`dbx_execute_query` accepts multiple SQL statements and executes them one at a time after checking each statement. It is read-only by default. To allow write statements such as `INSERT` or `UPDATE`, set:
 
 ```bash
 DBX_MCP_ALLOW_WRITES=1
@@ -127,7 +127,7 @@ PostgreSQL, MySQL, SQLite, Doris, StarRocks, and Redshift queries run directly f
 ## Requirements
 
 - [DBX](https://github.com/t8y2/dbx) installed with at least one connection configured
-- Node.js 18+
+- Node.js 22.13.0 或更高版本
 
 ## License
 
@@ -213,7 +213,7 @@ dbx query local "select 1" --json
 
 ### SQL 安全
 
-`dbx_execute_query` 默认只读。若要允许 `INSERT`、`UPDATE` 等写操作，设置：
+`dbx_execute_query` 支持多条 SQL 语句，会逐条完成安全检查并依次执行。默认只读。若要允许 `INSERT`、`UPDATE` 等写操作，设置：
 
 ```bash
 DBX_MCP_ALLOW_WRITES=1
@@ -242,4 +242,4 @@ PostgreSQL、MySQL、SQLite、Doris、StarRocks、Redshift 查询可由 MCP Serv
 ### 系统要求
 
 - 已安装 [DBX](https://github.com/t8y2/dbx) 并配置了至少一个数据库连接
-- Node.js 18+
+- Node.js 22.13.0 or newer

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type Backend } from "@dbx-app/node-core";
+export declare const DBX_MCP_PACKAGE_VERSION: string;
+export declare const DBX_CONNECTION_TYPE_DESCRIPTION = "Database type: postgres, mysql, sqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, doris, starrocks, redshift, dameng, kingbase, highgo, vastbase, goldendb, gaussdb, yashandb, databricks, saphana, teradata, vertica, firebird, exasol, opengauss, oceanbase-oracle, gbase, h2, snowflake, trino, hive, db2, informix, neo4j, cassandra, bigquery, kylin, sundb, tdengine, xugu, jdbc, access";
 export declare function createDbxMcpServer(backend: Backend, options?: {
     isWebMode?: boolean;
 }): McpServer;

package/dist/index.js

@@ -1,24 +1,34 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 import { z } from "zod";
-import { buildSchemaContext, createBackend, evaluateSqlSafety, formatSchemaContext, notifyReload, postBridge, sqlSafetyFromEnv, } from "@dbx-app/node-core";
+import { buildSchemaContext, createBackend, evaluateMongoAggregateSafety, evaluateSqlSafety, formatCell, formatSchemaContext, isMainModule, mdTable, notifyReload, parseMongoAggregateCommand, postBridge, sqlSafetyFromEnv, splitSqlStatements, } from "@dbx-app/node-core";
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+export const DBX_MCP_PACKAGE_VERSION = packageJson.version ?? "0.0.0";
 function text(s) {
     return { content: [{ type: "text", text: s }] };
 }
-function mdTable(headers, rows) {
-    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length), 3));
-    const header = `| ${headers.map((h, i) => h.padEnd(widths[i])).join(" | ")} |`;
-    const sep = `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`;
-    const body = rows.map((r) => `| ${r.map((c, i) => (c || "").padEnd(widths[i])).join(" | ")} |`).join("\n");
-    return `${header}\n${sep}\n${body}`;
+function toolError(code, message) {
+    return { ...text(`${code}: ${message}`), isError: true };
 }
+function withDatabase(config, database) {
+    return database === undefined ? config : { ...config, database };
+}
+function formatQueryToolResult(result, title) {
+    const prefix = title ? `${title}\n` : "";
+    if (result.columns.length === 0)
+        return text(`${prefix}Query executed. ${result.row_count} row(s) affected.`);
+    const rows = result.rows.map((r) => result.columns.map((c) => formatCell(r[c])));
+    return text(`${prefix}${mdTable(result.columns, rows)}\n\n${result.row_count} row(s)`);
+}
+export const DBX_CONNECTION_TYPE_DESCRIPTION = "Database type: postgres, mysql, sqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, doris, starrocks, redshift, dameng, kingbase, highgo, vastbase, goldendb, gaussdb, yashandb, databricks, saphana, teradata, vertica, firebird, exasol, opengauss, oceanbase-oracle, gbase, h2, snowflake, trino, hive, db2, informix, neo4j, cassandra, bigquery, kylin, sundb, tdengine, xugu, jdbc, access";
 export function createDbxMcpServer(backend, options = {}) {
     const isWebMode = options.isWebMode ?? !!process.env.DBX_WEB_URL;
     const server = new McpServer({
         name: "dbx",
-        version: "0.4.2",
+        version: DBX_MCP_PACKAGE_VERSION,
     });
     server.tool("dbx_list_connections", "List all database connections configured in DBX", {}, async () => {
         const connections = await backend.loadConnections();
@@ -29,12 +39,13 @@ export function createDbxMcpServer(backend, options = {}) {
     });
     server.tool("dbx_list_tables", "List tables and views for a database connection", {
         connection_name: z.string().describe("Name of the DBX connection"),
+        database: z.string().optional().describe("Database name"),
         schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
-    }, async ({ connection_name, schema }) => {
+    }, async ({ connection_name, database, schema }) => {
         const config = await backend.findConnection(connection_name);
         if (!config)
-            return text(`Connection "${connection_name}" not found`);
-        const tables = await backend.listTables(config, schema);
+            return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        const tables = await backend.listTables(withDatabase(config, database), schema);
         if (tables.length === 0)
             return text("No tables found.");
         const rows = tables.map((t) => [t.name, t.type]);
@@ -43,12 +54,13 @@ export function createDbxMcpServer(backend, options = {}) {
     server.tool("dbx_describe_table", "Get column definitions for a table", {
         connection_name: z.string().describe("Name of the DBX connection"),
         table: z.string().describe("Table name"),
+        database: z.string().optional().describe("Database name"),
         schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
-    }, async ({ connection_name, table, schema }) => {
+    }, async ({ connection_name, table, database, schema }) => {
         const config = await backend.findConnection(connection_name);
         if (!config)
-            return text(`Connection "${connection_name}" not found`);
-        const columns = await backend.describeTable(config, table, schema);
+            return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        const columns = await backend.describeTable(withDatabase(config, database), table, schema);
         if (columns.length === 0)
             return text("No columns found.");
         const rows = columns.map((c) => [
@@ -62,47 +74,58 @@ export function createDbxMcpServer(backend, options = {}) {
     });
     server.tool("dbx_execute_query", "Execute a SQL query on a database connection (max 100 rows returned)", {
         connection_name: z.string().describe("Name of the DBX connection"),
+        database: z.string().optional().describe("Database name"),
         sql: z.string().describe("SQL query to execute"),
-    }, async ({ connection_name, sql }) => {
+    }, async ({ connection_name, database, sql }) => {
         const config = await backend.findConnection(connection_name);
         if (!config)
-            return text(`Connection "${connection_name}" not found`);
-        const safety = evaluateSqlSafety(sql, sqlSafetyFromEnv());
-        if (!safety.allowed)
-            return text(`Query blocked: ${safety.reason}`);
+            return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        if (config.db_type !== "mongodb") {
+            const safety = evaluateSqlSafety(sql, { ...sqlSafetyFromEnv(), allowMultipleStatements: true });
+            if (!safety.allowed)
+                return toolError("SQL_BLOCKED", safety.reason ?? "SQL blocked.");
+        }
+        // MongoDB shell commands don't fit the SQL safety evaluator; the backend
+        // (node-core executeQuery) applies command-aware read/write gating.
         try {
-            const result = await backend.executeQuery(config, sql);
-            if (result.columns.length === 0)
-                return text(`Query executed. ${result.row_count} row(s) affected.`);
-            const rows = result.rows.map((r) => result.columns.map((c) => formatCell(r[c])));
-            return text(`${mdTable(result.columns, rows)}\n\n${result.row_count} row(s)`);
+            const statements = config.db_type === "mongodb" ? [sql] : splitSqlStatements(sql);
+            const results = [];
+            for (const statement of statements) {
+                results.push(await backend.executeQuery(withDatabase(config, database), statement));
+            }
+            if (results.length === 1)
+                return formatQueryToolResult(results[0]);
+            return text(results.map((result, index) => formatQueryToolResult(result, `Statement ${index + 1}`).content[0].text).join("\n\n"));
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            return text(`Query error: ${msg}`);
+            return toolError("QUERY_ERROR", msg);
         }
     });
     server.tool("dbx_get_schema_context", "Get compact table and column context for writing SQL", {
         connection_name: z.string().describe("Name of the DBX connection"),
+        database: z.string().optional().describe("Database name"),
         schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
         tables: z.array(z.string()).optional().describe("Specific table names to include"),
         max_tables: z.number().int().min(1).max(20).default(8).describe("Maximum number of tables to include"),
-    }, async ({ connection_name, schema, tables, max_tables }) => {
+    }, async ({ connection_name, database, schema, tables, max_tables }) => {
         const config = await backend.findConnection(connection_name);
         if (!config)
-            return text(`Connection "${connection_name}" not found`);
-        const context = await buildSchemaContext(backend, config, { schema, tables, maxTables: max_tables });
+            return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        const context = await buildSchemaContext(backend, withDatabase(config, database), {
+            schema,
+            tables,
+            maxTables: max_tables,
+        });
         if (context.tables.length === 0)
             return text("No matching tables found.");
         return text(formatSchemaContext(context));
     });
     server.tool("dbx_add_connection", "Add a new database connection to DBX", {
         name: z.string().describe("Connection name"),
-        db_type: z
-            .string()
-            .describe("Database type: postgres, mysql, sqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, doris, starrocks, redshift, dameng, kingbase, highgo, vastbase, goldendb, gaussdb, h2, snowflake, trino, hive, db2, informix, neo4j, cassandra, bigquery, kylin, sundb, tdengine, jdbc, access"),
+        db_type: z.string().describe(DBX_CONNECTION_TYPE_DESCRIPTION),
         host: z.string().describe("Database host"),
-        port: z.number().optional().describe("Database port (TDengine defaults to 6041)"),
+        port: z.number().optional().describe("Database port (TDengine defaults to 6041, XuguDB defaults to 5138)"),
         username: z.string().default("").describe("Username"),
         password: z.string().default("").describe("Password"),
         database: z.string().optional().describe("Default database name"),
@@ -112,7 +135,8 @@ export function createDbxMcpServer(backend, options = {}) {
         if (existing)
             return text(`Connection "${name}" already exists.`);
         const FILE_BASED_TYPES = new Set(["sqlite", "duckdb", "access"]);
-        const resolvedPort = port ?? (db_type === "tdengine" ? 6041 : FILE_BASED_TYPES.has(db_type) ? 0 : undefined);
+        const DEFAULT_PORTS = { tdengine: 6041, xugu: 5138 };
+        const resolvedPort = port ?? DEFAULT_PORTS[db_type] ?? (FILE_BASED_TYPES.has(db_type) ? 0 : undefined);
         if (resolvedPort === undefined)
             return text("Port is required for this database type.");
         const config = await backend.addConnection({
@@ -134,7 +158,7 @@ export function createDbxMcpServer(backend, options = {}) {
     }, async ({ connection_name }) => {
         const removed = await backend.removeConnection(connection_name);
         if (!removed)
-            return text(`Connection "${connection_name}" not found.`);
+            return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
         await notifyReload();
         return text(`Connection "${connection_name}" removed.`);
     });
@@ -146,6 +170,9 @@ export function createDbxMcpServer(backend, options = {}) {
             database: z.string().optional().describe("Database name"),
             schema: z.string().optional().describe("Schema name"),
         }, async ({ connection_name, table, database, schema }) => {
+            const config = await backend.findConnection(connection_name);
+            if (!config)
+                return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
             return bridgeRequest("/open-table", { connection_name, table, database, schema }, `Opened ${table} in DBX`);
         });
         server.tool("dbx_execute_and_show", "Execute a SQL query in DBX desktop app UI and show results there. Requires DBX to be running.", {
@@ -153,26 +180,42 @@ export function createDbxMcpServer(backend, options = {}) {
             sql: z.string().describe("SQL query to execute"),
             database: z.string().optional().describe("Database name"),
         }, async ({ connection_name, sql, database }) => {
-            const safety = evaluateSqlSafety(sql, sqlSafetyFromEnv());
-            if (!safety.allowed)
-                return text(`Query blocked: ${safety.reason}`);
-            return bridgeRequest("/execute-query", { connection_name, sql, database }, "Query sent to DBX");
+            const config = await backend.findConnection(connection_name);
+            if (!config)
+                return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+            const safetyOptions = sqlSafetyFromEnv();
+            if (config?.db_type === "mongodb") {
+                const aggregate = parseMongoAggregateCommand(sql);
+                if (aggregate) {
+                    const safety = evaluateMongoAggregateSafety(aggregate, safetyOptions);
+                    if (!safety.allowed)
+                        return toolError("SQL_BLOCKED", safety.reason ?? "Query blocked.");
+                }
+            }
+            else {
+                const safety = evaluateSqlSafety(sql, { ...safetyOptions, allowMultipleStatements: true });
+                if (!safety.allowed)
+                    return toolError("SQL_BLOCKED", safety.reason ?? "SQL blocked.");
+            }
+            // MongoDB shell commands bypass the SQL safety evaluator; pass MCP
+            // safety flags to the desktop executor for command-aware gating.
+            return bridgeRequest("/execute-query", {
+                connection_name,
+                sql,
+                database,
+                allow_writes: safetyOptions.allowWrites,
+                allow_dangerous: safetyOptions.allowDangerous,
+            }, "Query sent to DBX");
         });
     }
     return server;
 }
-function formatCell(value) {
-    if (value === null || value === undefined)
-        return "NULL";
-    if (typeof value === "object")
-        return JSON.stringify(value);
-    return String(value);
-}
 async function bridgeRequest(path, body, successMsg) {
     const res = await postBridge(path, body);
     if (res.ok)
         return text(successMsg);
-    return text(res.text.startsWith("DBX is not running") ? res.text : `Failed: ${res.text}`);
+    const message = res.text.startsWith("DBX is not running") ? res.text : `Failed: ${res.text}`;
+    return toolError("DBX_NOT_RUNNING", message);
 }
 async function main() {
     const backend = await createBackend();
@@ -180,7 +223,7 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+if (isMainModule(import.meta.url, process.argv[1])) {
     main().catch((e) => {
         console.error("MCP Server failed to start:", e);
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbx-app/mcp-server",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "mcpName": "io.github.t8y2/dbx",
   "description": "MCP server for DBX — query databases from Claude Code, Cursor, and other AI agents",
   "type": "module",
@@ -34,7 +34,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
     "zod": "^3.25.20",
-    "@dbx-app/node-core": "^0.4.3"
+    "@dbx-app/node-core": "^0.4.5"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/t8y2/dbx",
     "source": "github"
   },
-  "version": "0.4.3",
+  "version": "0.4.5",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@dbx-app/mcp-server",
-      "version": "0.4.3",
+      "version": "0.4.5",
       "transport": {
         "type": "stdio"
       }