@dbx-app/mcp-server 0.1.1 → 0.1.3

package/dist/index.js

@@ -2,22 +2,31 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
 import { loadConnections, findConnection } from "./connections.js";
 import { listTables, describeTable, executeQuery } from "./database.js";
+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}`;
+}
 const server = new McpServer({
     name: "dbx",
-    version: "0.1.0",
+    version: "0.1.1",
 });
 server.tool("dbx_list_connections", "List all database connections configured in DBX", {}, async () => {
     const connections = await loadConnections();
-    const list = connections.map((c) => ({
-        name: c.name,
-        type: c.db_type,
-        host: c.host,
-        port: c.port,
-        database: c.database || "",
-    }));
-    return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    if (connections.length === 0)
+        return text("No connections configured in DBX.");
+    const rows = connections.map((c) => [c.name, c.db_type, c.host, String(c.port), c.database || ""]);
+    return text(mdTable(["Name", "Type", "Host", "Port", "Database"], rows));
 });
 server.tool("dbx_list_tables", "List tables and views for a database connection", {
     connection_name: z.string().describe("Name of the DBX connection"),
@@ -25,9 +34,12 @@ server.tool("dbx_list_tables", "List tables and views for a database connection"
 }, async ({ connection_name, schema }) => {
     const config = await findConnection(connection_name);
     if (!config)
-        return { content: [{ type: "text", text: `Connection "${connection_name}" not found` }] };
+        return text(`Connection "${connection_name}" not found`);
     const tables = await listTables(config, schema);
-    return { content: [{ type: "text", text: JSON.stringify(tables, null, 2) }] };
+    if (tables.length === 0)
+        return text("No tables found.");
+    const rows = tables.map((t) => [t.name, t.type]);
+    return text(mdTable(["Table", "Type"], rows));
 });
 server.tool("dbx_describe_table", "Get column definitions for a table", {
     connection_name: z.string().describe("Name of the DBX connection"),
@@ -36,9 +48,18 @@ server.tool("dbx_describe_table", "Get column definitions for a table", {
 }, async ({ connection_name, table, schema }) => {
     const config = await findConnection(connection_name);
     if (!config)
-        return { content: [{ type: "text", text: `Connection "${connection_name}" not found` }] };
+        return text(`Connection "${connection_name}" not found`);
     const columns = await describeTable(config, table, schema);
-    return { content: [{ type: "text", text: JSON.stringify(columns, null, 2) }] };
+    if (columns.length === 0)
+        return text("No columns found.");
+    const rows = columns.map((c) => [
+        c.is_primary_key ? `${c.name} (PK)` : c.name,
+        c.data_type,
+        c.is_nullable ? "YES" : "NO",
+        c.column_default ?? "",
+        c.comment ?? "",
+    ]);
+    return text(mdTable(["Column", "Type", "Nullable", "Default", "Comment"], rows));
 });
 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"),
@@ -46,19 +67,26 @@ server.tool("dbx_execute_query", "Execute a SQL query on a database connection (
 }, async ({ connection_name, sql }) => {
     const config = await findConnection(connection_name);
     if (!config)
-        return { content: [{ type: "text", text: `Connection "${connection_name}" not found` }] };
+        return text(`Connection "${connection_name}" not found`);
     try {
         const result = await executeQuery(config, sql);
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        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)`);
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        return { content: [{ type: "text", text: `Query error: ${msg}` }] };
+        return text(`Query error: ${msg}`);
     }
 });
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir, platform } from "node:os";
+function formatCell(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
 function appDataDir() {
     const home = homedir();
     switch (platform()) {
@@ -81,23 +109,31 @@ server.tool("dbx_open_table", "Open a table in DBX desktop app UI. Requires DBX
     database: z.string().optional().describe("Database name"),
     schema: z.string().optional().describe("Schema name"),
 }, async ({ connection_name, table, database, schema }) => {
+    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.", {
+    connection_name: z.string().describe("Name of the DBX connection"),
+    sql: z.string().describe("SQL query to execute"),
+    database: z.string().optional().describe("Database name"),
+}, async ({ connection_name, sql, database }) => {
+    return bridgeRequest("/execute-query", { connection_name, sql, database }, "Query sent to DBX");
+});
+async function bridgeRequest(path, body, successMsg) {
     try {
         const bridgeUrl = await getBridgeUrl();
-        const res = await fetch(`${bridgeUrl}/open-table`, {
+        const res = await fetch(`${bridgeUrl}${path}`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ connection_name, table, database, schema }),
+            body: JSON.stringify(body),
         });
-        if (res.ok) {
-            return { content: [{ type: "text", text: `Opened ${table} in DBX` }] };
-        }
-        const text = await res.text();
-        return { content: [{ type: "text", text: `Failed: ${text}` }] };
+        if (res.ok)
+            return text(successMsg);
+        return text(`Failed: ${await res.text()}`);
     }
     catch {
-        return { content: [{ type: "text", text: "DBX is not running. Please start DBX first." }] };
+        return text("DBX is not running. Please start DBX first.");
     }
-});
+}
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@dbx-app/mcp-server",
-  "version": "0.1.1",
+  "version": "0.1.3",
+  "mcpName": "io.github.t8y2/dbx",
   "description": "MCP server for DBX — query databases from Claude Code, Cursor, and other AI agents",
   "type": "module",
   "bin": {