dsh-db-mcp 0.6.4

package/src/mcp.js

@@ -0,0 +1,264 @@
+/**
+ * A very small MCP client over stdio.
+ *
+ * The plugin owns the Python server instead of going through the Loader's
+ * `@deepseek-ai/dsh-mcp-client` row: the interpreter and the script live at
+ * machine-specific absolute paths that a static bundle patch cannot express, and
+ * owning the process lets the panel show its state and restart it after a
+ * datasource change.
+ *
+ * Wire format: newline-delimited JSON-RPC 2.0, one message per line, exactly what
+ * the official Python SDK speaks on stdio.
+ */
+
+import { spawn } from 'node:child_process';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const INIT_TIMEOUT_MS = 60_000;
+
+export class McpError extends Error {
+  constructor(message, { code = 'mcp_error', data } = {}) {
+    super(message);
+    this.name = 'McpError';
+    this.code = code;
+    this.data = data;
+  }
+}
+
+export class McpClient {
+  #child = null;
+  #buffer = '';
+  #nextId = 1;
+  #pending = new Map();
+  #stderr = [];
+  #closed = false;
+  #exitInfo = null;
+  #onExit = null;
+
+  constructor({ command, args = [], cwd, env = {}, label = 'db-mcp' }) {
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.env = env;
+    this.label = label;
+    this.serverInfo = null;
+    this.tools = [];
+  }
+
+  get running() {
+    return this.#child !== null && !this.#closed;
+  }
+
+  get exitInfo() {
+    return this.#exitInfo;
+  }
+
+  get stderrTail() {
+    return this.#stderr.slice(-40).join('');
+  }
+
+  async start() {
+    if (this.#child) return this;
+    const child = spawn(this.command, this.args, {
+      cwd: this.cwd,
+      env: { ...process.env, ...this.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    this.#child = child;
+    this.#closed = false;
+    this.#exitInfo = null;
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => this.#onStdout(chunk));
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      this.#stderr.push(String(chunk));
+      if (this.#stderr.length > 200) this.#stderr.shift();
+    });
+    child.on('error', (error) => {
+      this.#exitInfo = { code: null, signal: null, error: String(error) };
+      this.#failAll(new McpError(`cannot start ${this.command}: ${error.message}`, { code: 'spawn_error' }));
+    });
+    child.on('exit', (code, signal) => {
+      this.#closed = true;
+      this.#exitInfo = { code, signal };
+      this.#failAll(
+        new McpError(`${this.label} exited (code ${code ?? 'null'}${signal ? `, signal ${signal}` : ''})`, {
+          code: 'server_exited',
+        }),
+      );
+      const onExit = this.#onExit;
+      this.#onExit = null;
+      if (onExit) onExit(this.#exitInfo);
+    });
+
+    const init = await this.#request(
+      'initialize',
+      {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        clientInfo: { name: 'dsh-db-mcp', version: '0.3.0' },
+      },
+      INIT_TIMEOUT_MS,
+    );
+    this.serverInfo = init?.serverInfo ?? null;
+    this.#notify('notifications/initialized', {});
+    const listed = await this.#request('tools/list', {}, INIT_TIMEOUT_MS);
+    this.tools = Array.isArray(listed?.tools) ? listed.tools : [];
+    return this;
+  }
+
+  async callTool(name, args = {}, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+    const result = await this.#request('tools/call', { name, arguments: args }, timeoutMs);
+    const content = Array.isArray(result?.content) ? result.content : [];
+    const text = content
+      .filter((item) => item && item.type === 'text' && typeof item.text === 'string')
+      .map((item) => item.text)
+      .join('\n');
+    let parsed;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = undefined;
+      }
+    }
+    return { ...result, text, parsed };
+  }
+
+  onExit(handler) {
+    this.#onExit = handler;
+  }
+
+  async stop() {
+    const child = this.#child;
+    if (!child) return;
+    this.#child = null;
+    this.#closed = true;
+    this.#failAll(new McpError(`${this.label} stopped`, { code: 'stopped' }));
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          /* already gone */
+        }
+        resolve();
+      }, 3000);
+      child.once('exit', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      try {
+        child.kill();
+      } catch {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  }
+
+  // ------------------------------------------------------------------ wire
+
+  #onStdout(chunk) {
+    this.#buffer += chunk;
+    let index = this.#buffer.indexOf('\n');
+    while (index >= 0) {
+      const line = this.#buffer.slice(0, index).trim();
+      this.#buffer = this.#buffer.slice(index + 1);
+      if (line) this.#onLine(line);
+      index = this.#buffer.indexOf('\n');
+    }
+  }
+
+  #onLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      this.#stderr.push(`[non-json stdout] ${line}\n`);
+      return;
+    }
+    if (message && typeof message.id !== 'undefined' && !message.method) {
+      const pending = this.#pending.get(message.id);
+      if (!pending) return;
+      this.#pending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) {
+        pending.reject(
+          new McpError(message.error.message || 'MCP request failed', {
+            code: message.error.code ?? 'mcp_error',
+            data: message.error.data,
+          }),
+        );
+      } else {
+        pending.resolve(message.result);
+      }
+      return;
+    }
+    if (message && message.method && typeof message.id !== 'undefined') {
+      this.#answerServerRequest(message);
+    }
+    // notifications are ignored
+  }
+
+  #answerServerRequest(message) {
+    const reply = (payload) => this.#send({ jsonrpc: '2.0', id: message.id, ...payload });
+    switch (message.method) {
+      case 'ping':
+        reply({ result: {} });
+        break;
+      case 'roots/list':
+        reply({ result: { roots: [] } });
+        break;
+      case 'sampling/createMessage':
+        reply({ error: { code: -32601, message: 'sampling is not supported by dsh-db-mcp' } });
+        break;
+      default:
+        reply({ error: { code: -32601, message: `unsupported method: ${message.method}` } });
+    }
+  }
+
+  #send(message) {
+    const child = this.#child;
+    if (!child || this.#closed || !child.stdin.writable) {
+      throw new McpError(`${this.label} is not running`, { code: 'not_running' });
+    }
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  #notify(method, params) {
+    try {
+      this.#send({ jsonrpc: '2.0', method, params });
+    } catch {
+      /* the exit handler reports the real failure */
+    }
+  }
+
+  #request(method, params, timeoutMs) {
+    const id = this.#nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new McpError(`${method} timed out after ${timeoutMs}ms`, { code: 'timeout' }));
+      }, timeoutMs);
+      this.#pending.set(id, { resolve, reject, timer });
+      try {
+        this.#send({ jsonrpc: '2.0', id, method, params });
+      } catch (error) {
+        this.#pending.delete(id);
+        clearTimeout(timer);
+        reject(error);
+      }
+    });
+  }
+
+  #failAll(error) {
+    for (const [, pending] of this.#pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+  }
+}

