@cortexkit/opencode-magic-context 0.35.0 → 0.35.1

package/src/shared/sqlite.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "bun:test";
+import { loadSqliteModule, SqliteRuntimeUnavailableError } from "./sqlite";
+
+describe("SQLite runtime selector", () => {
+    it("wraps a missing node:sqlite module with the detected runtime and cause", async () => {
+        const cause = Object.assign(new Error("No such built-in module: node:sqlite"), {
+            code: "ERR_UNKNOWN_BUILTIN_MODULE",
+            name: "ResolveMessage",
+        });
+        let requestedSpecifier = "";
+        let thrown: unknown;
+
+        try {
+            await loadSqliteModule("Node.js", async (specifier) => {
+                requestedSpecifier = specifier;
+                throw cause;
+            });
+        } catch (error) {
+            thrown = error;
+        }
+
+        expect(requestedSpecifier).toBe("node:sqlite");
+        expect(thrown).toBeInstanceOf(SqliteRuntimeUnavailableError);
+        const compatibilityError = thrown as SqliteRuntimeUnavailableError;
+        expect(compatibilityError.runtime).toBe("Node.js");
+        expect(compatibilityError.specifier).toBe("node:sqlite");
+        expect(compatibilityError.message).toContain("Node.js >= 24");
+        expect(compatibilityError.message).toContain("Bun with bun:sqlite");
+        expect(compatibilityError.message).toContain("node:sqlite");
+        expect(compatibilityError.cause).toBe(cause);
+    });
+});

package/src/shared/sqlite.ts

@@ -45,12 +45,25 @@
 // node:sqlite at runtime (both expose prepare/run/get/all/exec/close).
 import type BetterSqlite3 from "better-sqlite3";
 
-// Detect Bun via process.versions.bun. Both globalThis.Bun and
-// process.versions.bun are set by the Bun runtime, but process.versions
-// is a lower-level surface less likely to be sandboxed by host runtimes
-// (e.g. Electron in OpenCode desktop apps that re-expose a Bun-flavored
-// environment). Real Node and Electron never set this field.
-const isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+export type SqliteRuntime = "Bun" | "Node.js";
+
+type SqliteModule = {
+    Database?: unknown;
+    DatabaseSync?: unknown;
+};
+
+export function detectSqliteRuntime(): SqliteRuntime {
+    // process.versions.bun is the least ambiguous marker, but some launchers
+    // proxy or partially sandbox process. Keep globalThis.Bun as a fallback so
+    // a Bun process does not accidentally select node:sqlite just because its
+    // process compatibility surface was trimmed.
+    const hasBunVersion =
+        typeof process !== "undefined" && typeof process.versions?.bun === "string";
+    const hasBunGlobal =
+        typeof globalThis !== "undefined" &&
+        typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+    return hasBunVersion || hasBunGlobal ? "Bun" : "Node.js";
+}
 
 // IMPORTANT: bundler-evading dynamic imports.
 //
@@ -69,9 +82,72 @@ const isBun = typeof process !== "undefined" && typeof process.versions?.bun ===
 const bunSpec = "bun:" + "sqlite";
 const nodeSpec = "node:" + "sqlite";
 
-const sqliteModule = isBun
-    ? await import(/* @vite-ignore */ bunSpec)
-    : await import(/* @vite-ignore */ nodeSpec);
+async function importSqliteModule(specifier: string): Promise<SqliteModule> {
+    // The runtime chooses this specifier; Vite must not resolve it as a
+    // build-time dependency because the other runtime's backend is absent.
+    return (await import(
+        /* @vite-ignore -- keep the runtime-selected backend unresolved */ specifier
+    )) as SqliteModule;
+}
+
+function isModuleNotFoundError(error: unknown, specifier: string): boolean {
+    const candidate = error as { code?: unknown; name?: unknown } | null;
+    const code = typeof candidate?.code === "string" ? candidate.code : "";
+    const name = typeof candidate?.name === "string" ? candidate.name : "";
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    const details = `${code} ${name} ${message}`.toLowerCase();
+    const mentionsSpecifier = details.includes(specifier.toLowerCase());
+    if (!mentionsSpecifier) return false;
+
+    return (
+        code === "ERR_MODULE_NOT_FOUND" ||
+        code === "ERR_UNKNOWN_BUILTIN_MODULE" ||
+        code === "MODULE_NOT_FOUND" ||
+        name === "ResolveMessage" ||
+        details.includes("module not found") ||
+        details.includes("cannot find module") ||
+        details.includes("cannot find package") ||
+        details.includes("no such built-in module")
+    );
+}
+
+export class SqliteRuntimeUnavailableError extends Error {
+    readonly runtime: SqliteRuntime;
+    readonly specifier: string;
+
+    constructor(runtime: SqliteRuntime, specifier: string, cause: unknown) {
+        const requirement =
+            specifier === nodeSpec
+                ? "Requires Node.js >= 24, or Bun with bun:sqlite — this Bun build lacks node:sqlite."
+                : "Requires Bun with bun:sqlite, or Node.js >= 24 — this Bun build lacks bun:sqlite.";
+        super(
+            `Magic Context detected ${runtime}, but could not load ${specifier}. ${requirement}`,
+            { cause },
+        );
+        this.name = "SqliteRuntimeUnavailableError";
+        this.runtime = runtime;
+        this.specifier = specifier;
+    }
+}
+
+export async function loadSqliteModule(
+    runtime: SqliteRuntime = detectSqliteRuntime(),
+    importer: (specifier: string) => Promise<SqliteModule> = importSqliteModule,
+): Promise<SqliteModule> {
+    const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
+    try {
+        return await importer(specifier);
+    } catch (error) {
+        if (isModuleNotFoundError(error, specifier)) {
+            throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
+        }
+        throw error;
+    }
+}
+
+const detectedRuntime = detectSqliteRuntime();
+const isBun = detectedRuntime === "Bun";
+const sqliteModule = await loadSqliteModule(detectedRuntime);
 
 // Different export shapes between the two backends:
 //   - bun:sqlite  → named export `Database` (has its own .transaction, accepts