@dbx-app/mcp-server 0.2.2 → 0.3.0

package/dist/connections.d.ts

@@ -10,6 +10,12 @@ export interface ConnectionConfig {
     database?: string;
     url_params?: string;
     ssh_enabled: boolean;
+    proxy_enabled?: boolean;
+    proxy_type?: "socks5" | "http";
+    proxy_host?: string;
+    proxy_port?: number;
+    proxy_username?: string;
+    proxy_password?: string;
     ssl: boolean;
 }
 export declare function loadConnections(): Promise<ConnectionConfig[]>;

package/dist/connections.js

@@ -31,6 +31,8 @@ export async function loadConnections() {
             config.id = row.id;
             if (!config.password)
                 config.password = getSecret(db, row.id, "password");
+            if (!config.proxy_password)
+                config.proxy_password = getSecret(db, row.id, "proxy_password");
             configs.push(config);
         }
         db.close();
@@ -68,6 +70,12 @@ export async function addConnection(config) {
         ssh_key_path: "",
         ssh_key_passphrase: "",
         ssh_expose_lan: false,
+        proxy_enabled: config.proxy_enabled ?? false,
+        proxy_type: config.proxy_type ?? "socks5",
+        proxy_host: config.proxy_host ?? "",
+        proxy_port: config.proxy_port ?? 1080,
+        proxy_username: config.proxy_username ?? "",
+        proxy_password: "",
         ssl: config.ssl ?? false,
         sysdba: false,
         connection_string: null,
@@ -78,6 +86,9 @@ export async function addConnection(config) {
         if (config.password) {
             db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "password", config.password);
         }
+        if (config.proxy_password) {
+            db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "proxy_password", config.proxy_password);
+        }
     });
     insert();
     db.close();

package/dist/database.js

@@ -1,7 +1,12 @@
+import { createServer, connect as netConnect } from "node:net";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
 const MAX_ROWS = 100;
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 const QUERY_TIMEOUT_MS = 30_000;
 const pools = new Map();
+const proxyTunnels = new Map();
 function poolKey(config) {
     return `${config.id}:${config.database || ""}`;
 }
@@ -26,8 +31,9 @@ async function getPgPool(config) {
         return existing.pool;
     }
     const pg = await import("pg");
