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

package/src/gui-state.ts

@@ -0,0 +1,160 @@
+import type { AutoModeDecision, 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. */
+  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;
+}
+
+/** 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 };
+}
+
+/** The status target of a routed session, or undefined while none is routed. */
+export function statusTarget(session: RoutedSession | undefined): StatusTarget | undefined {
+  return session === undefined
+    ? undefined
+    : { key: session.key, sessionID: session.id, ownServer: session.server.builtin };
+}
+
+/**
+ * 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 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;
+
+  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;
+    },
+  };
+}
+
+/** 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.
+ */
+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.
+    }
+  };
+}
+
+export function latest(status: AutoModeStatus | undefined): AutoModeDecision | undefined {
+  return status?.recent.at(-1);
+}
+
+/**
+ * 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";
+}
+
+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}`;
+}
+
+/**
+ * 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;
+}

package/src/gui.tsx

@@ -0,0 +1,129 @@
+/** @jsxImportSource solid-js */
+import { createSignal, For, onCleanup } from "solid-js";
+import { Command, ComposerPill, Panel, Plugin, createKeyed, type PanelTab } from "@opencode/plugin/gui";
+import { AutoMode, type AutoModeStatus } from "./rpc.js";
+import { createStatusLoader, latest, noticeExpired, panelView, pillLabel, 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",
+};
+
+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 refresh = createStatusLoader(
+      (sessionID) => ctx.client.rpc(AutoMode).status({ sessionID }) as Promise<AutoModeStatus | undefined>,
+      setStatus,
+    );
+    // `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 poll = () => {
+      setNow(Date.now());
+      void refresh(target());
+    };
+
+    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);
+      },
+    }));
+
+    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;
+        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,
+          })),
+        };
+      },
+    });
+  },
+});