@cortexkit/opencode-magic-context 0.32.0 → 0.32.2

package/src/tui/data/context-db.ts

@@ -102,7 +102,13 @@ const STICKY_MAX_ENTRIES = 100;
 const stickySidebarCache = new Map<string, CachedSnapshot>();
 
 function rememberSidebarSnapshot(snapshot: SidebarSnapshot): void {
-    if (!snapshot.sessionId || snapshot.inputTokens <= 0) return;
+    if (!snapshot.sessionId) return;
+    if (snapshot.inputTokens <= 0) {
+        // A successful zero is authoritative (new/deleted/reverted session) and
+        // must prevent a later transport failure from resurrecting old values.
+        stickySidebarCache.delete(snapshot.sessionId);
+        return;
+    }
     // LRU-style bound: drop the oldest entry once we hit the cap. With a
     // 5-min TTL most stale entries time out naturally; this just prevents
     // unbounded growth across many session switches in a long TUI session.
@@ -126,19 +132,9 @@ function recallSidebarSnapshot(sessionId: string, fallback: SidebarSnapshot): Si
         stickySidebarCache.delete(sessionId);
         return fallback;
     }
-    if (!hasInFlightEvidence(fallback)) {
-        stickySidebarCache.delete(sessionId);
-        return fallback;
-    }
     return cached.snapshot;
 }
 
-function hasInFlightEvidence(snapshot: SidebarSnapshot): boolean {
-    return (
-        snapshot.compartmentInProgress || snapshot.historianRunning || snapshot.pendingOpsCount > 0
-    );
-}
-
 /** Fetch sidebar snapshot from the server via RPC. */
 export async function loadSidebarSnapshot(
     sessionId: string,
@@ -152,9 +148,11 @@ export async function loadSidebarSnapshot(
             directory,
         });
         if ((result as unknown as Record<string, unknown>).error) {
+            // Snapshot-build errors are explicit failure envelopes, equivalent to
+            // a transport failure: retain the last known-good client snapshot.
             return recallSidebarSnapshot(sessionId, empty);
         }
-        // Trust successful server responses. The server has its own sticky
+        // Trust successful server responses, including authoritative zeroes. The server has its own sticky
         // sidebar cache (`sidebar-snapshot-cache.ts`) that handles transient
         // zero-token windows by hybriding cached breakdown values into a
         // fresh snapshot, AND clears that cache on `session.deleted`. If the
@@ -249,14 +247,23 @@ export async function loadEmbedDetail(sessionId: string, directory: string): Pro
     }
 }
 
-/** Get compartment count via RPC. */
-export async function getCompartmentCount(sessionId: string): Promise<number> {
-    if (!rpcClient) return 0;
+export type CompartmentCountResult = { ok: true; count: number } | { ok: false; error: string };
+
+/** Get compartment count without making transport failure look like a real zero. */
+export async function getCompartmentCount(sessionId: string): Promise<CompartmentCountResult> {
+    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
-        const result = await rpcClient.call<{ count: number }>("compartment-count", { sessionId });
-        return result.count ?? 0;
-    } catch {
-        return 0;
+        const result = await rpcClient.call<{ count?: number; error?: string }>(
+            "compartment-count",
+            { sessionId },
+        );
+        if (typeof result.error === "string") return { ok: false, error: result.error };
+        if (typeof result.count !== "number" || !Number.isFinite(result.count)) {
+            return { ok: false, error: "Invalid compartment count response" };
+        }
+        return { ok: true, count: result.count };
+    } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
 

package/src/tui/data/notification-socket.test.ts

@@ -1,13 +1,15 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
+    __resetNotificationStateForTests,
     drainNotifications,
     isTuiConnected,
     pushNotification,
 } from "../../shared/rpc-notifications";
 import { MagicContextRpcServer } from "../../shared/rpc-server";
