opencode-swarm 7.121.3 → 7.121.4

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-fs2q8jyf.js";
+} from "./index-q0fv0xec.js";
 import"./index-kyvg2cmp.js";
 import"./index-vqcgmy4y.js";
 import"./index-emkb0bbe.js";

package/dist/db/index.d.ts

@@ -7,7 +7,11 @@
  *   normalized directory path.
  * - `qa-gate-profile`: service layer for per-plan QA gate profiles stored
  *   in the project DB.
+ * - `sqlite-loader`: runtime-portable SQLite `Database` constructor resolver
+ *   (native `bun:sqlite` under Bun, a `node:sqlite` adapter under Node — issue
+ *   #1873). Used by `global-db`, `project-db`, and the memory SQLite provider.
  */
 export { closeGlobalDb, getGlobalDb, runGlobalMigrations, } from './global-db.js';
 export { closeAllProjectDbs, closeProjectDb, getProjectDb, projectDbExists, projectDbPath, runProjectMigrations, } from './project-db.js';
 export { computeProfileHash, DEFAULT_QA_GATES, getEffectiveGates, getOrCreateProfile, getProfile, lockProfile, type QaGateProfile, type QaGates, setGates, } from './qa-gate-profile.js';
+export { loadDatabaseCtor } from './sqlite-loader.js';

package/dist/db/sqlite-loader.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Runtime-portable SQLite driver loader for opencode-swarm.
+ *
+ * Why this exists (issue #1873): the published plugin bundle (`dist/index.js`) is
+ * built `--target node` and OpenCode Desktop loads it inside a **Node.js** Electron
+ * `utilityProcess` sidecar. The previous DB layer resolved the driver with a lazy
+ * `createRequire(import.meta.url)('bun:sqlite')` and **no fallback**. `bun:sqlite` is
+ * a Bun-only built-in, so under Node every SQLite-backed tool threw
+ * `Error: Cannot find module 'bun:sqlite'` (`swarm_memory_recall`, the QA-gate tools,
+ * `get_approved_plan`, …).
+ *
+ * The lazy require kept `bun:sqlite` out of the bundle's top-level ESM imports (which
+ * is what invariant #2 / issue #675 requires — a static `import … from 'bun:…'` breaks
+ * Node's ESM resolver with `ERR_UNSUPPORTED_ESM_URL_SCHEME`), but it still assumed a
+ * Bun runtime at call time.
+ *
+ * This module is the single, sanctioned place that resolves a `bun:sqlite`-shaped
+ * `Database` constructor:
+ *   1. Under Bun: return the native `bun:sqlite` `Database` (behaviour unchanged).
+ *   2. Under Node: wrap `node:sqlite`'s `DatabaseSync` (flag-free in Node 22.13+; added
+ *      behind `--experimental-sqlite` in 22.5; shipped by Electron 42+) in a small
+ *      adapter that presents the exact `Database` subset the
+ *      codebase uses — `run(sql, params?)`, `query(sql).{get,all,iterate}`,
+ *      `transaction(fn)`, `inTransaction`, `loadExtension(path)`, `close()`. A bare
+ *      constructor swap is NOT enough: `DatabaseSync` has none of
+ *      `run/query/transaction/inTransaction`.
+ *   3. If neither driver is available: throw one clear, combined diagnostic.
+ *
+ * Portability contract (invariant #2): all three former call sites
+ * (`project-db.ts`, `global-db.ts`, `memory/sqlite-provider.ts`) now import
+ * `loadDatabaseCtor` from here. No new lazy `require('bun:…')` may be added elsewhere —
+ * `tests/unit/build/bundle-portability.test.ts` enforces this statically, and
+ * `scripts/repro-1873.mjs` exercises the real Node driver end-to-end in CI.
+ */
+import type { Database } from 'bun:sqlite';
+interface NodeStatementSync {
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+    iterate(...params: unknown[]): IterableIterator<unknown>;
+    run(...params: unknown[]): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+}
+interface NodeDatabaseSync {
+    exec(sql: string): void;
+    prepare(sql: string): NodeStatementSync;
+    readonly isTransaction: boolean;
+    enableLoadExtension(enable: boolean): void;
+    loadExtension(path: string): void;
+    close(): void;
+}
+type NodeDatabaseSyncCtor = new (filename: string, options?: {
+    allowExtension?: boolean;
+}) => NodeDatabaseSync;
+/**
+ * Build a `bun:sqlite`-`Database`-compatible constructor backed by `node:sqlite`'s
+ * `DatabaseSync`. Exported for direct unit testing under Bun (which lacks
+ * `node:sqlite`) via an injected fake `DatabaseSync`.
+ */
+export declare function createNodeDatabaseCtor(DatabaseSyncCtor: NodeDatabaseSyncCtor): typeof Database;
+/**
+ * Internal seam for tests: `requireModule` is dependency-injected so a Bun test can
+ * force the Node fallback path with a fake `node:sqlite`, and `reset()` clears the
+ * module-level cache between cases. Not part of the public API.
+ */
+export declare const _internals: {
+    requireModule(id: string): unknown;
+    reset(): void;
+};
+/**
+ * Resolve a `bun:sqlite`-`Database`-compatible constructor for the current runtime.
+ * Cached after first resolution.
+ *
+ * Order: native `bun:sqlite` (Bun) → `node:sqlite` adapter (Node) → clear error.
+ */
+export declare function loadDatabaseCtor(): typeof Database;
+export {};