cq-mcp-server 0.3.2 → 0.3.4

package/README.md

@@ -14,9 +14,9 @@ npm install -g cq-mcp-server
 
 ```bash
 # 直接运行，默认 stdio
-CQ_BASE_URL=http://10.10.2.73 CQ_USERNAME=admin001 CQ_PASSWORD=Hello123$ cq-mcp-server
+CQ_BASE_URL=http://10.10.2.73 CQ_USERNAME=xxxxx CQ_PASSWORD=xxxx cq-mcp-server
 ```
-
+s
 ### HTTP 模式（Dify 接入）
 
 Dify 只支持 HTTP 传输，通过环境变量切换：

package/dist/index.js

@@ -122,11 +122,139 @@ function createSessionContext() {
         metaNode,
     };
 }
+async function implConnect(ctx, args) {
+    ctx.setConfig({ baseUrl: args.base_url.replace(/\/$/, ""), username: args.username, password: args.password });
+    log.info(`connect: 配置已更新 baseUrl=${args.base_url} user=${args.username}`);
+    return `连接配置已设置：${args.base_url}，用户：${args.username}`;
+}
+async function implListDatabases(ctx) {
+    log.info("list_databases: 查询连接列表");
+    const connections = await ctx.metaNode({ nodeType: "root", nodePath: "/root" });
+    if (!connections.length)
+        return "未找到任何数据库连接";
+    const lines = [];
+    for (const conn of connections) {
+        const { connectionId, connectionType, nodeName } = conn;
+        lines.push(`## 连接: ${nodeName}  (connection_id=${connectionId}, connection_type=${connectionType})`);
+        const databases = await ctx.metaNode({
+            nodeType: "connection",
+            nodePath: `/root/${connectionId}`,
+            nodePathWithType: `/CONNECTION:${connectionId}`,
+            connectionId,
+            connectionType,
+        });
+        log.info(`  └─ ${nodeName}: ${databases.length} 个数据库`);
+        if (databases.length) {
+            for (const db of databases)
+                lines.push(`  - ${db.nodeName}`);
+        }
+        else {
+            lines.push("  (无数据库)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+async function implListTables(ctx, args) {
+    const schema = args.schema ?? "public";
+    log.info(`list_tables: ${args.database}.${schema} (conn=${args.connection_id})`);
+    const tables = await ctx.metaNode({
+        nodeType: "tableGroup",
+        nodePath: `/root/${args.connection_id}/${args.database}/${schema}/tables`,
+        nodePathWithType: `/CONNECTION:${args.connection_id}/DATABASE:${args.database}/SCHEMA:${schema}`,
+        connectionId: args.connection_id,
+        connectionType: args.connection_type,
+    });
+    if (!tables.length)
+        return `${args.database}.${schema} 下未找到任何表`;
+    log.info(`  └─ 共 ${tables.length} 张表`);
+    const lines = [`${args.database}.${schema} 共 ${tables.length} 张表：`, ""];
+    for (const t of tables)
+        lines.push(`- ${t.nodeName}`);
+    return lines.join("\n");
+}
+async function implGetTableColumns(ctx, args) {
+    log.info(`get_table_columns: ${args.database}.${args.schema}.${args.table} (conn=${args.connection_id})`);
+    const columns = await ctx.metaNode({
+        nodeType: "columnGroup",
+        nodePath: `/root/${args.connection_id}/${args.database}/${args.schema}/tables/${args.table}/columns`,
+        nodePathWithType: `/CONNECTION:${args.connection_id}/DATABASE:${args.database}/SCHEMA:${args.schema}/TABLE:${args.table}`,
+        connectionId: args.connection_id,
+        connectionType: args.connection_type,
+    });
+    if (!columns.length)
+        return `表 ${args.database}.${args.schema}.${args.table} 未找到字段信息`;
+    log.info(`  └─ ${columns.length} 个字段`);
+    const lines = [
+        `表 ${args.database}.${args.schema}.${args.table}  共 ${columns.length} 个字段：`,
+        "",
+        `${"字段名".padEnd(25)} ${"类型".padEnd(15)} ${"长度".padEnd(8)} ${"可空".padEnd(6)} 注释`,
+        "-".repeat(75),
+    ];
+    for (const col of columns) {
+        const opts = col.nodeOptions ?? {};
+        lines.push(`${col.nodeName.padEnd(25)} ${(opts.dataType ?? "").padEnd(15)} ${(opts.dataLength ?? "").padEnd(8)} ${(opts.isNullable ? "是" : "否").padEnd(6)} ${opts.comments ?? ""}`);
+    }
+    return lines.join("\n");
+}
+async function implExecuteSql(ctx, args) {
+    const connection_type = args.connection_type ?? "PostgreSQL";
+    const schema = args.schema ?? "public";
+    const tabKey = `mcp-${Date.now()}`;
+    const preview = args.sql.length > 60 ? args.sql.slice(0, 60) + "..." : args.sql;
+    log.info(`execute_sql: [${args.database}.${schema}] ${preview}`);
+    const data = await ctx.post("/dms/segment/statement/blocking/execute", {
+        connectionId: args.connection_id,
+        dataSourceType: connection_type,
+        databaseName: args.database,
+        operatingObject: schema,
+        statements: [args.sql],
+        offset: 0,
+        rowCount: 500,
+        tabKey,
+        plSql: false,
+        sortModels: null,
+        filterModel: null,
+        autoCommit: false,
+        actionType: null,
+    });
+    const infos = data?.executionInfos ?? [];
+    const lines = [];
+    for (const info of infos) {
+        const log_msg = info.executeLogInfo?.message;
+        const resp = info.response;
+        if (!resp?.success || log_msg?.success === false) {
+            const errMsg = log_msg?.error ?? resp?.executeError?.message ?? "执行失败";
+            log.error(`SQL 执行失败: ${errMsg}`);
+            lines.push(`错误: ${errMsg}`);
+            continue;
+        }
+        if (!resp.resultData?.length) {
+            const affected = log_msg?.affectedRows ?? 0;
+            const ms = log_msg?.duration ?? 0;
+            log.info(`  └─ 执行成功，影响 ${affected} 行，${ms}ms`);
+            lines.push(`执行成功\n影响行数: ${affected}\n耗时: ${ms}ms`);
+            continue;
+        }
+        const resultData = resp.resultData;
+        const colInfos = resp.columnInfos ?? [];
+        const colNames = colInfos.length ? colInfos.map((c) => c.columnName) : Object.keys(resultData[0]);
+        const ms = log_msg?.duration ?? 0;
+        log.info(`  └─ 返回 ${resultData.length} 行，${ms}ms`);
+        const rows = resultData.map((row) => {
+            const obj = {};
+            for (const col of colNames)
+                obj[col] = row[col]?.value ?? null;
+            return obj;
+        });
+        lines.push(JSON.stringify({ columns: colNames, rows, total: resultData.length, elapsed_ms: ms }));
+    }
+    return lines.join("\n") || "无输出";
+}
 // ── 工具注册工厂（每个 session 独立） ─────────────────────────────
 function createMcpServer() {
     const server = new McpServer({ name: "cq-mcp-server", version: "0.2.0" });
     const ctx = createSessionContext();
-    // ── 工具零：连接配置 ────────────────────────────────────────────
     server.tool("connect", `配置 CloudQuery 平台的连接信息（地址、账号、密码）。
 
 用途：在调用其他工具前，先通过此工具设置连接参数。适用于未配置环境变量的场景（如 Dify、动态多租户等）。
@@ -139,47 +267,12 @@ function createMcpServer() {
         base_url: z.string().describe("CloudQuery 平台地址，如 http://10.10.2.73"),
         username: z.string().describe("登录账号"),
         password: z.string().describe("登录密码"),
-    }, async ({ base_url, username, password }) => {
-        ctx.setConfig({ baseUrl: base_url.replace(/\/$/, ""), username, password });
-        log.info(`connect: 配置已更新 baseUrl=${base_url} user=${username}`);
-        return {
-            content: [{ type: "text", text: `连接配置已设置：${base_url}，用户：${username}` }],
-        };
-    });
-    // ── 工具一：查询数据库清单 ───────────────────────────────────────
+    }, async (args) => ({ content: [{ type: "text", text: await implConnect(ctx, args) }] }));
     server.tool("list_databases", `查询所有数据库连接及其下的数据库实例列表。
 
 用途：了解当前 CloudQuery 平台上有哪些数据库连接，以及每个连接下有哪些数据库。
 返回：连接名称、连接ID、数据库类型，以及每个连接下的数据库列表。
-后续：拿到 connection_id 和 connection_type 后，可调用 list_tables 查看具体库的表。`, {}, async () => {
-        log.info("list_databases: 查询连接列表");
-        const connections = await ctx.metaNode({ nodeType: "root", nodePath: "/root" });
-        if (!connections.length)
-            return { content: [{ type: "text", text: "未找到任何数据库连接" }] };
-        const lines = [];
-        for (const conn of connections) {
-            const { connectionId, connectionType, nodeName } = conn;
-            lines.push(`## 连接: ${nodeName}  (connection_id=${connectionId}, connection_type=${connectionType})`);
-            const databases = await ctx.metaNode({
-                nodeType: "connection",
-                nodePath: `/root/${connectionId}`,
-                nodePathWithType: `/CONNECTION:${connectionId}`,
-                connectionId,
-                connectionType,
-            });
-            log.info(`  └─ ${nodeName}: ${databases.length} 个数据库`);
-            if (databases.length) {
-                for (const db of databases)
-                    lines.push(`  - ${db.nodeName}`);
-            }
-            else {
-                lines.push("  (无数据库)");
-            }
-            lines.push("");
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-    });
-    // ── 工具二：查询表清单 ──────────────────────────────────────────
+后续：拿到 connection_id 和 connection_type 后，可调用 list_tables 查看具体库的表。`, {}, async () => ({ content: [{ type: "text", text: await implListDatabases(ctx) }] }));
     server.tool("list_tables", `查询指定数据库 Schema 下的所有普通表。
 
 用途：了解某个数据库 Schema 下有哪些表，为后续字段查询或 SQL 编写做准备。
@@ -193,25 +286,7 @@ function createMcpServer() {
         connection_type: z.string().describe("数据库类型，如 PostgreSQL、MySQL，从 list_databases 获取"),
         database: z.string().describe("数据库名称，如 pam、postgres"),
         schema: z.string().default("public").describe("Schema 名称，PostgreSQL 默认 public"),
-    }, async ({ connection_id, connection_type, database, schema }) => {
-        log.info(`list_tables: ${database}.${schema} (conn=${connection_id})`);
-        const tables = await ctx.metaNode({
-            nodeType: "tableGroup",
-            nodePath: `/root/${connection_id}/${database}/${schema}/tables`,
-            nodePathWithType: `/CONNECTION:${connection_id}/DATABASE:${database}/SCHEMA:${schema}`,
-            connectionId: connection_id,
-            connectionType: connection_type,
-        });
-        if (!tables.length) {
-            return { content: [{ type: "text", text: `${database}.${schema} 下未找到任何表` }] };
-        }
-        log.info(`  └─ 共 ${tables.length} 张表`);
-        const lines = [`${database}.${schema} 共 ${tables.length} 张表：`, ""];
-        for (const t of tables)
-            lines.push(`- ${t.nodeName}`);
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-    });
-    // ── 工具三：查询表字段 ──────────────────────────────────────────
+    }, async (args) => ({ content: [{ type: "text", text: await implListTables(ctx, args) }] }));
     server.tool("get_table_columns", `查询指定表的完整字段定义，包括字段名、数据类型、长度、是否可空、业务注释。
 
 用途：了解表结构，辅助编写精确的 SQL 查询语句。
@@ -225,32 +300,7 @@ function createMcpServer() {
         database: z.string().describe("数据库名称"),
         schema: z.string().describe("Schema 名称"),
         table: z.string().describe("表名，从 list_tables 获取"),
-    }, async ({ connection_id, connection_type, database, schema, table }) => {
-        log.info(`get_table_columns: ${database}.${schema}.${table} (conn=${connection_id})`);
-        const columns = await ctx.metaNode({
-            nodeType: "columnGroup",
-            nodePath: `/root/${connection_id}/${database}/${schema}/tables/${table}/columns`,
-            nodePathWithType: `/CONNECTION:${connection_id}/DATABASE:${database}/SCHEMA:${schema}/TABLE:${table}`,
-            connectionId: connection_id,
-            connectionType: connection_type,
-        });
-        if (!columns.length) {
-            return { content: [{ type: "text", text: `表 ${database}.${schema}.${table} 未找到字段信息` }] };
-        }
-        log.info(`  └─ ${columns.length} 个字段`);
-        const lines = [
-            `表 ${database}.${schema}.${table}  共 ${columns.length} 个字段：`,
-            "",
-            `${"字段名".padEnd(25)} ${"类型".padEnd(15)} ${"长度".padEnd(8)} ${"可空".padEnd(6)} 注释`,
-            "-".repeat(75),
-        ];
-        for (const col of columns) {
-            const opts = col.nodeOptions ?? {};
-            lines.push(`${col.nodeName.padEnd(25)} ${(opts.dataType ?? "").padEnd(15)} ${(opts.dataLength ?? "").padEnd(8)} ${(opts.isNullable ? "是" : "否").padEnd(6)} ${opts.comments ?? ""}`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-    });
-    // ── 工具四：执行 SQL ────────────────────────────────────────────
+    }, async (args) => ({ content: [{ type: "text", text: await implGetTableColumns(ctx, args) }] }));
     server.tool("execute_sql", `在指定数据库上执行 SQL 语句，返回查询结果或执行状态。
 
 用途：直接运行 SQL 查询数据，或执行 DML（INSERT/UPDATE/DELETE）操作。
@@ -269,59 +319,7 @@ function createMcpServer() {
         database: z.string().describe("数据库名称"),
         schema: z.string().default("public").describe("执行 SQL 的默认 Schema，默认 public"),
         sql: z.string().describe("SQL 语句，一次执行一条"),
-    }, async ({ connection_id, connection_type, database, schema, sql }) => {
-        const tabKey = `mcp-${Date.now()}`;
-        const preview = sql.length > 60 ? sql.slice(0, 60) + "..." : sql;
-        log.info(`execute_sql: [${database}.${schema}] ${preview}`);
-        const data = await ctx.post("/dms/segment/statement/blocking/execute", {
-            connectionId: connection_id,
-            dataSourceType: connection_type,
-            databaseName: database,
-            operatingObject: schema,
-            statements: [sql],
-            offset: 0,
-            rowCount: 500,
-            tabKey,
-            plSql: false,
-            sortModels: null,
-            filterModel: null,
-            autoCommit: false,
-            actionType: null,
-        });
-        const infos = data?.executionInfos ?? [];
-        const lines = [];
-        for (const info of infos) {
-            const log_msg = info.executeLogInfo?.message;
-            const resp = info.response;
-            if (!resp?.success) {
-                const errMsg = resp?.executeError?.message ?? log_msg?.error ?? "执行失败";
-                log.error(`SQL 执行失败: ${errMsg}`);
-                lines.push(`错误: ${errMsg}`);
-                continue;
-            }
-            if (!resp.resultData?.length) {
-                const affected = log_msg?.affectedRows ?? 0;
-                const ms = log_msg?.duration ?? 0;
-                log.info(`  └─ 执行成功，影响 ${affected} 行，${ms}ms`);
-                lines.push(`执行成功\n影响行数: ${affected}\n耗时: ${ms}ms`);
-                continue;
-            }
-            const resultData = resp.resultData;
-            const colInfos = resp.columnInfos ?? [];
-            const colNames = colInfos.length
-                ? colInfos.map((c) => c.columnName)
-                : Object.keys(resultData[0]);
-            const ms = log_msg?.duration ?? 0;
-            log.info(`  └─ 返回 ${resultData.length} 行，${ms}ms`);
-            lines.push(colNames.join(" | "));
-            lines.push("-".repeat(Math.max(colNames.join(" | ").length, 20)));
-            for (const row of resultData) {
-                lines.push(colNames.map((col) => String(row[col]?.value ?? "")).join(" | "));
-            }
-            lines.push(`\n共 ${resultData.length} 行  耗时 ${ms}ms`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") || "无输出" }] };
-    });
+    }, async (args) => ({ content: [{ type: "text", text: await implExecuteSql(ctx, args) }] }));
     return server;
 }
 // ── 启动 ──────────────────────────────────────────────────────────
