@4da/mcp-server 6.0.1 → 6.1.0

package/dist/setup.js

@@ -7,160 +7,343 @@
  * the user can start using 4DA tools immediately after install.
  *
  * Usage:
- *   npx @4da/mcp-server --setup
- *   4da-mcp-setup
+ *   npx @4da/mcp-server --setup [--dry-run]
+ *   4da-mcp-setup [--dry-run]
  *   pnpm run setup
+ *
+ * Audited 2026-10-05: three of the four editors were configured in files the
+ * editor never reads (`~/.vscode/mcp.json`, `~/.windsurf/mcp.json`, and
+ * `mcpServers` in a project's `.claude/settings.json`), and any config file
+ * that failed `JSON.parse` (VS Code's `mcp.json` is JSONC: comments and
+ * trailing commas are legal) was replaced by `{}` plus our entry, deleting
+ * every other server the user had. Each path below cites the doc it was
+ * checked against, and a file that cannot be parsed is never written.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
 import { homedir } from "node:os";
+import jsonc from "jsonc-parser";
+/** The command every editor runs. */
+const SERVER_COMMAND = { command: "npx", args: ["@4da/mcp-server"] };
 /** MCP config snippet for editors that use the standard mcpServers format */
 const MCP_CONFIG = {
-    "4da": {
-        command: "npx",
-        args: ["@4da/mcp-server"],
-    },
+    "4da": SERVER_COMMAND,
 };
+/** The Claude Code command printed instead of editing `~/.claude.json`. */
+export const CLAUDE_CODE_COMMAND = "claude mcp add --scope user 4da -- npx @4da/mcp-server";
+export function currentContext() {
+    return { platform: process.platform, env: process.env, home: homedir() };
+}
+function pathFor(ctx) {
+    return ctx.platform === "win32" ? path.win32 : path.posix;
+}
+/** `%APPDATA%` on Windows, the Electron-style config base elsewhere. */
+function roamingDir(ctx) {
+    const p = pathFor(ctx);
+    return ctx.env.APPDATA?.trim() || p.join(ctx.home, "AppData", "Roaming");
+}
+function xdgConfigDir(ctx) {
+    return ctx.env.XDG_CONFIG_HOME?.trim() || pathFor(ctx).join(ctx.home, ".config");
+}
 /**
- * Safely read and parse a JSON file, returning empty object on failure.
+ * The per-platform user-data dir of a desktop app (Electron `appData`):
+ * `%APPDATA%\<name>`, `~/Library/Application Support/<name>`,
+ * `$XDG_CONFIG_HOME/<name>` (default `~/.config/<name>`).
  */
-function readJsonSafe(filePath) {
-    if (!existsSync(filePath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return {};
-    }
+function appDataDir(ctx, name) {
+    const p = pathFor(ctx);
+    if (ctx.platform === "win32")
+        return p.join(roamingDir(ctx), name);
+    if (ctx.platform === "darwin")
+        return p.join(ctx.home, "Library", "Application Support", name);
+    return p.join(xdgConfigDir(ctx), name);
 }
 /**
- * Ensure directory exists and write JSON to file.
+ * Every editor this setup can write, with its config path on `ctx.platform`.
+ * Pure: nothing is read from disk here.
  */
-function writeJsonFile(filePath, data) {
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-const editors = [
-    {
-        name: "Claude Code",
-        detect: () => {
-            // Project-level config takes priority
-            const projectClaudeDir = join(process.cwd(), ".claude");
-            if (existsSync(projectClaudeDir)) {
-                return join(projectClaudeDir, "settings.json");
-            }
-            // Fall back to global config
-            return join(homedir(), ".claude.json");
-        },
-        write: (configPath) => {
-            const config = readJsonSafe(configPath);
-            const mcpServers = (config.mcpServers || {});
-            mcpServers["4da"] = MCP_CONFIG["4da"];
-            config.mcpServers = mcpServers;
-            writeJsonFile(configPath, config);
-            console.log(`  Written: ${configPath}`);
-        },
-    },
-    {
-        name: "Cursor",
-        detect: () => {
-            const cursorDir = join(homedir(), ".cursor");
-            if (existsSync(cursorDir)) {
-                return join(cursorDir, "mcp.json");
-            }
-            return null;
-        },
-        write: (configPath) => {
-            const config = readJsonSafe(configPath);
-            const mcpServers = (config.mcpServers || {});
-            mcpServers["4da"] = MCP_CONFIG["4da"];
-            config.mcpServers = mcpServers;
-            writeJsonFile(configPath, config);
-            console.log(`  Written: ${configPath}`);
-        },
-    },
-    {
-        name: "VS Code (Copilot)",
-        detect: () => {
-            const vscodePath = join(homedir(), ".vscode");
-            if (existsSync(vscodePath)) {
-                return join(vscodePath, "mcp.json");
-            }
-            return null;
+export function editorTargets(ctx = currentContext()) {
+    const p = pathFor(ctx);
+    const vscodeEntry = { type: "stdio", ...SERVER_COMMAND };
+    const vscode = (name, product) => {
+        const userDir = p.join(appDataDir(ctx, product), "User");
+        return {
+            name,
+            // The default profile's user-level file; it sits beside settings.json.
+            // A non-default profile keeps its own under User/profiles/<id>/, which
+            // VS Code does not name anywhere setup could find it.
+            configPath: p.join(userDir, "mcp.json"),
+            detectDir: userDir,
+            key: "servers",
+            entry: vscodeEntry,
+            docs: "https://code.visualstudio.com/docs/copilot/reference/mcp-configuration",
+        };
+    };
+    const devinDir = ctx.platform === "win32" ? p.join(roamingDir(ctx), "devin") : p.join(xdgConfigDir(ctx), "devin");
+    const windsurfDir = p.join(ctx.home, ".codeium", "windsurf");
+    return [
+        {
+            name: "Cursor",
+            configPath: p.join(ctx.home, ".cursor", "mcp.json"),
+            detectDir: p.join(ctx.home, ".cursor"),
+            key: "mcpServers",
+            entry: SERVER_COMMAND,
+            docs: "https://cursor.com/docs/mcp",
         },
-        write: (configPath) => {
-            const config = readJsonSafe(configPath);
-            // VS Code uses "servers" key instead of "mcpServers"
-            const servers = (config.servers || {});
-            servers["4da"] = {
-                type: "stdio",
-                command: "npx",
-                args: ["@4da/mcp-server"],
-            };
-            config.servers = servers;
-            writeJsonFile(configPath, config);
-            console.log(`  Written: ${configPath}`);
+        vscode("VS Code (Copilot)", "Code"),
+        vscode("VS Code Insiders (Copilot)", "Code - Insiders"),
+        {
+            name: "Windsurf",
+            configPath: p.join(windsurfDir, "mcp_config.json"),
+            detectDir: windsurfDir,
+            key: "mcpServers",
+            entry: SERVER_COMMAND,
+            docs: "https://docs.devin.ai/cli/reference/configuration/read-config-from",
         },
-    },
-    {
-        name: "Windsurf",
-        detect: () => {
-            const windsurfDir = join(homedir(), ".windsurf");
-            if (existsSync(windsurfDir)) {
-                return join(windsurfDir, "mcp.json");
-            }
-            return null;
+        {
+            // Windsurf's successor. Its Cascade agent and the Devin CLI read the
+            // same user-level file.
+            name: "Devin Desktop / Devin CLI",
+            configPath: p.join(devinDir, "mcp_config.json"),
+            detectDir: devinDir,
+            key: "mcpServers",
+            entry: SERVER_COMMAND,
+            docs: "https://docs.devin.ai/desktop/cascade/mcp",
         },
-        write: (configPath) => {
-            const config = readJsonSafe(configPath);
-            const mcpServers = (config.mcpServers || {});
-            mcpServers["4da"] = MCP_CONFIG["4da"];
-            config.mcpServers = mcpServers;
-            writeJsonFile(configPath, config);
-            console.log(`  Written: ${configPath}`);
+        {
+            name: "Claude Desktop",
+            configPath: p.join(appDataDir(ctx, "Claude"), "claude_desktop_config.json"),
+            detectDir: appDataDir(ctx, "Claude"),
+            key: "mcpServers",
+            entry: SERVER_COMMAND,
+            docs: "https://modelcontextprotocol.io/docs/develop/connect-local-servers",
         },
-    },
-];
+    ];
+}
+/**
+ * Claude Code keeps user- and local-scope servers in `~/.claude.json`
+ * (`$CLAUDE_CONFIG_DIR/.claude.json` when set), a file it rewrites itself and
+ * that also holds the sign-in session and per-project state. Setup never
+ * edits it: it prints the `claude mcp add` command, which does.
+ * https://code.claude.com/docs/en/mcp
+ */
+export function claudeCodeConfigPath(ctx = currentContext()) {
+    const p = pathFor(ctx);
+    const configDir = ctx.env.CLAUDE_CONFIG_DIR?.trim();
+    return configDir ? p.join(configDir, ".claude.json") : p.join(ctx.home, ".claude.json");
+}
+function lineOf(text, offset) {
+    return text.slice(0, offset).split("\n").length;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sameJson(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+/**
+ * Decide what writing `entry` under `<key>["4da"]` does to a config file whose
+ * current text is `existing` (null when it does not exist).
+ *
+ * The file is parsed as JSONC (comments and trailing commas allowed) and
+ * edited in place with `jsonc-parser`'s `modify`, so other servers, other keys,
+ * comments and formatting all survive. A file that does not parse is refused,
+ * never replaced. An existing `4da` entry keeps its other fields (`env`, say);
+ * only the fields setup owns are set.
+ */
+export function planConfig(existing, key, entry) {
+    if (existing === null || existing.trim() === "") {
+        return {
+            action: existing === null ? "create" : "update",
+            content: JSON.stringify({ [key]: { "4da": entry } }, null, 2) + "\n",
+        };
+    }
+    const errors = [];
+    const root = jsonc.parse(existing, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length > 0) {
+        const first = errors[0];
+        return {
+            action: "refuse",
+            reason: `it does not parse (${jsonc.printParseErrorCode(first.error)} at line ${lineOf(existing, first.offset)})`,
+        };
+    }
+    if (!isPlainObject(root)) {
+        return { action: "refuse", reason: "its top level is not a JSON object" };
+    }
+    const servers = root[key];
+    if (servers !== undefined && !isPlainObject(servers)) {
+        return { action: "refuse", reason: `its "${key}" is not an object` };
+    }
+    const current = servers?.["4da"];
+    if (current !== undefined && !isPlainObject(current)) {
+        return { action: "refuse", reason: `its "${key}"."4da" is not an object` };
+    }
+    if (current && Object.entries(entry).every(([field, value]) => sameJson(current[field], value))) {
+        return { action: "unchanged" };
+    }
+    const eol = existing.includes("\r\n") ? "\r\n" : "\n";
+    const indent = /^([ \t]+)\S/m.exec(existing)?.[1] ?? "  ";
+    const formattingOptions = {
+        insertSpaces: !indent.startsWith("\t"),
+        tabSize: indent.startsWith("\t") ? 1 : indent.length,
+        eol,
+    };
+    let content = existing;
+    // Field by field when the entry exists, so its other fields and any
+    // comments inside it stay; whole when it does not.
+    const edits = current
+        ? Object.entries(entry).map(([field, value]) => [[key, "4da", field], value])
+        : [[[key, "4da"], entry]];
+    for (const [jsonPath, value] of edits) {
+        content = jsonc.applyEdits(content, jsonc.modify(content, jsonPath, value, { formattingOptions }));
+    }
+    return { action: "update", content };
+}
+/** Read a config file's text; null when it does not exist. */
+function readConfig(filePath) {
+    return existsSync(filePath) ? readFileSync(filePath, "utf-8") : null;
+}
+/** `<file>.bak`, or a timestamped name when that is taken: an earlier backup is never overwritten. */
+function backupPath(filePath) {
+    const plain = `${filePath}.bak`;
+    if (!existsSync(plain))
+        return plain;
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..*$/, "");
+    for (let n = 0;; n++) {
+        const candidate = `${filePath}.${stamp}${n === 0 ? "" : `-${n}`}.bak`;
+        if (!existsSync(candidate))
+            return candidate;
+    }
+}
+/**
+ * Write `content` to `filePath`: back up an existing file first, then write a
+ * temp file beside it and rename it over the original, so an interrupted run
+ * leaves either the old file or the new one, never half of one. A symlinked
+ * config (a dotfiles repo) is written through to its target.
+ * @returns The backup path, when one was made.
+ */
+export function writeConfigAtomic(filePath, content) {
+    // Only a symlinked file is resolved: resolving the whole path would turn
+    // macOS's /var/... into /private/var/... in every path reported back.
+    const target = existsSync(filePath) && lstatSync(filePath).isSymbolicLink() ? realpathSync(filePath) : filePath;
+    mkdirSync(path.dirname(target), { recursive: true });
+    let backup = null;
+    if (existsSync(target)) {
+        backup = backupPath(target);
+        copyFileSync(target, backup);
+    }
+    const temp = `${target}.4da-${process.pid}.tmp`;
+    try {
+        writeFileSync(temp, content);
+        renameSync(temp, target);
+    }
+    catch (error) {
+        rmSync(temp, { force: true });
+        throw error;
+    }
+    return backup;
+}
+/** The snippet an editor gets, as printed in a dry run and for manual setup. */
+function snippet(target) {
+    return JSON.stringify({ [target.key]: { "4da": target.entry } }, null, 2)
+        .split("\n")
+        .map((line) => `    ${line}`)
+        .join("\n");
+}
+/** Whether `~/.claude.json` already has a user-scope `4da` server. Read-only. */
+function claudeCodeHas4da(configPath) {
+    try {
+        const root = JSON.parse(readFileSync(configPath, "utf-8"));
+        return isPlainObject(root) && isPlainObject(root.mcpServers) && "4da" in root.mcpServers;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Run the setup wizard: detect editors and write MCP configurations.
  * @param dryRun If true, only report what would be written without modifying files.
  */
-export function runSetup(dryRun = false) {
-    console.log("\n  4DA MCP Server — Setup\n");
+export function runSetup(dryRun = false, ctx = currentContext(), log = console.log) {
+    log("\n  4DA MCP Server — Setup\n");
     if (dryRun)
-        console.log("  [DRY RUN] No files will be modified.\n");
-    console.log("  Detecting editors...\n");
-    let configured = 0;
-    for (const editor of editors) {
-        const configPath = editor.detect();
-        if (configPath) {
-            console.log(`  Found: ${editor.name}`);
-            if (dryRun) {
-                console.log(`  Would write: ${configPath}`);
+        log("  [DRY RUN] No files will be modified.\n");
+    log("  Detecting editors...\n");
+    let found = 0;
+    let refused = 0;
+    // Claude Code: print the command, never edit ~/.claude.json.
+    const claudeJson = claudeCodeConfigPath(ctx);
+    const claudeDir = pathFor(ctx).join(ctx.home, ".claude");
+    if (existsSync(claudeJson) || existsSync(claudeDir)) {
+        found++;
+        log("  Found: Claude Code");
+        if (claudeCodeHas4da(claudeJson)) {
+            log(`  Already configured (user scope, ${claudeJson}).`);
+        }
+        else {
+            log("  Claude Code keeps its MCP servers in ~/.claude.json, which it rewrites");
+            log("  itself; setup does not edit it. Add the server with:");
+            log(`    ${CLAUDE_CODE_COMMAND}`);
+        }
+        log("");
+    }
+    for (const target of editorTargets(ctx)) {
+        if (!existsSync(target.detectDir))
+            continue;
+        found++;
+        log(`  Found: ${target.name}`);
+        let plan;
+        try {
+            plan = planConfig(readConfig(target.configPath), target.key, target.entry);
+        }
+        catch (error) {
+            plan = { action: "refuse", reason: `it could not be read (${error instanceof Error ? error.message : String(error)})` };
+        }
+        if (plan.action === "unchanged") {
+            log(`  Already configured: ${target.configPath}`);
+        }
+        else if (plan.action === "refuse") {
+            refused++;
+            log(`  Not modified: ${target.configPath}`);
+            log(`  Setup left it untouched because ${plan.reason}. Add this by hand:`);
+            log(snippet(target));
+        }
+        else if (dryRun) {
+            log(`  Would ${plan.action === "create" ? "create" : "update"}: ${target.configPath}`);
+            log(`  Adding under "${target.key}":`);
+            log(snippet(target));
+        }
+        else {
+            try {
+                const backup = writeConfigAtomic(target.configPath, plan.content ?? "");
+                log(`  Written: ${target.configPath}`);
+                if (backup)
+                    log(`  Backup:  ${backup}`);
             }
-            else {
-                editor.write(configPath);
+            catch (error) {
+                refused++;
+                log(`  Could not write ${target.configPath}: ${error instanceof Error ? error.message : String(error)}`);
+                log("  Add this by hand:");
+                log(snippet(target));
             }
-            configured++;
-            console.log("");
         }
+        log("");
+    }
+    if (found === 0) {
+        log("  No supported editors detected.\n");
+        log("  Manual setup — add to your editor's MCP config:\n");
+        log(`  ${JSON.stringify({ mcpServers: MCP_CONFIG }, null, 2)}\n`);
+        log(`  Claude Code: ${CLAUDE_CODE_COMMAND}\n`);
     }
-    if (configured === 0) {
-        console.log("  No supported editors detected.\n");
-        console.log("  Manual setup — add to your editor's MCP config:\n");
-        console.log(`  ${JSON.stringify(MCP_CONFIG, null, 2)}\n`);
-    }
-    console.log("  Done. Restart your editor to activate 4DA.");
-    console.log("");
-    console.log("  Note: This server reads data from the 4DA desktop app.");
-    console.log("  If you haven't installed it yet:");
-    console.log("    https://github.com/4DA-Systems/4DA/releases/latest");
-    console.log("");
-    console.log("  Run: npx @4da/mcp-server --doctor  to verify everything works.\n");
+    if (refused > 0)
+        log(`  ${refused} config file${refused === 1 ? " needs" : "s need"} the entry added by hand (above).`);
+    log("  Done. Restart your editor to activate 4DA.");
+    log("");
+    log("  The server works on its own; with the 4DA desktop app installed it");
+    log("  also reads the app's scored feed:");
+    log("    https://github.com/4DA-Systems/4DA/releases/latest");
+    log("");
+    log("  Run: npx @4da/mcp-server --doctor  to verify everything works.\n");
 }
 // Run directly if invoked as a script (bin entry or pnpm run setup)
 const isDirectRun = process.argv[1]?.endsWith("setup.js") || process.argv[1]?.endsWith("setup.ts");

package/dist/sqlite-driver.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The SQLite driver: Node's built-in `node:sqlite` when the runtime has it,
+ * otherwise better-sqlite3, behind one interface.
+ *
+ * Why: npm 12 blocks dependency install scripts unless allowed, so a default
+ * `npx @4da/mcp-server` or `npm install` left better-sqlite3's native module
+ * unbuilt and every tool failed (measured 2026-10-03 on npm 12.2.0, see
+ * native-bindings.ts). `node:sqlite` ships inside Node: no install script, no
+ * native download. It is available without a flag from Node 22.13.0 (and
+ * 23.4.0); npm 12 itself requires Node ^22.22.2 || ^24.15.0 || >=26, so every
+ * npm 12 install has it. better-sqlite3 is an optional dependency now, used on
+ * Node 22.0-22.12 where it builds (npm 10 and 11 run its install script).
+ *
+ * The interface is the subset of better-sqlite3 this server uses: open
+ * options `readonly` / `fileMustExist`, prepare().get/all/run (positional
+ * parameters, arrays flattened, or one object of named parameters), exec,
+ * pragma (incl. `{ simple: true }`), transaction (nested calls become
+ * savepoints), close, and the `open` / `readonly` / `name` properties.
+ * better-sqlite3's Database satisfies it as is; node:sqlite is adapted
+ * (NodeSqliteDatabase) so that rows, BLOBs, error codes and the 5 s busy
+ * timeout match what the server's code already expects.
+ *
+ * `FOURDA_SQLITE_DRIVER=node|better` forces one driver (tests, diagnostics):
+ * a forced driver that cannot load is reported, never silently replaced.
+ * `none` simulates a host where neither works.
+ */
+export interface SqliteRunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+export interface SqliteStatement {
+    run(...params: unknown[]): SqliteRunResult;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+export interface SqliteOpenOptions {
+    readonly?: boolean;
+    fileMustExist?: boolean;
+}
+/** The subset of better-sqlite3's Database the server uses; both drivers provide it. */
+export interface SqliteDatabase {
+    prepare(source: string): SqliteStatement;
+    exec(source: string): unknown;
+    pragma(source: string, options?: {
+        simple?: boolean;
+    }): unknown;
+    transaction<F extends (...args: any[]) => unknown>(fn: F): (...args: Parameters<F>) => ReturnType<F>;
+    close(): unknown;
+    readonly open: boolean;
+    readonly readonly: boolean;
+    readonly name: string;
+}
+export type SqliteDriverName = "node:sqlite" | "better-sqlite3";
+export interface SqliteDriver {
+    name: SqliteDriverName;
+    open(file: string, options?: SqliteOpenOptions): SqliteDatabase;
+}
+/** Thrown by sqliteDriver() when neither driver can open a database here. */
+export declare class SqliteUnavailableError extends Error {
+    readonly code = "FOURDA_NO_SQLITE";
+}
+/** The first Node release with `node:sqlite` unflagged on the 22 line. */
+export declare const NODE_SQLITE_MIN = "22.13.0";
+/** better-sqlite3's error code for a SQLite result code (extended when known, else primary). */
+export declare function sqliteCodeName(errcode: number): string;
+interface NativeStatement {
+    run(...params: unknown[]): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+    setReadBigInts(enabled: boolean): void;
+}
+interface NativeDatabase {
+    prepare(sql: string): NativeStatement;
+    exec(sql: string): void;
+    close(): void;
+}
+type NativeDatabaseCtor = new (path: string, options?: Record<string, unknown>) => NativeDatabase;
+export declare class NodeSqliteDatabase implements SqliteDatabase {
+    readonly name: string;
+    readonly readonly: boolean;
+    private db;
+    private isOpen;
+    private depth;
+    private savepoints;
+    constructor(Ctor: NativeDatabaseCtor, file: string, options?: SqliteOpenOptions);
+    get open(): boolean;
+    private assertOpen;
+    prepare(source: string): SqliteStatement;
+    exec(source: string): this;
+    pragma(source: string, options?: {
+        simple?: boolean;
+    }): unknown;
+    transaction<F extends (...args: any[]) => unknown>(fn: F): (...args: Parameters<F>) => ReturnType<F>;
+    close(): this;
+}
+/** Load node:sqlite without its one-time "SQLite is an experimental feature" warning; every other warning passes. */
+export declare function loadNodeSqlite(): NativeDatabaseCtor;
+type BetterCtor = new (file: string, options?: {
+    readonly?: boolean;
+    fileMustExist?: boolean;
+}) => SqliteDatabase;
+export declare function loadBetterSqlite3(): BetterCtor;
+export interface DriverLoaders {
+    node: () => NativeDatabaseCtor;
+    better: () => BetterCtor;
+}
+export interface DriverResolution {
+    driver: SqliteDriver | null;
+    /** Why each driver tried was not used (empty when the first one worked). */
+    rejected: {
+        name: SqliteDriverName;
+        reason: string;
+    }[];
+    /** The actionable message when no driver is usable. */
+    problem: string | null;
+}
+/**
+ * Pick the driver: node:sqlite, then better-sqlite3 if its native module
+ * actually opens a database (importing it succeeds without one). Pure apart
+ * from the loaders, so tests can make either one fail.
+ */
+export declare function resolveSqliteDriver(loaders?: DriverLoaders, env?: NodeJS.ProcessEnv): DriverResolution;
+/** The resolution for this process (computed once). */
+export declare function sqliteDriverStatus(): DriverResolution;
+/** The driver in use; throws SqliteUnavailableError with the fix when there is none. */
+export declare function sqliteDriver(): SqliteDriver;
+/** Open a database with the driver in use. */
+export declare function openDatabase(file: string, options?: SqliteOpenOptions): SqliteDatabase;
+/** Forget the cached resolution (tests that change FOURDA_SQLITE_DRIVER). */
+export declare function resetSqliteDriver(): void;
+export {};