package/src/tools.js

@@ -0,0 +1,372 @@
+/**
+ * Bridges the Python MCP server into DSH tools.
+ *
+ * The Python process is spawned lazily on first use, its `tools/list` becomes
+ * `mcp__db__<name>` on the host `tools` service, and every call is forwarded over
+ * MCP. When a datasource changes the bridge can be restarted; tool registrations
+ * are disposed and rebuilt around the new process.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Same cache-busting marker as host.js, so editing this file takes effect on the
+// next `POST /api/reload` without restarting DSH.
+const GENERATION = new URL(import.meta.url).searchParams.get('v') || '0';
+const { McpClient, McpError } = await import(new URL(`./mcp.js?v=${GENERATION}`, import.meta.url).href);
+
+export const TOOL_PREFIX = 'mcp__db__';
+const TOOL_TIMEOUT_MS = 60_000;
+
+/** Candidate interpreters, most specific first. */
+export function pythonCandidates(config, runtimeDir) {
+  const list = [];
+  if (config.pythonPath) list.push(config.pythonPath);
+  list.push(join(runtimeDir, '.venv', 'Scripts', 'python.exe')); // Windows venv
+  list.push(join(runtimeDir, '.venv', 'bin', 'python')); // POSIX venv
+  list.push('python');
+  list.push('python3');
+  return list.filter((entry, index) => entry && list.indexOf(entry) === index);
+}
+
+export function serverEntry(packageDir) {
+  return join(packageDir, 'server', 'main.py');
+}
+
+/** Render one MCP tool result as readable text. */
+export function renderResult(value) {
+  if (!value || typeof value !== 'object') return typeof value === 'string' ? value : JSON.stringify(value);
+  if (value.ok === false && value.error) {
+    const { code = 'error', message = 'unknown error', hint } = value.error;
+    return `error [${code}]: ${message}${hint ? `\n${hint}` : ''}`;
+  }
+  if (Array.isArray(value.columns) && Array.isArray(value.rows)) {
+    const head = value.columns.join(' | ');
+    const body = value.rows
+      .slice(0, 50)
+      .map((row) => row.map((cell) => (cell === null ? 'NULL' : String(cell))).join(' | '))
+      .join('\n');
+    const more = value.rows.length > 50 ? `\n… ${value.rows.length - 50} more row(s)` : '';
+    const note = value.truncated ? `\ntruncated at ${value.rowCount} row(s)` : '';
+    return `${head}\n${'-'.repeat(Math.min(head.length, 120))}\n${body}${more}${note}\n(${value.rowCount} row(s), ${value.elapsedMs}ms)`;
+  }
+  if (Array.isArray(value.tables)) {
+    const lines = value.tables.map((table) => `${table.schema ? `${table.schema}.` : ''}${table.name}  [${table.type}]`);
+    const more = value.truncated ? `\n… truncated (${value.total} total)` : '';
+    return lines.join('\n') + more || 'no tables';
+  }
+  if (Array.isArray(value.datasources)) {
+    return (
+      value.datasources
+        .map((source) => `${source.id}  ${source.kind}  ${source.target}${source.readOnly ? '  [read-only]' : ''}${source.isDefault ? '  [default]' : ''}`)
+        .join('\n') || 'no datasources configured'
+    );
+  }
+  if (typeof value.ddl === 'string' && value.ddl.trim()) {
+    return value.ddl.trim();
+  }
+  if (Array.isArray(value.columns) && value.table) {
+    return value.columns.map((column) => `${column.name}  ${column.type}${column.primaryKey ? '  PK' : ''}${column.nullable ? '' : '  NOT NULL'}`).join('\n');
+  }
+  return JSON.stringify(value, null, 2);
+}
+
+/**
+ * MCP emits `anyOf: [{type:'string'}, {type:'null'}]` plus `default: null` and a
+ * `title` for every optional argument. That is valid JSON Schema but noisy for the
+ * model, so each property is reduced to its real branch before registration.
+ */
+function simplifyProperty(property) {
+  if (!property || typeof property !== 'object') return property;
+  const { title: _title, default: _default, ...rest } = property;
+  if (Array.isArray(rest.anyOf)) {
+    const branch = rest.anyOf.find((item) => item && item.type && item.type !== 'null') ?? { type: 'string' };
+    const merged = { ...branch };
+    if (rest.description) merged.description = rest.description;
+    return simplifyProperty(merged);
+  }
+  if (Array.isArray(rest.oneOf)) {
+    const branch = rest.oneOf.find((item) => item && item.type && item.type !== 'null') ?? { type: 'string' };
+    const merged = { ...branch };
+    if (rest.description) merged.description = rest.description;
+    return simplifyProperty(merged);
+  }
+  if (rest.type === 'array' && rest.items) rest.items = simplifyProperty(rest.items);
+  return rest;
+}
+
+function safeParameters(inputSchema) {
+  const schema = inputSchema && typeof inputSchema === 'object' ? inputSchema : {};
+  const source = schema.properties && typeof schema.properties === 'object' ? schema.properties : {};
+  const properties = {};
+  for (const [key, value] of Object.entries(source)) properties[key] = simplifyProperty(value);
+  const parameters = { type: 'object', properties, additionalProperties: schema.additionalProperties === true };
+  if (Array.isArray(schema.required) && schema.required.length > 0) {
+    parameters.required = schema.required.filter((name) => Object.prototype.hasOwnProperty.call(properties, name));
+  }
+  return parameters;
+}
+
+/**
+ * @param {object} options
+ * @param {any} options.ctx host context (needs `tools` and `logger`/`console`)
+ * @param {object} options.config plugin config
+ * @param {string} options.packageDir plugin package root (holds `server/`)
+ * @param {string} options.runtimeDir data directory (holds `.venv`, registry)
+ */
+export function createBridge({
+  ctx,
+  config = {},
+  packageDir,
+  runtimeDir,
+  log = () => {},
+  settings = null,
+  audit = null,
+}) {
+  let client = null;
+  let starting = null;
+  let disposers = [];
+  // Names of the tools currently published for this bridge instance.
+  let registeredNames = [];
+  // Bumped by restart()/dispose(): an in-flight boot started under an older epoch
+  // must not register its tools into a host that is already being torn down.
+  let bootEpoch = 0;
+  let state = { phase: 'idle', error: null, tools: [], serverInfo: null, startedAt: null };
+
+  function toolsService() {
+    if (!ctx) return undefined;
+    try {
+      if (typeof ctx.get === 'function') return ctx.get('tools');
+      return ctx.tools;
+    } catch {
+      return undefined;
+    }
+  }
+
+  function status() {
+    return {
+      phase: state.phase,
+      error: state.error,
+      toolCount: state.tools.length,
+      tools: state.tools,
+      serverInfo: state.serverInfo,
+      startedAt: state.startedAt,
+      command: state.command ?? null,
+      python: state.python ?? null,
+      exit: client?.exitInfo ?? null,
+      stderr: client?.stderrTail ?? '',
+    };
+  }
+
+  function auditEntry(name, args, startedAt, outcome, error) {
+    if (!audit) return;
+    const call = args && typeof args === 'object' ? args : {};
+    const entry = {
+      at: new Date().toISOString(),
+      tool: `${TOOL_PREFIX}${name}`,
+      datasource: typeof call.datasource === 'string' ? call.datasource : null,
+      ok: !error && !(outcome && outcome.isError === true),
+      ms: Date.now() - startedAt,
+    };
+    if (typeof call.sql === 'string') entry.sql = call.sql.slice(0, 2000);
+    if (typeof call.table === 'string') entry.table = call.table;
+    if (error) entry.error = String((error && error.message) || error);
+    else {
+      const parsed = outcome && outcome.parsed;
+      const rows = parsed && (parsed.rowCount ?? (Array.isArray(parsed.rows) ? parsed.rows.length : undefined));
+      if (typeof rows === 'number') entry.rows = rows;
+      if (parsed && parsed.error && parsed.error.code) entry.code = parsed.error.code;
+    }
+    try {
+      void audit(entry);
+    } catch {
+      // never let auditing break a call
+    }
+  }
+
+  async function invoke(name, args = {}, options = {}) {
+    const startedAt = Date.now();
+    const audited = options.audit !== false;
+    try {
+      await ensure();
+      const active = client;
+      if (!active || !active.running) {
+        throw new McpError('the database MCP server is not running', { code: 'not_running' });
+      }
+      const result = await active.callTool(name, args, { timeoutMs: TOOL_TIMEOUT_MS });
+      if (audited) auditEntry(name, args, startedAt, result, null);
+      return result;
+    } catch (error) {
+      if (audited) auditEntry(name, args, startedAt, null, error);
+      throw error;
+    }
+  }
+
+  function registerTools(tools) {
+    const service = toolsService();
+    if (!service || typeof service.register !== 'function') {
+      throw new McpError(
+        'the host `tools` service is unavailable, so the MCP tools cannot be published',
+        { code: 'no_tools_service' },
+      );
+    }
+    const names = tools.map((tool) => `${TOOL_PREFIX}${tool.name}`);
+    // Restarting the Python process must not churn the tool catalog: the agent
+    // resolves these names through the registry, so a dispose/re-register pair
+    // would make a live call fail with `unknown tool`. Keep the registrations
+    // and let `execute` follow the current client instead.
+    if (disposers.length === names.length && names.every((name, index) => registeredNames[index] === name)) {
+      state.tools = tools.map((tool) => tool.name);
+      return;
+    }
+    disposeTools();
+    disposers = tools.map((tool) => {
+      const name = `${TOOL_PREFIX}${tool.name}`;
+      const description = `${tool.description || tool.name}\n\n(PostgreSQL/MySQL/Oracle/SQLite via the DSH Database panel; source is chosen with the \`datasource\` argument.)`;
+      return service.register({
+        name,
+        description,
+        parameters: safeParameters(tool.inputSchema),
+        timeoutMs: TOOL_TIMEOUT_MS,
+        isConcurrencySafe: () => true,
+        output: {
+          schema: { type: 'object', additionalProperties: true },
+          render: (_args, value) => [{ type: 'text', text: renderResult(value) }],
+        },
+        execute: async (args) => {
+          const result = await invoke(tool.name, args ?? {});
+          if (result.parsed) return result.parsed;
+          if (result.text) return { ok: true, text: result.text };
+          return { ok: true, content: result.content ?? [] };
+        },
+      });
+    });
+    registeredNames = names;
+    state.tools = tools.map((tool) => tool.name);
+  }
+
+  function disposeTools() {
+    registeredNames = [];
+    for (const dispose of disposers.splice(0)) {
+      try {
+        dispose();
+      } catch (error) {
+        log(`dispose tool failed: ${error}`);
+      }
+    }
+    state.tools = [];
+  }
+
+  async function boot() {
+    const myEpoch = ++bootEpoch;
+    const entry = serverEntry(packageDir);
+    if (!existsSync(entry)) {
+      throw new McpError(`server/main.py not found under ${packageDir}`, { code: 'server_missing' });
+    }
+    const current = settings ? await settings().catch(() => ({ allowWrite: false })) : { allowWrite: false };
+    const allowWrite = current && current.allowWrite === true;
+    const candidates = pythonCandidates(config, runtimeDir);
+    let lastError = null;
+    for (const candidate of candidates) {
+      if (myEpoch !== bootEpoch) throw new McpError('start superseded', { code: 'superseded' });
+      if (candidate.includes('\\') || candidate.includes('/')) {
+        if (!existsSync(candidate)) continue;
+      }
+      const next = new McpClient({
+        command: candidate,
+        args: [entry],
+        cwd: join(packageDir, 'server'),
+        env: {
+          PYTHONIOENCODING: 'utf-8',
+          PYTHONUTF8: '1',
+          DB_MCP_RUNTIME: runtimeDir,
+          DB_MCP_ALLOW_WRITE: allowWrite ? '1' : '0',
+        },
+        label: `db-mcp (${candidate})`,
+      });
+      try {
+        await next.start();
+      } catch (error) {
+        lastError = error;
+        await next.stop();
+        log(`start failed with ${candidate}: ${error?.message ?? error}`);
+        continue;
+      }
+      if (myEpoch !== bootEpoch) {
+        await next.stop();
+        throw new McpError('start superseded', { code: 'superseded' });
+      }
+      try {
+        registerTools(next.tools);
+      } catch (error) {
+        disposeTools();
+        await next.stop();
+        state = {
+          ...state,
+          phase: 'failed',
+          error: `tool registration failed: ${error?.message ?? error}`,
+          python: candidate,
+          command: [candidate, entry].join(' '),
+          serverInfo: next.serverInfo,
+        };
+        throw new McpError(`tool registration failed: ${error?.message ?? error}`, { code: 'tool_registration' });
+      }
+      client = next;
+      state = {
+        phase: 'ready',
+        error: null,
+        tools: next.tools.map((tool) => `${TOOL_PREFIX}${tool.name}`),
+        serverInfo: next.serverInfo,
+        startedAt: new Date().toISOString(),
+        command: [candidate, entry].join(' '),
+        python: candidate,
+      };
+      next.onExit((info) => {
+        state = { ...state, phase: 'exited', error: `server exited (code ${info?.code ?? 'null'})` };
+        // Keep the published tools: the agent keeps a stable catalog and the
+        // next execute() call restarts the process through ensure().
+      });
+      log(`started ${next.tools.length} tool(s) with ${candidate}`);
+      return status();
+    }
+    state = { ...state, phase: 'failed', error: lastError ? String(lastError.message ?? lastError) : 'no usable Python interpreter' };
+    throw lastError ?? new McpError('no usable Python interpreter', { code: 'python_missing' });
+  }
+
+  async function ensure() {
+    if (client?.running && state.phase === 'ready') return status();
+    if (starting) return starting;
+    starting = boot().finally(() => {
+      starting = null;
+    });
+    return starting;
+  }
+
+  async function restart() {
+    bootEpoch += 1;
+    if (client) {
+      await client.stop();
+      client = null;
+    }
+    state = { ...state, phase: 'idle', error: null };
+    return ensure();
+  }
+
+  async function call(name, args = {}, options = {}) {
+    const result = await invoke(name, args, options);
+    return { tool: name, value: result.parsed ?? null, text: result.text, isError: result.isError === true };
+  }
+
+  async function dispose() {
+    bootEpoch += 1;
+    starting = null;
+    disposeTools();
+    if (client) {
+      await client.stop();
+      client = null;
+    }
+    state = { ...state, phase: 'idle', tools: [] };
+  }
+
+  return { ensure, restart, dispose, status, call };
+}