db-mcp 1.1.1 → 3.0.0

package/dist/chunk-W5WQVNVX.js

@@ -0,0 +1,568 @@
+import { registerToolScope } from './chunk-E5IESRTK.js';
+import { ValidationError, getAuthContext, isToolEnabled, ConnectionError, registerToolScopes, scopesGrantToolAccess, InsufficientScopeError, formatHandlerError } from './chunk-L552U3QS.js';
+import sqliteParser from 'sqlite-parser';
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+var UNSAFE_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LOAD_EXTENSION",
+  "WRITEFILE",
+  "READFILE",
+  "ATTACH",
+  "DETACH"
+]);
+var BLOCKED_PRAGMAS = /* @__PURE__ */ new Set([
+  "writable_schema",
+  "trusted_schema",
+  "defensive",
+  "cell_size_check",
+  "temp_store_directory",
+  "journal_mode",
+  "synchronous",
+  "page_size",
+  "temp_store",
+  "wal_autocheckpoint",
+  "locking_mode",
+  "mmap_size",
+  "busy_timeout",
+  "cache_size"
+]);
+function validateQuery(sql, isReadOnly) {
+  if (!sql || sql.trim() === "") {
+    return;
+  }
+  let stripped = "";
+  let inString = false;
+  let stringChar = "";
+  let inBlockComment = false;
+  let inLineComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const c = sql[i];
+    const next = sql[i + 1] || "";
+    if (inBlockComment) {
+      if (c === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inLineComment) {
+      if (c === "\n") {
+        inLineComment = false;
+      }
+      continue;
+    }
+    if (inString) {
+      if (c === stringChar) {
+        if (next === stringChar) {
+          i++;
+        } else {
+          inString = false;
+        }
+      }
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`" || c === "[") {
+      inString = true;
+      stringChar = c === "[" ? "]" : c;
+      continue;
+    }
+    if (c === "-" && next === "-") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    stripped += c;
+  }
+  const pragmaMatches = stripped.matchAll(
+    /\bPRAGMA\s+(?:[a-zA-Z_]+\.)?([a-zA-Z_]+)\s*(?:=|\()/gi
+  );
+  for (const match2 of pragmaMatches) {
+    if (match2[1] && BLOCKED_PRAGMAS.has(match2[1].toLowerCase())) {
+      throw new ValidationError(
+        `Mutating PRAGMA '${match2[1]}' is blocked for security`,
+        "DB_DANGEROUS_PATTERN"
+      );
+    }
+  }
+  let ast = null;
+  let parseError = false;
+  try {
+    ast = sqliteParser(stripped);
+  } catch {
+    parseError = true;
+  }
+  if (ast !== null && typeof ast === "object" && "statement" in ast && Array.isArray(ast.statement)) {
+    if (ast.statement.length > 1) {
+      throw new ValidationError(
+        "Multiple stacked statements are not allowed.",
+        "DB_DANGEROUS_PATTERN"
+      );
+    }
+  } else if (parseError) {
+    if (/;\s*(?:INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|REPLACE|UPSERT|PRAGMA|TRUNCATE)\b/i.test(
+      stripped
+    )) {
+      throw new ValidationError(
+        "Multiple stacked statements are not allowed.",
+        "DB_DANGEROUS_PATTERN"
+      );
+    }
+  }
+  const rootStmt = stripped.trim();
+  if (isReadOnly) {
+    const isSafeRead = /^\s*(?:WITH\s+[\s\S]+?)?(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(rootStmt);
+    const writeMatch = /\b(INSERT|UPDATE|DELETE|REPLACE|DROP|CREATE|ALTER|VACUUM|ANALYZE|TRUNCATE)\b/i.exec(
+      rootStmt
+    );
+    if (writeMatch) {
+      throw new ValidationError(
+        `Read-only mode: ${writeMatch[1]?.toUpperCase() ?? "WRITE"} statements are not allowed`,
+        "DB_READ_ONLY_VIOLATION"
+      );
+    }
+    if (!isSafeRead) {
+      throw new ValidationError(
+        `Read-only mode violation: statement contains disallowed keywords`,
+        "DB_READ_ONLY_VIOLATION"
+      );
+    }
+  } else {
+    const ddlPattern = /^\s*(?:BEGIN\s+)?(?:WITH\s+[\s\S]+?)?(CREATE|DROP|ALTER|VACUUM|ANALYZE)\b/i;
+    if (ddlPattern.test(stripped)) {
+      const authCtx = getAuthContext();
+      if (authCtx && authCtx.authenticated && !authCtx.scopes.includes("admin") && !authCtx.scopes.includes("full")) {
+        throw new ValidationError(
+          "DDL operations (CREATE, DROP, ALTER) require 'admin' or 'full' scope",
+          "DB_ADMIN_REQUIRED"
+        );
+      }
+    }
+  }
+  const unsafePattern = new RegExp(
+    `\\b(${Array.from(UNSAFE_FUNCTIONS).join("|")})\\b`,
+    "i"
+  );
+  const match = unsafePattern.exec(stripped);
+  if (match) {
+    throw new ValidationError(
+      `Unsafe function call detected: ${match[0].toUpperCase()}`,
+      "DB_DANGEROUS_PATTERN"
+    );
+  }
+}
+
+// src/adapters/registration/tools.ts
+function registerToolImpl(adapter, server, tool) {
+  const safeDescription = tool.description && tool.description.length > 2e3 ? tool.description.substring(0, 2e3) + "... (truncated)" : tool.description;
+  const toolOptions = {
+    description: safeDescription,
+    ...tool.annotations?.title ? { title: tool.annotations.title.substring(0, 256) } : {}
+  };
+  const requiredScope = tool.requiredScopes?.[0] ?? "admin";
+  registerToolScope(tool.name, requiredScope);
+  registerToolScopes(/* @__PURE__ */ new Map([[tool.name, tool.requiredScopes ?? ["admin"]]]));
+  if (tool.inputSchema !== void 0) {
+    const schema = tool.inputSchema;
+    toolOptions["inputSchema"] = schema;
+  }
+  if (tool.outputSchema !== void 0) {
+    toolOptions["outputSchema"] = tool.outputSchema;
+  }
+  if (tool.annotations) {
+    toolOptions["annotations"] = tool.annotations;
+  }
+  if (tool.icons) {
+    toolOptions["icons"] = tool.icons;
+  }
+  const hasOutputSchema = Boolean(tool.outputSchema);
+  server.registerTool(
+    tool.name,
+    toolOptions,
+    async (argsOrExtra, possibleExtra) => {
+      try {
+        const extra = possibleExtra !== void 0 ? possibleExtra : argsOrExtra;
+        const args = possibleExtra !== void 0 ? argsOrExtra : {};
+        const extraMeta = extra;
+        const progressToken = extraMeta?._meta?.progressToken;
+        const context = adapter.createContext(
+          void 0,
+          server.server,
+          progressToken
+        );
+        const execFn = async () => {
+          const authCtx = getAuthContext();
+          const requiredScopes = tool.requiredScopes ?? ["admin"];
+          const userScopes = authCtx?.scopes ?? [];
+          if (authCtx && !scopesGrantToolAccess(userScopes, tool.name)) {
+            throw new InsufficientScopeError(requiredScopes, userScopes);
+          }
+          const result = await tool.handler(args, context);
+          if (hasOutputSchema) {
+            const enriched = JSON.stringify({
+              ...result,
+              _meta: { tokenEstimate: 0 }
+            });
+            const tokenEstimate = Math.ceil(
+              Buffer.byteLength(enriched, "utf8") / 4
+            );
+            const finalText = enriched.replace(
+              '"tokenEstimate":0',
+              `"tokenEstimate":${String(tokenEstimate)}`
+            );
+            const response = {
+              content: [
+                {
+                  type: "text",
+                  text: finalText
+                }
+              ],
+              structuredContent: result
+            };
+            if (result["success"] === false) {
+              response.isError = true;
+            }
+            return response;
+          }
+          if (typeof result === "object" && result !== null) {
+            const withMeta = JSON.stringify(
+              { ...result, _meta: { tokenEstimate: 0 } },
+              null,
+              2
+            );
+            const tokenEstimate = Math.ceil(
+              Buffer.byteLength(withMeta, "utf8") / 4
+            );
+            const finalText = withMeta.replace(
+              '"tokenEstimate": 0',
+              `"tokenEstimate": ${String(tokenEstimate)}`
+            );
+            const response = {
+              content: [{ type: "text", text: finalText }]
+            };
+            if (result["success"] === false) {
+              response.isError = true;
+            }
+            return response;
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: typeof result === "string" ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        };
+        const auditInterceptor = adapter.getAuditInterceptor?.();
+        if (auditInterceptor) {
+          return await auditInterceptor.around(
+            tool.name,
+            args,
+            context.requestId,
+            execFn
+          );
+        }
+        return await execFn();
+      } catch (error) {
+        const structured = formatHandlerError(error);
+        if (hasOutputSchema) {
+          const enriched = JSON.stringify({
+            ...structured,
+            _meta: { tokenEstimate: 0 }
+          });
+          const tokenEstimate2 = Math.ceil(
+            Buffer.byteLength(enriched, "utf8") / 4
+          );
+          const finalText2 = enriched.replace(
+            '"tokenEstimate":0',
+            `"tokenEstimate":${String(tokenEstimate2)}`
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: finalText2
+              }
+            ],
+            structuredContent: structured,
+            isError: true
+          };
+        }
+        const withMeta = JSON.stringify(
+          { ...structured, _meta: { tokenEstimate: 0 } },
+          null,
+          2
+        );
+        const tokenEstimate = Math.ceil(
+          Buffer.byteLength(withMeta, "utf8") / 4
+        );
+        const finalText = withMeta.replace(
+          '"tokenEstimate": 0',
+          `"tokenEstimate": ${String(tokenEstimate)}`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: finalText
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerResourceImpl(adapter, server, resource) {
+  const isTemplate = /\{[^}]+\}/.test(resource.uri);
+  if (isTemplate) {
+    const template = new ResourceTemplate(resource.uri, { list: void 0 });
+    server.registerResource(
+      resource.name,
+      template,
+      {
+        mimeType: resource.mimeType ?? "application/json",
+        description: resource.description,
+        ...resource.icons ? { icons: resource.icons } : {}
+      },
+      async (resourceUri, _variables) => {
+        const context = adapter.createContext();
+        const content = await resource.handler(resourceUri.toString(), context);
+        return {
+          contents: [
+            {
+              uri: resourceUri.toString(),
+              mimeType: resource.mimeType ?? "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  } else {
+    server.registerResource(
+      resource.name,
+      resource.uri,
+      {
+        mimeType: resource.mimeType ?? "application/json",
+        description: resource.description,
+        ...resource.icons ? { icons: resource.icons } : {}
+      },
+      async (resourceUri) => {
+        const context = adapter.createContext();
+        const content = await resource.handler(resourceUri.toString(), context);
+        return {
+          contents: [
+            {
+              uri: resourceUri.toString(),
+              mimeType: resource.mimeType ?? "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  }
+}
+function buildArgsSchema(args) {
+  if (!args || args.length === 0) return void 0;
+  const hasRequired = args.some((a) => a.required === true);
+  if (!hasRequired) return void 0;
+  const schema = {};
+  for (const arg of args) {
+    const field = z.string().max(200, "Argument too long").describe(arg.description);
+    schema[arg.name] = arg.required ? field : field.optional();
+  }
+  return schema;
+}
+function registerPromptImpl(adapter, server, prompt) {
+  const argsSchema = buildArgsSchema(prompt.arguments);
+  const iconOpts = prompt.icons ? { icons: prompt.icons } : {};
+  const handleResult = async (args) => {
+    const context = adapter.createContext();
+    const safeArgs = args ?? {};
+    const result = await prompt.handler(safeArgs, context);
+    const messages = Array.isArray(result) ? result : result !== null && result !== void 0 && typeof result === "object" && "messages" in result && Array.isArray(result.messages) ? result.messages : [
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: typeof result === "string" ? result : JSON.stringify(result)
+        }
+      }
+    ];
+    return { messages };
+  };
+  if (argsSchema) {
+    server.registerPrompt(
+      prompt.name,
+      { description: prompt.description, argsSchema, ...iconOpts },
+      async (args) => handleResult(args)
+    );
+  } else {
+    server.registerPrompt(
+      prompt.name,
+      { description: prompt.description, ...iconOpts },
+      async (args) => handleResult(args)
+    );
+  }
+}
+
+// src/adapters/database-adapter.ts
+var DatabaseAdapter = class {
+  /** Connection status */
+  connected = false;
+  /** Database configuration */
+  config = null;
+  /**
+   * Check if connected to the database
+   */
+  isConnected() {
+    return this.connected;
+  }
+  // ===========================================================================
+  // Audit Subsystem
+  // ===========================================================================
+  auditInterceptor = null;
+  backupManager = null;
+  /**
+   * Inject the audit interceptor.
+   */
+  setAuditInterceptor(interceptor) {
+    this.auditInterceptor = interceptor;
+  }
+  /**
+   * Inject the backup manager for tools to use natively.
+   */
+  setBackupManager(manager) {
+    this.backupManager = manager;
+  }
+  /**
+   * Get the audit interceptor (used by registration layer and Code Mode).
+   */
+  getAuditInterceptor() {
+    return this.auditInterceptor;
+  }
+  /**
+   * Register tools with the MCP server
+   * @param server - MCP server instance
+   * @param filterConfig - Tool filter configuration
+   */
+  registerTools(server, filterConfig) {
+    const tools = this.getToolDefinitions();
+    for (const tool of tools) {
+      if (!isToolEnabled(tool, filterConfig)) {
+        continue;
+      }
+      this.registerTool(server, tool);
+    }
+  }
+  /**
+   * Register a single tool with the MCP server.
+   * Uses modern registerTool() API for MCP 2025-11-25 compliance.
+   * Subclasses may override for custom behavior.
+   */
+  registerTool(server, tool) {
+    registerToolImpl(this, server, tool);
+  }
+  /**
+   * Register resources with the MCP server
+   */
+  registerResources(server) {
+    const resources = this.getResourceDefinitions();
+    for (const resource of resources) {
+      this.registerResource(server, resource);
+    }
+  }
+  /**
+   * Register a single resource with the MCP server.
+   * Handles both static resources and URI templates.
+   * Subclasses may override for custom behavior.
+   */
+  registerResource(server, resource) {
+    registerResourceImpl(this, server, resource);
+  }
+  /**
+   * Register prompts with the MCP server
+   */
+  registerPrompts(server) {
+    const prompts = this.getPromptDefinitions();
+    for (const prompt of prompts) {
+      this.registerPrompt(server, prompt);
+    }
+  }
+  /**
+   * Register a single prompt with the MCP server.
+   * Subclasses may override for custom behavior.
+   */
+  registerPrompt(server, prompt) {
+    registerPromptImpl(this, server, prompt);
+  }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
+  /**
+   * Validate query for safety (SQL injection prevention)
+   * @param sql - SQL query to validate
+   * @param isReadOnly - Whether to enforce read-only restrictions
+   */
+  validateQuery(sql, isReadOnly) {
+    validateQuery(sql, isReadOnly);
+  }
+  /**
+   * Create a request context for tool execution
+   * @param requestId Optional request ID for tracing
+   * @param server Optional MCP Server instance for progress notifications
+   * @param progressToken Optional progress token from client request _meta
+   */
+  createContext(requestId, server, progressToken) {
+    const authContext = getAuthContext();
+    const context = {
+      timestamp: /* @__PURE__ */ new Date(),
+      requestId: requestId ?? crypto.randomUUID(),
+      auth: authContext?.claims,
+      clientIp: authContext?.clientIp
+    };
+    if (server !== void 0) {
+      context.server = server;
+    }
+    if (progressToken !== void 0) {
+      context.progressToken = progressToken;
+    }
+    return context;
+  }
+  /**
+   * Ensure the adapter is connected to the database.
+   * Throws ConnectionError if not connected.
+   * Subclasses may override to add additional checks (e.g., db instance null).
+   */
+  ensureConnected() {
+    if (!this.connected) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+  }
+  /**
+   * Get adapter info for logging/debugging
+   */
+  getInfo() {
+    return {
+      type: this.type,
+      name: this.name,
+      version: this.version,
+      connected: this.connected,
+      capabilities: this.getCapabilities(),
+      toolGroups: this.getSupportedToolGroups()
+    };
+  }
+};
+
+export { DatabaseAdapter, validateQuery };

package/dist/cli.d.ts

@@ -1 +1,8 @@
 #!/usr/bin/env node
+/**
+ * db-mcp - Command Line Interface
+ *
+ * Entry point for running the db-mcp server from the command line.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;GAIG"}