@cortexkit/opencode-magic-context 0.49.35 → 0.49.37

package/src/shared/reusable-worker.fixture.ts

@@ -0,0 +1,35 @@
+import { parentPort, threadId } from "node:worker_threads";
+import { serveWorkerJobs } from "./reusable-worker-entry";
+
+serveWorkerJobs<{
+    crash?: boolean;
+    hang?: boolean;
+    late?: boolean;
+    exitCode?: boolean;
+    value?: string;
+    shared?: SharedArrayBuffer;
+}>(async (input, port) => {
+    if (input.crash) throw new Error("injected worker crash");
+    if (input.hang) return await new Promise<void>(() => {});
+    if (input.exitCode) process.exitCode = 1;
+    if (input.shared) {
+        const state = new Int32Array(input.shared);
+        port.postMessage({ threadId, shared: Atomics.load(state, 0) });
+        await new Promise<void>((resolve) =>
+            port.once("message", () => {
+                port.postMessage({ threadId, shared: Atomics.add(state, 0, 1) });
+                resolve();
+            }),
+        );
+        port.close();
+        return;
+    }
+    if (input.late)
+        setTimeout(() => {
+            port.postMessage({ value: "stale" });
+            // Bypass the job port to verify the owner ignores a mismatched job id.
+            parentPort?.postMessage({ jobId: -1, value: { value: "stale" } });
+        }, 20);
+    port.postMessage({ threadId, value: input.value });
+    port.close();
+});

