@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/src/shared/sqlite-640-review.test.ts

@@ -0,0 +1,183 @@
+import { expect, spyOn, test } from "bun:test";
+import { openDatabase } from "../features/magic-context/storage-db";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { recordToolDefinition } from "../features/magic-context/tool-definition-tokens";
+import { captureLkgSlot } from "../hooks/magic-context/lkg-replay";
+import { lkgReplayFits } from "../hooks/magic-context/lkg-replay-fit";
+import { resetLkgSlotsForTest } from "../hooks/magic-context/lkg-slot";
+import type { MessageLike } from "../hooks/magic-context/transform-operations";
+import { createMessagesTransformHandler } from "../plugin/messages-transform";
+import { refreshModelLimitsFromApi } from "./models-dev-cache";
+import { Database, SqliteAcquisitionBusyError, withAsyncPrivilegedWriter } from "./sqlite";
+
+function fixture() {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    db.exec("CREATE TABLE writes(value INTEGER)");
+    return db;
+}
+
+test("review: shared async admission rolls back callback busy without retrying side effects", async () => {
+    const db = fixture();
+    let callbacks = 0;
+    let recoveries = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(
+                db,
+                () => {
+                    callbacks++;
+                    db.prepare("INSERT INTO writes VALUES (1)").run();
+                    throw new SqliteAcquisitionBusyError(new Error("nested acquisition busy"));
+                },
+                {
+                    beforeRetry: () => {
+                        recoveries++;
+                    },
+                },
+            ),
+        ).rejects.toThrow("SQLite writer acquisition remained busy");
+        expect(callbacks).toBe(1);
+        expect(recoveries).toBe(0);
+        expect(db.prepare("SELECT * FROM writes").all()).toEqual([]);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.close();
+    }
+});
+
+test("review: default OpenCode empty admission retries BEGIN only and preserves output bytes", async () => {
+    const db = fixture();
+    const exec = db.exec.bind(db);
+    let attempts = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts === 1)
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        return exec(sql);
+    });
+    try {
+        const output = [{ role: "user", content: "§1§ managed input" }];
+        const before = JSON.stringify(output);
+        await withAsyncPrivilegedWriter(db, () => undefined);
+        expect(attempts).toBe(2);
+        expect(JSON.stringify(output)).toBe(before);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        spy.mockRestore();
+        db.close();
+    }
+});
+
+test("review: COMMIT busy after empty admission is surfaced once and transaction is released", async () => {
+    const db = fixture();
+    const exec = db.exec.bind(db);
+    let callbacks = 0;
+    let commits = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "COMMIT") {
+            commits++;
+            throw Object.assign(new Error("reader holds rollback-journal lock"), {
+                code: "SQLITE_BUSY",
+            });
+        }
+        return exec(sql);
+    });
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                callbacks++;
+            }),
+        ).rejects.toThrow("reader holds rollback-journal lock");
+        expect(callbacks).toBe(1);
+        expect(commits).toBe(1);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        spy.mockRestore();
+        db.close();
+    }
+});
+
+test("review: OpenCode tries a valid saved request before backed-off writer retry", async () => {
+    resetLkgSlotsForTest();
+    const db = openDatabase();
+    if (!db) throw new Error("isolated test database unavailable");
+    const sessionId = "review-opencode-order";
+    const model = { providerID: "openai", modelID: "gpt-4.1" };
+    await refreshModelLimitsFromApi({
+        config: {
+            providers: async () => ({
+                data: {
+                    providers: [
+                        {
+                            id: model.providerID,
+                            models: {
+                                [model.modelID]: { limit: { context: 1000000, output: 8192 } },
+                            },
+                        },
+                    ],
+                },
+            }),
+        },
+    });
+    getOrCreateSessionMeta(db, sessionId);
+    updateSessionMeta(db, sessionId, { systemPromptTokens: 100 });
+    recordToolDefinition(model.providerID, model.modelID, undefined, "read", "read file", {
+        type: "object",
+    });
+    const messages = [
+        {
+            info: { id: "u0", role: "user", sessionID: sessionId, model },
+            parts: [{ type: "text", text: "old raw history" }],
+        },
+    ] as MessageLike[];
+    const managed = structuredClone(messages);
+    (managed[0].parts[0] as { text: string }).text = "saved managed prefix";
+    expect(
+        captureLkgSlot({
+            sessionId,
+            input: messages,
+            output: managed,
+            modelKey: "openai/gpt-4.1",
+            providerKey: "openai",
+        }),
+    ).toBe(true);
+    expect(
+        lkgReplayFits({
+            db,
+            sessionId,
+            messages: managed,
+            model,
+            modelKey: "openai/gpt-4.1",
+            systemPromptTokens: 100,
+        }).fits,
+    ).toBe(true);
+    const exec = db.exec.bind(db);
+    let attempts = 0;
+    let callbacks = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts === 1)
+            throw Object.assign(new Error("writer busy"), { code: "SQLITE_BUSY" });
+        return exec(sql);
+    });
+    try {
+        const output = { messages: structuredClone(messages) };
+        const handler = createMessagesTransformHandler({
+            magicContext: {
+                "experimental.chat.messages.transform": async (_input, result) => {
+                    callbacks++;
+                    (result.messages[0].parts[0] as { text: string }).text =
+                        "recomputed after retry";
+                },
+            },
+        });
+        await handler({}, output as Parameters<typeof handler>[1]);
+        expect({ callbacks, attempts, messages: output.messages }).toEqual({
+            callbacks: 0,
+            attempts: 1,
+            messages: managed,
+        });
+    } finally {
+        spy.mockRestore();
+        resetLkgSlotsForTest();
+    }
+});

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

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
     Database,
