@cortexkit/aft-opencode 0.30.1 → 0.30.2

package/src/shared/live-server-client.ts

@@ -23,11 +23,12 @@
  * reachable. OpenCode Desktop (Electron+Node) and TUI launched with
  * `opencode --port 0` bind a real API listener; plain TUI binds an
  * internal-only listener that 404s for `/session/*`. We probe once at
- * plugin init and cache the result. When the listener is unreachable
- * the wake path silently uses the in-process `input.client.session.promptAsync`,
- * which keeps wakes flowing (at the cost of the upstream duplicate-runner
- * bug) instead of producing no notification at all or nagging the user
- * to relaunch with a different flag.
+ * plugin init and cache the result by `serverUrl`. When that server is
+ * unreachable, the wake path silently uses the in-process
+ * `input.client.session.promptAsync`, which keeps wakes flowing (at the
+ * cost of the upstream duplicate-runner bug) instead of producing no
+ * notification at all or nagging the user to relaunch with a different
+ * flag.
  *
  * Tracked upstream as anomalyco/opencode#28202. When OpenCode fixes the
  * runtime split, this helper and its single consumer in `bg-notifications.ts`
@@ -51,6 +52,14 @@ function cacheKey(serverUrl: string, directory: string): string {
   return `${serverUrl}|${directory}`;
 }
 
+function normalizeServerUrl(serverUrl: string): string {
+  try {
+    return new URL(serverUrl).toString();
+  } catch {
+    return serverUrl;
+  }
+}
+
 /**
  * Build the Basic-auth header OpenCode's server expects when
  * `OPENCODE_SERVER_PASSWORD` is set. Read at call time (not at module load)
@@ -95,80 +104,103 @@ export function __resetLiveServerClientCacheForTests(): void {
 }
 
 /**
- * Probe whether `serverUrl` accepts a connection within `timeoutMs`.
- * Returns `true` for any HTTP response (including 4xx / 5xx) since the
- * goal is to confirm the listener exists. Returns `false` on connection
- * refused, DNS failure, timeout, or undefined URL.
+ * Per-server decision: should bg-notifications use the live-server wake
+ * transport (workaround for anomalyco/opencode#28202), or fall back to the
+ * in-process `input.client.session.promptAsync` path?
  *
- * Used at plugin init to decide whether bg-notifications should use the
- * live-server wake transport (workaround for anomalyco/opencode#28202)
- * or fall back to the in-process `input.client.session.promptAsync`
- * path. Plain TUI (no `--port 0`) binds an internal-only listener that
- * 404s for `/session/...`, so this returns false there; OpenCode
- * Desktop, `opencode run`, and `opencode --port 0` TUI return true.
+ * Keying by `serverUrl` matters because one plugin process can host
+ * multiple OpenCode windows with different live listener URLs. A missing
+ * keyed decision defaults to `false` for safety: the in-process client is
+ * part of the plugin contract, while the live-server path requires a
+ * probe-confirmed listener.
+ *
+ * `legacyLiveServerWakeAvailable` is retained only for older callers/tests
+ * that do not pass a `serverUrl`; keyed wake callers never read it.
+ */
+const liveServerWakeAvailableByServerUrl = new Map<string, boolean>();
+let legacyLiveServerWakeAvailable = false;
+
+/**
+ * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
+ * Returns `true` only when `/session` proves the API is usable: any 2xx
+ * response is reachable, and 401/403 also count as reachable because an
+ * auth-protected listener still exists. Returns `false` for 404 (plain
+ * TUI's internal listener), 5xx, connection refused, DNS failure, timeout,
+ * malformed URL, or undefined URL.
+ *
+ * The probe records its result in the per-`serverUrl` wake-availability
+ * cache. That keeps multiple OpenCode windows with different live listener
+ * URLs from sharing one process-global transport decision.
  */
 export async function probeServerReachable(
   serverUrl: string | undefined,
   timeoutMs = 1500,
 ): Promise<boolean> {
   if (!serverUrl) return false;
+  const normalizedServerUrl = normalizeServerUrl(serverUrl);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let reachable = false;
   try {
     // Hit a path that actually exists on the OpenCode HTTP API so a
-    // 200 confirms the API server is up, not just any random listener
-    // (e.g. an internal IPC port that happens to accept TCP but rejects
-    // all paths with 404 — which is exactly what TUI binds without
+    // successful response confirms the API server is up, not just any
+    // random listener (e.g. an internal IPC port that accepts TCP but
+    // rejects all paths with 404 — exactly what TUI binds without
     // `--port 0`).
     const probeUrl = new URL("/session", serverUrl).toString();
     const res = await globalThis.fetch(probeUrl, {
       method: "GET",
+      headers: serverAuthHeaders(),
       signal: controller.signal,
     });
-    return res.status >= 200 && res.status < 500;
+    reachable = res.ok || res.status === 401 || res.status === 403;
   } catch {
-    return false;
+    reachable = false;
   } finally {
     clearTimeout(timer);
+    liveServerWakeAvailableByServerUrl.set(normalizedServerUrl, reachable);
   }
+  return reachable;
 }
 
 /**
- * Per-plugin-process decision: should bg-notifications use the live-server
- * wake transport (workaround for anomalyco/opencode#28202), or fall back
- * to the in-process `input.client.session.promptAsync` path?
- *
- * Set once at plugin init from the result of `probeServerReachable()`.
- * Defaults to `false` if no decision has been recorded yet — that's the
- * safe direction because `input.client.session.promptAsync` is always
- * available (it's part of the plugin contract), whereas the live-server
- * path needs both a probe-confirmed listener and the workaround code
- * itself to be live.
- *
- * Read at wake time (not cached on a closure) so background probes that
- * complete after plugin init still take effect on the next wake.
- */
-let liveServerWakeAvailable = false;
-
-/**
- * Record the probe result. Idempotent; if you record twice, the latest
- * value wins. The wake path reads through `useLiveServerWake()`.
+ * Record a probe result. Prefer the `(serverUrl, available)` form; the
+ * single-boolean form is a compatibility fallback for old call sites and
+ * tests that do not yet have a URL to key by.
  */