package/src/shared/reusable-worker.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { once } from "node:events";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MessageChannel, type Worker } from "node:worker_threads";
+import { reuseWorker } from "./reusable-worker";
+import { withTestTempDir } from "./test-temp-dir";
+
+const entry = new URL("./reusable-worker.fixture.ts", import.meta.url);
+let key = 0;
+function start(path: string, input: Record<string, unknown> = {}, idleMs = 60_000) {
+    return reuseWorker(entry, { workerData: { path, ...input } }, idleMs);
+}
+async function result(worker: Worker) {
+    const reply = once(worker, "message");
+    const exit = once(worker, "exit");
+    const [message] = await reply;
+    await exit;
+    return message as { threadId: number; value?: string };
+}
+
+describe("reusable job workers", () => {
+    test("reuses a thread but gives each job fresh input and port state", async () => {
+        const path = `reuse-${++key}`;
+        const first = await result(start(path, { value: "first" }));
+        const second = await result(start(path, { value: "second" }));
+        expect(second.threadId).toBe(first.threadId);
+        expect(second.value).toBe("second");
+    });
+
+    test("replaces a crashed worker and fails its job", async () => {
+        const path = `crash-${++key}`;
+        const first = await result(start(path));
+        const crashed = start(path, { crash: true });
+        const error = new Promise<Error>((resolve) => crashed.once("error", resolve));
+        const exit = new Promise<void>((resolve) => crashed.once("exit", () => resolve()));
+        expect((await error).message).toContain("injected worker crash");
+        await exit;
+        const next = await result(start(path));
+        expect(next.threadId).not.toBe(first.threadId);
+    });
+
+    test("terminates a hung job and replaces its thread", async () => {
+        const path = `hang-${++key}`;
+        const first = await result(start(path));
+        const hung = start(path, { hang: true });
+        // Allow dispatch, then terminate the worker to exercise the hard-stop behavior.
+        await new Promise((resolve) => setTimeout(resolve, 25));
+        await hung.terminate();
+        const next = await result(start(path));
+        expect(next.threadId).not.toBe(first.threadId);
+    });
+
+    test("shuts the thread down after its idle lifetime", async () => {
+        const path = `idle-${++key}`;
+        const first = await result(start(path, {}, 20));
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        const next = await result(start(path, {}, 20));
+        expect(next.threadId).not.toBe(first.threadId);
+    });
+
+    test("rejects late replies from a released job", async () => {
+        const path = `late-${++key}`;
+        const prior = start(path, { late: true });
+        const oldReplies: unknown[] = [];
+        prior.on("message", (reply) => oldReplies.push(reply));
+        const first = await result(prior);
+        const next = start(path, { hang: true });
+        const replies: unknown[] = [];
+        next.on("message", (reply) => replies.push(reply));
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        expect(oldReplies).toHaveLength(1);
+        expect(replies).toEqual([]);
+        await next.terminate();
+        expect(first.threadId).toBeGreaterThan(0);
+    });
+
+    test("queues concurrent jobs without sharing job input", async () => {
+        const path = `queue-${++key}`;
+        const [a, b] = await Promise.all([
+            result(start(path, { value: "a" })),
+            result(start(path, { value: "b" })),
+        ]);
+        expect(a.threadId).toBe(b.threadId);
+        expect([a.value, b.value]).toEqual(["a", "b"]);
+    });
+
+    test("a crash does not fail a queued job that never entered the thread", async () => {
+        const path = `queued-crash-${++key}`;
+        const crashed = start(path, { crash: true });
+        crashed.on("error", () => {});
+        const next = await result(start(path, { value: "unstarted" }));
+        expect(next.value).toBe("unstarted");
+    });
+
+    test("keeps different database paths in separate threads", async () => {
+        const a = await result(start(`db-a-${++key}`));
+        const b = await result(start(`db-b-${++key}`));
+        expect(a.threadId).not.toBe(b.threadId);
+    });
+
+    test("copies a job's input before dispatch", async () => {
+        const data = { path: `copy-${++key}`, value: "submitted" };
+        const job = reuseWorker(entry, { workerData: data });
+        data.value = "changed after submission";
+        expect((await result(job)).value).toBe("submitted");
+    });
+
+    test("job input keeps shared coordination live in both directions", async () => {
+        const state = new Int32Array(new SharedArrayBuffer(4));
+        Atomics.store(state, 0, 1);
+        const worker = start(`shared-${++key}`, { shared: state.buffer });
+        const first = once(worker, "message");
+        const exit = once(worker, "exit");
+        expect((await first)[0].shared).toBe(1);
+        const changed = once(worker, "message");
+        Atomics.store(state, 0, 7);
+        worker.postMessage({ read: true });
+        expect((await changed)[0].shared).toBe(7);
+        await exit;
+        expect(Atomics.load(state, 0)).toBe(8);
+    });
+
+    test("a nonzero job exit fails the lease and replaces the thread", async () => {
+        const path = `exit-code-${++key}`;
+        const first = await result(start(path));
+        const failed = start(path, { exitCode: true });
+        expect((await once(failed, "exit"))[0]).toBe(1);
+        expect((await result(start(path))).threadId).not.toBe(first.threadId);
+    });
+
+    test("process shutdown releases queued jobs without starting a replacement worker", async () => {
+        const path = `shutdown-${++key}`;
+        await result(start(path));
+        const active = start(path, { hang: true });
+        const queued = start(path, { value: "must not run during shutdown" });
+        const replies: unknown[] = [];
+        queued.on("message", (message) => replies.push(message));
+        const activeExit = once(active, "exit");
+        const queuedExit = once(queued, "exit");
+        await Promise.resolve();
+
+        // Invoke only the registry's callback: emitting process exit would also
+        // tear down Bun's test runner before it could check the queued lease.
+        const abortAll = process.listeners("exit").find((listener) => listener.name === "abortAll");
+        expect(abortAll).toBeDefined();
+        abortAll!();
+
+        await activeExit;
+        await queuedExit;
+        expect(replies).toEqual([]);
+    });
+
+    test("a file ending with queued jobs cannot interrupt the next parallel file", () => {
+        withTestTempDir("reusable-worker-files-", (dir) => {
+            const outcomes = join(dir, "outcomes.jsonl");
+            writeFileSync(outcomes, "");
+            writeFileSync(
+                join(dir, "01-owner.test.ts"),
+                `import { test } from "bun:test";
+import { appendFileSync } from "node:fs";
+import { reuseWorker } from ${JSON.stringify(new URL("./reusable-worker.ts", import.meta.url).href)};
+test("owner finishes with queued work", async () => {
+    const entry = new URL(${JSON.stringify(entry.href)});
+    const active = reuseWorker(entry, { workerData: { path: "file-exit", hang: true } });
+    active.on("error", () => {});
+    for (let id = 0; id < 3; id++) {
+        const queued = reuseWorker(entry, { workerData: { path: "file-exit", value: "queued" } });
+        let replied = false;
+        let failed = false;
+        queued.on("message", () => { replied = true; });
+        queued.on("error", () => { failed = true; });
+        queued.on("exit", code => appendFileSync(${JSON.stringify(outcomes)}, JSON.stringify({
+            id, outcome: code === 0 && replied && !failed ? "completed" : "failed",
+        }) + "\\n"));
+    }
+    await Promise.resolve();
+});`,
+            );
+            writeFileSync(
+                join(dir, "02-next.test.ts"),
+                `import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+await new Promise(resolve => setTimeout(resolve, 50));
+describe("next file", () => {
+    test("still registers after every queued client settles once", () => {
+        const outcomes = readFileSync(${JSON.stringify(outcomes)}, "utf8").trim().split("\\n").filter(Boolean).map(line => JSON.parse(line));
+        expect(outcomes).toHaveLength(3);
+        for (let id = 0; id < 3; id++) {
+            const client = outcomes.filter(outcome => outcome.id === id);
+            expect(client).toHaveLength(1);
+            expect(["completed", "failed"]).toContain(client[0].outcome);
+        }
+    });
+});`,
+            );
+            // The real preload owns file teardown. Bun may discard a bare file's
+            // callbacks without notifying its workers' clients during VM teardown.
+            const child = spawnSync(
+                process.execPath,
+                [
+                    "test",
+                    "--parallel=1",
+                    "--preload",
+                    fileURLToPath(new URL("../../test-preload.ts", import.meta.url)),
+                    dir,
+                ],
+                { cwd: dir, encoding: "utf8", timeout: 5_000, windowsHide: true },
+            );
+            const output = child.stdout + child.stderr;
+            expect(output).toContain("2 pass");
+            expect(output).toContain("0 fail");
+            expect(output).not.toContain("Unhandled error");
+            expect(child.status).toBe(0);
+            const settled = readFileSync(outcomes, "utf8").trim().split("\n").filter(Boolean);
+            expect(settled).toHaveLength(3);
+        });
+    }, 10_000);
+
+    test("replacement construction failure settles every queued client exactly once", async () => {
+        const path = `replacement-failure-${++key}`;
+        const { port1, port2 } = new MessageChannel();
+        try {
+            const crashed = reuseWorker(entry, {
+                workerData: { path, crash: true },
+                transferList: [port1],
+            });
+            crashed.on("error", () => {});
+            const clients = [start(path), start(path)].map((worker) => {
+                const errors: unknown[] = [];
+                const exits: number[] = [];
+                worker.on("error", (error) => errors.push(error));
+                const done = new Promise<void>((resolve) =>
+                    worker.on("exit", (code) => {
+                        exits.push(code);
+                        resolve();
+                    }),
+                );
+                return { errors, exits, done };
+            });
+            await Promise.all(clients.map((client) => client.done));
+            await new Promise((resolve) => setImmediate(resolve));
+            for (const client of clients) {
+                expect(client.errors).toHaveLength(1);
+                expect(client.exits).toEqual([1]);
+            }
+        } finally {
+            port2.close();
+        }
+    });
+});

