@wolfx/opencode-magic-context 0.30.1 → 0.30.3

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

@@ -0,0 +1,229 @@
+/**
+ * Persistent WebSocket to the server plugin's RPC server, replacing the old
+ * 500ms HTTP notification poll.
+ *
+ * Why this exists: the TUI plugin and the server plugin run in separate Bun
+ * runners in the same process, so they bridge over a localhost socket. The old
+ * bridge polled `pending-notifications` over HTTP every 500ms — and each poll
+ * opened a NEW loopback TCP connection (Bun's fetch isn't pooled to our server),
+ * which was the entire source of idle TUI CPU (#200). A single long-lived WS
+ * carries server→TUI pushes with zero per-event connection cost, and the server
+ * pushes notifications the instant they're queued (no polling latency).
+ *
+ * Session scope: the socket carries the TUI's active session in its `hello` so
+ * the server delivers only that session's (plus global) notifications and its
+ * `isTuiConnected(session)` routing stays correct. The active session is tracked
+ * with a cheap watcher that only reads `api.route.current` (a property access,
+ * no IPC) and re-scopes the socket ONLY when the session actually changes — so
+ * unlike the old poll it does no network work at idle.
+ */
+
+import { getRpcClient, getRpcGeneration } from "./context-db";
+
+export interface SocketNotification {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}
+
+interface NotificationSocketOptions {
+    /** Current active session id (re-read cheaply to follow session switches). */
+    getSessionId: () => string | null;
+    /** Handle one delivered notification. Returns true if it was consumed (so its
+     *  id can advance the ack cursor). Async because dialog handlers await. */
+    onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
+}
+
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 10_000;
+/** Cheap session-watch interval. Reads a property only; no network. The CPU bug
+ *  was the per-tick fetch, not the timer — this tick does zero IPC at idle. */
+const SESSION_WATCH_MS = 1_000;
+
+let socket: WebSocket | null = null;
+let reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+let sessionWatchTimer: ReturnType<typeof setInterval> | undefined;
+let reconnectAttempt = 0;
+let closed = false;
+let helloedSession: string | null = null;
+let opts: NotificationSocketOptions | null = null;
+/** Generation of the rpc client at connect time; a dispose/reinit bumps it and
+ *  invalidates an in-flight socket so its late callbacks are ignored. */
+let connectGeneration = 0;
+/** Highest handled notification id (sent in hello so a reconnect re-delivers the
+ *  unhandled backlog; sent in ack so the server prunes the queue). */
+let lastHandledId = 0;
+
+/** Open the persistent notification socket. Idempotent: a second call while open
+ *  is a no-op. Reconnects on its own after any drop. */
+export function startNotificationSocket(options: NotificationSocketOptions): void {
+    opts = options;
+    closed = false;
+    connectGeneration = getRpcGeneration();
+    connect();
+    if (!sessionWatchTimer) {
+        sessionWatchTimer = setInterval(watchSession, SESSION_WATCH_MS);
+    }
+}
+
+/** Close the socket and stop reconnecting. Call on TUI dispose. */
+export function stopNotificationSocket(): void {
+    closed = true;
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = undefined;
+    }
+    if (sessionWatchTimer) {
+        clearInterval(sessionWatchTimer);
+        sessionWatchTimer = undefined;
+    }
+    try {
+        socket?.close();
+    } catch {
+        // best-effort
+    }
+    socket = null;
+    helloedSession = null;
+    reconnectAttempt = 0;
+}
+
+function scheduleReconnect(): void {
+    if (closed) return;
+    if (reconnectTimer) return;
+    const delay = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS);
+    reconnectAttempt += 1;
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = undefined;
+        connect();
+    }, delay);
+}
+
+async function connect(): Promise<void> {
+    if (closed) return;
+    if (socket) return; // already connected/connecting
+
+    const client = getRpcClient();
+    if (!client) {
+        scheduleReconnect();
+        return;
+    }
+    const endpoint = await client.resolveEndpoint();
+    // The generation may have bumped (dispose/reinit) while resolving — abandon.
+    if (closed || getRpcGeneration() !== connectGeneration) return;
+    if (!endpoint) {
+        scheduleReconnect();
+        return;
+    }
+
+    let ws: WebSocket;
+    try {
+        ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}/ws`);
+    } catch {
+        scheduleReconnect();
+        return;
+    }
+    socket = ws;
+
+    ws.addEventListener("open", () => {
+        if (socket !== ws) return;
+        reconnectAttempt = 0;
+        sendHello(ws, endpoint.token);
+    });
+
+    ws.addEventListener("message", (event) => {
+        if (socket !== ws) return;
+        void handleSocketMessage(ws, String((event as MessageEvent).data));
+    });
+
+    const onDown = () => {
+        if (socket === ws) {
+            socket = null;
+            helloedSession = null;
+        }
+        scheduleReconnect();
+    };
+    ws.addEventListener("close", onDown);
+    ws.addEventListener("error", onDown);
+}
+
+function sendHello(ws: WebSocket, token: string | null): void {
+    const sessionId = opts?.getSessionId() ?? undefined;
+    helloedSession = sessionId ?? null;
+    ws.send(
+        JSON.stringify({
+            type: "hello",
+            token: token ?? "",
+            sessionId,
+            lastReceivedId: lastHandledId,
+        }),
+    );
+}
+
+async function handleSocketMessage(ws: WebSocket, raw: string): Promise<void> {
+    let msg: { type?: string; notification?: SocketNotification; error?: string };
+    try {
+        msg = JSON.parse(raw);
+    } catch {
+        return;
+    }
+
+    if (msg.type === "notification" && msg.notification) {
+        const notification = msg.notification;
+        // Client-side session filter mirrors the old poller's per-message re-check:
+        // a session-scoped notification is only acted on while the TUI is actually
+        // viewing that session (the active session can change between queueing and
+        // delivery). Global (session-less) notifications always apply.
+        const active = opts?.getSessionId() ?? null;
+        if (notification.sessionId && active && notification.sessionId !== active) {
+            // Not for the session we're viewing — do NOT ack it (a TUI on the right
+            // session, or a later switch back, should still get it). Just skip.
+            return;
+        }
+        let consumed = false;
+        try {
+            consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
+        } catch {
+            consumed = false;
+        }
+        // A dispose/reinit during an awaited dialog handler invalidates this socket.
+        if (socket !== ws || getRpcGeneration() !== connectGeneration) return;
+        if (consumed && notification.id > lastHandledId) {
+            lastHandledId = notification.id;
+            // Ack so the server prunes the queue during this long-lived connection.
+            // (The id also rides the next reconnect hello via lastReceivedId, so a
+            // dropped ack just re-delivers an already-consumed item, which the
+            // handlers are idempotent against.)
+            try {
+                ws.send(JSON.stringify({ type: "ack", lastReceivedId: lastHandledId }));
+            } catch {
+                // best-effort; reconnect hello re-syncs via lastReceivedId
+            }
+        }
+        return;
+    }
+
+    if (msg.type === "error") {
+        // Server rejected us (bad token, etc.). Close and let backoff retry after
+        // rediscovering the port/token (the server may have been replaced).
+        try {
+            ws.close();
+        } catch {
+            // best-effort
+        }
+    }
+}
+
+/** Cheap session-change watcher: re-scope the socket only when the active session
+ *  actually changes. Reads a property; no network at idle. */
+function watchSession(): void {
+    if (closed || !socket || socket.readyState !== WebSocket.OPEN) return;
+    const current = opts?.getSessionId() ?? null;
+    if (current === helloedSession) return;
+    // Re-hello with the new session; the server replaces this socket's sink scope.
+    const client = getRpcClient();
+    void client?.resolveEndpoint().then((endpoint) => {
+        if (!socket || socket.readyState !== WebSocket.OPEN) return;
+        sendHello(socket, endpoint?.token ?? null);
+    });
+}

package/src/tui/index.tsx

@@ -6,7 +6,8 @@ import { createMemo } from "solid-js"
 import type { TuiPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import { createSidebarContentSlot, kickRecompProgressRefresh } from "./slots/sidebar-content"
 import packageJson from "../../package.json"
-import { closeRpc, consumeTuiMessages, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, markTuiMessagesHandled, requestRecomp, requestUpgrade, type EmbedDetail, type TuiMessage, type StatusDetail } from "./data/context-db"
+import { closeRpc, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, requestUpgrade, type EmbedDetail, type StatusDetail } from "./data/context-db"
+import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { detectConflicts } from "../shared/conflict-detector"
 import { fixConflicts } from "../shared/conflict-fixer"
@@ -869,128 +870,77 @@ const tui: TuiPlugin = async (api, _options, meta) => {
     // only when keymap is missing.
     registerCommandPaletteEntries(api)
 
-    // Poll for server→TUI messages: toasts and dialog requests.
-    // The poller owns cursor advancement so notifications are acked only after
-    // they are accepted for the still-active session and delivered to the UI.
-    let pollInFlight = false
-    const messagePoller = setInterval(() => {
-        // Scope the drain to the TUI's active session so notifications tagged for
-        // a different session (served by the same RPC process) are not consumed
-        // here. Do not poll on non-session routes: a session-scoped action fetched
-        // while sessionless could otherwise be acked without being shown.
-        // Avoid overlapping read-only drains: the server re-delivers until acked,
-        // so a second in-flight poll can fetch and dispatch the same batch twice.
-        if (pollInFlight) return
-
+    // Receive server→TUI notifications (toasts + dialog requests) over a single
+    // persistent WebSocket, pushed the instant the server queues them. This
+    // replaces the old 500ms HTTP poll whose new-connection-per-tick cost was the
+    // source of idle TUI CPU (#200). The socket carries the active session in its
+    // hello so the server scopes delivery; here we re-check the active session per
+    // notification (it can change between queue and delivery) before acting.
+    const handleNotification = async (n: SocketNotification): Promise<boolean> => {
         const requestedSessionId = getSessionId(api)
-        if (!requestedSessionId) return
+        const generation = getRpcGeneration()
+        // A session-scoped notification only applies while we're viewing that
+        // session; global (session-less) ones always apply. Returning false leaves
+        // it unacked so a TUI on the right session (or a later switch back) still
+        // gets it.
+        if (n.sessionId && requestedSessionId && n.sessionId !== requestedSessionId) {
+            return false
+        }
+        if (n.type === "toast") {
+            const p = n.payload
+            showToast(api, {
+                message: String(p.message ?? ""),
+                variant: (p.variant as "info" | "warning" | "error" | "success") ?? "info",
+                durationOverrideMs:
+                    typeof p.duration === "number" && Number.isFinite(p.duration)
+                        ? p.duration
+                        : undefined,
+            })
+            return true
+        }
+        if (n.type !== "action") return false
+        const action = n.payload?.action
+        const stillActive = () =>
+            getRpcGeneration() === generation && getSessionId(api) === requestedSessionId
+        if (action === "show-status-dialog") {
+            return stillActive() && (await showStatusDialog(api, requestedSessionId))
+        }
+        if (action === "show-recomp-dialog") {
+            return stillActive() && (await showRecompDialog(api, requestedSessionId))
+        }
+        if (action === "show-upgrade-dialog") {
+            const resume =
+                n.payload?.resume === true
+                    ? {
+                          stagedCount: Number(n.payload?.stagedCount ?? 0),
+                          stagedThrough: Number(n.payload?.stagedThrough ?? 0),
+                      }
+                    : undefined
+            return stillActive() && showUpgradeDialog(api, resume, requestedSessionId)
+        }
+        if (action === "show-embed-dialog") {
+            return stillActive() && (await showEmbedDialog(api, requestedSessionId))
+        }
+        if (action === "show-flush-dialog") {
+            const flushMsg = String(n.payload?.message ?? "Flushed.")
+            return stillActive() && showResultDialog(api, "Flush", flushMsg)
+        }
+        if (action === "show-result-dialog") {
+            const title = String(n.payload?.title ?? "Magic Context")
+            const body = String(n.payload?.message ?? "")
+            return stillActive() && showResultDialog(api, title, body)
+        }
+        return false
+    }
 
-        pollInFlight = true
-        const pollGeneration = getRpcGeneration()
-        void consumeTuiMessages(requestedSessionId).then(async (messages) => {
-            if (unifiedToastDurationMs === DEFAULT_TOAST_DURATION_MS) {
-                void refreshToastDurationMs()
-            }
-            // The dialog handlers read the current session when they run. If the
-            // user switched routes while the RPC was in flight, drop this whole
-            // batch without advancing the cursor; the next poll for the new
-            // session will fetch the right notifications.
-            // Ignore late responses from an older RPC client generation; close/init
-            // clears cursors and stale callbacks must not recreate them.
-            if (getRpcGeneration() !== pollGeneration) return
-
-            if (getSessionId(api) !== requestedSessionId) return
-
-            const orderedMessages = [...messages].sort((a, b) => a.id - b.id)
-            const handledMessageIds = new Set<number>()
-            for (const msg of orderedMessages) {
-                // A dialog helper earlier in this batch may have awaited; re-check
-                // the route before EACH message so a later action/toast in the same
-                // batch can't paint into a session the user switched to mid-batch
-                // (the pre-batch + pre-ack guards alone don't cover mid-batch awaits).
-                if (getRpcGeneration() !== pollGeneration) return
-                if (getSessionId(api) !== requestedSessionId) return
-                // Drop any action/dialog whose sessionId doesn't match this TUI's
-                // active session (session-less/global notifications still apply).
-                if (
-                    msg.type === "action" &&
-                    msg.sessionId &&
-                    msg.sessionId !== requestedSessionId
-                ) {
-                    continue
-                }
-                if (msg.type === "toast") {
-                    const p = msg.payload
-                    showToast(api, {
-                        message: String(p.message ?? ""),
-                        variant: (p.variant as "info" | "warning" | "error" | "success") ?? "info",
-                        durationOverrideMs:
-                            typeof p.duration === "number" && Number.isFinite(p.duration)
-                                ? p.duration
-                                : undefined,
-                    })
-                    handledMessageIds.add(msg.id)
-                } else if (msg.type === "action") {
-                    const action = msg.payload?.action
-                    if (action === "show-status-dialog") {
-                        if (await showStatusDialog(api, requestedSessionId)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    } else if (action === "show-recomp-dialog") {
-                        if (await showRecompDialog(api, requestedSessionId)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    } else if (action === "show-upgrade-dialog") {
-                        const resume =
-                            msg.payload?.resume === true
-                                ? {
-                                      stagedCount: Number(msg.payload?.stagedCount ?? 0),
-                                      stagedThrough: Number(msg.payload?.stagedThrough ?? 0),
-                                  }
-                                : undefined
-                        if (showUpgradeDialog(api, resume, requestedSessionId)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    } else if (action === "show-embed-dialog") {
-                        if (await showEmbedDialog(api, requestedSessionId)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    } else if (action === "show-flush-dialog") {
-                        const flushMsg = String(msg.payload?.message ?? "Flushed.")
-                        if (showResultDialog(api, "Flush", flushMsg)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    } else if (action === "show-result-dialog") {
-                        const title = String(msg.payload?.title ?? "Magic Context")
-                        const body = String(msg.payload?.message ?? "")
-                        if (showResultDialog(api, title, body)) {
-                            handledMessageIds.add(msg.id)
-                        }
-                    }
-                }
-            }
-            const handledPrefixMessages: TuiMessage[] = []
-            for (const msg of orderedMessages) {
-                if (!handledMessageIds.has(msg.id)) break
-                handledPrefixMessages.push(msg)
-            }
-            // A dialog helper may have awaited more RPC work; re-check before
-            // acking so a dispose/reinit or route switch during that await cannot
-            // advance a stale cursor.
-            if (getRpcGeneration() !== pollGeneration) return
-            if (getSessionId(api) !== requestedSessionId) return
-
-            markTuiMessagesHandled(requestedSessionId, handledPrefixMessages)
-        }).catch(() => {
-            // Intentional: message polling should never crash the TUI
-        }).finally(() => {
-            pollInFlight = false
-        })
-    }, 500)
+    startNotificationSocket({
+        getSessionId: () => getSessionId(api),
+        onNotification: handleNotification,
+    })
 
     // Clean up on dispose
     api.lifecycle.onDispose(() => {
-        clearInterval(messagePoller)
+        stopNotificationSocket()
         closeRpc()
     })