@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/src/shared/models-dev-cache.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -22,6 +22,7 @@ import {
     resolveLimit,
     setOutputReserveConfig,
 } from "./models-dev-cache";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 /**
  * Model context limits resolve from OpenCode's SDK only (`config.providers()`),
@@ -137,7 +138,7 @@ describe("models-dev-cache (SDK-only)", () => {
     }
 
     beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "mc-models-dev-"));
+        tempDir = createTestTempDirFromPath(join(tmpdir(), "mc-models-dev-"));
         // Isolate the persisted-cache file under a temp data dir so tests never
         // touch the real ~/.local/share/cortexkit/magic-context cache.
         originalXdgData = process.env.XDG_DATA_HOME;
@@ -646,3 +647,74 @@ describe("getSdkContextLimit prompt_only pre-carve arm", () => {
         ).toBe(167000);
     });
 });
+
+describe("prompt_only detected limit above a declared input cap", () => {
+    beforeEach(() => clearModelsDevCache());
+    afterEach(() => clearModelsDevCache());
+
+    const seed = () =>
+        refreshModelLimitsFromApi({
+            config: {
+                providers: async () => ({
+                    data: {
+                        providers: [
+                            {
+                                id: "anthropic",
+                                models: {
+                                    "capped-model": {
+                                        limit: {
+                                            context: 400_000,
+                                            input: 272_000,
+                                            output: 128_000,
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                }),
+            },
+        });
+
+    test("baseline: no detection resolves to the declared cap", async () => {
+        await seed();
+        expect(getSdkContextLimit("anthropic", "capped-model")).toBe(272_000);
+    });
+
+    test("reservation none keeps the declared cap", async () => {
+        await seed();
+        expect(
+            getSdkContextLimit("anthropic", "capped-model", 1_000_000, {
+                detectedLimitProvenance: "prompt_only",
+                reservation: "none",
+            }),
+        ).toBe(272_000);
+    });
+
+    test("combined keeps the declared cap", async () => {
+        await seed();
+        expect(
+            getSdkContextLimit("anthropic", "capped-model", 1_000_000, {
+                detectedLimitProvenance: "combined",
+            }),
+        ).toBe(272_000);
+    });
+
+    test("default arm: prompt_only keeps the declared cap", async () => {
+        await seed();
+        expect(
+            getSdkContextLimit("anthropic", "capped-model", 1_000_000, {
+                detectedLimitProvenance: "prompt_only",
+            }),
+        ).toBe(272_000);
+    });
+
+    test("default arm: geometry usableSoft keeps the declared cap", async () => {
+        await seed();
+        const geometry = getSdkWindowGeometry("anthropic", "capped-model", 1_000_000, {
+            detectedLimitProvenance: "prompt_only",
+        });
+        expect(geometry?.usableSoft).toBe(272_000);
+        expect(geometry?.usableHard).toBeGreaterThanOrEqual(geometry?.usableSoft ?? 0);
+    });
+});

package/src/shared/models-dev-cache.ts

@@ -533,7 +533,11 @@ export function getSdkWindowGeometry(
         },
     );
     if (!result || promptOnlyDetected === undefined) return result;
-    const usableSoft = promptOnlyDetected;
+    // A declared input cap bounds the prompt wall; without one the wall is
+    // already pre-carved and may exceed the catalog-derived window.
+    const usableSoft = isFinitePositive(metadata.inputLimit)
+        ? Math.min(promptOnlyDetected, result.usableSoft)
+        : promptOnlyDetected;
     return {
         ...result,
         usableSoft,

package/src/shared/off-thread-migration-clock.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+    __resetOffThreadMigrationClockForTests,
+    beginOffThreadMigration,
+    startBootDeadline,
+} from "./off-thread-migration-clock";
+
+const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+async function expiredWithin(promise: Promise<void>, ms: number): Promise<boolean> {
+    return Promise.race([promise.then(() => true), sleep(ms).then(() => false)]);
+}
+
+describe("boot deadline that excludes off-thread migration time", () => {
+    afterEach(() => __resetOffThreadMigrationClockForTests());
+
+    test("expires on time when no migration runs", async () => {
+        const deadline = startBootDeadline(30);
+        expect(await expiredWithin(deadline.expired, 500)).toBe(true);
+    });
+
+    test("does not expire while a migration runs, and resumes counting afterwards", async () => {
+        let deferred = 0;
+        const deadline = startBootDeadline(40, () => {
+            deferred += 1;
+        });
+        const end = beginOffThreadMigration();
+        expect(await expiredWithin(deadline.expired, 150)).toBe(false);
+        expect(deferred).toBe(1);
+
+        const endedAt = performance.now();
+        end();
+        await deadline.expired;
+        // Only the few milliseconds before the migration began were counted, so
+        // nearly the whole 40ms budget is still left once it ends.
+        expect(performance.now() - endedAt).toBeGreaterThanOrEqual(25);
+    });
+
+    test("time between migrations still counts", async () => {
+        const deadline = startBootDeadline(60);
+        await sleep(40);
+        const end = beginOffThreadMigration();
+        await sleep(80);
+        end();
+        const endedAt = performance.now();
+        await deadline.expired;
+        expect(performance.now() - endedAt).toBeLessThan(45);
+    });
+
+    test("a cancelled deadline never expires", async () => {
+        const deadline = startBootDeadline(20);
+        deadline.cancel();
+        expect(await expiredWithin(deadline.expired, 100)).toBe(false);
+    });
+});

package/src/shared/off-thread-migration-clock.ts

@@ -0,0 +1,124 @@
+/**
+ * Boot deadlines that do not count time spent migrating the schema on a worker
+ * thread.
+ *
+ * Plugin startup bounds the storage open with a timer so a stuck open cannot
+ * hold the host's plugin loader forever. When migrations ran on the main thread
+ * that timer could not fire while a migration body ran, so in effect migration
+ * time never counted against the deadline, and a long first-start upgrade still
+ * ended with tools registered. Migrations now run on a worker thread and the
+ * timer stays live, so without this clock a long upgrade would trip the
+ * deadline and start the host without Magic Context tools. Excluding the
+ * worker's busy time keeps the previous outcome while the host's event loop
+ * keeps serving requests. Waits for another process's write lock still count,
+ * exactly as before, because the worker reports them as idle time.
+ */
+
+let activeMigrations = 0;
+let activeSince = 0;
+let accumulatedMs = 0;
+let idleWaiters: Array<() => void> = [];
+
+/** Total milliseconds any off-thread migration has been running, up to `now`. */
+export function offThreadMigrationMs(now = performance.now()): number {
+    return accumulatedMs + (activeMigrations > 0 ? Math.max(0, now - activeSince) : 0);
+}
+
+export function isOffThreadMigrationRunning(): boolean {
+    return activeMigrations > 0;
+}
+
+/**
+ * Mark the start of off-thread migration work. The returned function marks its
+ * end; calling it more than once has no further effect.
+ */
+export function beginOffThreadMigration(): () => void {
+    if (activeMigrations === 0) activeSince = performance.now();
+    activeMigrations += 1;
+    let ended = false;
+    return () => {
+        if (ended) return;
+        ended = true;
+        activeMigrations -= 1;
+        if (activeMigrations > 0) return;
+        accumulatedMs += Math.max(0, performance.now() - activeSince);
+        const waiters = idleWaiters;
+        idleWaiters = [];
+        for (const wake of waiters) wake();
+    };
+}
+
+function whenOffThreadMigrationIdle(): Promise<void> {
+    if (activeMigrations === 0) return Promise.resolve();
+    return new Promise((resolve) => idleWaiters.push(resolve));
+}
+
+export interface BootDeadlineTimer {
+    /** Resolves once `timeoutMs` of non-migration time has passed. */
+    readonly expired: Promise<void>;
+    cancel(): void;
+}
+
+/**
+ * Start a deadline that expires after `timeoutMs` of elapsed time, not counting
+ * time during which an off-thread migration was running. `onDeferred` is called
+ * once, the first time the deadline would have expired but a migration was
+ * still running.
+ */
+export function startBootDeadline(timeoutMs: number, onDeferred?: () => void): BootDeadlineTimer {
+    const startedAt = performance.now();
+    const migratedAtStart = offThreadMigrationMs(startedAt);
+    const budgetMs = Math.max(0, timeoutMs);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let cancelled = false;
+    let deferredReported = false;
+    let resolveExpired!: () => void;
+    const expired = new Promise<void>((resolve) => {
+        resolveExpired = resolve;
+    });
+
+    const remainingMs = (): number => {
+        const now = performance.now();
+        const countedMs = now - startedAt - (offThreadMigrationMs(now) - migratedAtStart);
+        return budgetMs - countedMs;
+    };
+
+    const check = (): void => {
+        timer = undefined;
+        if (cancelled) return;
+        if (isOffThreadMigrationRunning()) {
+            if (!deferredReported) {
+                deferredReported = true;
+                onDeferred?.();
+            }
+            void whenOffThreadMigrationIdle().then(check);
+            return;
+        }
+        const left = remainingMs();
+        if (left > 0) {
+            timer = setTimeout(check, left);
+            return;
+        }
+        resolveExpired();
+    };
+
+    timer = setTimeout(check, budgetMs);
+    return {
+        expired,
+        cancel: () => {
+            cancelled = true;
+            if (timer) clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}
+
+/** Test seam: forget accumulated migration time between isolated tests. */
+export function __resetOffThreadMigrationClockForTests(): void {
+    activeMigrations = 0;
+    activeSince = 0;
+    accumulatedMs = 0;
+    const waiters = idleWaiters;
+    idleWaiters = [];
+    for (const wake of waiters) wake();
+}

package/src/shared/opencode-db-path.test.ts

@@ -1,7 +1,7 @@
 /// <reference types="bun-types" />
 
 import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -17,6 +17,7 @@ import {
     sourceOpenCodeDatabaseFilename,
 } from "./opencode-db-path";
 import { Database } from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 const ORIGINAL_ENV = {
     XDG_DATA_HOME: process.env.XDG_DATA_HOME,
@@ -42,7 +43,7 @@ afterEach(() => {
 });
 
 function useDataHome(): { dataHome: string; openCodeDir: string } {
-    const dataHome = mkdtempSync(join(tmpdir(), "opencode-db-path-"));
+    const dataHome = createTestTempDirFromPath(join(tmpdir(), "opencode-db-path-"));
     const openCodeDir = join(dataHome, "opencode");
     mkdirSync(openCodeDir, { recursive: true });
     tempDirs.push(dataHome);

package/src/shared/plugin-package-version.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_NAME = "@cortexkit/opencode-magic-context";
+
+let cachedVersion: string | null | undefined;
+
+/**
+ * Version of the Magic Context package this code was loaded from.
+ *
+ * The server and the TUI each call this from their own loaded copy, and the
+ * status RPC carries the server's answer to the TUI. After an update the two
+ * can differ (OpenCode keeps running the copy it started with), and comparing
+ * the two values is how the status dialog tells the user to restart.
+ *
+ * Found by walking up from this module to the nearest `package.json` carrying
+ * the package's name, which works for the source tree, the built `dist/`
+ * bundle and an npm cache install alike. Null when no such file is readable.
+ */
+export function pluginPackageVersion(moduleUrl: string = import.meta.url): string | null {
+    const useCache = moduleUrl === import.meta.url;
+    if (useCache && cachedVersion !== undefined) return cachedVersion;
+    let found: string | null = null;
+    try {
+        let directory = dirname(fileURLToPath(moduleUrl));
+        for (let depth = 0; depth < 10; depth++) {
+            const candidate = join(directory, "package.json");
+            if (existsSync(candidate)) {
+                const parsed: unknown = JSON.parse(readFileSync(candidate, "utf8"));
+                if (
+                    typeof parsed === "object" &&
+                    parsed !== null &&
+                    "name" in parsed &&
+                    parsed.name === PACKAGE_NAME &&
+                    "version" in parsed &&
+                    typeof parsed.version === "string"
+                ) {
+                    found = parsed.version;
+                    break;
+                }
+            }
+            const parent = dirname(directory);
+            if (parent === directory) break;
+            directory = parent;
+        }
+    } catch {
+        // An unreadable or unparsable manifest leaves the version unknown.
+    }
+    if (useCache) cachedVersion = found;
+    return found;
+}

package/src/shared/project-directory-key.test.ts

@@ -0,0 +1,111 @@
+/**
+ * The RPC server files its discovery record under `projectHash(directory)` and
+ * the TUI looks it up with its own spelling of the same directory. Each pair
+ * below is one directory spelled two ways that hosts really produce; both must
+ * hash to the same discovery directory, or the TUI finds no server and the
+ * sidebar reads zero.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, realpathSync, rmSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    __setCanonicalDirectoryRealpathForTests,
+    canonicalProjectDirectory,
+    projectDirectoryKey,
+} from "./project-directory-key";
+import { projectHash, rpcPortDirsForLookup } from "./rpc-utils";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+const created: string[] = [];
+
+afterEach(() => {
+    __setCanonicalDirectoryRealpathForTests();
+    for (const dir of created.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+const WINDOWS_PAIRS: Array<[string, string, string]> = [
+    [
+        "drive-letter case",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup",
+        "c:\\Users\\Amministratore\\Pictures\\TGroup",
+    ],
+    [
+        "separators",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup",
+        "C:/Users/Amministratore/Pictures/TGroup",
+    ],
+    [
+        "trailing separator",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup\\",
+    ],
+    [
+        "long-path prefix",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup",
+        "\\\\?\\C:\\Users\\Amministratore\\Pictures\\TGroup",
+    ],
+    [
+        "name case",
+        "C:\\Users\\Amministratore\\Pictures\\TGroup",
+        "C:\\USERS\\amministratore\\pictures\\tgroup",
+    ],
+    ["UNC long-path prefix", "\\\\server\\share\\TGroup", "\\\\?\\UNC\\server\\share\\TGroup"],
+];
+
+describe("one discovery directory per project directory", () => {
+    for (const [name, left, right] of WINDOWS_PAIRS) {
+        test(`Windows ${name}`, () => {
+            expect(projectDirectoryKey(left)).toBe(projectDirectoryKey(right));
+            expect(projectHash(left)).toBe(projectHash(right));
+        });
+    }
+
+    test("Windows 8.3 short name resolves through the filesystem's realpath", () => {
+        // realpathSync.native expands short names on Windows; this host cannot
+        // create one, so the realpath is stood in for.
+        const long = "C:\\Users\\Amministratore\\Pictures\\Camera Roll\\VikStudio\\TGroup";
+        const short = "C:\\Users\\AMMINI~1\\Pictures\\CAMERA~1\\VikStudio\\TGroup";
+        __setCanonicalDirectoryRealpathForTests((directory) => {
+            if (directory === short || directory === long) return long;
+            throw new Error("ENOENT");
+        });
+        expect(canonicalProjectDirectory(short)).toBe(canonicalProjectDirectory(long));
+        expect(projectHash(short)).toBe(projectHash(long));
+    });
+
+    test("macOS /var and /private/var", () => {
+        const raw = createTestTempDirFromPath(join(tmpdir(), "mc-key-var-"));
+        created.push(raw);
+        const real = realpathSync(raw);
+        if (process.platform === "darwin") expect(real.startsWith("/private/")).toBe(true);
+        expect(projectHash(raw)).toBe(projectHash(real));
+    });
+
+    test("a symlinked directory and its target", () => {
+        const root = realpathSync(createTestTempDirFromPath(join(tmpdir(), "mc-key-link-")));
+        created.push(root);
+        const target = join(root, "Pictures", "project");
+        mkdirSync(target, { recursive: true });
+        const link = join(root, "linked-project");
+        symlinkSync(target, link);
+        expect(projectHash(link)).toBe(projectHash(target));
+    });
+
+    test("POSIX trailing slash", () => {
+        const root = realpathSync(createTestTempDirFromPath(join(tmpdir(), "mc-key-slash-")));
+        created.push(root);
+        expect(projectHash(`${root}/`)).toBe(projectHash(root));
+    });
+
+    test("different directories still get different discovery directories", () => {
+        expect(projectHash("C:\\Users\\A\\one")).not.toBe(projectHash("C:\\Users\\A\\two"));
+        expect(projectHash("/tmp/does-not-exist-a")).not.toBe(projectHash("/tmp/does-not-exist-b"));
+    });
+
+    test("lookups also read the pre-canonical directory older servers wrote", () => {
+        const dirs = rpcPortDirsForLookup("/storage", "C:\\Users\\A\\Proj\\");
+        expect(dirs).toHaveLength(2);
+        expect(dirs[0]).toBe(join("/storage", "rpc", projectHash("C:\\Users\\A\\Proj\\")));
+    });
+});

package/src/shared/project-directory-key.ts

@@ -0,0 +1,54 @@
+import { realpathSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * Normalize Windows-formatted directory paths consistently, even on a non-Windows OS.
+ *
+ * Spelling only, no filesystem access: separators become `/`, the `\\?\` and
+ * `\\?\UNC\` long-path prefixes are dropped, a trailing separator is removed and
+ * the result is lowercased, because Windows paths are case-insensitive. A POSIX
+ * path is resolved to an absolute path, which also drops a trailing slash.
+ */
+export function projectDirectoryKey(directory: string): string {
+    const slashed = directory
+        .replaceAll("\\", "/")
+        .replace(/^\/\/\?\/UNC\//i, "//")
+        .replace(/^\/\/\?\//, "");
+    if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
+        return path.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+    }
+    return path.resolve(directory);
+}
+
+let realpathForCanonicalDirectory: (directory: string) => string = (directory) =>
+    realpathSync.native(directory);
+
+/**
+ * One spelling for a project directory, shared by everything that has to agree
+ * on it across processes (the RPC server that writes its discovery file and the
+ * TUI that looks the file up).
+ *
+ * The filesystem's own answer comes first where the directory exists:
+ * `realpathSync.native` resolves symlinks (macOS `/var` → `/private/var`),
+ * junctions, and Windows 8.3 short names (`AMMINI~1` → the long name). The
+ * result then goes through `projectDirectoryKey`, so drive-letter case,
+ * separators, `\\?\` prefixes and trailing separators cannot make two
+ * spellings of one directory differ. A directory that cannot be resolved (it
+ * no longer exists, or access is denied) falls back to its spelling alone.
+ */
+export function canonicalProjectDirectory(directory: string): string {
+    let resolved = directory;
+    try {
+        resolved = realpathForCanonicalDirectory(directory);
+    } catch {
+        // Keep the given spelling; the key below still normalizes it.
+    }
+    return projectDirectoryKey(resolved);
+}
+
+/** Test seam: stand in for the filesystem's realpath (for example Windows 8.3 expansion). */
+export function __setCanonicalDirectoryRealpathForTests(
+    realpath?: (directory: string) => string,
+): void {
+    realpathForCanonicalDirectory = realpath ?? ((directory) => realpathSync.native(directory));
+}