db-mcp 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,13 +1,845 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
 /**
- * db-mcp - SQLite MCP Server
+ * db-mcp — Database Types
  *
- * Main entry point and public API exports.
+ * Core database type definitions: connections, queries, schema,
+ * tables, columns, indexes, and constraints.
  */
-export { DbMcpServer, createServer, DEFAULT_CONFIG, } from "./server/McpServer.js";
-export type { DatabaseType, DatabaseConfig, HealthStatus, QueryResult, ColumnInfo, TableInfo, SchemaInfo, IndexInfo, ConstraintInfo, TransportType, McpServerConfig, OAuthConfig, OAuthScope, TokenClaims, RequestContext, ToolGroup, ToolFilterRule, ToolFilterConfig, AdapterCapabilities, ToolDefinition, ResourceDefinition, PromptDefinition, } from "./types/index.js";
-export { DbMcpError, ConnectionError, QueryError, AuthenticationError, AuthorizationError, ValidationError, } from "./types/index.js";
-export { DatabaseAdapter } from "./adapters/DatabaseAdapter.js";
-export { TOOL_GROUPS, META_GROUPS, ALL_TOOL_GROUPS, parseToolFilter, isToolEnabled, filterTools, getToolFilterFromEnv, getFilterSummary, } from "./filtering/ToolFilter.js";
-export declare const VERSION = "0.1.0";
-export declare const NAME = "db-mcp";
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Supported database types.
+ * This MCP server only supports SQLite. Other database types
+ * would require separate MCP server projects.
+ */
+type DatabaseType = "sqlite";
+/**
+ * Database connection configuration
+ */
+interface DatabaseConfig {
+    /** Database type identifier */
+    type: DatabaseType;
+    /** Connection string (file path or ":memory:") */
+    connectionString?: string;
+    /** Additional database-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Database connection health status
+ */
+interface HealthStatus {
+    connected: boolean;
+    latencyMs?: number;
+    version?: string;
+    details?: Record<string, unknown>;
+    error?: string;
+}
+/**
+ * Query execution result
+ */
+interface QueryResult {
+    /** Rows returned (for SELECT queries) */
+    rows?: Record<string, unknown>[];
+    /** Number of rows affected (for INSERT/UPDATE/DELETE) */
+    rowsAffected?: number;
+    /** Last inserted ID (for INSERT with auto-increment) */
+    lastInsertId?: number | string;
+    /** Query execution time in milliseconds */
+    executionTimeMs?: number;
+    /** Column metadata */
+    columns?: ColumnInfo[];
+}
+/**
+ * Column metadata information
+ */
+interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    defaultValue?: unknown;
+}
+/**
+ * Table information
+ */
+interface TableInfo {
+    name: string;
+    schema?: string;
+    type: "table" | "view" | "materialized_view";
+    rowCount?: number;
+    columns?: ColumnInfo[];
+}
+/**
+ * Schema information for a database
+ */
+interface SchemaInfo {
+    tables: TableInfo[];
+    views?: TableInfo[];
+    indexes?: IndexInfo[];
+    constraints?: ConstraintInfo[];
+}
+/**
+ * Index information
+ */
+interface IndexInfo {
+    name: string;
+    tableName: string;
+    columns: string[];
+    unique: boolean;
+    type?: string;
+}
+/**
+ * Constraint information
+ */
+interface ConstraintInfo {
+    name: string;
+    tableName: string;
+    type: "primary_key" | "foreign_key" | "unique" | "check";
+    columns: string[];
+    referencedTable?: string;
+    referencedColumns?: string[];
+}
+
+/**
+ * db-mcp — OAuth & Auth Types
+ *
+ * OAuth 2.1 configuration, scopes, token claims, and request context.
+ */
+/**
+ * OAuth 2.1 configuration
+ */
+interface OAuthConfig {
+    /** Enable OAuth authentication */
+    enabled: boolean;
+    /** Authorization server URL */
+    authorizationServerUrl?: string;
+    /** Token validation endpoint */
+    tokenEndpoint?: string;
+    /** JWKS URI for token verification */
+    jwksUri?: string;
+    /** Expected audience in tokens */
+    audience?: string;
+    /** Expected issuer in tokens */
+    issuer?: string;
+    /** Clock tolerance for token validation (seconds) */
+    clockTolerance?: number;
+    /** JWKS cache TTL (seconds) */
+    jwksCacheTtl?: number;
+    /** Paths that bypass authentication */
+    publicPaths?: string[];
+}
+/**
+ * OAuth scopes for access control
+ */
+type OAuthScope = "read" | "write" | "admin" | `db:${string}` | `table:${string}:${string}`;
+/**
+ * Validated OAuth token claims
+ */
+interface TokenClaims {
+    /** Subject (user ID) */
+    sub: string;
+    /** Granted scopes */
+    scopes: OAuthScope[];
+    /** Token expiration time */
+    exp: number;
+    /** Token issued at time */
+    iat: number;
+    /** Token issuer */
+    iss?: string;
+    /** Token audience */
+    aud?: string | string[];
+    /** Additional claims */
+    [key: string]: unknown;
+}
+/**
+ * Request context with authentication info
+ */
+interface RequestContext {
+    /** Validated token claims (if authenticated) */
+    auth?: TokenClaims;
+    /** Raw access token */
+    accessToken?: string;
+    /** Request timestamp */
+    timestamp: Date;
+    /** Request ID for tracing */
+    requestId: string;
+    /**
+     * MCP Server instance for sending progress notifications.
+     * Only available when running in HTTP/SSE transport with stateful sessions.
+     */
+    server?: unknown;
+    /**
+     * Progress token from client request _meta (MCP 2025-11-25).
+     * If present, the client has requested progress updates.
+     */
+    progressToken?: string | number;
+}
+
+/**
+ * db-mcp — MCP Server Types
+ *
+ * Configuration types for the MCP server: transport, port, host,
+ * database config references, and server-level options.
+ */
+
+/**
+ * Transport type for MCP communication
+ */
+type TransportType = "stdio" | "http" | "sse";
+/**
+ * MCP Server configuration
+ */
+interface McpServerConfig {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Transport configuration */
+    transport: TransportType;
+    /** HTTP port (for http/sse transports) */
+    port?: number;
+    /** Host/IP to bind to (for http/sse transports, default: 0.0.0.0) */
+    host?: string;
+    /** Database configurations */
+    databases: DatabaseConfig[];
+    /** OAuth 2.1 configuration */
+    oauth?: OAuthConfig;
+    /** Simple bearer token for HTTP authentication (non-OAuth) */
+    authToken?: string;
+    /** Tool filtering configuration */
+    toolFilter?: string;
+    /**
+     * Enable stateless HTTP mode (no session management, no SSE streaming).
+     * Ideal for serverless deployments (Lambda, Workers, Vercel).
+     * Default: false (stateful mode with session management and SSE support)
+     */
+    statelessHttp?: boolean;
+    enableHSTS?: boolean;
+}
+
+/**
+ * db-mcp — Tool Filtering Types
+ *
+ * Tool groups, meta-groups, and filter configuration types.
+ */
+/**
+ * Tool group identifiers
+ */
+type ToolGroup = "core" | "json" | "text" | "stats" | "vector" | "admin" | "geo" | "introspection" | "migration" | "codemode";
+/**
+ * Meta-group identifiers for common multi-group selections.
+ * These are shortcuts that expand to multiple ToolGroups.
+ */
+type MetaGroup = "starter" | "analytics" | "search" | "spatial" | "dev-schema" | "minimal" | "full";
+/**
+ * Tool filter rule
+ */
+interface ToolFilterRule {
+    /** Rule type: include or exclude */
+    type: "include" | "exclude";
+    /** Target: group name or tool name */
+    target: string;
+    /** Whether target is a group (true) or individual tool (false) */
+    isGroup: boolean;
+}
+/**
+ * Parsed tool filter configuration
+ */
+interface ToolFilterConfig {
+    /** Original filter string */
+    raw: string;
+    /** Parsed rules in order */
+    rules: ToolFilterRule[];
+    /** Set of enabled tool groups after applying rules */
+    enabledGroups: Set<ToolGroup>;
+    /** Set of explicitly excluded tool names (base names without prefix) */
+    excludedTools: Set<string>;
+    /** Set of explicitly included tool names (base names without prefix) */
+    includedTools: Set<string>;
+}
+
+/**
+ * db-mcp — Adapter Types
+ *
+ * Types for database adapter capabilities, tool/resource/prompt definitions,
+ * MCP icons, and tool annotations.
+ */
+
+/**
+ * MCP Icon Definition (MCP Spec 2025-11-25)
+ *
+ * Icons can be added to servers, tools, resources, and prompts for
+ * visual representation in client interfaces.
+ */
+interface McpIcon {
+    /** Icon source — URL or data URI */
+    src: string;
+    /** MIME type (e.g., 'image/svg+xml', 'image/png') */
+    mimeType?: string;
+    /** Size descriptors (e.g., ['48x48'], ['any']) */
+    sizes?: string[];
+    /** Theme hint: 'light' or 'dark' */
+    theme?: "light" | "dark";
+}
+/**
+ * Tool annotations provide behavioral hints to clients
+ * following the MCP 2025-11-25 specification.
+ */
+interface ToolAnnotations {
+    /** Human-readable title for the tool */
+    title?: string;
+    /** If true, the tool is guaranteed not to modify any state */
+    readOnlyHint?: boolean;
+    /** If true, multiple identical requests have the same effect as a single request */
+    idempotentHint?: boolean;
+    /** If true, the operation is irreversible or causes significant data loss */
+    destructiveHint?: boolean;
+    /** If true, the tool interacts with external/"open world" systems (network, filesystem, etc.) */
+    openWorldHint?: boolean;
+}
+/**
+ * Capabilities supported by a database adapter
+ */
+interface AdapterCapabilities {
+    /** Supports JSON operations */
+    json: boolean;
+    /** Supports full-text search */
+    fullTextSearch: boolean;
+    /** Supports vector/embedding operations */
+    vector: boolean;
+    /** Supports geospatial operations */
+    geospatial: boolean;
+    /** Supports transactions */
+    transactions: boolean;
+    /** Supports prepared statements */
+    preparedStatements: boolean;
+    /** Supports connection pooling */
+    connectionPooling: boolean;
+    /** Additional capability flags */
+    [key: string]: boolean;
+}
+/**
+ * Tool definition for registration
+ */
+interface ToolDefinition {
+    /** Unique tool name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Tool group for filtering */
+    group: ToolGroup;
+    /** Zod schema for input validation */
+    inputSchema: unknown;
+    /** Zod schema for output validation (MCP 2025-11-25) */
+    outputSchema?: unknown;
+    /** Required OAuth scopes */
+    requiredScopes?: OAuthScope[];
+    /** MCP tool annotations (behavioral hints) */
+    annotations?: ToolAnnotations;
+    /** MCP icons for visual representation (MCP 2025-11-25) */
+    icons?: McpIcon[];
+    /** Tool handler function */
+    handler: (params: unknown, context: RequestContext) => Promise<unknown>;
+}
+/**
+ * MCP Resource Annotations (SDK 1.25+)
+ * Provides metadata hints about resource content to help clients
+ * manage and display resources appropriately.
+ */
+interface ResourceAnnotations {
+    /** Intended audience for the resource content */
+    audience?: ("user" | "assistant")[];
+    /** Priority hint for display ordering (0-1 range) */
+    priority?: number;
+    /** ISO 8601 timestamp of last modification for cache invalidation */
+    lastModified?: string;
+}
+/**
+ * Resource definition for MCP
+ */
+interface ResourceDefinition {
+    /** Resource URI template */
+    uri: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description: string;
+    /** MIME type */
+    mimeType?: string;
+    /** MCP Resource Annotations for behavior hints */
+    annotations?: ResourceAnnotations;
+    /** MCP icons for visual representation (MCP 2025-11-25) */
+    icons?: McpIcon[];
+    /** Resource handler */
+    handler: (uri: string, context: RequestContext) => Promise<unknown>;
+}
+/**
+ * Prompt definition for MCP
+ */
+interface PromptDefinition {
+    /** Prompt name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Argument definitions */
+    arguments?: {
+        name: string;
+        description: string;
+        required?: boolean;
+    }[];
+    /** MCP icons for visual representation (MCP 2025-11-25) */
+    icons?: McpIcon[];
+    /** Prompt handler */
+    handler: (args: Record<string, string>, context: RequestContext) => Promise<unknown>;
+}
+
+/**
+ * Error Categories
+ *
+ * Classification enum for all db-mcp errors.
+ */
+/**
+ * Error categories for classification and handling
+ */
+declare enum ErrorCategory {
+    /** Input validation failures (invalid names, paths, types) */
+    VALIDATION = "validation",
+    /** Database connection issues */
+    CONNECTION = "connection",
+    /** SQL execution errors */
+    QUERY = "query",
+    /** Authorization/permission failures */
+    PERMISSION = "permission",
+    /** Configuration/setup issues */
+    CONFIGURATION = "config",
+    /** Missing resources (tables, columns, views) */
+    RESOURCE = "resource",
+    /** Authentication failures (invalid credentials, expired tokens) */
+    AUTHENTICATION = "authentication",
+    /** Authorization failures (insufficient scope/permissions) */
+    AUTHORIZATION = "authorization",
+    /** Unexpected internal errors */
+    INTERNAL = "internal"
+}
+/**
+ * Structured error response format
+ */
+interface ErrorResponse {
+    success: false;
+    error: string;
+    code: string;
+    category: ErrorCategory;
+    suggestion: string | undefined;
+    recoverable: boolean;
+    details: Record<string, unknown> | undefined;
+}
+
+/**
+ * Base Error Class
+ *
+ * DbMcpError provides enhanced diagnostics: category, code, suggestion,
+ * recoverable flag, and structured response conversion.
+ */
+
+/**
+ * Base error class for db-mcp with enhanced diagnostics
+ */
+declare class DbMcpError extends Error {
+    /** Error category for classification */
+    readonly category: ErrorCategory;
+    /** Module-prefixed error code (e.g., DB_QUERY_FAILED) */
+    readonly code: string;
+    /** Actionable suggestion for resolving the error */
+    readonly suggestion: string | undefined;
+    /** Additional error details */
+    readonly details: Record<string, unknown> | undefined;
+    /** Whether the error is recoverable (can retry) */
+    readonly recoverable: boolean;
+    constructor(message: string, code: string, category: ErrorCategory, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        recoverable?: boolean | undefined;
+        cause?: Error | undefined;
+    });
+    /**
+     * Convert to structured response object
+     */
+    toResponse(): ErrorResponse;
+}
+
+/**
+ * Specific Error Classes
+ *
+ * Typed error subclasses for each ErrorCategory.
+ */
+
+/**
+ * Validation error for invalid inputs
+ */
+declare class ValidationError extends DbMcpError {
+    constructor(message: string, code?: string, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        cause?: Error | undefined;
+    });
+}
+/**
+ * Connection error for database connectivity issues
+ */
+declare class ConnectionError extends DbMcpError {
+    constructor(message: string, code?: string, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        cause?: Error | undefined;
+    });
+}
+/**
+ * Query error for SQL execution failures
+ */
+declare class QueryError extends DbMcpError {
+    constructor(message: string, code?: string, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        sql?: string | undefined;
+        cause?: Error | undefined;
+    });
+}
+/**
+ * Authentication error (401-type: invalid credentials, expired tokens)
+ */
+declare class AuthenticationError extends DbMcpError {
+    constructor(message: string, code?: string, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        cause?: Error | undefined;
+    });
+}
+/**
+ * Authorization error (403-type: insufficient permissions)
+ */
+declare class AuthorizationError extends DbMcpError {
+    constructor(message: string, code?: string, options?: {
+        suggestion?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+        cause?: Error | undefined;
+    });
+}
+
+/**
+ * db-mcp - Database Adapter Interface
+ *
+ * Abstract base class for SQLite database adapters.
+ * Provides a consistent interface for SQLite database operations
+ * across WASM and native backend variants.
+ *
+ * Includes concrete default implementations for MCP registration
+ * (registerTool, registerResource, registerPrompt) that subclasses
+ * inherit. Override only if the adapter needs custom behavior.
+ */
+
+/**
+ * Abstract base class for database adapters
+ */
+declare abstract class DatabaseAdapter {
+    /** Database type identifier */
+    abstract readonly type: DatabaseType;
+    /** Human-readable adapter name */
+    abstract readonly name: string;
+    /** Adapter version */
+    abstract readonly version: string;
+    /** Connection status */
+    protected connected: boolean;
+    /** Database configuration */
+    protected config: DatabaseConfig | null;
+    /**
+     * Connect to the database
+     * @param config - Database connection configuration
+     */
+    abstract connect(config: DatabaseConfig): Promise<void>;
+    /**
+     * Disconnect from the database
+     */
+    abstract disconnect(): Promise<void>;
+    /**
+     * Check if connected to the database
+     */
+    isConnected(): boolean;
+    /**
+     * Get health status of the database connection
+     */
+    abstract getHealth(): Promise<HealthStatus>;
+    /**
+     * Execute a read-only query (SELECT)
+     * @param sql - SQL query string
+     * @param params - Query parameters for prepared statements
+     */
+    abstract executeReadQuery(sql: string, params?: unknown[]): Promise<QueryResult>;
+    /**
+     * Execute a write query (INSERT, UPDATE, DELETE)
+     * @param sql - SQL query string
+     * @param params - Query parameters for prepared statements
+     * @param skipValidation - Skip security validation (for trusted internal operations)
+     */
+    abstract executeWriteQuery(sql: string, params?: unknown[], skipValidation?: boolean): Promise<QueryResult>;
+    /**
+     * Execute any query (for admin operations)
+     * @param sql - SQL query string
+     * @param params - Query parameters for prepared statements
+     */
+    abstract executeQuery(sql: string, params?: unknown[]): Promise<QueryResult>;
+    /**
+     * Get full database schema information
+     */
+    abstract getSchema(): Promise<SchemaInfo>;
+    /**
+     * List all tables in the database
+     */
+    abstract listTables(): Promise<TableInfo[]>;
+    /**
+     * Describe a specific table's structure
+     * @param tableName - Name of the table
+     */
+    abstract describeTable(tableName: string): Promise<TableInfo>;
+    /**
+     * List available schemas/databases
+     */
+    abstract listSchemas(): Promise<string[]>;
+    /**
+     * Get adapter capabilities
+     */
+    abstract getCapabilities(): AdapterCapabilities;
+    /**
+     * Get supported tool groups for this adapter
+     */
+    abstract getSupportedToolGroups(): ToolGroup[];
+    /**
+     * Get all tool definitions for this adapter
+     */
+    abstract getToolDefinitions(): ToolDefinition[];
+    /**
+     * Get all resource definitions for this adapter
+     */
+    abstract getResourceDefinitions(): ResourceDefinition[];
+    /**
+     * Get all prompt definitions for this adapter
+     */
+    abstract getPromptDefinitions(): PromptDefinition[];
+    /**
+     * Register tools with the MCP server
+     * @param server - MCP server instance
+     * @param filterConfig - Tool filter configuration
+     */
+    registerTools(server: McpServer, filterConfig: ToolFilterConfig): void;
+    /**
+     * Register a single tool with the MCP server.
+     * Uses modern registerTool() API for MCP 2025-11-25 compliance.
+     * Subclasses may override for custom behavior.
+     */
+    protected registerTool(server: McpServer, tool: ToolDefinition): void;
+    /**
+     * Register resources with the MCP server
+     */
+    registerResources(server: McpServer): void;
+    /**
+     * Register a single resource with the MCP server.
+     * Handles both static resources and URI templates.
+     * Subclasses may override for custom behavior.
+     */
+    protected registerResource(server: McpServer, resource: ResourceDefinition): void;
+    /**
+     * Register prompts with the MCP server
+     */
+    registerPrompts(server: McpServer): void;
+    /**
+     * Register a single prompt with the MCP server.
+     * Subclasses may override for custom behavior.
+     */
+    protected registerPrompt(server: McpServer, prompt: PromptDefinition): void;
+    /**
+     * Validate query for safety (SQL injection prevention)
+     * @param sql - SQL query to validate
+     * @param isReadOnly - Whether to enforce read-only restrictions
+     */
+    protected validateQuery(sql: string, isReadOnly: boolean): void;
+    /**
+     * 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?: string, server?: unknown, progressToken?: string | number): RequestContext;
+    /**
+     * 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).
+     */
+    protected ensureConnected(): void;
+    /**
+     * Get adapter info for logging/debugging
+     */
+    getInfo(): Record<string, unknown>;
+}
+
+/**
+ * db-mcp - Main MCP Server
+ *
+ * SQLite MCP server with OAuth 2.1 authentication,
+ * HTTP/SSE transport, and dynamic tool filtering.
+ */
+
+/**
+ * Main db-mcp server class
+ *
+ * Manages database adapters, tool registration, and MCP protocol handling.
+ */
+declare class DbMcpServer {
+    private server;
+    private adapters;
+    private toolFilter;
+    private config;
+    constructor(config: McpServerConfig);
+    /**
+     * Register a database adapter
+     */
+    registerAdapter(adapter: DatabaseAdapter, config: DatabaseConfig): Promise<void>;
+    /**
+     * Get an adapter by ID
+     */
+    getAdapter(adapterId: string): DatabaseAdapter | undefined;
+    /**
+     * Get all registered adapters
+     */
+    getAdapters(): Map<string, DatabaseAdapter>;
+    /**
+     * Register built-in server tools (health, info, etc.)
+     */
+    private registerBuiltInTools;
+    /**
+     * Register sqlite://help resources for on-demand reference documentation.
+     * Always registers sqlite://help (gotchas). Group-specific help is filtered
+     * by the tool filter configuration.
+     */
+    private registerHelpResources;
+    /**
+     * Start the server with the configured transport
+     */
+    start(): Promise<void>;
+    /**
+     * Start server with stdio transport
+     */
+    private startStdio;
+    /**
+     * Start server with HTTP transport (Streamable HTTP with SSE support)
+     */
+    private startHttp;
+    /**
+     * Gracefully shut down the server
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Create and configure a db-mcp server instance
+ */
+declare function createServer(config: McpServerConfig): DbMcpServer;
+/**
+ * Default server configuration
+ */
+declare const DEFAULT_CONFIG: Partial<McpServerConfig>;
+
+/**
+ * db-mcp - Tool Constants
+ *
+ * Defines the tool groups and meta-groups used for filtering.
+ *
+ * Actual tool groups (from code audit):
+ *   core: 9 tools (core/queries.ts, core/tables.ts, core/indexes.ts)
+ *   json: 23 tools (json-operations/crud+query+transform.ts, json-helpers/read+write.ts)
+ *   text: 13 WASM / 17 Native (text/regex+formatting+search+validate.ts, fts.ts)
+ *   stats: 13 WASM / 19 Native (stats/basic+advanced.ts, native: window.ts)
+ *   vector: 11 tools (vector/storage+search+metadata.ts)
+ *   admin: 26 WASM / 33 Native (admin/backup+verify+pragma.ts, virtual/views+vtable+extensions+analysis.ts, native: transactions.ts)
+ *   geo: 4 WASM / 11 Native (geo.ts, native: spatialite/tools+analysis.ts)
+ *   introspection: 9 tools (introspection/graph/tools.ts, analysis/constraints+risks+snapshot.ts, diagnostics/storage+indexes+query-plan.ts)
+ *   migration: 6 tools (migration/tracking.ts) — opt-in
+ *   codemode: 1 tool (codemode.ts)
+ *   Total: 115 WASM / 139 Native tools
+ *
+ * Note: 3 built-in server tools (server_info, server_health, list_adapters)
+ * are always available regardless of filter settings.
+ */
+
+/**
+ * All valid tool groups
+ */
+declare const ALL_TOOL_GROUPS: ToolGroup[];
+/**
+ * Tool groups - kept for backwards compatibility with scopes.ts
+ * The actual filtering uses the tool's 'group' property, not these lists.
+ */
+declare const TOOL_GROUPS: Record<ToolGroup, string[]>;
+/**
+ * Meta-groups that expand to multiple tool groups.
+ * These provide shortcuts for common use cases.
+ */
+declare const META_GROUPS: Record<MetaGroup, ToolGroup[]>;
+
+/**
+ * db-mcp - Tool Filtering System
+ *
+ * Parses and applies tool filter rules from environment variables.
+ * Compatible with postgres-mcp-server filtering syntax.
+ *
+ * Syntax:
+ *   groupName     → Enable only this group (whitelist mode)
+ *   shortcut      → Use a preset (starter, analytics, search, etc.)
+ *   -group        → Disable all tools in a group
+ *   +group        → Enable all tools in a group
+ *   -tool         → Disable a specific tool
+ *   +tool         → Enable a specific tool
+ *
+ * Mode Detection:
+ *   - If first token starts with '-', start with ALL groups enabled (exclusion mode)
+ *   - Otherwise, start with NO groups enabled (whitelist mode)
+ *
+ * Examples:
+ *   "core,json"           → Whitelist: only core and json groups
+ *   "starter"             → Preset: core + json + text groups
+ *   "starter,-fts5"       → Preset minus fts5 group
+ *   "-vector,-geo"        → Legacy: all groups except vector and geo
+ */
+
+/**
+ * Parse a tool filter string into structured rules
+ *
+ * @param filterString - The filter string (e.g., "starter" or "-vector,-geo")
+ * @returns Parsed filter configuration with enabled groups
+ */
+declare function parseToolFilter(filterString: string | undefined): ToolFilterConfig;
+/**
+ * Check if a tool is enabled based on filter configuration
+ * Uses the tool's group property for matching
+ */
+declare function isToolEnabled(tool: ToolDefinition, config: ToolFilterConfig): boolean;
+/**
+ * Filter a list of tool definitions based on filter configuration
+ */
+declare function filterTools(tools: ToolDefinition[], config: ToolFilterConfig): ToolDefinition[];
+/**
+ * Get the tool filter from environment variable
+ */
+declare function getToolFilterFromEnv(): ToolFilterConfig;
+/**
+ * Generate a summary of the current filter configuration
+ */
+declare function getFilterSummary(config: ToolFilterConfig): string;
+
+/**
+ * Version Constants
+ *
+ * Single source of truth — reads from package.json at runtime.
+ */
+/** Server version from package.json */
+declare const VERSION: string;
+/** Package name from package.json */
+declare const NAME: string;
+
+export { ALL_TOOL_GROUPS, type AdapterCapabilities, AuthenticationError, AuthorizationError, type ColumnInfo, ConnectionError, type ConstraintInfo, DEFAULT_CONFIG, DatabaseAdapter, type DatabaseConfig, type DatabaseType, DbMcpError, DbMcpServer, type HealthStatus, type IndexInfo, META_GROUPS, type McpServerConfig, NAME, type OAuthConfig, type OAuthScope, type PromptDefinition, QueryError, type QueryResult, type RequestContext, type ResourceDefinition, type SchemaInfo, TOOL_GROUPS, type TableInfo, type TokenClaims, type ToolDefinition, type ToolFilterConfig, type ToolFilterRule, type ToolGroup, type TransportType, VERSION, ValidationError, createServer, filterTools, getFilterSummary, getToolFilterFromEnv, isToolEnabled, parseToolFilter };