@mortz.prk/opencode-auto-mode 1.0.2 → 1.1.1

package/src/gui-state.ts

@@ -1,160 +1,269 @@
-import type { AutoModeDecision, AutoModeStatus } from "./rpc.js";
+import { MAX_SESSION_ID_CHARS, type AutoModeAction, type AutoModeStatus } from "./rpc.js";
 
-/**
- * The routed session as status polling sees it. The RPC client reads the app's
- * own server, so a session on another server has no status to show here, and
- * the selection key must carry the server: two servers can use the same
- * session id.
- */
 export interface StatusTarget {
-  /** `${server id}\n${session id}`: unique across servers. */
+  /** Server, session and location fingerprint. */
   key: string;
-  /** The session id on its own server, the id the status RPC takes. */
   sessionID: string;
-  /** Whether the session runs on the app's own server, the one the client reads. */
   ownServer: boolean;
+  location: { directory: string; workspaceID?: string };
 }
 
-/** The session identity the status client needs; the desktop's mounted session satisfies it. */
 export interface RoutedSession {
-  /** `${server id}\n${session id}`: unique across servers. */
   readonly key: string;
-  /** The session's id on its server. */
   readonly id: string;
-  /** The session's server. */
   readonly server: { readonly builtin: boolean };
+  readonly location: { readonly directory: string; readonly workspaceID?: string } | undefined;
+}
+
+/** Shared location fingerprint for routed sessions and server targets. */
+export function statusLocationKey(serverKey: string, location: { directory: string; workspaceID?: string }): string {
+  return JSON.stringify([serverKey, location.directory, location.workspaceID]);
 }
 
-/** The status target of a routed session, or undefined while none is routed. */
+/** Unknown locations must not accidentally query the server's default location. */
 export function statusTarget(session: RoutedSession | undefined): StatusTarget | undefined {
-  return session === undefined
-    ? undefined
-    : { key: session.key, sessionID: session.id, ownServer: session.server.builtin };
+  if (session?.location === undefined || !session.id || session.id.length > MAX_SESSION_ID_CHARS || !session.location.directory) return undefined;
+  return {
+    key: statusLocationKey(session.key, session.location),
+    sessionID: session.id,
+    ownServer: session.server.builtin,
+    location: { ...session.location },
+  };
 }
 
