@cortexkit/aft-opencode 0.62.0 → 0.63.5

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

@@ -49,6 +49,14 @@ const WEB_SOCKET_OPEN = 1;
 const clients = new Map<string, AftRpcClient>();
 const statusInvalidationListeners = new Set<(event: StatusInvalidation) => void>();
 const lastHandledIdBySession = new Map<string, number>();
+const socketEndpoints = new WeakMap<WebSocketLike, AftRpcEndpoint>();
+const CURSOR_CACHE_LIMIT = 200;
+
+function cursorKey(ws: WebSocketLike, sessionId: string): string | null {
+  const endpoint = socketEndpoints.get(ws);
+  // The authentication token distinguishes server instances, even when a new instance reuses the port.
+  return endpoint?.token ? `${endpoint.token}\0${sessionId}` : null;
+}
 
 function defaultWebSocketCtor(): WebSocketFactory | null {
   const ctor = (globalThis as typeof globalThis & { WebSocket?: WebSocketFactory }).WebSocket;
@@ -128,6 +136,7 @@ export function stopAftTuiSocket(): void {
   closeCurrentSocket(false);
   for (const client of clients.values()) client.reset();
   clients.clear();
+  lastHandledIdBySession.clear();
   reconnectAttempt = 0;
 }
 
@@ -250,6 +259,7 @@ async function connect(scope: SocketScope, connectGeneration: number): Promise<v
   }
 
   socket = ws;
+  socketEndpoints.set(ws, endpoint);
   socketScope = scope;
   helloedScope = null;
 
@@ -335,13 +345,21 @@ async function sendHelloWithFreshToken(
   ) {
     return;
   }
