@cortexkit/aft-opencode 0.30.0 → 0.30.2

package/src/tui/sidebar.tsx

@@ -12,6 +12,7 @@ import { createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 
 import { AftRpcClient } from "../shared/rpc-client";
 import { type AftStatusSnapshot, coerceAftStatus, type StatusCompression } from "../shared/status";
+import { resolveCortexKitStorageRoot } from "../shared/storage-paths";
 
 const SINGLE_BORDER = { type: "single" } as any;
 const REFRESH_DEBOUNCE_MS = 200;
@@ -135,6 +136,13 @@ const SectionHeader = (props: { theme: TuiThemeCurrent; title: string; marginTop
   </box>
 );
 
+// v0.27 moved AFT storage to the CortexKit root. TUI code must use a
+// lightweight local path helper rather than the shared bridge barrel, which
+// also exports URL-fetch helpers unsuitable for Bun's TUI runtime.
+export function resolveTuiStorageDir(): string {
+  return resolveCortexKitStorageRoot();
+}
+
 // One RPC client per project directory — same pattern as the /aft-status
 // dialog handler in tui/index.tsx. Sharing the map avoids opening a second
 // connection just for the sidebar.
@@ -142,56 +150,111 @@ const sidebarClients = new Map<string, AftRpcClient>();
 function getClient(directory: string): AftRpcClient {
   let client = sidebarClients.get(directory);
   if (client) return client;
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  const dataHome = process.env.XDG_DATA_HOME || `${home}/.local/share`;
-  // v0.27 moved AFT storage to the CortexKit root. Must match the server
-  // plugin's `resolveCortexKitStorageRoot()` or the sidebar will poll a
-  // stale legacy port file and never connect to the live RPC server.
-  const storageDir = `${dataHome}/cortexkit/aft`;
-  client = new AftRpcClient(storageDir, directory);
+  client = new AftRpcClient(resolveTuiStorageDir(), directory);
   sidebarClients.set(directory, client);
   return client;
 }
 
+export type ScopedSidebarStatus = {
+  directory: string;
+  sessionID: string;
+  snapshot: AftStatusSnapshot;
+};
+
+export function scopedSidebarSnapshot(
+  scoped: ScopedSidebarStatus | null,
+  directory: string,
+  sessionID: string,
+): AftStatusSnapshot | null {
+  if (!scoped) return null;
+  if (scoped.directory !== directory || scoped.sessionID !== sessionID) return null;
+  return scoped.snapshot;
+}
+
 const SidebarContent = (props: {
   api: TuiPluginApi;
   sessionID: () => string;
   theme: TuiThemeCurrent;
   pluginVersion: string;
 }) => {
-  const [status, setStatus] = createSignal<AftStatusSnapshot | null>(null);
-  // Once a request is in flight, suppress any overlapping refresh so we
-  // don't open a thundering herd of RPCs on rapid event bursts.
-  let inflight = false;
+  const [status, setStatus] = createSignal<ScopedSidebarStatus | null>(null);
+  let inflight: {
+    controller: AbortController;
+    generation: number;
+    directory: string;
+    sessionID: string;
+  } | null = null;
+  let generation = 0;
   let debounceTimer: ReturnType<typeof setTimeout> | undefined;
   let pollTimer: ReturnType<typeof setInterval> | undefined;
 
+  const currentDirectory = () => props.api.state.path.directory ?? "";
+  const requestRender = () => {
+    try {
+      props.api.renderer.requestRender();
+    } catch {
+      // renderer may not be available during teardown; safe to ignore
+    }
+  };
+  const abortInflight = () => {
+    if (!inflight) return;
+    inflight.controller.abort();
+    inflight = null;
+  };
+  const clearStatusForContext = (directory: string, sessionID: string) => {
+    const current = status();
+    if (!current) return;
+    if (current.directory === directory && current.sessionID === sessionID) return;
+    setStatus(null);
+    requestRender();
+  };
+
   const refresh = async () => {
     const sid = props.sessionID();
-    if (!sid) return;
-    if (inflight) return;
-    const directory = props.api.state.path.directory ?? "";
-    if (!directory) return;
+    const directory = currentDirectory();
+    if (!sid || !directory) {
+      generation++;
+      abortInflight();
+      if (status()) {
+        setStatus(null);
+        requestRender();
+      }
+      return;
+    }
+
+    clearStatusForContext(directory, sid);
+
+    if (inflight) {
+      if (inflight.directory === directory && inflight.sessionID === sid) return;
+      generation++;
+      abortInflight();
+    }
+
+    const requestGeneration = ++generation;
+    const controller = new AbortController();
+    inflight = { controller, generation: requestGeneration, directory, sessionID: sid };
 
-    inflight = true;
     try {
       const client = getClient(directory);
-      const response = await client.call("status", { sessionID: sid });
+      const response = await client.call(
+        "status",
+        { sessionID: sid },
+        { signal: controller.signal },
+      );
+      if (controller.signal.aborted || requestGeneration !== generation) return;
+      if (currentDirectory() !== directory || props.sessionID() !== sid) return;
       if (response && (response as Record<string, unknown>).success !== false) {
         const snapshot = coerceAftStatus(response as Record<string, unknown>);
-        setStatus(snapshot);
-        try {
-          props.api.renderer.requestRender();
-        } catch {
-          // renderer may not be available during teardown; safe to ignore
-        }
+        setStatus({ directory, sessionID: sid, snapshot });
+        requestRender();
       }
     } catch {
+      if (controller.signal.aborted || requestGeneration !== generation) return;
       // RPC server may not be ready yet, or the bridge may be respawning
-      // after a binary swap — leave the previous snapshot visible rather
-      // than blanking the sidebar.
+      // after a binary swap. Keep the previous snapshot only when it belongs
+      // to the current project/session; mismatched snapshots were cleared above.
     } finally {
-      inflight = false;
+      if (inflight?.generation === requestGeneration) inflight = null;
     }
   };
 
@@ -204,6 +267,8 @@ const SidebarContent = (props: {
   };
 
   onCleanup(() => {
+    generation++;
+    abortInflight();
     if (debounceTimer) clearTimeout(debounceTimer);
     if (pollTimer) clearInterval(pollTimer);
   });
@@ -250,6 +315,8 @@ const SidebarContent = (props: {
               // best effort
             }
           }
+          generation++;
+          abortInflight();
           if (pollTimer) {
             clearInterval(pollTimer);
             pollTimer = undefined;
@@ -260,7 +327,7 @@ const SidebarContent = (props: {
     ),
   );
 
-  const s = createMemo(() => status());
+  const s = () => scopedSidebarSnapshot(status(), currentDirectory(), props.sessionID());
 
   // Lazy-bridge: while AFT has no live bridge yet, the RPC server returns a
   // synthetic snapshot with `cache_role === "not_initialized"`. In that state