-/**
- * Guards the desktop app's status snapshot against slow responses. A status
- * request can outlive the session it was made for: a poll for session A can
- * settle after the user routed B, and two polls for one session can settle out
- * of order. The guard numbers requests, invalidates every request made before
- * a selection change, and advances a watermark as responses are accepted, so
- * only the newest response for the selection that is still routed reaches the
- * panel and the pill. Issuing a request never invalidates an earlier response:
- * a poll that takes longer than the polling interval still describes the
- * session it settles for.
- */
-export interface StatusGuard {
-  /** Follow a selection key; true when the snapshot belongs to an earlier selection. */
-  select(key: string | undefined): boolean;
-  /** Number a request; undefined when the selection is no longer routed. */
-  begin(key: string): number | undefined;
-  /** Whether a response is newer than every response already accepted for this selection. */
-  accept(token: number): boolean;
+export type StatusSource = (target: StatusTarget, signal: AbortSignal) => Promise<AutoModeStatus | undefined>;
+export interface StatusLoader {
+  (target: StatusTarget | undefined): Promise<void>;
+  invalidate(): void;
+  dispose(): void;
 }
 
-export function createStatusGuard(): StatusGuard {
-  let selected: string | undefined;
-  let issued = 0;
-  // Highest token issued before the current selection: every token at or below
-  // it belongs to a request for an earlier selection, including one the user
-  // routed away from and back to.
-  let invalidated = 0;
-  // Highest token whose response was accepted for the current selection.
-  let accepted = 0;
+const UNAVAILABLE: AutoModeStatus = {
+  enabled: false, mode: "invalid", configError: "status unavailable", errorKind: "status",
+  reviewTimeoutMs: 0, reviewing: [], counts: { allow: 0, ask: 0, deny: 0 },
+};
 
+const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+
+interface AbortableRequest<T> { abort(): void; done: Promise<T> }
+
+/**
+ * One deferred, abortable request: timeout, caller abort and disposal reject
+ * alike, and the timer is always cleared. Deferral keeps synchronous transport
+ * errors on that same cleanup path.
+ */
+function startAbortableRequest<T>(
+  timeoutMs: number,
+  abortMessage: string,
+  work: (signal: AbortSignal) => Promise<T>,
+): AbortableRequest<T> {
+  const controller = new AbortController();
+  const aborted = new Promise<never>((_, reject) => {
+    controller.signal.addEventListener("abort", () => reject(new Error(abortMessage)), { once: true });
+  });
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const request = Promise.resolve().then(() => {
+    if (controller.signal.aborted) throw new Error(abortMessage);
+    return work(controller.signal);
+  });
   return {
-    select(key) {
-      if (key === selected) return false;
-      selected = key;
-      // Responses to requests for the previous selection are now stale.
-      invalidated = issued;
-      accepted = 0;
-      return true;
-    },
-    begin(key) {
-      if (key !== selected) return undefined;
-      return ++issued;
-    },
-    accept(token) {
-      // A response is accepted unless a newer one for this selection already
-      // was; accepting it advances the watermark past every older request.
-      if (token <= invalidated || token <= accepted) return false;
-      accepted = token;
-      return true;
-    },
+    abort: () => controller.abort(),
+    done: Promise.race([request, aborted]).finally(() => clearTimeout(timer)),
   };
 }
 
-/** Reads the status of one session, as the RPC client does. */
-export type StatusSource = (sessionID: string) => Promise<AutoModeStatus | undefined>;
-
 /**
- * Builds the refresh the desktop app polls with. Switching selections discards
- * the previous snapshot before the next request starts, so a failed request
- * for the new session cannot leave the old session's decisions on screen. A
- * failed request for the current session keeps its last snapshot, so a server
- * restart does not flash an empty panel.
- *
- * A session on another server is never requested: the client reads the app's
- * own server, and the same session id there is a different session.
+ * One abortable request at a time. Selection changes, timeout and disposal
+ * cancel it; tokens prevent late replies even if a transport ignores abort.
+ * Failed requests immediately replace stale successful status with unavailable.
  */
 export function createStatusLoader(
   load: StatusSource,
-  apply: (next: AutoModeStatus | undefined) => void,
-): (target: StatusTarget | undefined) => Promise<void> {
-  const guard = createStatusGuard();
-
-  return async (target) => {
-    if (guard.select(target?.key)) apply(undefined);
-    if (target === undefined || !target.ownServer) return;
-    const token = guard.begin(target.key);
-    if (token === undefined) return;
-    try {
-      const next = await load(target.sessionID);
-      if (guard.accept(token)) apply(next);
-    } catch {
-      // The server may be restarting; the next poll refreshes this session.
-    }
+  apply: (next: AutoModeStatus | undefined, target?: StatusTarget) => void,
+  timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+): StatusLoader {
+  let selected: string | undefined;
+  let pending: { request: AbortableRequest<AutoModeStatus | undefined>; done: Promise<void> } | undefined;
+  let generation = 0;
+  let disposed = false;
+  const cancelPending = () => {
+    pending?.request.abort();
+    pending = undefined;
   };
+
+  const refresh: StatusLoader = Object.assign((target: StatusTarget | undefined): Promise<void> => {
+    if (disposed) return Promise.resolve();
+    if (selected !== target?.key) {
+      selected = target?.key;
+      generation++;
+      cancelPending();
+      apply(undefined);
+    }
+    if (target === undefined || !target.ownServer) return Promise.resolve();
+    if (pending !== undefined) return pending.done;
+    const token = generation;
+    const request = startAbortableRequest(timeoutMs, "status request aborted", (signal) => load(target, signal));
+    const done = request.done.then(
+      (next) => { if (!disposed && token === generation) apply(next ?? { ...UNAVAILABLE }, target); },
+      () => { if (!disposed && token === generation) apply({ ...UNAVAILABLE }, target); },
+    ).finally(() => {
+      if (pending?.request === request) pending = undefined;
+    });
+    pending = { request, done };
+    return done;
+  }, {
+    invalidate() {
+      generation++;
+      cancelPending();
+    },
+    dispose() {
+      disposed = true;
+      generation++;
+      cancelPending();
+    },
+  });
+  return refresh;
 }
 
-export function latest(status: AutoModeStatus | undefined): AutoModeDecision | undefined {
-  return status?.recent.at(-1);
+export type ModeSource = (target: StatusTarget, mode: AutoModeAction, signal: AbortSignal) => Promise<AutoModeStatus>;
+
+/** Coalesce repeated clicks per captured session/location; never toggle from stale state. */
+export function createModeRunner(
+  change: ModeSource,
+  apply: (target: StatusTarget, status: AutoModeStatus) => void,
+  failure: () => void,
+  changed: () => void = () => {},
+  timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+) {
+  const pending = new Map<string, { request: AbortableRequest<AutoModeStatus>; done: Promise<void> }>();
+  let disposed = false;
+  const limit = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_REQUEST_TIMEOUT_MS;
+  return {
+    pending: (target: StatusTarget) => pending.has(target.key),
+    run(target: StatusTarget | undefined, mode: AutoModeAction | undefined): Promise<void> {
+      if (disposed || target === undefined || !target.ownServer || mode === undefined) return Promise.resolve();
+      const existing = pending.get(target.key);
+      if (existing) return existing.done;
+      const request = startAbortableRequest(limit, "mode change aborted", (signal) => change(target, mode, signal));
+      const done = request.done.then((next) => {
+        if (!disposed && next !== undefined) apply(target, next);
+      }, () => { if (!disposed) failure(); }).finally(() => {
+        if (pending.get(target.key)?.request === request) pending.delete(target.key);
+        if (!disposed) changed();
+      });
+      pending.set(target.key, { request, done });
+      changed();
+      return done;
+    },
+    dispose() {
+      disposed = true;
+      for (const entry of pending.values()) entry.request.abort();
+      pending.clear();
+    },
+  };
 }
 
-/**
- * What the decisions panel lists for a snapshot. A defined snapshot with
- * nothing reviewing and no decisions yet is still the normal new-session case,
- * so it shows the empty state rather than a blank panel.
- */
-export function panelView(status: AutoModeStatus | undefined): "empty" | "entries" {
-  return status === undefined || (status.reviewing.length === 0 && status.recent.length === 0)
-    ? "empty"
-    : "entries";
+/** Invalid/unavailable status cannot enable automatic approval. */
+export function pillAction(status: AutoModeStatus | undefined): AutoModeAction | undefined {
+  switch (status?.mode) {
+    case "on": return status.enabled ? "off" : "on";
+    case "off": return "on";
+    case "paused": return "resume";
+    default: return undefined;
+  }
 }
 
 export function pillLabel(status: AutoModeStatus | undefined): string | undefined {
   if (status === undefined) return undefined;
-  if (status.reviewing.length > 0) return "auto-mode reviewing…";
-  const last = latest(status);
-  if (last === undefined) return undefined;
-  if (last.errorKind !== undefined) return `auto-mode ${last.decision}: ${last.errorKind}`;
-  return `auto-mode ${last.decision}`;
+  switch (status.mode) {
+    case "invalid":
+      if (status.errorKind === "status" || (status.errorKind === undefined && status.configError === "status unavailable")) return "status unavailable";
+      return status.errorKind === "config" ? "Invalid config — review disabled" : "Review unavailable";
+    case "paused": return "paused (breaker)";
+    case "off": return "off";
+    case "on": return status.enabled ? "auto" : "off";
+  }
 }
 
-/**
- * Whether the pill's notice for the latest decision has expired. A review in
- * progress is always shown; a finished decision stays visible for `noticeMs`
- * after it was recorded.
- *
- * `now` must come from a clock the caller reads reactively and advances on
- * every polling tick, including failed ones: the status loader keeps its
- * previous snapshot when a request fails without applying it, so a notice
- * expired against wall-clock time read only on snapshot changes would never
- * disappear while the server is unreachable.
- */
-export function noticeExpired(status: AutoModeStatus | undefined, now: number, noticeMs: number): boolean {
-  if (status === undefined || status.reviewing.length > 0) return false;
-  const last = latest(status);
-  return last !== undefined && now - last.at > noticeMs;
+/** Invalid configuration must show its bounded error, not a generic on/off pill. */
+export function pillDescription(status: AutoModeStatus | undefined): string | undefined {
+  if (status?.mode !== "invalid" || status.configError === undefined || status.configError === "status unavailable") return undefined;
+  return `${pillLabel(status)}: ${status.configError}`;
+}
+
+export function pillTone(status: AutoModeStatus | undefined): "success" | "warning" | "danger" | undefined {
+  if (status === undefined) return undefined;
+  if (status.mode === "invalid") return "danger";
+  if (status.mode === "paused") return "warning";
+  return status.mode === "on" && status.enabled ? "success" : undefined;
+}
+
+export interface DecisionEvent {
+  location: { directory: string; workspaceID?: string };
+  data: unknown;
+}
+export interface ModeNotice {
+  message: string;
+  kind: "deny" | "breaker";
+}
+
+/** No replay/history, raw reasons, saved-approval nags, or unbounded dedup state. */
+export function createDecisionNotifier(
+  target: () => StatusTarget | undefined,
+  show: (notice: ModeNotice) => void,
+  now: () => number = Date.now,
+): (event: DecisionEvent) => void {
+  const seen = new Set<string>();
+  let windowStart = 0;
+  let shown = 0;
+  return (event) => {
+    const current = target();
+    if (current === undefined || !current.ownServer || event.location.directory !== current.location.directory
+      || event.location.workspaceID !== current.location.workspaceID) return;
+    if (event.data === null || typeof event.data !== "object") return;
+    const data = event.data as Record<string, unknown>;
+    if (data.sessionID !== current.sessionID || typeof data.reviewID !== "string" || data.reviewID.length > 256) return;
+    const kind = data.stage === "breaker" ? "breaker" : data.decision === "deny" ? "deny" : undefined;
+    if (kind === undefined) return;
+    const key = JSON.stringify([current.key, data.reviewID, kind]);
+    if (seen.has(key)) return;
+    seen.add(key);
+    if (seen.size > 128) seen.delete(seen.values().next().value!);
+    const at = now();
+    if (at - windowStart >= 5_000) { windowStart = at; shown = 0; }
+    // Cap bursts of deny toasts, but never suppress a new breaker trip.
+    if (kind === "deny" && shown >= 4) return;
+    shown++;
+    show({ kind, message: kind === "breaker" ? "Auto mode paused (breaker)" : "Auto mode denied" });
+  };
+}
+
+/** One live subscription, rebound when the host replaces its client. */
+export function createDecisionSubscription(
+  receive: (event: DecisionEvent) => void,
+): {
+  update(client: object, subscribe: (receive: (event: DecisionEvent) => void, signal: AbortSignal) => () => void): void;
+  dispose(): void;
+} {
+  let current: object | undefined;
+  let controller: AbortController | undefined;
+  let stop: (() => void) | undefined;
+  let disposed = false;
+  const disconnect = () => { controller?.abort(); stop?.(); controller = undefined; stop = undefined; };
+  return {
+    update(client, subscribe) {
+      if (disposed || client === current) return;
+      disconnect();
+      current = client;
+      const next = new AbortController();
+      controller = next;
+      try {
+        stop = subscribe((event) => { if (!next.signal.aborted) receive(event); }, next.signal);
+      } catch {
+        disconnect();
+        current = undefined; // Retry at the next poll if the server is unavailable.
+      }
+    },
+    dispose() { disposed = true; disconnect(); current = undefined; },
+  };
 }

package/src/gui.tsx

@@ -1,127 +1,76 @@
 /** @jsxImportSource solid-js */
-import { createSignal, For, onCleanup } from "solid-js";
-import { Command, ComposerPill, Panel, Plugin, createKeyed, type PanelTab } from "@opencode/plugin/gui";
+import { createSignal, onCleanup } from "solid-js";
+import { ComposerPill, Plugin, createKeyed } from "@opencode/plugin/gui";
 import { AutoMode, type AutoModeStatus } from "./rpc.js";
-import { createStatusLoader, latest, noticeExpired, panelView, pillLabel, statusTarget } from "./gui-state.js";
+import { createDecisionNotifier, createDecisionSubscription, createModeRunner, createStatusLoader, pillAction, pillDescription, pillLabel, pillTone, statusTarget } from "./gui-state.js";
 
-const POLL_MS = 3_000;
-const NOTICE_MS = 30_000;
-
-const TONE: Record<string, "success" | "warning" | "danger" | undefined> = {
-  allow: "success",
-  ask: "warning",
-  deny: "danger",
-};
+const POLL_MS = 1_000;
 
 export default Plugin.define({
-  i18n: {
-    en: {
-      "command.open": "Open auto-mode decisions",
-      "panel.title": "Auto-mode",
-      "panel.empty": "No decisions in this session yet.",
-      "panel.disabled": "Auto-mode has no valid configuration; automatic review is disabled. Host permissions still apply.",
-      "panel.reviewing": "Reviewing…",
-      "pill.title": "Auto-mode decisions",
-    },
-  },
   setup(ctx) {
-    const [status, setStatus] = createSignal<AutoModeStatus | undefined>(undefined);
+    const [status, setStatus] = createSignal<{ key: string; value: AutoModeStatus } | undefined>(undefined);
+    const [revision, setRevision] = createSignal(0);
+    // The desktop client reads its own server only. Never query that server for
+    // a routed session belonging to a different server or an unknown location.
+    const target = () => statusTarget(ctx.sessions.current());
     const refresh = createStatusLoader(
-      (sessionID) => ctx.client.rpc(AutoMode).status({ sessionID }) as Promise<AutoModeStatus | undefined>,
-      setStatus,
+      (selected, signal) => ctx.client.rpc(AutoMode).status({ sessionID: selected.sessionID }, {
+        location: selected.location, signal,
+      }) as Promise<AutoModeStatus | undefined>,
+      (value, selected) => {
+        if (value === undefined) { setStatus(undefined); return; }
+        if (selected !== undefined && target()?.key === selected.key) setStatus({ key: selected.key, value });
+      },
     );
-    // `ctx.client` reads the app's own server, so a session on another server
-    // has no status here; `session.key` keeps the same session id on two
-    // servers apart.
-    const target = () => statusTarget(ctx.sessions.current());
-    // The pill's notice expiry needs a clock of its own: the loader keeps the
-    // previous snapshot when a poll fails without applying it, so a clock read
-    // only when the snapshot changes would leave an expired decision on screen
-    // while the server is unreachable. Advance it on every tick regardless.
-    const [now, setNow] = createSignal(Date.now());
+    const runner = createModeRunner(
+      (selected, mode, signal) => {
+        refresh.invalidate(); // An older poll must not overwrite a successful mutation.
+        return ctx.client.rpc(AutoMode).setMode({ sessionID: selected.sessionID, mode }, {
+          location: selected.location, signal,
+        }) as Promise<AutoModeStatus>;
+      },
+      (selected, value) => {
+        if (target()?.key === selected.key) setStatus({ key: selected.key, value });
+      },
+      () => ctx.toast.show({ title: "Auto-mode", description: "Could not change auto mode. Try again.", variant: "error", duration: 5_000 }),
+      () => setRevision((value) => value + 1),
+    );
+    const receive = createDecisionNotifier(target, (notice) => {
+      ctx.toast.show({ title: "Auto-mode", description: notice.message,
+        variant: notice.kind === "deny" ? "error" : "default", duration: 5_000 });
+    });
+    const subscription = createDecisionSubscription(receive);
     const poll = () => {
-      setNow(Date.now());
-      void refresh(target());
+      const client = ctx.client;
+      subscription.update(client, (handler, signal) => client.rpc(AutoMode).events.on("decision", handler, { signal }));
+      const selected = target();
+      if (selected === undefined || !runner.pending(selected)) void refresh(selected);
     };
-
     createKeyed(() => target()?.key, poll, { otherwise: poll });
     const timer = setInterval(poll, POLL_MS);
-    onCleanup(() => clearInterval(timer));
-
-    const tab: PanelTab = {
-      id: "decisions",
-      get title() { return ctx.t("panel.title"); },
-      closable: "compact",
-      fallback: true,
-    };
-
-    ctx.add(Panel, {
-      id: "decisions",
-      region: "side",
-      mobile: { get title() { return ctx.t("panel.title"); }, order: 60, kind: "menu", icon: "shield" },
-      list: (input) => (input.open.includes("decisions") ? [tab] : []),
-      render: () => (
-        <div style={{ padding: "8px 12px", "font-size": "12px", display: "flex", "flex-direction": "column", gap: "6px" }}>
-          {status()?.enabled === false
-            ? <div>{ctx.t("panel.disabled")}</div>
-            : null}
-          {panelView(status()) === "empty"
-            ? <div>{ctx.t("panel.empty")}</div>
-            : (
-              <>
-                <For each={[...(status()?.reviewing ?? [])]}>
-                  {(entry) => <div>{ctx.t("panel.reviewing")} {entry.reviewID}</div>}
-                </For>
-                <For each={[...(status()?.recent ?? [])].reverse()}>
-                  {(entry) => (
-                    <div style={{ display: "flex", "flex-direction": "column", gap: "2px" }}>
-                      <span style={{ "font-weight": 600 }}>
-                        {entry.decision}{entry.errorKind === undefined ? "" : ` (${entry.errorKind})`} · {entry.action}
-                      </span>
-                      <span>{entry.reason}</span>
-                      <span style={{ opacity: 0.6 }}>
-                        {entry.stage} · {Math.round(entry.durationMs)}ms · {new Date(entry.at).toLocaleTimeString()}
-                      </span>
-                    </div>
-                  )}
-                </For>
-              </>
-            )}
-        </div>
-      ),
-    });
-
-    ctx.add(Command, () => ({
-      id: "open",
-      title: ctx.t("command.open"),
-      group: "tools",
-      run: () => {
-        const session = ctx.sessions.current();
-        if (session) ctx.layout.toggle(`${ctx.id}:decisions`, session);
-      },
-    }));
+    onCleanup(() => { clearInterval(timer); runner.dispose(); refresh.dispose(); subscription.dispose(); });
 
     ctx.add(ComposerPill, {
       id: "status",
       order: 20,
-      show: () => {
-        const snapshot = status();
-        const label = pillLabel(snapshot);
-        if (label === undefined) return undefined;
-        // `now()` is tracked, so the pill disappears on the tick that passes
-        // the notice window even if no snapshot arrives after it.
-        if (noticeExpired(snapshot, now(), NOTICE_MS)) return undefined;
-        const reviewing = (snapshot?.reviewing.length ?? 0) > 0;
+      show: (input) => {
+        revision();
+        const selected = statusTarget(input.session);
+        const stored = status();
+        const snapshot = selected?.ownServer && stored?.key === selected.key ? stored.value : undefined;
+        const action = pillAction(snapshot);
+        const pending = selected !== undefined && runner.pending(selected);
+        const label = pending ? "changing auto mode…" : pillLabel(snapshot) ?? "status unavailable";
+        const description = pillDescription(snapshot);
         return {
-          label,
-          tone: reviewing ? "warning" : TONE[latest(snapshot)?.decision ?? "allow"],
-          title: ctx.t("pill.title"),
-          rows: (snapshot?.recent ?? []).slice(-5).reverse().map((entry) => ({
-            id: entry.reviewID,
-            label: `${entry.decision} · ${entry.action}`,
-            tone: TONE[entry.decision],
-            detail: entry.reason,
-          })),
+          label, tone: pillTone(snapshot),
+          title: pending ? "Auto-mode: change pending"
+            : description !== undefined ? `Auto-mode: ${description}`
+              : action === undefined ? "Auto-mode unavailable" : `Auto-mode: ${action}`,
+          // Capture this pill's session/location. Never consult the active route
+          // inside a click handler: cached composers and session switches differ.
+          run: !pending && action !== undefined && selected?.ownServer
+            ? () => { void runner.run(selected, action); } : undefined,
         };
       },
     });