-  sendHello(ws, scope, endpoint?.token ?? null);
+  const connected = socketEndpoints.get(ws);
+  if (!endpoint || endpoint.port !== connected?.port || endpoint.token !== connected.token) {
+    generation += 1;
+    closeCurrentSocket(false);
+    void connect(scope, generation);
+    return;
+  }
+  sendHello(ws, scope, connected.token);
 }
 
 function sendHello(ws: WebSocketLike, scope: SocketScope, token: string | null): void {
   helloedScope = scope;
   if (socket === ws) socketScope = scope;
-  const lastReceivedId = lastHandledIdBySession.get(scope.sessionId) ?? 0;
+  const key = cursorKey(ws, scope.sessionId);
+  const lastReceivedId = key ? (lastHandledIdBySession.get(key) ?? 0) : 0;
   ws.send(
     JSON.stringify({
       type: "hello",
@@ -400,8 +418,16 @@ async function handleSocketMessage(
     ) {
       return;
     }
-    if (consumed && notification.id > (lastHandledIdBySession.get(active) ?? 0)) {
-      lastHandledIdBySession.set(active, notification.id);
+    const key = cursorKey(ws, active);
+    if (consumed && notification.id > (key ? (lastHandledIdBySession.get(key) ?? 0) : 0)) {
+      if (key) {
+        lastHandledIdBySession.delete(key);
+        lastHandledIdBySession.set(key, notification.id);
+        if (lastHandledIdBySession.size > CURSOR_CACHE_LIMIT) {
+          const oldest = lastHandledIdBySession.keys().next().value;
+          if (oldest !== undefined) lastHandledIdBySession.delete(oldest);
+        }
+      }
       try {
         ws.send(JSON.stringify({ type: "ack", lastReceivedId: notification.id }));
       } catch {

package/src/tui-compiled/preferences.ts

@@ -39,6 +39,12 @@ export interface AftTuiPrefs {
   startCollapsed: boolean;
   rememberCollapsed: boolean;
   collapsed: boolean | null;
+  /**
+   * Whether OpenCode 2 shows AFT's health line (`AFT E0 W0 | D0 U0 C0 | T0`)
+   * in the prompt footer. Off hides it entirely; the sidebar and the status
+   * dialog are unaffected.
+   */
+  footer: boolean;
   header: {
     label: string;
     showVersion: boolean;
@@ -57,6 +63,7 @@ export const DEFAULT_PREFS: AftTuiPrefs = {
   startCollapsed: false,
   rememberCollapsed: true,
   collapsed: null,
+  footer: true,
   header: { label: "AFT", showVersion: true },
   sections: {
     searchIndex: true,
@@ -99,6 +106,7 @@ export function resolveAftPrefs(root: Record<string, unknown>): AftTuiPrefs {
     startCollapsed: bool(entry.startCollapsed, d.startCollapsed),
     rememberCollapsed: bool(entry.rememberCollapsed, d.rememberCollapsed),
     collapsed: typeof entry.collapsed === "boolean" ? entry.collapsed : null,
+    footer: bool(entry.footer, d.footer),
     header: {
       label: label(header.label, d.header.label, 20),
       showVersion: bool(header.showVersion, d.header.showVersion),
@@ -161,18 +169,14 @@ async function writePreference(pluginKey: string, path: string[], value: JsonVal
   let text: string;
   try {
     text = await readFile(file, "utf8");
-  } catch {
-    text = "";
-  }
-  if (text.trim() === "") text = TEMPLATE;
-
-  let root: Record<string, unknown>;
-  try {
-    const parsed = parse(text);
-    root = isRecord(parsed) ? (parsed as Record<string, unknown>) : {};
-  } catch {
-    root = {};
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    text = TEMPLATE;
   }
+  // Only a missing file can be initialized. Invalid existing bytes may belong to another plugin.
+  const parsed: unknown = parse(text);
+  if (!isRecord(parsed)) throw new Error("TUI preferences must contain an object");
+  const root = parsed;
 
   if (!isRecord(root[pluginKey])) {
     root[pluginKey] = {};
@@ -193,22 +197,52 @@ export function queueTuiPreferenceUpdate(
   path: string[],
   value: JsonValue,
 ): Promise<void> {
-  writeChain = writeChain.then(() => writePreference(pluginKey, path, value)).catch(() => {});
-  return writeChain;
+  const update = writeChain.then(() => writePreference(pluginKey, path, value));
+  // Keep subsequent writes usable while returning the actual failure to this caller.
+  writeChain = update.catch(() => {});
+  return update;
 }
 
 const WATCH_DEBOUNCE_MS = 150;
 
+/**
+ * What the watcher last saw where the preferences file should be: its text,
+ * or FILE_ABSENT once a read has confirmed the file does not exist. A symbol
+ * can never equal any file text, so deleting the file always counts as a
+ * change, even from an empty file.
+ */
+const FILE_ABSENT: unique symbol = Symbol("tui-preferences file absent");
+type WatchedState = string | typeof FILE_ABSENT;
+
+/**
+ * Read the file for the watcher. Returns FILE_ABSENT only for ENOENT; any
+ * other failure (a permission error, a directory at the path) returns null,
+ * meaning "unknown", so a file that is present but momentarily unreadable
+ * never makes callers fall back to defaults.
+ */
+async function readWatchedState(file: string): Promise<WatchedState | null> {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "ENOENT" ? FILE_ABSENT : null;
+  }
+}
+
+/**
+ * Calls `onChange` after the preferences file's content changes, including
+ * when the file is deleted (callers then read defaults) and when it is
+ * created again.
+ */
 export function watchTuiPreferences(onChange: () => void): () => void {
   const file = getTuiPreferencesFile();
   const name = basename(file);
   let timer: ReturnType<typeof setTimeout> | null = null;
-  let lastSeen: string | null = null;
-  void readFile(file, "utf8")
-    .then((text) => {
-      if (lastSeen === null) lastSeen = text;
-    })
-    .catch(() => {});
+  // null until a read has succeeded or confirmed the file is missing.
+  let lastSeen: WatchedState | null = null;
+  let stopped = false;
+  void readWatchedState(file).then((state) => {
+    if (lastSeen === null && state !== null) lastSeen = state;
+  });
   try {
     const watcher = watch(dirname(file), (_event, filename) => {
       const isOurs =
@@ -217,20 +251,23 @@ export function watchTuiPreferences(onChange: () => void): () => void {
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
         timer = null;
-        void readFile(file, "utf8")
-          .catch(() => null)
-          .then((text) => {
-            if (text === null) return;
-            if (text === lastSeen) return;
-            lastSeen = text;
-            onChange();
-          });
+        void readWatchedState(file).then((state) => {
+          if (stopped || state === null) return;
+          if (state === lastSeen) return;
+          lastSeen = state;
+          onChange();
+        });
       }, WATCH_DEBOUNCE_MS);
     });
-    return () => {
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
       if (timer) clearTimeout(timer);
+      timer = null;
       watcher.close();
     };
+    watcher.on("error", stop);
+    return stop;
   } catch {
     return () => {};
   }
@@ -238,6 +275,6 @@ export function watchTuiPreferences(onChange: () => void): () => void {
 
 export function persistCollapsedIfEnabled(prefs: AftTuiPrefs, collapsed: boolean): void {
   if (prefs.rememberCollapsed) {
-    void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], collapsed);
+    void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], collapsed).catch(() => {});
   }
 }

package/src/tui-compiled/sidebar-view.tsx

@@ -399,7 +399,8 @@ export const AftSidebarPanel = props => {
         stage: s()?.semantic_index?.stage,
         error: s()?.semantic_index?.error,
         reason: s()?.semantic_index?.reason,
-        backend_url: s()?.semantic_index?.backend_url
+        backend_url: s()?.semantic_index?.backend_url,
+        pending_reason: s()?.semantic_index?.pending_reason
       })
     };
   };

package/src/tui-compiled/v2.tsx

@@ -1,4 +1,5 @@
 import { createComponent as _$createComponent } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo } from "opentui:runtime-module:%40opentui%2Fsolid";
 import { insert as _$insert } from "opentui:runtime-module:%40opentui%2Fsolid";
 import { createElement as _$createElement } from "opentui:runtime-module:%40opentui%2Fsolid";
 /** @jsxImportSource @opentui/solid */
@@ -8,6 +9,7 @@ import { createEffect, createSignal, onCleanup } from "opentui:runtime-module:so
 import { version as packageVersion } from "../../package.json";
 import { coerceAftStatus, formatStatusDialogMessage } from "../shared/status";
 import { AftRpc } from "./aft-rpc";
+import { readTuiPreferencesFile, resolveAftPrefs, watchTuiPreferences } from "./preferences";
 import { AftSidebarPanel, createSidebarPreferences } from "./sidebar-view";
 import { formatAftStatusSegment } from "./v2-status";
 
@@ -163,7 +165,38 @@ function useAftStatus(context, rpc, sessionID) {
   });
   return status;
 }
-function FooterStatus(props) {
+
+/**
+ * The `footer` switch from the `aft` entry of `tui-preferences.jsonc`, kept
+ * current while the file is edited, as the sidebar's preferences are.
+ *
+ * It reads as hidden until the file has been read once. Starting from the
+ * default (shown) instead would flash the line on every prompt mount for
+ * someone who turned it off; the read takes milliseconds, and a missing or
+ * unreadable file resolves to the default, so the line still appears for
+ * everyone else.
+ */
+function createFooterVisibility() {
+  const [visible, setVisible] = createSignal(false);
+  // Reads can overlap when the file changes twice in quick succession; only
+  // the most recently started read may set the value.
+  let generation = 0;
+  const reload = async () => {
+    const current = ++generation;
+    const prefs = resolveAftPrefs(await readTuiPreferencesFile());
+    if (current === generation) setVisible(prefs.footer);
+  };
+  void reload();
+  const unwatch = watchTuiPreferences(() => {
+    void reload();
+  });
+  onCleanup(() => {
+    generation += 1;
+    unwatch();
+  });
+  return visible;
+}
+function FooterSegment(props) {
   const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
   return (() => {
     var _el$ = _$createElement("text");
@@ -171,6 +204,26 @@ function FooterStatus(props) {
     return _el$;
   })();
 }
+
+/**
+ * The prompt footer claim. With `footer: false` it renders no element at all,
+ * so the line takes no space, and the status subscription behind it is torn
+ * down until the switch is turned back on.
+ */
+function FooterStatus(props) {
+  const visible = createFooterVisibility();
+  return _$memo(() => _$memo(() => !!visible())() ? _$createComponent(FooterSegment, {
+    get context() {
+      return props.context;
+    },
+    get rpc() {
+      return props.rpc;
+    },
+    get sessionID() {
+      return props.sessionID;
+    }
+  }) : null);
+}
 function SidebarStatus(props) {
   const status = useAftStatus(props.context, props.rpc, () => props.sessionID);
   const preferences = createSidebarPreferences();