package/src/shared/reusable-worker.ts

@@ -0,0 +1,240 @@
+import { EventEmitter } from "node:events";
+import * as timers from "node:timers";
+import {
+    MessageChannel,
+    receiveMessageOnPort,
+    Worker,
+    type WorkerOptions,
+} from "node:worker_threads";
+import { registerExitAbort, unregisterExitAbort } from "./exit-abort-registry";
+import { inRootAsyncContext } from "./sqlite";
+
+const pools = new Map<string, Slot>();
+const liveSlots = new Set<Slot>();
+let nextId = 0;
+const IDLE_MS = 60_000;
+const sharedCloneWorks = (() => {
+    const source = new SharedArrayBuffer(1);
+    const clone = structuredClone(source);
+    new Uint8Array(source)[0] = 1;
+    return new Uint8Array(clone)[0] === 1;
+})();
+let cloneChannel: MessageChannel | undefined;
+
+function cloneJobValue<T>(value: T, transferList?: readonly object[]): T {
+    if (sharedCloneWorks) return structuredClone(value, { transfer: transferList as never });
+    // Bun 1.3's structuredClone snapshots shared buffers, but native message
+    // transport preserves them. One reusable channel keeps cancellation and
+    // writer coordination shared without allocating ports for every job.
+    if (!cloneChannel) {
+        cloneChannel = inRootAsyncContext(() => new MessageChannel());
+        cloneChannel.port1.unref();
+        cloneChannel.port2.unref();
+    }
+    cloneChannel.port1.postMessage(value, transferList as never);
+    const packet = receiveMessageOnPort(cloneChannel.port2);
+    if (!packet) throw new Error("worker input clone did not arrive synchronously");
+    return packet.message as T;
+}
+
+interface Slot {
+    worker: Worker;
+    controller: AbortController;
+    queue: Lease[];
+    active?: Lease;
+    idle?: ReturnType<typeof timers.setTimeout>;
+    advance(): void;
+}
+
+class Lease extends EventEmitter {
+    readonly id = ++nextId;
+    ended = false;
+    referenced = true;
+    readonly outbox: Array<{ value: unknown; transferList?: readonly object[] }> = [];
+    constructor(
+        public slot: Slot,
+        readonly data: unknown,
+    ) {
+        super();
+    }
+    postMessage(value: unknown, transferList?: readonly object[]) {
+        if (this.ended) return;
+        if (this.slot.active === this)
+            this.slot.worker.postMessage({ jobId: this.id, value }, transferList as never);
+        else this.outbox.push(cloneJobValue({ value, transferList }, transferList));
+    }
+    start() {
+        if (this.referenced) this.slot.worker.ref();
+        else this.slot.worker.unref();
+        this.emit("online");
+        this.slot.worker.postMessage({ jobId: this.id, start: this.data });
+        for (const { value, transferList } of this.outbox.splice(0))
+            this.postMessage(value, transferList);
+    }
+    ref() {
+        this.referenced = true;
+        if (this.slot.active === this) this.slot.worker.ref();
+        return this;
+    }
+    unref() {
+        this.referenced = false;
+        if (this.slot.active === this) this.slot.worker.unref();
+        return this;
+    }
+    async terminate(): Promise<number> {
+        if (this.ended) return 0;
+        if (this.slot.active === this) return await this.slot.worker.terminate();
+        this.ended = true;
+        this.slot.queue.splice(this.slot.queue.indexOf(this), 1);
+        this.emit("exit", 0);
+        return 0;
+    }
+}
+
+/** A job-local Worker interface; only the idle thread, never job state, is reused. */
+export function reuseWorker(entry: URL | string, options: WorkerOptions, idleMs = IDLE_MS): Worker {
+    // Native Worker construction copies its input immediately, even if the job
+    // cannot start yet. Do not let a queued job observe later caller mutations.
+    const data = cloneJobValue(options.workerData);
+    const slot = acquireSlot(entry, options, idleMs);
+    const lease = new Lease(slot, data);
+    enqueue(slot, lease);
+    return lease as unknown as Worker;
+}
+
+/** End test-owned pools before another test can replace their timers or databases. */
+export async function resetReusableWorkersForTests(): Promise<void> {
+    while (liveSlots.size) {
+        const slots = [...liveSlots];
+        pools.clear();
+        await Promise.all(
+            slots.map(
+                (slot) =>
+                    new Promise<void>((resolve) => {
+                        timers.clearTimeout(slot.idle);
+                        slot.idle = undefined;
+                        slot.worker.once("exit", () => resolve());
+                        slot.controller.abort();
+                    }),
+            ),
+        );
+    }
+    cloneChannel?.port1.close();
+    cloneChannel?.port2.close();
+    cloneChannel = undefined;
+}
+
+function enqueue(slot: Slot, lease: Lease): void {
+    timers.clearTimeout(slot.idle);
+    lease.slot = slot;
+    slot.queue.push(lease);
+    // Let callers attach their listeners before a queued job starts.
+    queueMicrotask(() => slot.advance());
+}
+
+function acquireSlot(entry: URL | string, options: WorkerOptions, idleMs: number): Slot {
+    const data = options.workerData;
+    const key = JSON.stringify([
+        String(entry),
+        data?.path ?? data?.dbPath,
+        data?.harness,
+        data?.job,
+    ]);
+    let slot = pools.get(key);
+    if (!slot) {
+        const worker = inRootAsyncContext(
+            () => new Worker(entry, { ...options, workerData: { reusableWorker: true } }),
+        );
+        const controller = new AbortController();
+        slot = { worker, controller, queue: [], advance: () => {} };
+        pools.set(key, slot);
+        liveSlots.add(slot);
+        const owned = slot;
+        const advance = () => {
+            if (controller.signal.aborted || owned.active) return;
+            timers.clearTimeout(owned.idle);
+            const lease = owned.queue.shift();
+            owned.active = lease;
+            if (!lease) {
+                worker.unref();
+                // A caller's temporary clock must not own a shared pool's lifetime.
+                owned.idle = timers.setTimeout(() => {
+                    if (pools.get(key) === owned) pools.delete(key);
+                    void worker.terminate();
+                }, idleMs);
+                owned.idle.unref();
+                return;
+            }
+            lease.start();
+        };
+        owned.advance = advance;
+        worker.on(
+            "message",
+            (message: { jobId: number; value?: unknown; finished?: boolean; code?: number }) => {
+                const lease = owned.active;
+                if (!lease || message.jobId !== lease.id) return;
+                if (!message.finished) {
+                    lease.emit("message", message.value);
+                    return;
+                }
+                lease.ended = true;
+                owned.active = undefined;
+                if (message.code) {
+                    if (pools.get(key) === owned) pools.delete(key);
+                    lease.emit("exit", message.code);
+                    void worker.terminate();
+                    return;
+                }
+                lease.emit("exit", 0);
+                advance();
+            },
+        );
+        worker.on("error", (error) => {
+            if (pools.get(key) === owned) pools.delete(key);
+            owned.active?.emit("error", error);
+        });
+        worker.on("exit", (code) => {
+            liveSlots.delete(owned);
+            timers.clearTimeout(owned.idle);
+            if (pools.get(key) === owned) pools.delete(key);
+            const active = owned.active;
+            owned.active = undefined;
+            if (active && !active.ended) {
+                active.ended = true;
+                active.emit("exit", code);
+            }
+            // Only the active job hit the failed thread. Move unstarted jobs to
+            // its replacement without retrying any work that may have run.
+            // During process shutdown, release queued leases instead of
+            // spawning threads into a torn-down host.
+            for (const lease of owned.queue.splice(0)) {
+                if (controller.signal.aborted) {
+                    lease.ended = true;
+                    lease.emit("exit", code);
+                } else {
+                    try {
+                        enqueue(acquireSlot(entry, options, idleMs), lease);
+                    } catch (error) {
+                        // Bun can destroy a test file's worker communication
+                        // channel without firing process exit. Report a failed
+                        // replacement through its lease rather than throwing
+                        // from this exit callback between files.
+                        lease.ended = true;
+                        lease.emit("error", error);
+                        lease.emit("exit", 1);
+                    }
+                }
+            }
+        });
+        controller.signal.addEventListener(
+            "abort",
+            () => {
+                void worker.terminate();
+            },
+            { once: true },
+        );
+        registerExitAbort(controller);
+        worker.once("exit", () => unregisterExitAbort(controller));
+    }
+    return slot;
+}