+    const endpoint = await connectionEndpoint(config);
     const pool = new pg.default.Pool({
-        connectionString: buildConnectionUrl(config),
+        connectionString: buildConnectionUrl(config, endpoint),
         max: 3,
         idleTimeoutMillis: 30_000,
         connectionTimeoutMillis: 10_000,
@@ -46,8 +52,9 @@ async function getMysqlPool(config) {
         return existing.pool;
     }
     const mysql = await import("mysql2/promise");
+    const endpoint = await connectionEndpoint(config);
     const pool = mysql.default.createPool({
-        uri: buildConnectionUrl(config),
+        uri: buildConnectionUrl(config, endpoint),
         connectionLimit: 3,
         idleTimeout: 30_000,
         connectTimeout: 10_000,
@@ -57,18 +64,194 @@ async function getMysqlPool(config) {
     resetIdleTimer(key, entry);
     return pool;
 }
-function buildConnectionUrl(config) {
+async function connectionEndpoint(config) {
+    if (!config.proxy_enabled || !config.proxy_host)
+        return { host: config.host, port: config.port };
+    const existing = proxyTunnels.get(config.id);
+    if (existing)
+        return { host: "127.0.0.1", port: existing.port };
+    const server = createServer((inbound) => {
+        connectViaProxy(config)
+            .then((outbound) => {
+            inbound.pipe(outbound);
+            outbound.pipe(inbound);
+        })
+            .catch(() => inbound.destroy());
+    });
+    const port = await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (address && typeof address === "object")
+                resolve(address.port);
+            else
+                reject(new Error("Failed to bind proxy tunnel"));
+        });
+    });
+    proxyTunnels.set(config.id, { server, port });
+    return { host: "127.0.0.1", port };
+}
+function buildConnectionUrl(config, endpoint) {
     const db = config.database || "";
     const params = config.url_params || "";
     const suffix = params ? `?${params}` : "";
     if (isMysqlType(config.db_type)) {
-        return `mysql://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${config.host}:${config.port}/${db}${suffix}`;
+        return `mysql://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${endpoint.host}:${endpoint.port}/${db}${suffix}`;
+    }
+    return `postgres://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${endpoint.host}:${endpoint.port}/${db}${suffix}`;
+}
+function connectViaProxy(config) {
+    return new Promise((resolve, reject) => {
+        const socket = netConnect(config.proxy_port || 1080, config.proxy_host || "127.0.0.1");
+        socket.once("error", reject);
+        socket.once("connect", () => {
+            if ((config.proxy_type || "socks5") === "http") {
+                httpConnect(socket, config, resolve, reject);
+            }
+            else {
+                socks5Connect(socket, config, resolve, reject);
+            }
+        });
+    });
+}
+function httpConnect(socket, config, resolve, reject) {
+    const target = `${config.host}:${config.port}`;
+    const lines = [`CONNECT ${target} HTTP/1.1`, `Host: ${target}`];
+    if (config.proxy_username || config.proxy_password) {
+        const token = Buffer.from(`${config.proxy_username || ""}:${config.proxy_password || ""}`).toString("base64");
+        lines.push(`Proxy-Authorization: Basic ${token}`);
     }
-    return `postgres://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${config.host}:${config.port}/${db}${suffix}`;
+    socket.write(`${lines.join("\r\n")}\r\n\r\n`);
+    let buffer = Buffer.alloc(0);
+    socket.on("data", function onData(chunk) {
+        buffer = Buffer.concat([buffer, chunk]);
+        const end = buffer.indexOf("\r\n\r\n");
+        if (end < 0)
+            return;
+        socket.off("data", onData);
+        const head = buffer.subarray(0, end).toString("utf8");
+        if (!/^HTTP\/1\.[01] 200\b/.test(head)) {
+            reject(new Error(`HTTP proxy CONNECT failed: ${head.split("\r\n")[0] || "invalid response"}`));
+            socket.destroy();
+            return;
+        }
+        const rest = buffer.subarray(end + 4);
+        if (rest.length)
+            socket.unshift(rest);
+        resolve(socket);
+    });
+}
+function socks5Connect(socket, config, resolve, reject) {
+    const wantsAuth = !!(config.proxy_username || config.proxy_password);
+    socket.write(Buffer.from(wantsAuth ? [0x05, 0x02, 0x00, 0x02] : [0x05, 0x01, 0x00]));
+    socket.once("data", (method) => {
+        if (method.length < 2 || method[0] !== 0x05) {
+            reject(new Error("Invalid SOCKS greeting"));
+            socket.destroy();
+            return;
+        }
+        if (method[1] === 0x02) {
+            const user = Buffer.from(config.proxy_username || "");
+            const pass = Buffer.from(config.proxy_password || "");
+            socket.write(Buffer.concat([Buffer.from([0x01, user.length]), user, Buffer.from([pass.length]), pass]));
+            socket.once("data", (auth) => {
+                if (auth.length < 2 || auth[1] !== 0x00) {
+                    reject(new Error("SOCKS proxy authentication failed"));
+                    socket.destroy();
+                    return;
+                }
+                sendSocksConnect(socket, config, resolve, reject);
+            });
+        }
+        else if (method[1] === 0x00) {
+            sendSocksConnect(socket, config, resolve, reject);
+        }
+        else {
+            reject(new Error("SOCKS proxy rejected authentication methods"));
+            socket.destroy();
+        }
+    });
+}
+function sendSocksConnect(socket, config, resolve, reject) {
+    const host = Buffer.from(config.host);
+    socket.write(Buffer.concat([Buffer.from([0x05, 0x01, 0x00, 0x03, host.length]), host, portBytes(config.port)]));
+    socket.once("data", (res) => {
+        if (res.length < 4 || res[0] !== 0x05 || res[1] !== 0x00) {
+            reject(new Error(`SOCKS proxy connect failed with code ${res[1] ?? "unknown"}`));
+            socket.destroy();
+            return;
+        }
+        resolve(socket);
+    });
+}
+function portBytes(port) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16BE(port);
+    return buf;
 }
 function isMysqlType(dbType) {
     return dbType === "mysql" || dbType === "doris" || dbType === "starrocks";
 }
