@cortexkit/opencode-magic-context 0.44.0 → 0.44.2

package/src/shared/sqlite-acquisition-fence.test.ts

@@ -0,0 +1,132 @@
+import { expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+const root = resolve(import.meta.dir, "../../../..");
+const shared = "packages/plugin/src/shared/sqlite.ts";
+function files(dir: string): string[] {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) return files(path);
+        return /\.tsx?$/.test(path) && !/\.test\.|test-support|\.d\.ts$/.test(path) ? [path] : [];
+    });
+}
+
+function scan(
+    path: string,
+    text: string,
+): { violations: string[]; transactions: number; literals: number } {
+    const violations: string[] = [];
+    let transactions = 0;
+    let literals = 0;
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const visit = (node: ts.Node) => {
+        if (
+            ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            node.expression.name.text === "transaction"
+        )
+            transactions++;
+        if (
+            path !== shared &&
+            ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            !node.importClause?.isTypeOnly &&
+            /^(bun:sqlite|node:sqlite|better-sqlite3)$/.test(node.moduleSpecifier.text)
+        ) {
+            violations.push(`${path}: native SQLite import bypasses shared acquisition`);
+        }
+        if (
+            path !== shared &&
+            ts.isExportDeclaration(node) &&
+            !node.isTypeOnly &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            /^(bun:sqlite|node:sqlite|better-sqlite3)$/.test(node.moduleSpecifier.text)
+        ) {
+            violations.push(`${path}: native SQLite re-export bypasses shared acquisition`);
+        }
+        if (
+            path !== shared &&
+            ts.isCallExpression(node) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) && node.expression.text === "require")) &&
+            /(?:bun:sqlite|node:sqlite|better-sqlite3)/.test(
+                node.arguments.map((arg) => arg.getText(source)).join(""),
+            )
+        ) {
+            violations.push(`${path}: dynamic native SQLite import bypasses shared acquisition`);
+        }
+        const sqlText = ts.isStringLiteralLike(node)
+            ? node.text
+            : ts.isTemplateExpression(node)
+              ? node.head.text + node.templateSpans.map((span) => span.literal.text).join("")
+              : undefined;
+        if (
+            sqlText !== undefined &&
+            /\bBEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*(?:;|$)/i.test(sqlText)
+        ) {
+            literals++;
+            if (path !== shared) {
+                const call = node.parent;
+                const routed =
+                    !ts.isTemplateExpression(node) &&
+                    ts.isCallExpression(call) &&
+                    ts.isPropertyAccessExpression(call.expression) &&
+                    call.expression.name.text === "exec" &&
+                    /^\s*BEGIN\s+(IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sqlText);
+                if (!routed)
+                    violations.push(
+                        `${path}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: BEGIN acquisition must be a standalone shared Database.exec call`,
+                    );
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return { violations, transactions, literals };
+}
+
+test("all production transaction acquisition routes through the shared SQLite runtime", () => {
+    const scans = ["packages/plugin/src", "packages/pi-plugin/src", "packages/cli/src"]
+        .flatMap((directory) => files(join(root, directory)))
+        .map((path) => scan(relative(root, path), readFileSync(path, "utf8")));
+    expect(scans.reduce((sum, scan) => sum + scan.transactions, 0)).toBeGreaterThan(50);
+    expect(scans.reduce((sum, scan) => sum + scan.literals, 0)).toBeGreaterThan(20);
+    expect(scans.flatMap((scan) => scan.violations)).toEqual([]);
+});
+
+test("acquisition fence rejects raw native transactions and unrouted BEGIN shapes", () => {
+    expect(
+        scan(
+            "new-writer.ts",
+            'import { Database } from "bun:sqlite"; new Database(":memory:").transaction(() => write())();',
+        ).violations,
+    ).toHaveLength(1);
+    expect(
+        scan(
+            "new-writer.ts",
+            'const { DatabaseSync } = require("node:sqlite"); new DatabaseSync(":memory:").transaction(() => write())();',
+        ).violations,
+    ).toHaveLength(1);
+    expect(scan("new-writer.ts", 'export { Database } from "bun:sqlite";').violations).toHaveLength(
+        1,
+    );
+    expect(scan("new-writer.ts", 'db.prepare("BEGIN IMMEDIATE").run();').violations).toHaveLength(
+        1,
+    );
+    expect(
+        scan("new-writer.ts", 'db.exec("BEGIN IMMEDIATE; INSERT INTO result VALUES (1)");')
+            .violations,
+    ).toHaveLength(1);
+    expect(scan("new-writer.ts", "db.exec(`BEGIN IMMEDIATE; ${extra}`);").violations).toHaveLength(
+        1,
+    );
+    expect(
+        scan(
+            "new-writer.ts",
+            'import { Database } from "./shared/sqlite"; db.exec("BEGIN IMMEDIATE"); db.transaction(() => write()).immediate();',
+        ).violations,
+    ).toEqual([]);
+});

package/src/shared/sqlite-acquisition-routing.test.ts

@@ -0,0 +1,94 @@
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database, withPrivilegedWriter, withSqliteTransformPass } from "./sqlite";
+import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
+
+for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
+    test(`shared SQLite retries ${mode} acquisition before running any writes`, async () => {
+        const dir = mkdtempSync(join(tmpdir(), "mc-routed-acquisition-"));
+        const path = join(dir, "context.db");
+        const db = new Database(path);
+        db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=50; CREATE TABLE result(value TEXT)");
+        const locker = await startSqliteWriteLocker(path, 650);
+        let calls = 0;
+        const write = () => {
+            calls++;
+            db.prepare("INSERT INTO result VALUES (?)").run("once");
+            return "managed";
+        };
+        try {
+            withSqliteTransformPass(() => {
+                if (mode === "literal") {
+                    db.exec("BEGIN IMMEDIATE");
+                    write();
+                    db.exec("COMMIT");
+                } else {
+                    const transaction = db.transaction(write);
+                    expect(mode === "default" ? transaction() : transaction[mode]()).toBe(
+                        "managed",
+                    );
+                }
+            });
+            expect(calls).toBe(1);
+            expect(db.prepare("SELECT * FROM result").all()).toEqual([{ value: "once" }]);
+        } finally {
+            await locker.exited;
+            db.close();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }, 30000);
+}
+
+test("routed transactions preserve nesting, receiver, arguments and rollback without callback retries", () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE result(value TEXT)");
+    let calls = 0;
+    const transaction = db.transaction(function (this: { prefix: string }, value: string) {
+        calls++;
+        db.prepare("INSERT INTO result VALUES (?)").run(this.prefix + value);
+        db.transaction(() => {
+            db.exec("INSERT INTO result VALUES ('inner')");
+        }).immediate();
+        throw Object.assign(new Error("busy after writes"), { code: "SQLITE_BUSY" });
+    });
+    try {
+        expect(() =>
+            withSqliteTransformPass(() => transaction.call({ prefix: "outer-" }, "value")),
+        ).toThrow("busy after writes");
+        expect(calls).toBe(1);
+        expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
+    } finally {
+        db.close();
+    }
+});
+
+test("exhausted routed acquisition never enters the callback or multiplies privileged retries", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mc-routed-exhaustion-"));
+    const path = join(dir, "context.db");
+    const blocker = new Database(path);
+    const db = new Database(path);
+    blocker.exec("PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT)");
+    db.exec("PRAGMA busy_timeout=0");
+    blocker.exec("BEGIN IMMEDIATE");
+    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+    let callbacks = 0;
+    try {
+        for (const run of [
+            () => db.transaction(() => callbacks++)(),
+            () => withPrivilegedWriter(db, () => callbacks++),
+        ]) {
+            wait.mockClear();
+            expect(() => withSqliteTransformPass(run)).toThrow("after 3 attempts");
+            expect(wait).toHaveBeenCalledTimes(2);
+            expect(callbacks).toBe(0);
+        }
+    } finally {
+        wait.mockRestore();
+        blocker.exec("ROLLBACK");
+        blocker.close();
+        db.close();
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

package/src/shared/sqlite-pass-scope.test.ts

@@ -0,0 +1,182 @@
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    Database,
+    withoutSqliteTransformPass,
+    withPrivilegedWriter,
+    withSqliteTransformPass,
+} from "./sqlite";
+
+test("background privileged acquisition attempts once without backoff", () => {
+    const db = new Database(":memory:");
+    const error = Object.assign(new Error("original busy"), { code: "SQLITE_BUSY" });
+    const exec = spyOn(db, "exec").mockImplementation(() => {
+        throw error;
+    });
+    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+    let callbacks = 0;
+    try {
+        expect(() => withPrivilegedWriter(db, () => callbacks++)).toThrow("original busy");
+        expect(exec).toHaveBeenCalledTimes(1);
+        expect(wait).not.toHaveBeenCalled();
+        expect(callbacks).toBe(0);
+    } finally {
+        exec.mockRestore();
+        wait.mockRestore();
+        db.close();
+    }
+});
+
+test("background transaction exhausts one five-second busy timeout", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mc-background-busy-"));
+    const path = join(dir, "context.db");
+    const blocker = new Database(path);
+    const writer = new Database(path);
+    blocker.exec("PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT)");
+    writer.exec("PRAGMA busy_timeout=5000");
+    blocker.exec("BEGIN IMMEDIATE");
+    let callbacks = 0;
+    try {
+        const start = performance.now();
+        expect(() => writer.transaction(() => callbacks++)()).toThrow();
+        const elapsed = performance.now() - start;
+        expect(callbacks).toBe(0);
+        expect(elapsed).toBeGreaterThanOrEqual(4500);
+        expect(elapsed).toBeLessThan(7500);
+    } finally {
+        blocker.exec("ROLLBACK");
+        blocker.close();
+        writer.close();
+        rmSync(dir, { recursive: true, force: true });
+    }
+}, 30000);
+
+test("foreground retry scope crosses awaits, nests and excludes detached maintenance", async () => {
+    const db = new Database(":memory:");
+    const error = Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+    const exec = spyOn(db, "exec").mockImplementation(() => {
+        throw error;
+    });
+    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+    const acquire = () =>
+        withPrivilegedWriter(db, () => {
+            throw new Error("callback must not run");
+        });
+    let late: Promise<void> | undefined;
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => {
+        release = resolve;
+    });
+    try {
+        await withSqliteTransformPass(async () => {
+            await Promise.resolve();
+            expect(() => withSqliteTransformPass(acquire)).toThrow("after 3 attempts");
+            expect(exec).toHaveBeenCalledTimes(3);
+            exec.mockClear();
+            wait.mockClear();
+            withoutSqliteTransformPass(() => {
+                expect(acquire).toThrow("busy");
+                expect(exec).toHaveBeenCalledTimes(1);
+                expect(wait).not.toHaveBeenCalled();
+            });
+            exec.mockClear();
+            expect(acquire).toThrow("after 3 attempts");
+            expect(exec).toHaveBeenCalledTimes(3);
+            late = (async () => {
+                await gate;
+                exec.mockClear();
+                wait.mockClear();
+                expect(acquire).toThrow("busy");
+                expect(exec).toHaveBeenCalledTimes(1);
+                expect(wait).not.toHaveBeenCalled();
+            })();
+        });
+        release();
+        await late;
+        exec.mockClear();
+        expect(acquire).toThrow("busy");
+        expect(exec).toHaveBeenCalledTimes(1);
+    } finally {
+        release();
+        exec.mockRestore();
+        wait.mockRestore();
+        db.close();
+    }
+});
+
+test("throwing foreground passes cannot leak retry policy to later work", async () => {
+    const db = new Database(":memory:");
+    const exec = spyOn(db, "exec").mockImplementation(() => {
+        throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+    });
+    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+    try {
+        await expect(
+            withSqliteTransformPass(async () => {
+                throw new Error("pass failed");
+            }),
+        ).rejects.toThrow("pass failed");
+        expect(() => withPrivilegedWriter(db, () => undefined)).toThrow("busy");
+        expect(exec).toHaveBeenCalledTimes(1);
+        expect(wait).not.toHaveBeenCalled();
+    } finally {
+        exec.mockRestore();
+        wait.mockRestore();
+        db.close();
+    }
+});
+
+test("explicit deferred reads on a writable handle do not contend with the writer", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mc-deferred-read-"));
+    const path = join(dir, "context.db");
+    const writer = new Database(path);
+    const reader = new Database(path);
+    writer.exec(
+        "PRAGMA journal_mode=WAL; CREATE TABLE result(value TEXT); INSERT INTO result VALUES ('committed')",
+    );
+    reader.exec("PRAGMA busy_timeout=0");
+    writer.exec("BEGIN IMMEDIATE");
+    writer.exec("INSERT INTO result VALUES ('uncommitted')");
+    try {
+        const rows = withSqliteTransformPass(() =>
+            reader.transaction(() => reader.prepare("SELECT value FROM result").all()).deferred(),
+        );
+        expect(rows).toEqual([{ value: "committed" }]);
+    } finally {
+        writer.exec("ROLLBACK");
+        writer.close();
+        reader.close();
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+test("an explicitly started foreground pass owns its lifetime independently", async () => {
+    const db = new Database(":memory:");
+    const exec = spyOn(db, "exec").mockImplementation(() => {
+        throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+    });
+    const wait = spyOn(Atomics, "wait").mockReturnValue("timed-out");
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => {
+        release = resolve;
+    });
+    let child!: Promise<void>;
+    try {
+        await withSqliteTransformPass(async () => {
+            child = withSqliteTransformPass(async () => {
+                await gate;
+                expect(() => withPrivilegedWriter(db, () => undefined)).toThrow("after 3 attempts");
+                expect(exec).toHaveBeenCalledTimes(3);
+            });
+        });
+        release();
+        await child;
+    } finally {
+        release();
+        exec.mockRestore();
+        wait.mockRestore();
+        db.close();
+    }
+});

package/src/shared/sqlite-transaction-mode-guard.test.ts

@@ -4,14 +4,14 @@ import { join, relative, resolve } from "node:path";
 import ts from "typescript";
 
 /**
- * A deferred transaction (`db.transaction(fn)()`, `.deferred()`, `.default()`)
- * starts with no lock. If it reads before it writes, the write must upgrade a read
+ * An explicitly deferred transaction starts with no writer lock. If it reads before it writes, the write must upgrade a read
  * snapshot to a write lock, and SQLite never runs the busy handler for that
  * upgrade: under another process's write it fails at once with SQLITE_BUSY, or
  * with SQLITE_BUSY_SNAPSHOT when another commit landed after the read, and
  * busy_timeout never applies. Many OpenCode and Pi processes share one context.db,
- * so every transaction that writes must start with `.immediate()` (or
- * `.exclusive()`), which takes the write lock at BEGIN where busy_timeout covers it.
+ * so writing transactions must acquire at BEGIN. The shared runtime defaults
+ * writable handles to IMMEDIATE; plugin/Pi call sites keep their explicit
+ * `.immediate()` / `.exclusive()` declarations as an additional intent fence.
  *
  * Only read-only transactions may stay deferred. Each one is listed here, keyed
  * by file and the nearest named enclosing function, with the reason it never
@@ -26,7 +26,7 @@ const READ_ONLY_DEFERRED_TRANSACTIONS: Record<string, string> = {
 };
 
 const REPOSITORY_ROOT = resolve(import.meta.dir, "../../../..");
-const SOURCE_ROOTS = ["packages/plugin/src", "packages/pi-plugin/src"];
+const SOURCE_ROOTS = ["packages/plugin/src", "packages/pi-plugin/src", "packages/cli/src"];
 const LOCKING_MODES = new Set(["immediate", "exclusive"]);
 
 function sourceFiles(directory: string): string[] {
@@ -56,13 +56,16 @@ function isTransactionCall(node: ts.Node): node is ts.CallExpression {
 }
 
 /** True when `node` is the receiver of a called `.immediate()` / `.exclusive()`. */
-function isCalledWithLockingMode(node: ts.Node): boolean {
+function isCalledWithLockingMode(
+    node: ts.Node,
+    modes: ReadonlySet<string> = LOCKING_MODES,
+): boolean {
     const access = node.parent;
     return (
         access !== undefined &&
         ts.isPropertyAccessExpression(access) &&
         access.expression === node &&
-        LOCKING_MODES.has(access.name.text) &&
+        modes.has(access.name.text) &&
         access.parent !== undefined &&
         ts.isCallExpression(access.parent) &&
         access.parent.expression === access
@@ -92,7 +95,11 @@ function enclosingFunctionName(node: ts.Node): string {
  * A transaction stored in a variable is locking only when every use of that
  * variable calls `.immediate()` or `.exclusive()` on it.
  */
-function storedTransactionLocks(call: ts.CallExpression, source: ts.SourceFile): boolean {
+function storedTransactionLocks(
+    call: ts.CallExpression,
+    source: ts.SourceFile,
+    modes: ReadonlySet<string> = LOCKING_MODES,
+): boolean {
     const declaration = call.parent;
     if (!ts.isVariableDeclaration(declaration) || !ts.isIdentifier(declaration.name)) return false;
     const name = declaration.name.text;
@@ -111,7 +118,7 @@ function storedTransactionLocks(call: ts.CallExpression, source: ts.SourceFile):
         ts.forEachChild(node, visit);
     };
     visit(scope);
-    return uses.length > 0 && uses.every(isCalledWithLockingMode);
+    return uses.length > 0 && uses.every((use) => isCalledWithLockingMode(use, modes));
 }
 
 interface TransactionScan {
@@ -154,8 +161,33 @@ function repositorySources(): Array<{ path: string; text: string }> {
 }
 
 describe("SQLite transaction lock mode", () => {
+    it("declares every audited read-only transaction explicitly deferred", () => {
+        const candidates: string[] = [];
+        for (const file of repositorySources()) {
+            const source = ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true);
+            const visit = (node: ts.Node): void => {
+                if (isTransactionCall(node)) {
+                    const key = `${file.path}#${enclosingFunctionName(node)}`;
+                    if (key in READ_ONLY_DEFERRED_TRANSACTIONS) {
+                        const deferred = new Set(["deferred"]);
+                        if (
+                            !isCalledWithLockingMode(node, deferred) &&
+                            !storedTransactionLocks(node, source, deferred)
+                        )
+                            candidates.push(key);
+                    }
+                }
+                ts.forEachChild(node, visit);
+            };
+            visit(source);
+        }
+        expect(candidates.sort()).toEqual([]);
+    });
+
     it("starts every writing transaction with .immediate() or .exclusive()", () => {
-        const { deferredSites, lockingSites } = scanTransactionModes(repositorySources());
+        const { deferredSites, lockingSites } = scanTransactionModes(
+            repositorySources().filter((file) => !file.path.startsWith("packages/cli/")),
+        );
         // The scan must actually see the codebase's transactions.
         expect(lockingSites).toBeGreaterThan(50);
 

package/src/shared/sqlite-write-locker-test-support.ts

@@ -26,6 +26,7 @@ export async function startSqliteWriteLocker(
     const child = Bun.spawn(["bun", import.meta.path, dbPath, String(holdMs)], {
         stdout: "pipe",
         stderr: "pipe",
+        windowsHide: true,
     });
     const reader = child.stdout.getReader();
     const decoder = new TextDecoder();