@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

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

@@ -3,14 +3,38 @@
  * All data is fetched from the server plugin via HTTP RPC.
  */
 import { getMagicContextStorageDir } from "../../shared/data-path";
-import { MagicContextRpcClient } from "../../shared/rpc-client";
+import { pluginPackageVersion } from "../../shared/plugin-package-version";
+import { MagicContextRpcClient, RpcServerNotFoundError } from "../../shared/rpc-client";
 import type { EmbedDetail, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
+import {
+    checkStatusDetailPayload,
+    type OpenCodeStatusExtras,
+    type StatusCheck,
+    statusRpcFailure,
+} from "../../shared/status-view-check";
 
 export type { EmbedDetail, SidebarSnapshot, StatusDetail };
 
 let rpcClient: MagicContextRpcClient | null = null;
+let rpcClientDirectory: string | null = null;
 let rpcGeneration = 0;
 
+/**
+ * Clients for session directories other than the one the TUI started in.
+ *
+ * OpenCode runs one Magic Context server instance per directory, and each one
+ * writes its RPC discovery file under that directory's hash. A TUI started in
+ * one directory (commonly the home directory) can show a session whose
+ * directory is another project; asking the startup directory's server about
+ * that session returns the startup directory's answer (for the home directory:
+ * no project state at all), so the sidebar and `/ctx-status` showed nothing.
+ * Session-scoped calls therefore go to the client for the session's own
+ * directory. The startup client stays as it is for the notification socket and
+ * the process-wide calls.
+ */
+const sessionDirectoryClients = new Map<string, MagicContextRpcClient>();
+const MAX_SESSION_DIRECTORY_CLIENTS = 16;
+
 /** Initialize the RPC client. Call once on TUI startup. */
 export function initRpcClient(directory: string): void {
     const storageDir = getMagicContextStorageDir();
@@ -19,6 +43,127 @@ export function initRpcClient(directory: string): void {
     // new generation and abandons its in-flight connect).
     rpcGeneration += 1;
     rpcClient = new MagicContextRpcClient(storageDir, directory);
+    rpcClientDirectory = directory;
+    resetSessionDirectoryClients();
+}
+
+function resetSessionDirectoryClients(): void {
+    for (const client of sessionDirectoryClients.values()) client.reset();
+    sessionDirectoryClients.clear();
+}
+
+/**
+ * The client for the server instance that owns `directory`: the startup client
+ * when the directory is the one the TUI started in (or unknown), otherwise a
+ * client discovering that directory's own server. Null before init.
+ */
+function clientForDirectory(directory: string): MagicContextRpcClient | null {
+    if (!rpcClient) return null;
+    if (!directory || directory === rpcClientDirectory) return rpcClient;
+    const existing = sessionDirectoryClients.get(directory);
+    if (existing) return existing;
+    if (sessionDirectoryClients.size >= MAX_SESSION_DIRECTORY_CLIENTS) {
+        const oldest = sessionDirectoryClients.keys().next().value;
+        if (oldest !== undefined) {
+            sessionDirectoryClients.get(oldest)?.reset();
+            sessionDirectoryClients.delete(oldest);
+        }
+    }
+    // Short resolution: when this directory has no discovery file the caller
+    // falls back to asking every local server (see `callSessionRpc`) instead of
+    // retrying the miss for fifteen seconds.
+    const client = new MagicContextRpcClient(getMagicContextStorageDir(), directory, {
+        resolveAttempts: 2,
+        reresolveAttempts: 1,
+    });
+    sessionDirectoryClients.set(directory, client);
+    return client;
+}
+
+/**
+ * The server the notification socket should subscribe to: the one that owns
+ * the shown session's directory, so a push from the command that session runs
+ * (for example `/ctx-status` asking to open its dialog) reaches this TUI. That
+ * is the startup directory's server when no session is shown or the session is
+ * in the startup directory. A session directory with no discovery file falls
+ * back to the server that claims the session, then to the startup server so
+ * session-less notifications still arrive.
+ */
+export async function resolveNotificationTarget(
+    sessionDirectory: string | null,
+    sessionId: string | null,
+): Promise<{
+    client: MagicContextRpcClient;
+    directory: string;
+    endpoint: { port: number; token: string | null; instanceId: string | null };
+} | null> {
+    const startup = rpcClient;
+    if (!startup) return null;
+    const directory = sessionDirectory ?? "";
+    let client = clientForDirectory(directory) ?? startup;
+    let endpoint = await client.resolveEndpoint();
+    if (!endpoint && client !== startup && sessionId) {
+        const owner = await MagicContextRpcClient.findSessionOwner(
+            getMagicContextStorageDir(),
+            sessionId,
+        );
+        if (owner) {
+            sessionDirectoryClients.get(directory)?.reset();
+            sessionDirectoryClients.set(directory, owner);
+            client = owner;
+            endpoint = await owner.resolveEndpoint();
+        }
+    }
+    if (endpoint) {
+        return {
+            client,
+            directory: client === startup ? (rpcClientDirectory ?? "") : directory,
+            endpoint,
+        };
+    }
+    if (client === startup) return null;
+    const startupEndpoint = await startup.resolveEndpoint();
+    return startupEndpoint
+        ? { client: startup, directory: rpcClientDirectory ?? "", endpoint: startupEndpoint }
+        : null;
+}
+
+/** The directory whose server a notification subscription for `sessionDirectory` targets first. */
+export function notificationDirectoryFor(sessionDirectory: string | null): string {
+    const directory = sessionDirectory ?? "";
+    if (!directory || directory === rpcClientDirectory) return rpcClientDirectory ?? "";
+    return directory;
+}
+
+/**
+ * Call a session-scoped RPC on the server that owns the session's directory.
+ * When no server is filed under that directory (the host spelled it in a way
+ * the canonical form still does not match), every live local server is asked
+ * whether it owns the session, and the owner, if any, answers this call and
+ * later ones for the directory. Only when no server claims the session does
+ * the call fail as before.
+ */
+async function callSessionRpc<T>(
+    directory: string,
+    sessionId: string,
+    method: string,
+    params: Record<string, unknown>,
+): Promise<T> {
+    const client = clientForDirectory(directory);
+    if (!client) throw new Error("RPC client is not initialized");
+    try {
+        return await client.call<T>(method, params);
+    } catch (error) {
+        if (!(error instanceof RpcServerNotFoundError) || client === rpcClient) throw error;
+        const owner = await MagicContextRpcClient.findSessionOwner(
+            getMagicContextStorageDir(),
+            sessionId,
+        );
+        if (!owner) throw error;
+        sessionDirectoryClients.get(directory)?.reset();
+        sessionDirectoryClients.set(directory, owner);
+        return owner.call<T>(method, params);
+    }
 }
 
 export function getRpcGeneration(): number {
@@ -38,6 +183,8 @@ export function closeRpc(): void {
     rpcGeneration += 1;
     rpcClient?.reset();
     rpcClient = null;
+    rpcClientDirectory = null;
+    resetSessionDirectoryClients();
 }
 
 const EMPTY_SNAPSHOT: SidebarSnapshot = {
@@ -134,10 +281,15 @@ export async function loadSidebarSnapshot(
     const empty: SidebarSnapshot = { ...EMPTY_SNAPSHOT, sessionId };
     if (!rpcClient) return recallSidebarSnapshot(sessionId, empty);
     try {
-        const result = await rpcClient.call<SidebarSnapshot>("sidebar-snapshot", {
-            sessionId,
+        const result = await callSessionRpc<SidebarSnapshot>(
             directory,
-        });
+            sessionId,
+            "sidebar-snapshot",
+            {
+                sessionId,
+                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.
@@ -162,26 +314,29 @@ export async function loadSidebarSnapshot(
     }
 }
 
-export type StatusDetailResult = { ok: true; detail: StatusDetail } | { ok: false; error: string };
+export type StatusDetailResult = StatusCheck<OpenCodeStatusExtras>;
 
-/** Fetch full status detail without presenting transport failure as an empty session. */
+/**
+ * Fetch the status for the `/ctx-status` dialog. Every reply, including a
+ * transport failure, comes back as a checked result: either a snapshot the
+ * view model can draw, or the reason there is none. The dialog never receives
+ * an unchecked payload.
+ */
 export async function loadStatusDetail(
     sessionId: string,
     directory: string,
     modelKey?: string,
 ): Promise<StatusDetailResult> {
-    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
+    if (!rpcClient) return statusRpcFailure("RPC client is not initialized");
     try {
-        const result = await rpcClient.call<StatusDetail>("status-detail", {
+        const reply = await callSessionRpc<unknown>(directory, sessionId, "status-detail", {
             sessionId,
             directory,
             modelKey,
         });
-        const error = (result as unknown as Record<string, unknown>).error;
-        if (typeof error === "string") return { ok: false, error };
-        return { ok: true, detail: result };
+        return checkStatusDetailPayload(reply, pluginPackageVersion() ?? "unknown");
     } catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        return statusRpcFailure(error instanceof Error ? error.message : String(error));
     }
 }
 
@@ -199,7 +354,7 @@ const EMPTY_EMBED_DETAIL: EmbedDetail = {
 export async function loadEmbedDetail(sessionId: string, directory: string): Promise<EmbedDetail> {
     if (!rpcClient) return EMPTY_EMBED_DETAIL;
     try {
-        const result = await rpcClient.call<EmbedDetail>("embed-detail", {
+        const result = await callSessionRpc<EmbedDetail>(directory, sessionId, "embed-detail", {
             sessionId,
             directory,
         });
@@ -221,9 +376,14 @@ export async function getCompartmentCount(
 ): Promise<CompartmentCountResult> {
     if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
-        const result = await rpcClient.call<{ count?: number; error?: string }>(
+        const result = await callSessionRpc<{ count?: number; error?: string }>(
+            directory ?? "",
+            sessionId,
             "compartment-count",
-            { sessionId, directory },
+            {
+                sessionId,
+                directory,
+            },
         );
         if (typeof result.error === "string") return { ok: false, error: result.error };
         if (typeof result.count !== "number" || !Number.isFinite(result.count)) {
@@ -235,11 +395,17 @@ export async function getCompartmentCount(
     }
 }
 
-/** Send recomp request to server via RPC. */
-export async function requestRecomp(sessionId: string): Promise<boolean> {
+/**
+ * Send recomp request to server via RPC. `directory` is the session's
+ * directory, so the request reaches the server instance that owns the session
+ * (the same one the recomp dialog read its compartment count from).
+ */
+export async function requestRecomp(sessionId: string, directory?: string): Promise<boolean> {
     if (!rpcClient) return false;
     try {
-        const result = await rpcClient.call<{ ok: boolean }>("recomp", { sessionId });
+        const result = await callSessionRpc<{ ok: boolean }>(directory ?? "", sessionId, "recomp", {
+            sessionId,
+        });
         return result.ok ?? false;
     } catch {
         return false;

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

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import {
@@ -10,6 +10,7 @@ import {
 } from "../../shared/rpc-notifications";
 import { MagicContextRpcServer } from "../../shared/rpc-server";
 import { rpcPortFilePath } from "../../shared/rpc-utils";
+import { createTestTempDirFromPath } from "../../shared/test-temp-dir";
 import { closeRpc, initRpcClient } from "./context-db";
 import {
     _resetNotificationSocketStateForTesting,
@@ -41,7 +42,7 @@ afterEach(() => {
 });
 
 function makeDataHome(): string {
-    const dir = mkdtempSync(join(tmpdir(), "mc-notification-socket-"));
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-notification-socket-"));
     tempDirs.push(dir);
     process.env.XDG_DATA_HOME = dir;
     return dir;
@@ -167,6 +168,52 @@ describe("notification socket", () => {
         expect(drainNotifications(0, "ses_hidden", { sessionOnly: true })).toHaveLength(1);
     });
 
+    test("subscribes to the server of the shown session's directory, not the startup one", async () => {
+        // A TUI started in the home directory showing a session from a project
+        // directory: the project's server runs that session's commands, so its
+        // "show status dialog" push only reaches a socket subscribed to it.
+        const dataHome = makeDataHome();
+        const home = startLegacyServer(dataHome, "/home-startup", []);
+        const project = startLegacyServer(dataHome, "/home-startup/Pictures/project", [
+            {
+                id: 1,
+                type: "action",
+                payload: { action: "show-status-dialog" },
+                sessionId: "ses_p",
+            },
+        ]);
+        initRpcClient("/home-startup");
+        const received: SocketNotification[] = [];
+        startNotificationSocket({
+            getSessionId: () => "ses_p",
+            getSessionDirectory: () => "/home-startup/Pictures/project",
+            onNotification: (notification) => {
+                received.push(notification);
+                return true;
+            },
+        });
+        await waitFor(() => received.length === 1, "the project server's push");
+        expect(project.sockets.size).toBe(1);
+        expect(home.sockets.size).toBe(0);
+    });
+
+    test("moves the socket when the shown session changes directory", async () => {
+        const dataHome = makeDataHome();
+        const home = startLegacyServer(dataHome, "/home-move", []);
+        const project = startLegacyServer(dataHome, "/home-move/project", []);
+        initRpcClient("/home-move");
+        let sessionDirectory: string | null = null;
+        startNotificationSocket({
+            getSessionId: () => (sessionDirectory ? "ses_moved" : null),
+            getSessionDirectory: () => sessionDirectory,
+            onNotification: () => true,
+        });
+        await waitFor(() => home.sockets.size === 1, "startup subscription");
+        sessionDirectory = "/home-move/project";
+        await waitFor(() => project.sockets.size === 1, "project subscription", 5_000);
+        await waitFor(() => home.sockets.size === 0, "startup socket closed");
+    });
+
     test("overlapping starts create one socket and one delivery", async () => {
         drainNotifications(Number.MAX_SAFE_INTEGER);
         const dataHome = makeDataHome();

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

@@ -18,7 +18,11 @@
  * unlike the old poll it does no network work at idle.
  */
 
-import { getRpcClient, getRpcGeneration } from "./context-db";
+import {
+    getRpcGeneration,
+    notificationDirectoryFor,
+    resolveNotificationTarget,
+} from "./context-db";
 
 export interface SocketNotification {
     id: number;
@@ -30,6 +34,12 @@ export interface SocketNotification {
 interface NotificationSocketOptions {
     /** Current active session id (re-read cheaply to follow session switches). */
     getSessionId: () => string | null;
+    /**
+     * Directory of the active session, when the host reports it. The socket
+     * subscribes to that directory's server, because that is the server whose
+     * commands push this session's notifications; null means the startup one.
+     */
+    getSessionDirectory?: () => string | null;
     /** Handle one delivered notification. Returns true only after it is fully
      *  consumed and can be acknowledged. Async because dialog handlers await. */
     onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
@@ -47,6 +57,13 @@ let sessionWatchTimer: ReturnType<typeof setInterval> | undefined;
 let reconnectAttempt = 0;
 let closed = false;
 let helloedSession: string | null = null;
+/** Directory whose server the open socket is subscribed to. */
+let connectedDirectory: string | null = null;
+/** Last time the socket was moved to follow a session's directory. */
+let lastRetargetAt = 0;
+/** Minimum spacing between moves, so a session whose server is not up yet does
+ *  not reconnect the socket every watcher tick. */
+const RETARGET_MIN_INTERVAL_MS = 10_000;
 let opts: NotificationSocketOptions | null = null;
 let activeToken: string | null = null;
 /** Generation of the rpc client used by the active socket. */
@@ -110,6 +127,8 @@ export function stopNotificationSocket(): void {
     opts = null;
     activeToken = null;
     helloedSession = null;
+    connectedDirectory = null;
+    lastRetargetAt = 0;
     reconnectAttempt = 0;
     activeInstanceId = null;
     notificationProtocolMode = null;
@@ -136,24 +155,22 @@ function scheduleReconnect(): void {
 async function connect(): Promise<void> {
     if (closed || socket || inFlightAttemptId !== null) return;
 
-    const client = getRpcClient();
-    if (!client) {
-        scheduleReconnect();
-        return;
-    }
-
     const attemptId = ++nextAttemptId;
     const rpcGeneration = getRpcGeneration();
     inFlightAttemptId = attemptId;
-    const endpoint = await client.resolveEndpoint();
+    const target = await resolveNotificationTarget(
+        opts?.getSessionDirectory?.() ?? null,
+        opts?.getSessionId() ?? null,
+    );
     if (closed || inFlightAttemptId !== attemptId || getRpcGeneration() !== rpcGeneration) {
         return;
     }
     inFlightAttemptId = null;
-    if (!endpoint) {
+    if (!target) {
         scheduleReconnect();
         return;
     }
+    const { client, endpoint } = target;
 
     let ws: WebSocket;
     try {
@@ -171,6 +188,7 @@ async function connect(): Promise<void> {
         return;
     }
     connectGeneration = rpcGeneration;
+    connectedDirectory = target.directory;
     activeToken = endpoint.token;
     notificationProtocolMode = null;
     bufferedNotifications.length = 0;
@@ -457,6 +475,26 @@ export function _resetNotificationSocketStateForTesting(): void {
  *  actually changes. Reads a property; no network at idle. */
 function watchSession(): void {
     if (closed || !socket || socket.readyState !== WebSocket.OPEN) return;
+    // The shown session belongs to another directory's server: move the socket
+    // there, or that server's pushes for this session never reach this TUI.
+    const wanted = notificationDirectoryFor(opts?.getSessionDirectory?.() ?? null);
+    if (wanted !== connectedDirectory && Date.now() - lastRetargetAt >= RETARGET_MIN_INTERVAL_MS) {
+        lastRetargetAt = Date.now();
+        const previous = socket;
+        socket = null;
+        activeToken = null;
+        helloedSession = null;
+        connectedDirectory = null;
+        notificationProtocolMode = null;
+        bufferedNotifications.length = 0;
+        try {
+            previous.close();
+        } catch {
+            // best-effort
+        }
+        void connect();
+        return;
+    }
     const current = opts?.getSessionId() ?? null;
     if (current === helloedSession) return;
     // Re-hello with the token authenticated by this socket; no rediscovery or

package/src/tui/data/session-directory.ts

@@ -0,0 +1,19 @@
+/**
+ * The directory whose Magic Context server owns a session.
+ *
+ * OpenCode starts one Magic Context server instance per directory. The TUI
+ * starts in one directory but can show a session from another one (non-git
+ * directories share OpenCode's global project, so a TUI started in the home
+ * directory lists sessions from any of them). The sidebar and `/ctx-status`
+ * must ask the server for the session's directory, not the startup one.
+ *
+ * `sessionDirectory` is what the host reports for the session (OpenCode 1:
+ * `api.state.session.get(id).directory`; OpenCode 2:
+ * `context.data.session.get(id).location.directory`). The startup directory is
+ * the fallback while the host has not loaded the session yet.
+ */
+export function directoryForSession(sessionDirectory: unknown, startupDirectory: string): string {
+    return typeof sessionDirectory === "string" && sessionDirectory.length > 0
+        ? sessionDirectory
+        : startupDirectory;
+}