+import { rpcPortFilePath } from "../../shared/rpc-utils";
 import { closeRpc, initRpcClient } from "./context-db";
 import {
     _resetNotificationSocketStateForTesting,
@@ -18,6 +20,7 @@ import {
 const originalXdgDataHome = process.env.XDG_DATA_HOME;
 const tempDirs: string[] = [];
 const servers: MagicContextRpcServer[] = [];
+const legacyServers: Array<ReturnType<typeof Bun.serve>> = [];
 
 afterEach(() => {
     _resetNotificationSocketStateForTesting();
@@ -25,7 +28,8 @@ afterEach(() => {
     for (const server of servers.splice(0)) {
         server.stop();
     }
-    drainNotifications(Number.MAX_SAFE_INTEGER);
+    for (const server of legacyServers.splice(0)) server.stop(true);
+    __resetNotificationStateForTests();
     for (const dir of tempDirs.splice(0)) {
         rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
     }
@@ -54,6 +58,77 @@ async function startServer(dataHome: string, directory: string): Promise<MagicCo
     return server;
 }
 
+function startLegacyServer(
+    dataHome: string,
+    directory: string,
+    notifications: SocketNotification[],
+): {
+    sockets: Set<{ close(): void }>;
+    helloCursors: number[];
+    ackCursors: number[];
+} {
+    const token = "v032-query-token";
+    const sockets = new Set<{ close(): void }>();
+    const helloCursors: number[] = [];
+    const ackCursors: number[] = [];
+    const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch(req, bunServer) {
+            const url = new URL(req.url);
+            if (url.pathname === "/health") {
+                // Frozen v0.32 response: pid only, with no instance_id.
+                return Response.json({ ok: true, pid: process.pid });
+            }
+            if (
+                url.pathname === "/ws" &&
+                req.headers.get("authorization") === `Bearer ${token}` &&
+                bunServer.upgrade(req, { data: {} })
+            ) {
+                return undefined;
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+        websocket: {
+            open(ws) {
+                sockets.add(ws);
+            },
+            message(ws, raw) {
+                const msg = JSON.parse(String(raw)) as {
+                    type?: string;
+                    lastReceivedId?: number;
+                    cursor?: number;
+                };
+                if (msg.type === "hello") {
+                    const cursor = Number(msg.lastReceivedId ?? 0);
+                    helloCursors.push(cursor);
+                    for (const notification of notifications) {
+                        if (notification.id > cursor) {
+                            ws.send(JSON.stringify({ type: "notification", notification }));
+                        }
+                    }
+                    // Frozen v0.32 acknowledgement: protocol epoch fields did not exist.
+                    ws.send(JSON.stringify({ type: "hello-ack" }));
+                } else if (msg.type === "ack" && typeof msg.cursor === "number") {
+                    ackCursors.push(msg.cursor);
+                }
+            },
+            close(ws) {
+                sockets.delete(ws);
+            },
+        },
+    });
+    legacyServers.push(server);
+
+    const portFile = rpcPortFilePath(storageDir(dataHome), directory, process.pid);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(
+        portFile,
+        JSON.stringify({ port: server.port, pid: process.pid, started_at: Date.now(), token }),
+    );
+    return { sockets, helloCursors, ackCursors };
+}
+
 async function waitFor(condition: () => boolean, label: string, timeoutMs = 4_000): Promise<void> {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
@@ -64,6 +139,58 @@ async function waitFor(condition: () => boolean, label: string, timeoutMs = 4_00
 }
 
 describe("notification socket", () => {
+    test("a home-screen socket receives globals but leaves scoped notifications pending", async () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const dataHome = makeDataHome();
+        const directory = "/repo-home-screen";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        const received: SocketNotification[] = [];
+        startNotificationSocket({
+            getSessionId: () => null,
+            onNotification: (notification) => {
+                received.push(notification);
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected(), "home-screen socket connection");
+        expect(isTuiConnected("ses_hidden")).toBe(false);
+
+        pushNotification("scoped", { action: "show-status-dialog" }, "ses_hidden");
+        pushNotification("global", { action: "show-status-dialog" });
+        await waitFor(
+            () => received.some((notification) => notification.type === "global"),
+            "global home-screen notification",
+        );
+        expect(received.some((notification) => notification.type === "scoped")).toBe(false);
+        expect(drainNotifications(0, "ses_hidden", { sessionOnly: true })).toHaveLength(1);
+    });
+
+    test("overlapping starts create one socket and one delivery", async () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const dataHome = makeDataHome();
+        const directory = "/repo-overlapping-start";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let deliveries = 0;
+        const options = {
+            getSessionId: () => "ses_once",
+            onNotification: () => {
+                deliveries += 1;
+                return true;
+            },
+        };
+        startNotificationSocket(options);
+        startNotificationSocket(options);
+        await waitFor(() => isTuiConnected("ses_once"), "single overlapping connection");
+        pushNotification("once", { ok: true }, "ses_once");
+        await waitFor(() => deliveries === 1, "single notification delivery");
+        await new Promise((resolve) => setTimeout(resolve, 75));
+        expect(deliveries).toBe(1);
+    });
+
     test("uses the active session cursor when switching sessions", async () => {
         drainNotifications(Number.MAX_SAFE_INTEGER);
         const dataHome = makeDataHome();
@@ -99,8 +226,8 @@ describe("notification socket", () => {
         expect(received.map((notification) => notification.type)).toContain("for-b");
     });
 
-    test("resets the cached endpoint after websocket close so reconnect discovers a new server", async () => {
-        drainNotifications(Number.MAX_SAFE_INTEGER);
+    test("clears cursors and deduplication when a fresh server reuses notification ids", async () => {
+        __resetNotificationStateForTests();
         const dataHome = makeDataHome();
         const directory = "/repo-reconnect";
         const first = await startServer(dataHome, directory);
@@ -116,16 +243,155 @@ describe("notification socket", () => {
         });
         await waitFor(() => isTuiConnected("ses_R"), "initial websocket connection");
 
-        const second = await startServer(dataHome, directory);
-        expect(second).toBeDefined();
+        pushNotification("before-restart", { action: "show-status-dialog" }, "ses_R");
+        await waitFor(() => received.length === 1, "first notification acknowledgement");
+        await waitFor(
+            () => drainNotifications(0, "ses_R").length === 0,
+            "first server queue to empty",
+        );
+        expect(received[0].id).toBe(1);
+
         first.stop();
         await waitFor(() => !isTuiConnected("ses_R"), "old websocket sink removed");
-        await waitFor(() => isTuiConnected("ses_R"), "websocket reconnected to replacement server");
+        // A process restart recreates module state as well as the RPC server. The
+        // client state intentionally survives so reused ids exercise epoch reset.
+        __resetNotificationStateForTests();
+        pushNotification("queued-after-restart", { action: "show-status-dialog" }, "ses_R");
+        const second = await startServer(dataHome, directory);
+        expect(second).toBeDefined();
 
-        pushNotification("after-restart", { action: "show-status-dialog" }, "ses_R");
         await waitFor(
-            () => received.some((notification) => notification.type === "after-restart"),
-            "notification from replacement server",
+            () => received.some((notification) => notification.type === "queued-after-restart"),
+            "reused id from replacement server backlog",
         );
+        const restarted = received.find(
+            (notification) => notification.type === "queued-after-restart",
+        );
+        expect(restarted?.id).toBe(received[0].id);
+    });
+
+    test("acknowledges only consumed ids and redelivers a failed earlier notification", async () => {
+        __resetNotificationStateForTests();
+        const dataHome = makeDataHome();
+        const directory = "/repo-exact-ack";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let releaseFirst: ((consumed: boolean) => void) | undefined;
+        const firstResult = new Promise<boolean>((resolve) => {
+            releaseFirst = resolve;
+        });
+        let slowCalls = 0;
+        let fastCalls = 0;
+        startNotificationSocket({
+            getSessionId: () => "ses_exact",
+            onNotification: (notification) => {
+                if (notification.type === "slow") {
+                    slowCalls += 1;
+                    return slowCalls === 1 ? firstResult : true;
+                }
+                fastCalls += 1;
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected("ses_exact"), "exact ack socket connection");
+
+        pushNotification("slow", { action: "show-status-dialog" }, "ses_exact");
+        pushNotification("fast", { action: "show-toast" }, "ses_exact");
+        await waitFor(() => slowCalls === 1, "blocked first handler");
+        expect(fastCalls).toBe(0);
+        releaseFirst?.(false);
+        await waitFor(() => fastCalls === 1, "later handler completion");
+        await waitFor(() => {
+            const pending = drainNotifications(0, "ses_exact");
+            return pending.length === 1 && pending[0].type === "slow";
+        }, "only failed notification to remain queued");
+
+        _resetNotificationSocketStateForTesting();
+        await waitFor(() => !isTuiConnected("ses_exact"), "socket disconnect before redelivery");
+        startNotificationSocket({
+            getSessionId: () => "ses_exact",
+            onNotification: (notification) => {
+                if (notification.type === "slow") slowCalls += 1;
+                if (notification.type === "fast") fastCalls += 1;
+                return true;
+            },
+        });
+        await waitFor(() => slowCalls === 2, "failed notification redelivery");
+        expect(fastCalls).toBe(1);
+    });
+
+    test("legacy mode keeps its watermark behind a declined notification across reconnect", async () => {
+        const dataHome = makeDataHome();
+        const directory = "/repo-v032-notifications";
+        const sessionId = "ses_v032";
+        const legacy = startLegacyServer(dataHome, directory, [
+            { id: 1, type: "declined", payload: {}, sessionId },
+            { id: 2, type: "consumed", payload: {}, sessionId },
+        ]);
+        initRpcClient(directory);
+
+        let declinedCalls = 0;
+        let consumedCalls = 0;
+        startNotificationSocket({
+            getSessionId: () => sessionId,
+            onNotification: (notification) => {
+                if (notification.type === "declined") {
+                    declinedCalls += 1;
+                    return declinedCalls > 1;
+                }
+                consumedCalls += 1;
+                return true;
+            },
+        });
+
+        await waitFor(() => declinedCalls === 1 && consumedCalls === 1, "legacy backlog handling");
+        expect(Math.max(0, ...legacy.ackCursors)).toBe(0);
+        for (const ws of legacy.sockets) ws.close();
+
+        await waitFor(() => legacy.helloCursors.length >= 2, "legacy reconnect hello");
+        await waitFor(() => declinedCalls === 2, "declined notification redelivery");
+        expect(legacy.helloCursors[1]).toBe(0);
+        expect(consumedCalls).toBe(1);
+        await waitFor(() => legacy.ackCursors.includes(2), "gap-safe legacy watermark advance");
+    });
+
+    test("serializes back-to-back dialog notification handlers", async () => {
+        __resetNotificationStateForTests();
+        const dataHome = makeDataHome();
+        const directory = "/repo-serialized-dialogs";
+        await startServer(dataHome, directory);
+        initRpcClient(directory);
+
+        let releaseFirst: (() => void) | undefined;
+        const firstSettled = new Promise<void>((resolve) => {
+            releaseFirst = resolve;
+        });
+        const events: string[] = [];
+        startNotificationSocket({
+            getSessionId: () => "ses_dialogs",
+            onNotification: async (notification) => {
+                events.push(`start:${notification.type}`);
+                if (notification.type === "dialog-one") await firstSettled;
+                events.push(`finish:${notification.type}`);
+                return true;
+            },
+        });
+        await waitFor(() => isTuiConnected("ses_dialogs"), "dialog socket connection");
+
+        pushNotification("dialog-one", { action: "show-status-dialog" }, "ses_dialogs");
+        pushNotification("dialog-two", { action: "show-upgrade-dialog" }, "ses_dialogs");
+        await waitFor(() => events.includes("start:dialog-one"), "first dialog handler start");
+        await new Promise((resolve) => setTimeout(resolve, 75));
+        expect(events).toEqual(["start:dialog-one"]);
+
+        releaseFirst?.();
+        await waitFor(() => events.includes("finish:dialog-two"), "second dialog handler finish");
+        expect(events).toEqual([
+            "start:dialog-one",
+            "finish:dialog-one",
+            "start:dialog-two",
+            "finish:dialog-two",
+        ]);
     });
 });