@cortexkit/aft-opencode 0.45.1 → 0.47.0

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

@@ -0,0 +1,448 @@
+import { AftRpcClient, type AftRpcEndpoint, subscribeRpcRedirects } from "../shared/rpc-client";
+import { resolveCortexKitStorageRoot } from "../shared/storage-paths";
+
+export interface SocketNotification {
+  id: number;
+  type: string;
+  payload: Record<string, unknown>;
+  sessionId?: string;
+}
+
+export interface StatusInvalidation {
+  sessionId?: string;
+}
+
+export interface TuiSocketOptions {
+  getDirectory: () => string | null | undefined;
+  getSessionId: () => string | null;
+  onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
+}
+
+interface WebSocketLike {
+  readyState: number;
+  addEventListener(
+    type: "open" | "message" | "close" | "error",
+    listener: (event: unknown) => void,
+  ): void;
+  send(data: string): void;
+  close(): void;
+}
+
+type WebSocketFactory = new (url: string) => WebSocketLike;
+type RpcClientLike = Pick<AftRpcClient, "resolveEndpoint" | "reset">;
+
+interface SocketDeps {
+  createClient: (directory: string) => RpcClientLike;
+  WebSocketCtor: WebSocketFactory | null;
+  setTimeout: typeof setTimeout;
+  clearTimeout: typeof clearTimeout;
+}
+
+interface SocketScope {
+  directory: string;
+  sessionId: string;
+}
+
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_MAX_MS = 10_000;
+const WEB_SOCKET_OPEN = 1;
+const clients = new Map<string, AftRpcClient>();
+const statusInvalidationListeners = new Set<(event: StatusInvalidation) => void>();
+const lastHandledIdBySession = new Map<string, number>();
+
+function defaultWebSocketCtor(): WebSocketFactory | null {
+  const ctor = (globalThis as typeof globalThis & { WebSocket?: WebSocketFactory }).WebSocket;
+  return ctor ?? null;
+}
+
+function defaultClient(directory: string): AftRpcClient {
+  let client = clients.get(directory);
+  if (!client) {
+    client = new AftRpcClient(resolveCortexKitStorageRoot(), directory);
+    clients.set(directory, client);
+  }
+  return client;
+}
+
+let deps: SocketDeps = {
+  createClient: defaultClient,
+  WebSocketCtor: defaultWebSocketCtor(),
+  setTimeout,
+  clearTimeout,
+};
+
+let opts: TuiSocketOptions | null = null;
+let socket: WebSocketLike | null = null;
+let socketScope: SocketScope | null = null;
+let helloedScope: SocketScope | null = null;
+let reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+let reconnectAttempt = 0;
+let closed = true;
+let generation = 0;
+let connectingGeneration: number | null = null;
+let connectingScope: SocketScope | null = null;
+
+export function startAftTuiSocket(options: TuiSocketOptions): void {
+  opts = options;
+  closed = false;
+  generation += 1;
+  ensureRedirectSubscription();
+  void reconcileSocketScope();
+}
+
+/**
+ * Re-home the socket when a status call learns a verified-directory redirect
+ * (see rpc-client). The socket may already be connected to this directory's
+ * bridgeless instance — which authenticates and accepts hello but will never
+ * push a status-changed frame, because the session's bridge lives in another
+ * process. Drop it and reconnect; resolveEndpoint now follows the redirect.
+ */
+let redirectUnsubscribe: (() => void) | null = null;
+function ensureRedirectSubscription(): void {
+  if (redirectUnsubscribe) return;
+  redirectUnsubscribe = subscribeRpcRedirects((from) => {
+    if (closed) return;
+    const scope = currentScope();
+    if (!scope || scope.directory !== from) return;
+    generation += 1;
+    connectingGeneration = null;
+    connectingScope = null;
+    closeCurrentSocket(false);
+    void connect(scope, generation);
+  });
+}
+
+export function stopAftTuiSocket(): void {
+  closed = true;
+  generation += 1;
+  connectingGeneration = null;
+  connectingScope = null;
+  if (redirectUnsubscribe) {
+    redirectUnsubscribe();
+    redirectUnsubscribe = null;
+  }
+  if (reconnectTimer) {
+    deps.clearTimeout(reconnectTimer);
+    reconnectTimer = undefined;
+  }
+  closeCurrentSocket(false);
+  for (const client of clients.values()) client.reset();
+  clients.clear();
+  reconnectAttempt = 0;
+}
+
+export function refreshAftTuiSocketScope(): void {
+  if (closed) return;
+  void reconcileSocketScope();
+}
+
+export function subscribeStatusInvalidations(
+  listener: (event: StatusInvalidation) => void,
+): () => void {
+  statusInvalidationListeners.add(listener);
+  return () => {
+    statusInvalidationListeners.delete(listener);
+  };
+}
+
+export function createDebouncedStatusRefresh(
+  refresh: () => void | Promise<void>,
+  delayMs: number,
+): { schedule: () => void; dispose: () => void } {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let disposed = false;
+  return {
+    schedule() {
+      if (disposed) return;
+      if (timer) deps.clearTimeout(timer);
+      timer = deps.setTimeout(() => {
+        timer = undefined;
+        void refresh();
+      }, delayMs);
+    },
+    dispose() {
+      disposed = true;
+      if (timer) {
+        deps.clearTimeout(timer);
+        timer = undefined;
+      }
+    },
+  };
+}
+
+function currentScope(): SocketScope | null {
+  const directory = opts?.getDirectory() ?? "";
+  const sessionId = opts?.getSessionId() ?? "";
+  if (!directory || !sessionId) return null;
+  return { directory, sessionId };
+}
+
+function sameScope(a: SocketScope | null, b: SocketScope | null): boolean {
+  return a?.directory === b?.directory && a?.sessionId === b?.sessionId;
+}
+
+async function reconcileSocketScope(): Promise<void> {
+  if (closed || !opts) return;
+  const scope = currentScope();
+  if (!scope) {
+    generation += 1;
+    connectingGeneration = null;
+    connectingScope = null;
+    closeCurrentSocket(false);
+    return;
+  }
+
+  if (socket && socketScope?.directory === scope.directory) {
+    if (!sameScope(socketScope, scope) && socket.readyState !== WEB_SOCKET_OPEN) {
+      generation += 1;
+      closeCurrentSocket(false);
+      await connect(scope, generation);
+      return;
+    }
+    if (socket.readyState === WEB_SOCKET_OPEN && !sameScope(helloedScope, scope)) {
+      await sendHelloWithFreshToken(socket, scope, generation);
+    }
+    return;
+  }
+
+  if (sameScope(connectingScope, scope)) return;
+
+  generation += 1;
+  connectingGeneration = null;
+  connectingScope = null;
+  closeCurrentSocket(false);
+  await connect(scope, generation);
+}
+
+async function connect(scope: SocketScope, connectGeneration: number): Promise<void> {
+  if (closed || socket || connectingGeneration !== null) return;
+  const WebSocketCtor = deps.WebSocketCtor ?? defaultWebSocketCtor();
+  if (!WebSocketCtor) {
+    scheduleReconnect();
+    return;
+  }
+
+  connectingGeneration = connectGeneration;
+  connectingScope = scope;
+  let endpoint: AftRpcEndpoint | null = null;
+  try {
+    endpoint = await deps.createClient(scope.directory).resolveEndpoint();
+  } catch {
+    endpoint = null;
+  }
+
+  if (connectingGeneration === connectGeneration) {
+    connectingGeneration = null;
+    connectingScope = null;
+  }
+  if (closed || connectGeneration !== generation || !sameScope(currentScope(), scope)) return;
+  if (!endpoint) {
+    scheduleReconnect();
+    return;
+  }
+
+  let ws: WebSocketLike;
+  try {
+    ws = new WebSocketCtor(`ws://127.0.0.1:${endpoint.port}/ws`);
+  } catch {
+    scheduleReconnect();
+    return;
+  }
+
+  socket = ws;
+  socketScope = scope;
+  helloedScope = null;
+
+  ws.addEventListener("open", () => {
+    if (socket !== ws || connectGeneration !== generation) return;
+    reconnectAttempt = 0;
+    sendHello(ws, scope, endpoint.token);
+  });
+
+  ws.addEventListener("message", (event) => {
+    if (socket !== ws || connectGeneration !== generation) return;
+    const data =
+      typeof (event as { data?: unknown }).data === "string"
+        ? (event as { data: string }).data
+        : String((event as { data?: unknown }).data ?? "");
+    void handleSocketMessage(ws, data, connectGeneration);
+  });
+
+  const onDown = () => {
+    if (socket !== ws) return;
+    socket = null;
+    socketScope = null;
+    helloedScope = null;
+    generation += 1;
+    scheduleReconnect();
+  };
+  ws.addEventListener("close", onDown);
+  ws.addEventListener("error", () => {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+    onDown();
+  });
+}
+
+function closeCurrentSocket(schedule: boolean): void {
+  const ws = socket;
+  socket = null;
+  socketScope = null;
+  helloedScope = null;
+  if (ws) {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+  }
+  if (schedule) scheduleReconnect();
+}
+
+function scheduleReconnect(): void {
+  if (closed || reconnectTimer) return;
+  const scope = currentScope();
+  if (!scope) return;
+  const delay = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS);
+  reconnectAttempt += 1;
+  reconnectTimer = deps.setTimeout(() => {
+    reconnectTimer = undefined;
+    const nextScope = currentScope();
+    if (!nextScope) return;
+    void connect(nextScope, generation);
+  }, delay);
+}
+
+async function sendHelloWithFreshToken(
+  ws: WebSocketLike,
+  scope: SocketScope,
+  expectedGeneration: number,
+): Promise<void> {
+  let endpoint: AftRpcEndpoint | null = null;
+  try {
+    endpoint = await deps.createClient(scope.directory).resolveEndpoint();
+  } catch {
+    endpoint = null;
+  }
+  if (
+    closed ||
+    socket !== ws ||
+    expectedGeneration !== generation ||
+    !sameScope(currentScope(), scope)
+  ) {
+    return;
+  }
+  sendHello(ws, scope, endpoint?.token ?? null);
+}
+
+function sendHello(ws: WebSocketLike, scope: SocketScope, token: string | null): void {
+  helloedScope = scope;
+  if (socket === ws) socketScope = scope;
+  const lastReceivedId = lastHandledIdBySession.get(scope.sessionId) ?? 0;
+  ws.send(
+    JSON.stringify({
+      type: "hello",
+      token: token ?? "",
+      sessionId: scope.sessionId,
+      lastReceivedId,
+    }),
+  );
+}
+
+async function handleSocketMessage(
+  ws: WebSocketLike,
+  raw: string,
+  messageGeneration: number,
+): Promise<void> {
+  let msg: {
+    type?: string;
+    notification?: SocketNotification;
+    sessionId?: string;
+    error?: string;
+  };
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  if (msg.type === "status-changed") {
+    for (const listener of statusInvalidationListeners) {
+      try {
+        listener({ sessionId: msg.sessionId });
+      } catch {
+        // One sidebar/dialog listener must not block the others.
+      }
+    }
+    return;
+  }
+
+  if (msg.type === "notification" && msg.notification) {
+    const notification = msg.notification;
+    const active = opts?.getSessionId() ?? null;
+    if (!active) return;
+    if (notification.sessionId && notification.sessionId !== active) return;
+
+    let consumed = false;
+    try {
+      consumed = await Promise.resolve(opts?.onNotification(notification) ?? false);
+    } catch {
+      consumed = false;
+    }
+
+    if (
+      socket !== ws ||
+      messageGeneration !== generation ||
+      (opts?.getSessionId() ?? null) !== active
+    ) {
+      return;
+    }
+    if (consumed && notification.id > (lastHandledIdBySession.get(active) ?? 0)) {
+      lastHandledIdBySession.set(active, notification.id);
+      try {
+        ws.send(JSON.stringify({ type: "ack", lastReceivedId: notification.id }));
+      } catch {
+        // best-effort; reconnect hello replays the cursor.
+      }
+    }
+    return;
+  }
+
+  if (msg.type === "error") {
+    try {
+      ws.close();
+    } catch {
+      // best-effort
+    }
+  }
+}
+
+export function __setAftTuiSocketDepsForTest(overrides: Partial<SocketDeps>): () => void {
+  const previous = deps;
+  deps = { ...deps, ...overrides };
+  return () => {
+    deps = previous;
+  };
+}
+
+export function __resetAftTuiSocketForTest(): void {
+  stopAftTuiSocket();
+  opts = null;
+  statusInvalidationListeners.clear();
+  lastHandledIdBySession.clear();
+  clients.clear();
+  reconnectAttempt = 0;
+  generation = 0;
+  connectingGeneration = null;
+  connectingScope = null;
+  closed = true;
+  deps = {
+    createClient: defaultClient,
+    WebSocketCtor: defaultWebSocketCtor(),
+    setTimeout,
+    clearTimeout,
+  };
+}

