db-mcp 2.0.0 → 3.0.0

package/dist/{chunk-Z7C2TM4L.js → chunk-W5WQVNVX.js}

@@ -1,80 +1,175 @@
-import { ConnectionError, formatHandlerError, ValidationError } from './chunk-X3MUUOWM.js';
-import { isToolEnabled } from './chunk-645ZEFLA.js';
+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';
 
-// src/adapters/query-validation.ts
-var DANGEROUS_SQL_PATTERNS = [
-  /;\s*DROP\s+/i,
-  /;\s*DELETE\s+/i,
-  /;\s*TRUNCATE\s+/i,
-  /;\s*ALTER\s+/i,
-  /;\s*UNION\s+ALL\s+SELECT/i,
-  /;\s*UNION\s+SELECT/i,
-  /;\s*ATTACH\s+/i,
-  /;\s*DETACH\s+/i
-];
-var COMMENT_SQL_PATTERNS = [/--.*$/m, /\/\*[\s\S]*?\*\//];
-function stripSqlStringLiterals(sql) {
-  return sql.replace(/'(?:''|[^'])*'/g, "''");
-}
-var WRITE_PREFIXES = [
-  "INSERT",
-  "UPDATE",
-  "DELETE",
-  "DROP",
-  "CREATE",
-  "ALTER",
-  "TRUNCATE"
-];
+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) {
-  const trimmedSql = sql.trim().toUpperCase();
-  if (isReadOnly) {
-    for (const prefix of WRITE_PREFIXES) {
-      if (trimmedSql.startsWith(prefix)) {
-        throw new ValidationError(
-          `Read-only mode: ${prefix} statements are not allowed`,
-          "DB_READ_ONLY_VIOLATION"
-        );
+  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;
   }
-  for (const pattern of DANGEROUS_SQL_PATTERNS) {
-    if (pattern.test(sql)) {
+  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(
-        "Query contains potentially dangerous patterns",
+        `Mutating PRAGMA '${match2[1]}' is blocked for security`,
         "DB_DANGEROUS_PATTERN"
       );
     }
   }
-  const sqlWithoutStrings = stripSqlStringLiterals(sql);
-  for (const pattern of COMMENT_SQL_PATTERNS) {
-    if (pattern.test(sqlWithoutStrings)) {
+  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(
-        "Query contains potentially dangerous patterns",
+        "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: tool.description
+    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;
-    if (typeof schema === "object" && schema !== null && "partial" in schema && typeof schema["partial"] === "function") {
-      try {
-        toolOptions["inputSchema"] = schema.partial().passthrough();
-      } catch (e) {
-        console.error(`Error applying .partial() to ${tool.name}:`, e);
-        toolOptions["inputSchema"] = schema;
-      }
-    } else {
-      toolOptions["inputSchema"] = schema;
-    }
+    toolOptions["inputSchema"] = schema;
   }
   if (tool.outputSchema !== void 0) {
     toolOptions["outputSchema"] = tool.outputSchema;
@@ -101,6 +196,12 @@ function registerToolImpl(adapter, server, tool) {
           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({
@@ -114,7 +215,7 @@ function registerToolImpl(adapter, server, tool) {
               '"tokenEstimate":0',
               `"tokenEstimate":${String(tokenEstimate)}`
             );
-            return {
+            const response = {
               content: [
                 {
                   type: "text",
@@ -123,6 +224,10 @@ function registerToolImpl(adapter, server, tool) {
               ],
               structuredContent: result
             };
+            if (result["success"] === false) {
+              response.isError = true;
+            }
+            return response;
           }
           if (typeof result === "object" && result !== null) {
             const withMeta = JSON.stringify(
@@ -137,9 +242,13 @@ function registerToolImpl(adapter, server, tool) {
               '"tokenEstimate": 0',
               `"tokenEstimate": ${String(tokenEstimate)}`
             );
-            return {
+            const response = {
               content: [{ type: "text", text: finalText }]
             };
+            if (result["success"] === false) {
+              response.isError = true;
+            }
+            return response;
           }
           return {
             content: [
@@ -267,7 +376,7 @@ function buildArgsSchema(args) {
   if (!hasRequired) return void 0;
   const schema = {};
   for (const arg of args) {
-    const field = z.string().describe(arg.description);
+    const field = z.string().max(200, "Argument too long").describe(arg.description);
     schema[arg.name] = arg.required ? field : field.optional();
   }
   return schema;
@@ -413,9 +522,12 @@ var DatabaseAdapter = class {
    * @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()
+      requestId: requestId ?? crypto.randomUUID(),
+      auth: authContext?.claims,
+      clientIp: authContext?.clientIp
     };
     if (server !== void 0) {
       context.server = server;
@@ -453,4 +565,4 @@ var DatabaseAdapter = class {
   }
 };
 
-export { DatabaseAdapter };
+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"}

package/dist/cli.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { DEFAULT_CONFIG, createServer } from './chunk-WBER5YY4.js';
-import './chunk-SFJQCNG7.js';
-import { VERSION } from './chunk-VIDSICEL.js';
-import './chunk-645ZEFLA.js';
+import { DEFAULT_CONFIG, createServer } from './chunk-THATOQRT.js';
+import { VERSION } from './chunk-E5IESRTK.js';
+import { logger } from './chunk-L552U3QS.js';
 
 // src/audit/types.ts
 var DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES = 10 * 1024 * 1024;
@@ -18,7 +17,7 @@ function parseArgs() {
   let enableCsv = false;
   let enableSpatialite = false;
   let auditLogPath;
-  let auditRedact = false;
+  let auditRedact = true;
   let auditReads = false;
   let auditBackup = false;
   let auditBackupData = false;
@@ -43,11 +42,8 @@ function parseArgs() {
       config.statelessHttp = true;
     } else if (arg === "--enable-hsts") {
       config.enableHSTS = true;
-    } else if (arg === "--auth-token") {
-      const tokenValue = args[++i];
-      if (tokenValue) {
-        config.authToken = tokenValue;
-      }
+    } else if (arg === "--no-auth-enforcement") {
+      config.noAuthEnforcement = true;
     } else if (arg === "--oauth-enabled" || arg === "-o") {
       if (!config.oauth) {
         config.oauth = { enabled: true };
@@ -132,8 +128,8 @@ function parseArgs() {
       if (logPath) {
         auditLogPath = logPath;
       }
-    } else if (arg === "--audit-redact") {
-      auditRedact = true;
+    } else if (arg === "--audit-no-redact") {
+      auditRedact = false;
     } else if (arg === "--audit-reads") {
       auditReads = true;
     } else if (arg === "--audit-backup") {
@@ -177,19 +173,19 @@ Usage: db-mcp [options]
 Transport Options:
   --transport, -t <type>    Transport type: stdio (default), http, sse
   --port, -p <port>         HTTP port (default: 3000)
-  --server-host <host>      Host/IP to bind to (default: 0.0.0.0)
-                            Use 127.0.0.1 to restrict to local connections
+  --server-host <host>      Host/IP to bind to (default: 127.0.0.1)
+                            Use 127.0.0.1 for local, 0.0.0.0 to allow external connections
   --stateless               Use stateless HTTP mode (no session management, no SSE)
                             Ideal for serverless deployments (Lambda, Workers)
   --enable-hsts             Enable HSTS header (use when behind HTTPS)
 
 Authentication Options:
-  --auth-token <token>      Simple bearer token for HTTP authentication
+  --no-auth-enforcement     Explicitly bypass auth enforcement for HTTP
   --oauth-enabled, -o       Enable OAuth 2.1 authentication
   --oauth-issuer <url>      Authorization server URL (issuer)
   --oauth-audience <aud>    Expected token audience
   --oauth-jwks-uri <url>    JWKS URI (auto-discovered from issuer if not set)
-  --oauth-clock-tolerance <seconds>  Clock tolerance in seconds (default: 60)
+  --oauth-clock-tolerance <seconds>  Clock tolerance in seconds (default: 30)
 
 Database Options:
   --sqlite <path>           Add SQLite database (WASM/sql.js)
@@ -201,7 +197,7 @@ Extension Options (Native only):
 
 Audit Options:
   --audit-log <path>        Enable audit logging (JSONL file path, or "stderr")
-  --audit-redact            Redact tool arguments from audit entries
+  --audit-no-redact          Include tool arguments in audit entries (default: redacted)
   --audit-reads             Also log read-scoped tool invocations
   --audit-backup            Enable pre-mutation DDL snapshots
   --audit-backup-data       Include sample data rows in snapshots
@@ -216,8 +212,8 @@ Server Options:
                               Legacy: -vector,-geo (exclusion from all)
 
 Environment Variables:
-  MCP_HOST                  Host/IP to bind to (default: 0.0.0.0)
-  MCP_AUTH_TOKEN             Simple bearer token (same as --auth-token)
+  MCP_HOST                  Host/IP to bind to (default: 127.0.0.1)
+  MCP_AUTH_TOKEN             Simple bearer token
   OAUTH_ENABLED              Enable OAuth 2.1 (same as --oauth-enabled)
   OAUTH_ISSUER               Authorization server URL
   OAUTH_AUDIENCE             Expected token audience
@@ -229,7 +225,7 @@ Environment Variables:
   CSV_EXTENSION_PATH        Custom path to CSV extension binary
   SPATIALITE_PATH           Custom path to SpatiaLite extension binary
   AUDIT_LOG                 Audit log file path (or "stderr")
-  AUDIT_REDACT              Redact arguments (true/false)
+  AUDIT_REDACT              Redact arguments (default: true, set false to include args)
   AUDIT_READS               Log reads (true/false)
   AUDIT_BACKUP              Enable backups (true/false)
   AUDIT_BACKUP_DATA         Include data (true/false)
@@ -252,8 +248,19 @@ function loadEnvConfig() {
   }
   const authToken = process.env["MCP_AUTH_TOKEN"];
   if (authToken) {
+    if (authToken.length < 32) {
+      logger.warning(
+        "MCP_AUTH_TOKEN is too short (< 32 chars). Use a cryptographically random token."
+      );
+    }
     config.authToken = authToken;
   }
+  if (process.env["NO_AUTH_ENFORCEMENT"] === "true") {
+    logger.warning(
+      "Auth enforcement explicitly disabled via NO_AUTH_ENFORCEMENT. Ensure this is not running in production."
+    );
+    config.noAuthEnforcement = true;
+  }
   const oauthEnabled = process.env["OAUTH_ENABLED"] === "true";
   if (oauthEnabled) {
     const oauth = { enabled: true };
@@ -279,7 +286,7 @@ function loadEnvConfig() {
     config.audit = {
       enabled: true,
       logPath: auditLog,
-      redact: process.env["AUDIT_REDACT"] === "true",
+      redact: process.env["AUDIT_REDACT"] !== "false",
       auditReads: process.env["AUDIT_READS"] === "true",
       maxSizeBytes: DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES,
       ...process.env["AUDIT_BACKUP"] === "true" && {
@@ -315,6 +322,13 @@ async function main() {
         ...cliConfig.databases ?? []
       ]
     };
+    if (process.env["NODE_ENV"] === "production" && config.transport === "http" && !config.oauth?.enabled && !config.authToken && !config.noAuthEnforcement) {
+      logger.error(
+        "FATAL SECURITY ERROR: HTTP transport in production requires authentication (--oauth-enabled or --auth-token). If you intend to run without authentication, you must explicitly pass --no-auth-enforcement.",
+        { module: "SERVER" }
+      );
+      process.exit(1);
+    }
     const server = createServer(config);
     process.on("SIGINT", () => {
       void server.shutdown().then(() => {
@@ -330,25 +344,32 @@ async function main() {
       if (dbConfig.type === "sqlite") {
         const options = dbConfig.options;
         if (options?.backend === "better-sqlite3") {
-          const { NativeSqliteAdapter } = await import('./sqlite-native-JXMCFQBA.js');
+          const { NativeSqliteAdapter } = await import('./sqlite-native-ZSSWCTYC.js');
           const adapter = new NativeSqliteAdapter();
           await server.registerAdapter(adapter, dbConfig);
         } else {
-          const { SqliteAdapter } = await import('./sqlite-U5KSYQXK.js');
+          const { SqliteAdapter } = await import('./sqlite-6C3AJI4I.js');
           const adapter = new SqliteAdapter();
           await server.registerAdapter(adapter, dbConfig);
         }
       }
     }
     if (config.databases.length === 0) {
-      console.error(
+      logger.warning(
         "Warning: No databases configured. Use --sqlite or --sqlite-native, or set SQLITE_DATABASE"
       );
     }
     await server.start();
   } catch (error) {
-    console.error("Fatal error:", error);
+    logger.error("Fatal error", {
+      error: error instanceof Error ? error : new Error(String(error))
+    });
     process.exit(1);
   }
 }
-main().catch(console.error);
+main().catch((error) => {
+  logger.error("Unhandled fatal error", {
+    error: error instanceof Error ? error : new Error(String(error))
+  });
+  process.exit(1);
+});

package/dist/codemode/api-constants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * db-mcp - Code Mode API Constants
+ *
+ * Static constant maps for the sandbox API:
+ * - METHOD_ALIASES: shorthand names within each group
+ * - GROUP_EXAMPLES: help() output per group
+ * - POSITIONAL_PARAM_MAP: positional → named arg mapping
+ * - GROUP_PREFIX_MAP: tool name prefix stripping rules
+ * - KEEP_PREFIX_GROUPS: groups that retain their prefix in method names
+ */
+/**
+ * Aliases for common naming shortcuts within each group.
+ * Maps alias name → canonical method name.
+ */
+export declare const METHOD_ALIASES: Record<string, Record<string, string>>;
+/**
+ * Usage examples for each group's help() output
+ */
+export declare const GROUP_EXAMPLES: Record<string, string[]>;
+/**
+ * Maps method names to their parameter names for positional argument support.
+ * Single string = first positional arg maps to this key.
+ * Array = multiple positional args map to these keys in order.
+ *
+ * Enables:
+ * - `sqlite.core.readQuery("SELECT...")` → `{ query: "SELECT..." }`
+ * - `sqlite.core.describeTable("users")` → `{ table: "users" }`
+ */
+export declare const POSITIONAL_PARAM_MAP: Record<string, string | string[]>;
+/**
+ * Map group name to the prefix used in tool names.
+ * Some groups use different prefixes.
+ */
+export declare const GROUP_PREFIX_MAP: Record<string, string>;
+/**
+ * Groups where the prefix should be kept in the method name
+ * (because it's semantically part of the method identity)
+ */
+export declare const KEEP_PREFIX_GROUPS: Set<string>;
+//# sourceMappingURL=api-constants.d.ts.map

package/dist/codemode/api-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-constants.d.ts","sourceRoot":"","sources":["../../src/codemode/api-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsEjE,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAwDnD,CAAC;AAMF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkIlE,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAYnD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,aAA2C,CAAC"}

package/dist/codemode/api.d.ts

@@ -0,0 +1,70 @@
+/**
+ * db-mcp - Code Mode API
+ *
+ * Generates the `sqlite.*` API object that is injected into the sandbox.
+ * Each tool group becomes a namespace (e.g., `sqlite.core.readQuery()`).
+ *
+ * Architecture:
+ * - Reads tool definitions from the adapter
+ * - Groups tools by their `group` property
+ * - Converts tool names to camelCase method names
+ * - Creates proxy methods that normalize positional args and call handlers
+ * - Exposes `help()` at top level and per-group for discoverability
+ */
+import type { ToolDefinition, ToolGroup, RequestContext } from "../types/index.js";
+/**
+ * Convert tool name to camelCase method name.
+ *
+ * Examples:
+ *   sqlite_read_query (core) → readQuery
+ *   sqlite_json_extract (json) → extract
+ *   sqlite_stats_basic (stats) → statsBasic
+ *   sqlite_vector_search (vector) → search
+ *   sqlite_geo_distance (geo) → distance
+ *   sqlite_backup (admin) → backup
+ *   sqlite_transaction_begin (admin) → transactionBegin
+ *   sqlite_transaction_begin (transactions) → begin
+ */
+export declare function toolNameToMethodName(toolName: string, groupName: string): string;
+/** Type alias for group API record */
+type GroupApiRecord = Record<string, (...args: unknown[]) => Promise<unknown>>;
+/**
+ * Main API class exposing all SQLite tool groups.
+ * This is the object injected as `sqlite` in the sandbox.
+ */
+export declare class SqliteApi {
+    readonly core: GroupApiRecord;
+    readonly json: GroupApiRecord;
+    readonly text: GroupApiRecord;
+    readonly stats: GroupApiRecord;
+    readonly vector: GroupApiRecord;
+    readonly admin: GroupApiRecord;
+    readonly transactions: GroupApiRecord;
+    readonly geo: GroupApiRecord;
+    readonly introspection: GroupApiRecord;
+    readonly migration: GroupApiRecord;
+    private readonly toolsByGroup;
+    private readonly baseContext;
+    constructor(tools: ToolDefinition[], baseContext?: RequestContext);
+    /**
+     * Get all available groups
+     */
+    getGroups(): string[];
+    /**
+     * Get method names for a group
+     */
+    getGroupMethods(group: ToolGroup): string[];
+    /**
+     * Create the sandbox bindings object.
+     * This is the object injected as `sqlite` in the sandbox.
+     * Includes group namespaces + top-level aliases for common operations.
+     */
+    createSandboxBindings(): Record<string, unknown>;
+}
+/**
+ * Create a SqliteApi instance from tool definitions.
+ * Convenience factory for use in tool handler setup.
+ */
+export declare function createSqliteApi(tools: ToolDefinition[], baseContext?: RequestContext): SqliteApi;
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/codemode/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/codemode/api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACT,cAAc,EACf,MAAM,mBAAmB,CAAC;AAW3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,MAAM,CAcR;AA6GD,sCAAsC;AACtC,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AA8E/E;;;GAGG;AACH,qBAAa,SAAS;IACpB,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,cAAc,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgC;IAC7D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;gBAE7C,KAAK,EAAE,cAAc,EAAE,EAAE,WAAW,CAAC,EAAE,cAAc;IAkEjE;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAIrB;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,EAAE;IAU3C;;;;OAIG;IACH,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAuDjD;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EAAE,EACvB,WAAW,CAAC,EAAE,cAAc,GAC3B,SAAS,CAEX"}

package/dist/codemode/auto-return.d.ts

@@ -0,0 +1,25 @@
+/**
+ * db-mcp — Code Mode Auto-Return Transform
+ *
+ * Transforms user code so the last expression statement is implicitly
+ * returned from the async IIFE wrapper.  Mimics Node REPL / Chrome
+ * DevTools semantics where bare expressions surface their value.
+ *
+ * The transform is intentionally heuristic (string-based, not AST)
+ * because the code runs in a sandboxed vm.Script that already
+ * handles syntax errors.  Edge-case misfires are safe — they either
+ * produce a benign return of the last expression or leave the code
+ * unchanged (returning undefined, the previous behavior).
+ */
+/**
+ * Transform user code so the last expression statement gets an
+ * implicit `return`, enabling the IIFE wrapper to propagate the value.
+ *
+ * Examples:
+ *   `sqlite.help()`                   → `return sqlite.help()`
+ *   `const r = await foo(); r`        → `const r = await foo(); return r`
+ *   `return 42`                       → `return 42`          (no change)
+ *   `for (const x of xs) { ... }`    → unchanged             (control flow)
+ */
+export declare function transformAutoReturn(code: string): string;
+//# sourceMappingURL=auto-return.d.ts.map

package/dist/codemode/auto-return.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-return.d.ts","sourceRoot":"","sources":["../../src/codemode/auto-return.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsCxD"}

package/dist/codemode/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * db-mcp - Code Mode Module
+ *
+ * Exports for the sandboxed code execution environment.
+ */
+export type { SandboxOptions, PoolOptions, SandboxResult, ExecutionMetrics, SecurityConfig, ValidationResult, ExecutionRecord, ExecuteCodeOptions, ExecuteCodeResult, GroupApi, } from "./types.js";
+export { DEFAULT_SANDBOX_OPTIONS, DEFAULT_POOL_OPTIONS, DEFAULT_SECURITY_CONFIG, } from "./types.js";
+export { CodeModeSandbox, SandboxPool } from "./sandbox.js";
+export { setDefaultSandboxMode, getDefaultSandboxMode, getAvailableSandboxModes, createSandbox, createSandboxPool, getSandboxModeInfo, type SandboxMode, type ISandbox, type ISandboxPool, type SandboxModeInfo, } from "./sandbox-factory.js";
+export { CodeModeSecurityManager } from "./security.js";
+export { SqliteApi, createSqliteApi } from "./api.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/codemode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codemode/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,cAAc,EACd,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG5D,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}