@@ -333,6 +331,20 @@ if (MCP_TRANSPORT === "http") {
     const sessions = new Map();
     // SSE transport 映射（sessionId → transport），用于兼容 Dify 等旧版客户端
     const sseSessions = new Map();
+    // /invoke 端点使用的全局 session context（持久化凭证，供 Dify 调用）
+    const invokeCtx = createSessionContext();
+    /** 读取请求体 */
+    function readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+            req.on("error", reject);
+        });
+    }
+    // Schema 缓存（10 分钟 TTL，避免每次请求都重新查询所有表）
+    let schemaCache = null;
+    let schemaCacheTime = 0;
     const httpServer = createServer(async (req, res) => {
         // 允许跨域（Dify 可能从不同域访问）
         res.setHeader("Access-Control-Allow-Origin", "*");
@@ -343,6 +355,115 @@ if (MCP_TRANSPORT === "http") {
             res.writeHead(204).end();
             return;
         }
+        // ── /schema 端点：一次性返回所有数据库+表结构，供 LLM 参考生成 SQL ──
+        if (req.url === "/schema" && req.method === "GET") {
+            // 返回缓存（10分钟有效），避免每次重新查询所有表
+            const now = Date.now();
+            if (schemaCache && now - schemaCacheTime < 10 * 60 * 1000) {
+                log.info(`/schema: 命中缓存 (${Math.round((now - schemaCacheTime) / 1000)}s前)`);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(schemaCache);
+                return;
+            }
+            try {
+                // Parse connection info from list_databases text output
+                const dbText = await implListDatabases(invokeCtx);
+                // Extract connection blocks: "## 连接: name  (connection_id=N, connection_type=T)\n  - db1\n  - db2"
+                const result = [];
+                const connBlocks = dbText.split(/^## /m).filter(Boolean);
+                for (const block of connBlocks) {
+                    const headerMatch = block.match(/^连接: (\S+)\s+\(connection_id=(\d+), connection_type=(\w+)\)/);
+                    if (!headerMatch)
+                        continue;
+                    const [, connName, connIdStr, connType] = headerMatch;
+                    const connectionId = parseInt(connIdStr, 10);
+                    const dbNames = [...block.matchAll(/^  - (.+)$/mg)].map(m => m[1].trim());
+                    const databases = [];
+                    for (const dbName of dbNames) {
+                        let found = false;
+                        for (const schema of [dbName, "public"]) {
+                            try {
+                                const tablesText = await implListTables(invokeCtx, {
+                                    connection_id: connectionId,
+                                    connection_type: connType,
+                                    database: dbName,
+                                    schema,
+                                });
+                                if (!tablesText.includes("未找到任何表")) {
+                                    // Parse table names from the result text
+                                    const tableNames = [...tablesText.matchAll(/^- (.+)$/mg)].map(m => m[1].trim());
+                                    databases.push({ name: dbName, schema, tables: tableNames });
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            catch {
+                                // Skip schemas that error (e.g., not enabled)
+                            }
+                        }
+                        if (!found)
+                            databases.push({ name: dbName, schema: dbName, tables: [] });
+                    }
+                    result.push({ connection_id: connectionId, connection_type: connType, name: connName, databases });
+                }
+                const body = JSON.stringify({ schema: result });
+                schemaCache = body;
+                schemaCacheTime = Date.now();
+                log.info(`/schema: 已缓存 (${result.length} 个连接)`);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(body);
+            }
+            catch (err) {
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ error: String(err) }));
+            }
+            return;
+        }
+        // ── /invoke 端点：简单 REST API，返回纯 JSON，供 Dify 等直接调用 ──
+        if (req.url === "/invoke" && req.method === "POST") {
+            const body = await readBody(req);
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "Invalid JSON" }));
+                return;
+            }
+            const { tool, args = {} } = parsed;
+            log.info(`/invoke: tool=${tool} args=${JSON.stringify(args).slice(0, 200)}`);
+            try {
+                let result;
+                switch (tool) {
+                    case "connect":
+                        result = await implConnect(invokeCtx, args);
+                        break;
+                    case "list_databases":
+                        result = await implListDatabases(invokeCtx);
+                        break;
+                    case "list_tables":
+                        result = await implListTables(invokeCtx, args);
+                        break;
+                    case "get_table_columns":
+                        result = await implGetTableColumns(invokeCtx, args);
+                        break;
+                    case "execute_sql": {
+                        // 只执行第一条 SQL 语句（LLM 有时会输出多条）
+                        const sqlArgs = args;
+                        if (typeof sqlArgs.sql === "string") {
+                            sqlArgs.sql = sqlArgs.sql.split(/;[\s\n]+(?=\S)/)[0].replace(/;[\s]*$/, "").trim();
+                        }
+                        result = await implExecuteSql(invokeCtx, sqlArgs);
+                        break;
+                    }
+                    default:
+                        result = `未知工具: ${tool}。可用工具: connect, list_databases, list_tables, get_table_columns, execute_sql`;
+                }
+                res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" }).end(result);
+            }
+            catch (err) {
+                log.error(`/invoke error: ${err}`);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ error: String(err) }));
+            }
+            return;
+        }
         if (!req.url?.startsWith("/mcp")) {
             res.writeHead(404).end("Not Found");
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cq-mcp-server",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "MCP Server for CloudQuery platform — list databases, list tables, inspect columns, and execute SQL via MCP tools.",
   "type": "module",
   "main": "dist/index.js",