package/src/tui-compiled/preferences.ts

@@ -0,0 +1,243 @@
+import { watch } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+
+export const TUI_PREFS_FILE_ENV = "OPENCODE_TUI_PREFERENCES_FILE";
+const FILE_NAME = "tui-preferences.jsonc";
+
+export function getTuiPreferencesFile(): string {
+  const override = process.env[TUI_PREFS_FILE_ENV];
+  if (override) return override;
+  const configDir =
+    process.env.OPENCODE_CONFIG_DIR ||
+    join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+  return join(configDir, FILE_NAME);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export async function readTuiPreferencesFile(): Promise<Record<string, unknown>> {
+  try {
+    const raw = await readFile(getTuiPreferencesFile(), "utf8");
+    const root: unknown = parse(raw);
+    return isRecord(root) ? (root as Record<string, unknown>) : {};
+  } catch {
+    return {};
+  }
+}
+
+export const PLUGIN_KEY = "aft";
+export const DEFAULT_SLOT_ORDER = 180;
+
+export interface AftTuiPrefs {
+  forceToTop: boolean;
+  order: number;
+  startCollapsed: boolean;
+  rememberCollapsed: boolean;
+  collapsed: boolean | null;
+  header: {
+    label: string;
+    showVersion: boolean;
+  };
+  sections: {
+    searchIndex: boolean;
+    semanticIndex: boolean;
+    codeHealth: boolean;
+    compression: boolean;
+  };
+}
+
+export const DEFAULT_PREFS: AftTuiPrefs = {
+  forceToTop: false,
+  order: DEFAULT_SLOT_ORDER,
+  startCollapsed: false,
+  rememberCollapsed: true,
+  collapsed: null,
+  header: { label: "AFT", showVersion: true },
+  sections: {
+    searchIndex: true,
+    semanticIndex: true,
+    codeHealth: true,
+    compression: true,
+  },
+};
+
+function bool(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function int(value: unknown, fallback: number, min: number, max: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(Math.max(Math.round(value), min), max);
+}
+
+function label(value: unknown, fallback: string, maxLength: number): string {
+  if (typeof value !== "string" || value.length === 0) return fallback;
+  return value.slice(0, maxLength);
+}
+
+/** Initial collapsed state from persisted prefs or startCollapsed default. */
+export function seedCollapsedFromPrefs(prefs: AftTuiPrefs): boolean {
+  return prefs.collapsed ?? prefs.startCollapsed;
+}
+
+export function resolveAftPrefs(root: Record<string, unknown>): AftTuiPrefs {
+  const entry = root[PLUGIN_KEY];
+  if (!isRecord(entry)) return structuredClone(DEFAULT_PREFS);
+
+  const d = DEFAULT_PREFS;
+  const header = isRecord(entry.header) ? entry.header : {};
+  const sections = isRecord(entry.sections) ? entry.sections : {};
+
+  return {
+    forceToTop: bool(entry.forceToTop, d.forceToTop),
+    order: int(entry.order, d.order, -10000, 10000),
+    startCollapsed: bool(entry.startCollapsed, d.startCollapsed),
+    rememberCollapsed: bool(entry.rememberCollapsed, d.rememberCollapsed),
+    collapsed: typeof entry.collapsed === "boolean" ? entry.collapsed : null,
+    header: {
+      label: label(header.label, d.header.label, 20),
+      showVersion: bool(header.showVersion, d.header.showVersion),
+    },
+    sections: {
+      searchIndex: bool(sections.searchIndex, d.sections.searchIndex),
+      semanticIndex: bool(sections.semanticIndex, d.sections.semanticIndex),
+      codeHealth: bool(sections.codeHealth, d.sections.codeHealth),
+      compression: bool(sections.compression, d.sections.compression),
+    },
+  };
+}
+
+const FORCE_TOP_BASE = -100000;
+
+export function computeEffectiveOrder(
+  root: Record<string, unknown>,
+  pluginKey: string,
+  defaultOrder: number,
+): number {
+  const entry = root[pluginKey];
+  if (!isRecord(entry)) return defaultOrder;
+  if (entry.forceToTop === true) {
+    return FORCE_TOP_BASE + Object.keys(root).indexOf(pluginKey);
+  }
+  return int(entry.order, defaultOrder, -10000, 10000);
+}
+
+const TEMPLATE = `// Shared preferences for opencode TUI plugins.
+// One top-level key per plugin (short name). See each plugin's README for
+// its supported settings. This file is safe to hand-edit; plugins update
+// individual keys in place and preserve comments.
+{}
+`;
+
+type JsonValue = string | number | boolean | null;
+
+function setNested(target: Record<string, unknown>, path: string[], value: JsonValue): void {
+  let current: Record<string, unknown> = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (key === undefined) return;
+    const next = current[key];
+    if (!isRecord(next)) {
+      const created: Record<string, unknown> = {};
+      current[key] = created;
+      current = created;
+    } else {
+      current = next;
+    }
+  }
+  const leaf = path[path.length - 1];
+  if (leaf === undefined) return;
+  current[leaf] = value;
+}
+
+async function writePreference(pluginKey: string, path: string[], value: JsonValue): Promise<void> {
+  const file = getTuiPreferencesFile();
+  await mkdir(dirname(file), { recursive: true });
+  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 = {};
+  }
+
+  if (!isRecord(root[pluginKey])) {
+    root[pluginKey] = {};
+  }
+  const entry = root[pluginKey] as Record<string, unknown>;
+  setNested(entry, path, value);
+
+  const next = `${stringify(root, null, 2)}\n`;
+  const tmp = `${file}.${process.pid}.tmp`;
+  await writeFile(tmp, next, "utf8");
+  await rename(tmp, file);
+}
+
+let writeChain: Promise<void> = Promise.resolve();
+
+export function queueTuiPreferenceUpdate(
+  pluginKey: string,
+  path: string[],
+  value: JsonValue,
+): Promise<void> {
+  writeChain = writeChain.then(() => writePreference(pluginKey, path, value)).catch(() => {});
+  return writeChain;
+}
+
+const WATCH_DEBOUNCE_MS = 150;
+
+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(() => {});
+  try {
+    const watcher = watch(dirname(file), (_event, filename) => {
+      const isOurs =
+        filename === name || (filename?.startsWith(`${name}.`) && filename.endsWith(".tmp"));
+      if (filename != null && !isOurs) return;
+      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();
+          });
+      }, WATCH_DEBOUNCE_MS);
+    });
+    return () => {
+      if (timer) clearTimeout(timer);
+      watcher.close();
+    };
+  } catch {
+    return () => {};
+  }
+}
+
+export function persistCollapsedIfEnabled(prefs: AftTuiPrefs, collapsed: boolean): void {
+  if (prefs.rememberCollapsed) {
+    void queueTuiPreferenceUpdate(PLUGIN_KEY, ["collapsed"], collapsed);
+  }
+}