-export function setLiveServerWakeAvailable(available: boolean): void {
-  liveServerWakeAvailable = available;
+export function setLiveServerWakeAvailable(available: boolean): void;
+export function setLiveServerWakeAvailable(serverUrl: string | undefined, available: boolean): void;
+export function setLiveServerWakeAvailable(
+  serverUrlOrAvailable: string | boolean | undefined,
+  available?: boolean,
+): void {
+  if (typeof serverUrlOrAvailable === "boolean") {
+    legacyLiveServerWakeAvailable = serverUrlOrAvailable;
+    return;
+  }
+  if (!serverUrlOrAvailable) {
+    legacyLiveServerWakeAvailable = available ?? false;
+    return;
+  }
+  liveServerWakeAvailableByServerUrl.set(
+    normalizeServerUrl(serverUrlOrAvailable),
+    available ?? false,
+  );
 }
 
 /**
- * Read the cached probe decision. `true` means the wake path should use
- * `getLiveServerClient(serverUrl, directory)` and POST through the live
- * HTTP listener. `false` means fall back to the in-process client passed
- * via plugin context (`input.client`).
+ * Read the cached probe decision for `serverUrl`. `true` means the wake path
+ * should use `getLiveServerClient(serverUrl, directory)` and POST through
+ * the live HTTP listener. `false` means fall back to the in-process client
+ * passed via plugin context (`input.client`).
  */
-export function useLiveServerWake(): boolean {
-  return liveServerWakeAvailable;
+export function useLiveServerWake(serverUrl?: string): boolean {
+  if (!serverUrl) return legacyLiveServerWakeAvailable;
+  return liveServerWakeAvailableByServerUrl.get(normalizeServerUrl(serverUrl)) ?? false;
 }
 
 /** Test helper — reset the decision cache between cases. */
 export function __resetLiveServerWakeForTests(): void {
-  liveServerWakeAvailable = false;
+  liveServerWakeAvailableByServerUrl.clear();
+  legacyLiveServerWakeAvailable = false;
 }

package/src/shared/rpc-client.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { warn } from "../logger";
 import { rpcPortFileDir, rpcPortFilePath } from "./rpc-utils";
@@ -7,13 +7,46 @@ const MAX_RETRIES = 10;
 const RETRY_DELAY_MS = 500;
 const REQUEST_TIMEOUT_MS = 5000;
 
-type PortInfo = { port: number; token: string | null };
+type PortInfoSource = "instance" | "legacy";
+type ParsedPortInfo = { port: number; token: string | null };
+type PortInfo = ParsedPortInfo & { source: PortInfoSource; path?: string };
+
+export interface AftRpcCallOptions {
+  signal?: AbortSignal;
+}
+
+function abortError(signal: AbortSignal): Error {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason;
+  return new Error("AFT RPC request aborted");
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) throw abortError(signal);
+}
+
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout>;
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal ? abortError(signal) : new Error("AFT RPC request aborted"));
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 
 export class AftRpcClient {
   private port: number | null = null;
   private token: string | null = null;
   private portsDir: string;
   private legacyPortFile: string;
+  private stalePortFailures = new Map<string, number>();
 
   constructor(storageDir: string, directory: string) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
@@ -24,11 +57,15 @@ export class AftRpcClient {
   async call<T = Record<string, unknown>>(
     method: string,
     params: Record<string, unknown> = {},
+    options: AftRpcCallOptions = {},
   ): Promise<T> {
+    const { signal } = options;
+    throwIfAborted(signal);
+
     // Try ALL discovered ports for this project (OpenCode TUI under --port 0
     // loads our plugin twice in the same process, so two RPC servers listen
     // and we have to try both — only one's bridge is actually warm).
-    const infos = await this.resolvePortInfos();
+    const infos = await this.resolvePortInfos(signal);
     if (infos.length === 0) {
       throw new Error("AFT RPC server not available");
     }
@@ -39,8 +76,9 @@ export class AftRpcClient {
     let placeholder: T | null = null;
     let lastError: unknown = null;
     for (const info of infos) {
+      throwIfAborted(signal);
       try {
-        const result = await this.callOne<T>(method, params, info);
+        const result = await this.callOne<T>(method, params, info, signal);
         if (this.looksLikePlaceholder(result)) {
           placeholder = result; // remember but keep trying
           continue;
@@ -50,6 +88,7 @@ export class AftRpcClient {
         this.token = info.token;
         return result;
       } catch (err) {
+        throwIfAborted(signal);
         lastError = err;
       }
     }
@@ -64,12 +103,17 @@ export class AftRpcClient {
     method: string,
     params: Record<string, unknown>,
     info: PortInfo,
+    signal?: AbortSignal,
   ): Promise<T> {
-    const response = await this.fetchWithTimeout(`http://127.0.0.1:${info.port}/rpc/${method}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...params, token: info.token }),
-    });
+    const response = await this.fetchWithTimeout(
+      `http://127.0.0.1:${info.port}/rpc/${method}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ...params, token: info.token }),
+      },
+      signal,
+    );
     if (!response.ok) {
       const text = await response.text();
       throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
@@ -100,23 +144,28 @@ export class AftRpcClient {
 
   /**
    * Discover all live RPC port files for this project. Tries the per-instance
-   * directory first (v0.28.2+), then falls back to the single legacy `port`
-   * file (older plugin versions in mixed deployments).
+   * directory first (v0.28.2+), then the single legacy `port` file (older
+   * plugin versions in mixed deployments) as the final fallback candidate.
    */
-  private async resolvePortInfos(): Promise<PortInfo[]> {
+  private async resolvePortInfos(signal?: AbortSignal): Promise<PortInfo[]> {
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      throwIfAborted(signal);
       const infos = this.readAllPortFiles();
       if (infos.length > 0) {
         const alive: PortInfo[] = [];
         for (const info of infos) {
-          if (await this.healthCheck(info.port)) {
+          throwIfAborted(signal);
+          if (await this.healthCheck(info.port, signal)) {
+            this.clearPortFailure(info);
             alive.push(info);
+          } else {
+            this.recordPortFailure(info);
           }
         }
         if (alive.length > 0) return alive;
       }
       if (attempt < MAX_RETRIES - 1) {
-        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+        await delay(RETRY_DELAY_MS, signal);
       }
     }
     return [];
@@ -124,30 +173,40 @@ export class AftRpcClient {
 
   private readAllPortFiles(): PortInfo[] {
     const collected: PortInfo[] = [];
+    const seenPorts = new Set<number>();
+    const add = (info: PortInfo) => {
+      if (seenPorts.has(info.port)) return;
+      seenPorts.add(info.port);
+      collected.push(info);
+    };
+
     // Per-instance directory (v0.28.2+): one file per plugin load.
     if (existsSync(this.portsDir)) {
       try {
-        const entries = readdirSync(this.portsDir);
+        const entries = readdirSync(this.portsDir).sort();
         for (const entry of entries) {
           if (!entry.endsWith(".json")) continue;
-          const info = this.parsePortFile(join(this.portsDir, entry));
-          if (info) collected.push(info);
+          const filePath = join(this.portsDir, entry);
+          const info = this.parsePortFile(filePath);
+          if (info) add({ ...info, source: "instance", path: filePath });
         }
       } catch {
         // ignore read errors
       }
     }
+
     // Legacy single file (pre-v0.28.2 plugin versions in mixed deployments).
-    if (collected.length === 0) {
-      const info = this.parsePortFile(this.legacyPortFile);
-      if (info) collected.push(info);
-    }
+    // Always append it after per-instance entries so a stale JSON file cannot
+    // mask an older live server, then de-dupe by port with per-instance winning.
+    const legacyInfo = this.parsePortFile(this.legacyPortFile);
+    if (legacyInfo) add({ ...legacyInfo, source: "legacy", path: this.legacyPortFile });
+
     return collected;
   }
 
-  private parsePortFile(path: string): PortInfo | null {
+  private parsePortFile(filePath: string): ParsedPortInfo | null {
     try {
-      const content = readFileSync(path, "utf-8").trim();
+      const content = readFileSync(filePath, "utf-8").trim();
       let port: number;
       let token: string | null;
       if (content.startsWith("{")) {
@@ -168,29 +227,74 @@ export class AftRpcClient {
     }
   }
 
-  private async healthCheck(port: number): Promise<boolean> {
+  private portFailureKey(info: PortInfo): string | null {
+    if (info.source !== "instance" || !info.path) return null;
+    return `${info.path}\0${info.port}\0${info.token ?? ""}`;
+  }
+
+  private clearPortFailure(info: PortInfo): void {
+    const key = this.portFailureKey(info);
+    if (key) this.stalePortFailures.delete(key);
+  }
+
+  private recordPortFailure(info: PortInfo): void {
+    const key = this.portFailureKey(info);
+    if (!key || !info.path) return;
+
+    const failures = (this.stalePortFailures.get(key) ?? 0) + 1;
+    if (failures < 2) {
+      this.stalePortFailures.set(key, failures);
+      return;
+    }
+
+    this.stalePortFailures.delete(key);
     try {
-      const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
-        method: "GET",
-      });
+      // Do not unlink a replacement written after the failed health checks.
+      const current = this.parsePortFile(info.path);
+      if (current?.port === info.port && current.token === info.token) {
+        unlinkSync(info.path);
+      }
+    } catch {
+      // best-effort stale cleanup only
+    }
+  }
+
+  private async healthCheck(port: number, signal?: AbortSignal): Promise<boolean> {
+    try {
+      const response = await this.fetchWithTimeout(
+        `http://127.0.0.1:${port}/health`,
+        { method: "GET" },
+        signal,
+      );
       return response.ok;
     } catch {
+      throwIfAborted(signal);
       return false;
     }
   }
 
-  private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
+  private async fetchWithTimeout(
+    url: string,
+    options: RequestInit,
+    signal?: AbortSignal,
+  ): Promise<Response> {
+    throwIfAborted(signal);
+
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    const onAbort = () => controller.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
     try {
       return await fetch(url, { ...options, signal: controller.signal });
     } finally {
       clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
     }
   }
 
   reset(): void {
     this.port = null;
     this.token = null;
+    this.stalePortFailures.clear();
   }
 }

package/src/shared/storage-paths.ts

@@ -0,0 +1,22 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+function homeDir(): string {
+  if (process.platform === "win32") return process.env.USERPROFILE || process.env.HOME || homedir();
+  return process.env.HOME || homedir();
+}
+
+function dataHome(): string {
+  // Keep this in sync with the bridge package's storage migration helper,
+  // but do not import that package from TUI code: its public barrel also
+  // exports URL-fetch helpers unsuitable for Bun's TUI runtime.
+  if (process.env.XDG_DATA_HOME) return process.env.XDG_DATA_HOME;
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join(homeDir(), "AppData", "Local");
+  }
+  return join(homeDir(), ".local", "share");
+}
+
+export function resolveCortexKitStorageRoot(): string {
+  return join(dataHome(), "cortexkit", "aft");
+}

package/src/tui/index.tsx

@@ -4,10 +4,14 @@
 import type { TuiPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui";
 import { createMemo, createSignal, onCleanup } from "solid-js";
 
-import packageJson from "../../package.json";
+import { version as packageVersion } from "../../package.json";
 import { AftRpcClient } from "../shared/rpc-client";
 import { type AftStatusSnapshot, coerceAftStatus, formatBytes } from "../shared/status";
-import { createAftSidebarSlot, formatCompressionSidebarRows } from "./sidebar";
+import {
+  createAftSidebarSlot,
+  formatCompressionSidebarRows,
+  resolveTuiStorageDir,
+} from "./sidebar";
 
 // The TUI talks to the server plugin via AftRpcClient. The client reads the
 // JSON port file written by AftRpcServer ({ port, token }) and includes that
@@ -23,16 +27,7 @@ function getRpcClient(directory: string): AftRpcClient {
   let client = rpcClients.get(directory);
   if (client) return client;
 
-  // v0.27 moved AFT storage to the CortexKit root. The TUI plugin must use
-  // the same path as the server plugin (`resolveCortexKitStorageRoot()`),
-  // otherwise it polls stale legacy port files written by older versions
-  // and never picks up the live RPC server, leaving the sidebar/dialog
-  // stuck on the "AFT is starting up" placeholder forever.
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  const dataHome = process.env.XDG_DATA_HOME || `${home}/.local/share`;
-  const storageDir = `${dataHome}/cortexkit/aft`;
-
-  client = new AftRpcClient(storageDir, directory);
+  client = new AftRpcClient(resolveTuiStorageDir(), directory);
   rpcClients.set(directory, client);
   return client;
 }
@@ -142,18 +137,45 @@ const StatusDialog = (props: StatusDialogProps) => {
   const [status, setStatus] = createSignal<AftStatusSnapshot | null>(props.initial);
   const [error, setError] = createSignal<string | null>(props.initialError);
 
-  const timer = setInterval(async () => {
+  let pollGeneration = 0;
+  let pollController: AbortController | null = null;
+  const pollStatus = async () => {
+    if (pollController) return;
+
+    const controller = new AbortController();
+    const requestGeneration = ++pollGeneration;
+    pollController = controller;
+
     try {
-      const response = await props.client.call("status", { sessionID: props.sessionID });
+      const response = await props.client.call(
+        "status",
+        { sessionID: props.sessionID },
+        { signal: controller.signal },
+      );
+      if (controller.signal.aborted || requestGeneration !== pollGeneration) return;
       if ((response as Record<string, unknown>).success !== false) {
         setStatus(coerceAftStatus(response as Record<string, unknown>));
         setError(null);
       }
     } catch {
+      if (controller.signal.aborted || requestGeneration !== pollGeneration) return;
       // transient — keep showing last good snapshot
+    } finally {
+      if (pollController === controller) pollController = null;
     }
+  };
+
+  const timer = setInterval(() => {
+    void pollStatus();
   }, POLL_INTERVAL_MS);
-  onCleanup(() => clearInterval(timer));
+  onCleanup(() => {
+    clearInterval(timer);
+    pollGeneration++;
+    if (pollController) {
+      pollController.abort();
+      pollController = null;
+    }
+  });
 
   // Visual cache-role badge: main is accent, worktree is warning,
   // not_initialized is muted. Matches the sidebar convention.
@@ -182,7 +204,7 @@ const StatusDialog = (props: StatusDialogProps) => {
           <b>⚡ AFT Status</b>
         </text>
         {status()?.cache_role !== "not_initialized" && (
-          <text fg={t().textMuted}>v{status()?.version ?? packageJson.version}</text>
+          <text fg={t().textMuted}>v{status()?.version ?? packageVersion}</text>
         )}
       </box>
 
@@ -602,7 +624,7 @@ const tui: TuiPlugin = async (api) => {
   // command palette entry so the sidebar is available immediately when the
   // user opens their first session.
   try {
-    api.slots.register(createAftSidebarSlot(api, packageJson.version));
+    api.slots.register(createAftSidebarSlot(api, packageVersion));
   } catch {
     // Older OpenCode TUI hosts may not implement api.slots; fall through
     // and keep the slash command working.