@dbx-app/mcp-server 0.1.3 → 0.2.1

package/README.md

@@ -7,7 +7,7 @@ MCP server for [DBX](https://github.com/t8y2/dbx) — lets AI agents (Claude Cod
 ## Features
 
 - **Zero config** — Automatically reads your DBX connections (including passwords from system keyring)
-- **5 tools** — List connections, list tables, describe table, execute SQL, open table in DBX UI
+- **7 tools** — List/add/remove connections, list tables, describe table, execute SQL, open table in DBX UI
 - **Connection pooling** — Reuses database connections across queries
 - **PostgreSQL & MySQL** — Supports PostgreSQL, MySQL, and compatible databases (Doris, StarRocks, etc.)
 - **DBX UI integration** — Open tables directly in the DBX desktop app from your AI agent
@@ -69,6 +69,8 @@ In Claude Code, just ask:
 | Tool | Description |
 |---|---|
 | `dbx_list_connections` | List all database connections configured in DBX |
+| `dbx_add_connection` | Add a new database connection |
+| `dbx_remove_connection` | Remove a database connection |
 | `dbx_list_tables` | List tables and views for a connection |
 | `dbx_describe_table` | Get column definitions for a table |
 | `dbx_execute_query` | Execute a SQL query (max 100 rows) |
@@ -79,17 +81,14 @@ In Claude Code, just ask:
 ```
 AI Agent → MCP Server → Database
                 ↓
-         DBX connections.json
-         + system keyring (passwords)
+         DBX SQLite database (dbx.db)
 ```
 
-The MCP server reads your database connections from DBX's config directory:
+The MCP server reads your database connections from DBX's SQLite database:
 
-- **macOS**: `~/Library/Application Support/com.dbx.app/connections.json`
-- **Linux**: `~/.config/com.dbx.app/connections.json`
-- **Windows**: `%APPDATA%\com.dbx.app\connections.json`
-
-Passwords are retrieved from the system keyring (macOS Keychain / Linux Secret Service / Windows Credential Manager).
+- **macOS**: `~/Library/Application Support/com.dbx.app/dbx.db`
+- **Linux**: `~/.config/com.dbx.app/dbx.db`
+- **Windows**: `%APPDATA%\com.dbx.app\dbx.db`
 
 ## DBX UI Integration
 
@@ -112,8 +111,8 @@ MIT
 
 ### 特性
 
-- **零配置** — 自动读取 DBX 的连接配置（包括系统钥匙串中的密码）
-- **5 个工具** — 列出连接、列出表、查看表结构、执行 SQL、在 DBX 中打开表
+- **零配置** — 自动读取 DBX 的连接配置
+- **7 个工具** — 列出/添加/删除连接、列出表、查看表结构、执行 SQL、在 DBX 中打开表
 - **连接池** — 跨查询复用数据库连接
 - **PostgreSQL 和 MySQL** — 支持 PostgreSQL、MySQL 及兼容数据库（Doris、StarRocks 等）
 - **DBX UI 联动** — 从 AI 助手直接在 DBX 桌面端打开表
@@ -161,6 +160,8 @@ npx @dbx-app/mcp-server
 | 工具 | 说明 |
 |---|---|
 | `dbx_list_connections` | 列出 DBX 中所有已配置的数据库连接 |
+| `dbx_add_connection` | 添加新的数据库连接 |
+| `dbx_remove_connection` | 删除数据库连接 |
 | `dbx_list_tables` | 列出指定连接的表和视图 |
 | `dbx_describe_table` | 获取表的列定义 |
 | `dbx_execute_query` | 执行 SQL 查询（最多返回 100 行） |
@@ -168,13 +169,11 @@ npx @dbx-app/mcp-server
 
 ### 工作原理
 
-MCP Server 从 DBX 的配置目录读取连接信息：
-
-- **macOS**: `~/Library/Application Support/com.dbx.app/connections.json`
-- **Linux**: `~/.config/com.dbx.app/connections.json`
-- **Windows**: `%APPDATA%\com.dbx.app\connections.json`
+MCP Server 从 DBX 的 SQLite 数据库读取连接信息：
 
-密码从系统钥匙串中获取（macOS Keychain / Linux Secret Service / Windows 凭据管理器）。
+- **macOS**: `~/Library/Application Support/com.dbx.app/dbx.db`
+- **Linux**: `~/.config/com.dbx.app/dbx.db`
+- **Windows**: `%APPDATA%\com.dbx.app\dbx.db`
 
 ### DBX UI 联动
 

package/dist/connections.d.ts

@@ -14,3 +14,5 @@ export interface ConnectionConfig {
 }
 export declare function loadConnections(): Promise<ConnectionConfig[]>;
 export declare function findConnection(name: string): Promise<ConnectionConfig | undefined>;
+export declare function addConnection(config: Omit<ConnectionConfig, "id">): Promise<ConnectionConfig>;
+export declare function removeConnection(name: string): Promise<boolean>;

package/dist/connections.js

@@ -1,7 +1,7 @@
-import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir, platform } from "node:os";
-const KEYRING_SERVICE = "dev.dbx.connections";
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
 function appDataDir() {
     const home = homedir();
     switch (platform()) {
@@ -13,41 +13,27 @@ function appDataDir() {
             return join(home, ".config", "com.dbx.app");
     }
 }
-async function getKeytarSecret(connectionId, key) {
-    try {
-        const keytar = await import("keytar");
-        return await keytar.default.getPassword(KEYRING_SERVICE, `connection:${connectionId}:${key}`);
-    }
-    catch {
-        return null;
-    }
-}
-async function getFileSecret(connectionId, key) {
-    try {
-        const secretsPath = join(appDataDir(), "secrets.json");
-        const data = JSON.parse(await readFile(secretsPath, "utf-8"));
-        return data[`connection:${connectionId}:${key}`] ?? null;
-    }
-    catch {
-        return null;
-    }
+function openDb(readonly = false) {
+    const dbPath = join(appDataDir(), "dbx.db");
+    return new Database(dbPath, { readonly });
 }
-async function getSecret(connectionId, key) {
-    const fromKeyring = await getKeytarSecret(connectionId, key);
-    if (fromKeyring)
-        return fromKeyring;
-    const fromFile = await getFileSecret(connectionId, key);
-    return fromFile ?? "";
+function getSecret(db, connectionId, key) {
+    const row = db.prepare("SELECT secret FROM connection_secrets WHERE connection_id = ? AND key = ?").get(connectionId, key);
+    return row?.secret ?? "";
 }
 export async function loadConnections() {
-    const configPath = join(appDataDir(), "connections.json");
     try {
-        const raw = await readFile(configPath, "utf-8");
-        const configs = JSON.parse(raw);
-        for (const config of configs) {
+        const db = openDb(true);
+        const rows = db.prepare("SELECT id, config_json FROM connections").all();
+        const configs = [];
+        for (const row of rows) {
+            const config = JSON.parse(row.config_json);
+            config.id = row.id;
             if (!config.password)
-                config.password = await getSecret(config.id, "password");
+                config.password = getSecret(db, row.id, "password");
+            configs.push(config);
         }
+        db.close();
         return configs;
     }
     catch {
@@ -58,3 +44,31 @@ export async function findConnection(name) {
     const connections = await loadConnections();
     return connections.find((c) => c.name.toLowerCase() === name.toLowerCase());
 }
+export async function addConnection(config) {
+    const id = randomUUID();
+    const db = openDb();
+    const sanitized = { ...config, id, password: "" };
+    const configJson = JSON.stringify(sanitized);
+    const insert = db.transaction(() => {
+        db.prepare("INSERT INTO connections (id, config_json) VALUES (?, ?)").run(id, configJson);
+        if (config.password) {
+            db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "password", config.password);
+        }
+    });
+    insert();
+    db.close();
+    return { ...config, id };
+}
+export async function removeConnection(name) {
+    const connection = await findConnection(name);
+    if (!connection)
+        return false;
+    const db = openDb();
+    const remove = db.transaction(() => {
+        db.prepare("DELETE FROM connections WHERE id = ?").run(connection.id);
+        db.prepare("DELETE FROM connection_secrets WHERE connection_id = ?").run(connection.id);
+    });
+    remove();
+    db.close();
+    return true;
+}

package/dist/index.js

@@ -5,8 +5,25 @@ 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";
+import { loadConnections as desktopLoadConnections, findConnection as desktopFindConnection, addConnection as desktopAddConnection, removeConnection as desktopRemoveConnection, } from "./connections.js";
+import { listTables as desktopListTables, describeTable as desktopDescribeTable, executeQuery as desktopExecuteQuery, } from "./database.js";
+const isWebMode = !!process.env.DBX_WEB_URL;
+let backend;
+if (isWebMode) {
+    const web = await import("./web-backend.js");
+    backend = web;
+}
+else {
+    backend = {
+        loadConnections: desktopLoadConnections,
+        findConnection: desktopFindConnection,
+        addConnection: desktopAddConnection,
+        removeConnection: desktopRemoveConnection,
+        listTables: desktopListTables,
+        describeTable: desktopDescribeTable,
+        executeQuery: desktopExecuteQuery,
+    };
+}
 function text(s) {
     return { content: [{ type: "text", text: s }] };
 }
@@ -19,10 +36,10 @@ function mdTable(headers, rows) {
 }
 const server = new McpServer({
     name: "dbx",
-    version: "0.1.1",
+    version: "0.2.1",
 });
 server.tool("dbx_list_connections", "List all database connections configured in DBX", {}, async () => {
-    const connections = await loadConnections();
+    const connections = await backend.loadConnections();
     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 || ""]);
@@ -32,10 +49,10 @@ server.tool("dbx_list_tables", "List tables and views for a database connection"
     connection_name: z.string().describe("Name of the DBX connection"),
     schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
 }, async ({ connection_name, schema }) => {
-    const config = await findConnection(connection_name);
+    const config = await backend.findConnection(connection_name);
     if (!config)
         return text(`Connection "${connection_name}" not found`);
-    const tables = await listTables(config, schema);
+    const tables = await backend.listTables(config, schema);
     if (tables.length === 0)
         return text("No tables found.");
     const rows = tables.map((t) => [t.name, t.type]);
@@ -46,10 +63,10 @@ server.tool("dbx_describe_table", "Get column definitions for a table", {
     table: z.string().describe("Table name"),
     schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
 }, async ({ connection_name, table, schema }) => {
-    const config = await findConnection(connection_name);
+    const config = await backend.findConnection(connection_name);
     if (!config)
         return text(`Connection "${connection_name}" not found`);
-    const columns = await describeTable(config, table, schema);
+    const columns = await backend.describeTable(config, table, schema);
     if (columns.length === 0)
         return text("No columns found.");
     const rows = columns.map((c) => [
@@ -65,11 +82,11 @@ server.tool("dbx_execute_query", "Execute a SQL query on a database connection (
     connection_name: z.string().describe("Name of the DBX connection"),
     sql: z.string().describe("SQL query to execute"),
 }, async ({ connection_name, sql }) => {
-    const config = await findConnection(connection_name);
+    const config = await backend.findConnection(connection_name);
     if (!config)
         return text(`Connection "${connection_name}" not found`);
     try {
-        const result = await executeQuery(config, sql);
+        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])));
@@ -80,6 +97,35 @@ server.tool("dbx_execute_query", "Execute a SQL query on a database connection (
         return text(`Query error: ${msg}`);
     }
 });
+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"),
+    host: z.string().describe("Database host"),
+    port: z.number().describe("Database port"),
+    username: z.string().default("").describe("Username"),
+    password: z.string().default("").describe("Password"),
+    database: z.string().optional().describe("Default database name"),
+    ssl: z.boolean().default(false).describe("Enable SSL"),
+}, async ({ name, db_type, host, port, username, password, database, ssl }) => {
+    const existing = await backend.findConnection(name);
+    if (existing)
+        return text(`Connection "${name}" already exists.`);
+    const config = await backend.addConnection({
+        name, db_type, host, port, username, password,
+        database, ssl, ssh_enabled: false,
+    });
+    await notifyReload();
+    return text(`Connection "${config.name}" added (id: ${config.id}).`);
+});
+server.tool("dbx_remove_connection", "Remove a database connection from DBX", {
+    connection_name: z.string().describe("Name of the connection to remove"),
+}, async ({ connection_name }) => {
+    const removed = await backend.removeConnection(connection_name);
+    if (!removed)
+        return text(`Connection "${connection_name}" not found.`);
+    await notifyReload();
+    return text(`Connection "${connection_name}" removed.`);
+});
 function formatCell(value) {
     if (value === null || value === undefined)
         return "NULL";
@@ -103,21 +149,31 @@ async function getBridgeUrl() {
     const port = (await readFile(portFile, "utf-8")).trim();
     return `http://127.0.0.1:${port}`;
 }
-server.tool("dbx_open_table", "Open a table in DBX desktop app UI. Requires DBX to be running.", {
-    connection_name: z.string().describe("Name of the DBX connection"),
-    table: z.string().describe("Table name to open"),
-    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 notifyReload() {
+    try {
+        const bridgeUrl = await getBridgeUrl();
+        await fetch(`${bridgeUrl}/reload-connections`, { method: "POST" });
+    }
+    catch { }
+}
+// Desktop-only tools: open table and execute-and-show require the Tauri bridge
+if (!isWebMode) {
+    server.tool("dbx_open_table", "Open a table in DBX desktop app UI. Requires DBX to be running.", {
+        connection_name: z.string().describe("Name of the DBX connection"),
+        table: z.string().describe("Table name to open"),
+        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();

package/dist/web-backend.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionConfig } from "./connections.js";
+import type { TableInfo, ColumnInfo, QueryResult } from "./database.js";
+export declare function loadConnections(): Promise<ConnectionConfig[]>;
+export declare function findConnection(name: string): Promise<ConnectionConfig | undefined>;
+export declare function addConnection(config: Omit<ConnectionConfig, "id">): Promise<ConnectionConfig>;
+export declare function removeConnection(name: string): Promise<boolean>;
+export declare function listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]>;
+export declare function describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]>;
+export declare function executeQuery(config: ConnectionConfig, sql: string): Promise<QueryResult>;

package/dist/web-backend.js

@@ -0,0 +1,114 @@
+const baseUrl = process.env.DBX_WEB_URL.replace(/\/+$/, "");
+const password = process.env.DBX_WEB_PASSWORD || "";
+let sessionCookie = null;
+async function ensureAuth() {
+    if (sessionCookie)
+        return;
+    if (!password)
+        return; // no password set, assume no auth required
+    const res = await fetch(`${baseUrl}/api/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ password }),
+        redirect: "manual",
+    });
+    if (!res.ok) {
+        throw new Error(`Authentication failed: ${res.status} ${res.statusText}`);
+    }
+    const setCookie = res.headers.get("set-cookie");
+    if (setCookie) {
+        const match = setCookie.match(/dbx_session=([^;]+)/);
+        if (match) {
+            sessionCookie = match[1];
+        }
+    }
+}
+function headers(extra) {
+    const h = { "Content-Type": "application/json", ...extra };
+    if (sessionCookie) {
+        h["Cookie"] = `dbx_session=${sessionCookie}`;
+    }
+    return h;
+}
+async function apiFetch(path, init) {
+    await ensureAuth();
+    const res = await fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: headers(init?.headers),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`API request ${path} failed: ${res.status} ${res.statusText} ${body}`);
+    }
+    return res;
+}
+export async function loadConnections() {
+    const res = await apiFetch("/api/connection/list");
+    return res.json();
+}
+export async function findConnection(name) {
+    const connections = await loadConnections();
+    return connections.find((c) => c.name.toLowerCase() === name.toLowerCase());
+}
+export async function addConnection(config) {
+    const res = await apiFetch("/api/connection/save", {
+        method: "POST",
+        body: JSON.stringify({ configs: [config] }),
+    });
+    const saved = (await res.json());
+    return saved;
+}
+export async function removeConnection(name) {
+    const connection = await findConnection(name);
+    if (!connection)
+        return false;
+    await apiFetch(`/api/connection/delete?id=${encodeURIComponent(connection.id)}`, { method: "DELETE" });
+    return true;
+}
+async function ensureConnected(config) {
+    await apiFetch("/api/connection/connect", {
+        method: "POST",
+        body: JSON.stringify({ config }),
+    });
+}
+export async function listTables(config, schema) {
+    await ensureConnected(config);
+    const params = new URLSearchParams({
+        connection_id: config.id,
+        database: config.database || "",
+        schema: schema || "",
+    });
+    const res = await apiFetch(`/api/schema/tables?${params}`);
+    return res.json();
+}
+export async function describeTable(config, table, schema) {
+    await ensureConnected(config);
+    const params = new URLSearchParams({
+        connection_id: config.id,
+        database: config.database || "",
+        schema: schema || "",
+        table,
+    });
+    const res = await apiFetch(`/api/schema/columns?${params}`);
+    return res.json();
+}
+export async function executeQuery(config, sql) {
+    await ensureConnected(config);
+    const res = await apiFetch("/api/query/execute", {
+        method: "POST",
+        body: JSON.stringify({
+            connectionId: config.id,
+            database: config.database || "",
+            sql,
+        }),
+    });
+    const data = (await res.json());
+    const rows = data.rows.map((row) => {
+        const obj = {};
+        data.columns.forEach((col, i) => {
+            obj[col] = row[i];
+        });
+        return obj;
+    });
+    return { columns: data.columns, rows, row_count: rows.length };
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@dbx-app/mcp-server",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "mcpName": "io.github.t8y2/dbx",
-  "description": "MCP server for DBX — query databases from Claude Code, Cursor, and other AI agents",
+  "description": "MCP server for DBX \u2014 query databases from Claude Code, Cursor, and other AI agents",
   "type": "module",
   "bin": {
     "dbx-mcp-server": "dist/index.js"
@@ -33,15 +33,23 @@
   "homepage": "https://github.com/t8y2/dbx/tree/main/mcp",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "better-sqlite3": "^12.9.0",
     "keytar": "^7.9.0",
     "mysql2": "^3.14.1",
     "pg": "^8.16.0",
     "zod": "^3.25.20"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.15.21",
     "@types/pg": "^8.15.4",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3",
+      "esbuild"
+    ]
   }
-}
+}