+function isDirectType(dbType) {
+    switch (dbType) {
+        case "postgres":
+        case "redshift":
+        case "mysql":
+        case "doris":
+        case "starrocks":
+            return true;
+        default:
+            return false;
+    }
+}
+function bridgeAppDataDir() {
+    const home = homedir();
+    switch (platform()) {
+        case "darwin":
+            return join(home, "Library", "Application Support", "com.dbx.app");
+        case "win32":
+            return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "com.dbx.app");
+        default:
+            return join(home, ".config", "com.dbx.app");
+    }
+}
+async function bridgeDataRequest(path, body) {
+    let bridgeUrl;
+    try {
+        const portFile = join(bridgeAppDataDir(), "mcp-bridge-port");
+        const port = (await readFile(portFile, "utf-8")).trim();
+        bridgeUrl = `http://127.0.0.1:${port}`;
+    }
+    catch {
+        throw new Error("DBX desktop app is not running. This database type requires DBX to be running for query execution.");
+    }
+    const res = await fetch(`${bridgeUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const errBody = await res.text().catch(() => "");
+        let errorMsg;
+        try {
+            const parsed = JSON.parse(errBody);
+            errorMsg = parsed.error || errBody;
+        }
+        catch {
+            errorMsg = errBody;
+        }
+        throw new Error(errorMsg || `Bridge request failed: ${res.status}`);
+    }
+    return res.json();
+}
+function convertBridgeQueryResult(result) {
+    const rows = result.rows.slice(0, MAX_ROWS).map((row) => {
+        const obj = {};
+        result.columns.forEach((col, i) => { obj[col] = row[i]; });
+        return obj;
+    });
+    return { columns: result.columns, rows, row_count: rows.length };
+}
 function withTimeout(promise, ms) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(`Query timed out after ${ms}ms`)), ms);
@@ -114,9 +297,25 @@ async function query(config, sql, params) {
     return pgQuery(config, sql, params);
 }
 export async function executeQuery(config, sql) {
-    return query(config, sql);
+    if (isDirectType(config.db_type)) {
+        return query(config, sql);
+    }
+    const result = await bridgeDataRequest("/data/execute-query", {
+        connection_name: config.name,
+        database: config.database || "",
+        sql,
+    });
+    return convertBridgeQueryResult(result);
 }
 export async function listTables(config, schema) {
+    if (!isDirectType(config.db_type)) {
+        const tables = await bridgeDataRequest("/data/list-tables", {
+            connection_name: config.name,
+            database: config.database || "",
+            schema: schema || "",
+        });
+        return tables.map((t) => ({ name: t.name, type: t.table_type || "TABLE" }));
+    }
     let result;
     if (isMysqlType(config.db_type)) {
         result = await query(config, `SELECT TABLE_NAME AS name, TABLE_TYPE AS type FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME`);
@@ -127,6 +326,22 @@ export async function listTables(config, schema) {
     return result.rows.map((r) => ({ name: String(r.name || r.NAME), type: String(r.type || r.TYPE || "TABLE") }));
 }
 export async function describeTable(config, table, schema) {
+    if (!isDirectType(config.db_type)) {
+        const columns = await bridgeDataRequest("/data/describe-table", {
+            connection_name: config.name,
+            database: config.database || "",
+            schema: schema || "",
+            table,
+        });
+        return columns.map((c) => ({
+            name: c.name,
+            data_type: c.data_type,
+            is_nullable: c.is_nullable,
+            column_default: c.column_default,
+            is_primary_key: c.is_primary_key,
+            comment: c.comment,
+        }));
+    }
     let result;
     if (isMysqlType(config.db_type)) {
         result = await query(config, `SELECT c.COLUMN_NAME AS name, c.DATA_TYPE AS data_type, c.IS_NULLABLE = 'YES' AS is_nullable, c.COLUMN_DEFAULT AS column_default, c.COLUMN_KEY = 'PRI' AS is_primary_key, c.COLUMN_COMMENT AS comment FROM information_schema.COLUMNS c WHERE c.TABLE_SCHEMA = DATABASE() AND c.TABLE_NAME = ? ORDER BY c.ORDINAL_POSITION`, [table]);

package/dist/index.js

@@ -36,7 +36,7 @@ function mdTable(headers, rows) {
 }
 const server = new McpServer({
     name: "dbx",
-    version: "0.2.1",
+    version: "0.3.0",
 });
 server.tool("dbx_list_connections", "List all database connections configured in DBX", {}, async () => {
     const connections = await backend.loadConnections();
@@ -99,7 +99,7 @@ server.tool("dbx_execute_query", "Execute a SQL query on a database connection (
 });
 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"),
+    db_type: z.string().describe("Database type: postgres, mysql, sqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, doris, starrocks, redshift, dameng, kingbase, vastbase, goldendb, gaussdb, h2, snowflake, trino, hive, db2, informix, neo4j, cassandra, bigquery, kylin, sundb, jdbc"),
     host: z.string().describe("Database host"),
     port: z.number().describe("Database port"),
     username: z.string().default("").describe("Username"),

package/package.json

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