package/src/shared/worker-shutdown.ts

@@ -48,6 +48,7 @@ export function isWorkerCloseMessage(message: unknown): boolean {
 export function exitOnWorkerClose(
     port: WorkerClosePort | null,
     closeConnections: () => void,
+    exitThread = true,
 ): { closePort(): void } {
     const listener = (message: unknown) => {
         if (!isWorkerCloseMessage(message)) return;
@@ -56,27 +57,30 @@ export function exitOnWorkerClose(
         } finally {
             // Exit even if a close threw: the thread is ending and a connection
             // that could not close is released by the thread's teardown instead.
-            process.exit(0);
+            if (exitThread) process.exit(0);
+            // A reusable job with no asynchronous work left releases only its
+            // job port, after closing the connection and removing this listener.
+            closePort();
         }
     };
     if (!port) return { closePort() {} };
-    port.on("message", listener);
+    const owner = port;
+    owner.on("message", listener);
     let closed = false;
-    return {
-        closePort() {
-            if (closed) return;
-            closed = true;
-            // Close on a later timer turn, not synchronously: on Bun 1.3.14 a
-            // port closed while an entry module with a top-level await is still
-            // evaluating does not end the thread. Every current caller closes
-            // its port at the end of the module body or later, so the timer runs
-            // after evaluation has finished.
-            setTimeout(() => {
-                port.off("message", listener);
-                port.close();
-            });
-        },
-    };
+    function closePort() {
+        if (closed) return;
+        closed = true;
+        // Close on a later timer turn, not synchronously: on Bun 1.3.14 a
+        // port closed while an entry module with a top-level await is still
+        // evaluating does not end the thread. Every current caller closes
+        // its port at the end of the module body or later, so the timer runs
+        // after evaluation has finished.
+        setTimeout(() => {
+            owner.off("message", listener);
+            owner.close();
+        });
+    }
+    return { closePort };
 }
 
 /** The parts of a worker's parent port that {@link exitOnWorkerClose} uses. */