+    SqliteAcquisitionBusyError,
     withAsyncPrivilegedWriter,
     withPrivilegedWriter,
     withSqliteTransformPass,
@@ -11,6 +12,23 @@ import {
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 import { createTestTempDirFromPath } from "./test-temp-dir";
 
+test("async writer never retries callback acquisition errors after work began", async () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    let calls = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                calls++;
+                throw new SqliteAcquisitionBusyError(new Error("nested BEGIN"));
+            }),
+        ).rejects.toThrow("acquisition remained busy");
+        expect(calls).toBe(1);
+    } finally {
+        db.close();
+    }
+});
+
 for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
     test(`shared SQLite retries ${mode} acquisition before running any writes`, async () => {
         const dir = createTestTempDirFromPath(join(tmpdir(), "mc-routed-acquisition-"));

package/src/shared/sqlite.test.ts

@@ -1,12 +1,64 @@
 import { describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
 import {
     Database,
+    detectSqliteRuntime,
     getSqliteMemoryStats,
     loadSqliteModule,
     SqliteRuntimeUnavailableError,
 } from "./sqlite";
 
 describe("SQLite runtime selector", () => {
+    it("suppresses only the node:sqlite experimental warning in a real Node process", () => {
+        // Node 24.21 no longer emits this warning, so inject it during loading
+        // to keep the suppression assertion load-bearing on newer runtimes.
+        const selectorUrl = new URL("./sqlite.ts", import.meta.url).href;
+        const script = `
+            import { loadSqliteModule } from ${JSON.stringify(selectorUrl)};
+            const originalEmitWarning = process.emitWarning;
+            let listenerSawX = false;
+            process.on("warning", (warning) => {
+                if (warning.message === "x") listenerSawX = true;
+            });
+            await loadSqliteModule("Node.js", async (specifier) => {
+                if (specifier !== "node:sqlite") throw new Error("unexpected backend: " + specifier);
+                process.emitWarning("SQLite is an experimental feature and might change at any time", "ExperimentalWarning");
+                process.emitWarning("x", "ExperimentalWarning");
+                return {};
+            });
+            if (process.emitWarning !== originalEmitWarning) throw new Error("emitWarning was not restored");
+            process.emitWarning("after", "ExperimentalWarning");
+            await new Promise((resolve) => setImmediate(resolve));
+            if (!listenerSawX) throw new Error("the original warning listener was not called");
+        `;
+        const child = spawnSync("node", ["--trace-warnings", "--input-type=module", "-e", script], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+
+        expect(child.error).toBeUndefined();
+        expect(child.status).toBe(0);
+        expect(child.stderr).not.toContain("SQLite is an experimental feature");
+        expect(child.stderr).toContain("ExperimentalWarning: x");
+        expect(child.stderr).toContain("ExperimentalWarning: after");
+        expect(child.stderr).toMatch(/ExperimentalWarning: x[\s\S]*?\n\s+at /);
+    });
+
+    it("leaves Bun and OpenCode warning emission untouched", async () => {
+        expect(detectSqliteRuntime()).toBe("Bun");
+        const originalEmitWarning = process.emitWarning;
+        let requestedSpecifier = "";
+
+        await loadSqliteModule("Bun", async (specifier) => {
+            requestedSpecifier = specifier;
+            expect(process.emitWarning).toBe(originalEmitWarning);
+            return {};
+        });
+
+        expect(requestedSpecifier).toBe("bun:sqlite");
+        expect(process.emitWarning).toBe(originalEmitWarning);
+    });
+
     it("reports live connection PRAGMAs and removes closed handles", () => {
         const before = getSqliteMemoryStats().connectionCount;
         const db = new Database(":memory:");