@tiuxo/opencode-openrgb 0.0.0-stage → 0.1.1

package/src/state.ts

@@ -0,0 +1,215 @@
+/**
+ * Maps opencode's event stream onto a single lighting state.
+ *
+ * State is aggregated across *all* sessions rather than tracked per session.
+ * Subagent/task invocations create their own sessions that emit their own
+ * status events, so aggregation is what makes nested work behave sensibly: the
+ * lights stay busy until everything is genuinely finished.
+ *
+ * Events are typed structurally rather than against the SDK's event union.
+ * We read a handful of fields from a large and evolving union, so structural
+ * access with defensive lookups is more robust than tracking upstream changes.
+ */
+
+export type LightingState = "idle" | "busy" | "retry" | "permission" | "error"
+
+/**
+ * The subset of an opencode V2 event we care about.
+ *
+ * V2 carries the payload on `data` (V1 used `properties`) and renamed several
+ * of the events below. See `SUBSCRIBED_EVENTS` for the full list we ask for.
+ */
+export interface OpencodeEvent {
+  type: string
+  data?: unknown
+}
+
+/**
+ * Exactly the events `handle` acts on, for `ctx.event.subscribe({ types })`.
+ *
+ * Subscribing narrowly keeps the plugin off the firehose: session.step.*
+ * and the text/reasoning delta events fire constantly during a response and
+ * none of them change the lighting.
+ */
+export const SUBSCRIBED_EVENTS = [
+  "session.status",
+  "session.idle",
+  "session.execution.failed",
+  "session.retry.scheduled",
+  "permission.asked",
+  "permission.replied",
+  "session.deleted",
+] as const
+
+type SessionActivity = "idle" | "busy" | "retry"
+
+/** Higher wins when several conditions hold at once. */
+const PRIORITY: Record<LightingState, number> = {
+  error: 4,
+  permission: 3,
+  retry: 2,
+  busy: 1,
+  idle: 0,
+}
+
+export interface StateTrackerOptions {
+  /**
+   * How long an error keeps the lights red before decaying back. Errors have
+   * no natural "cleared" event, so they expire on a timer.
+   */
+  errorHoldMs?: number
+  /** Called when an error expires, since that changes state with no event. */
+  onExpire?: () => void
+}
+
+export class StateTracker {
+  private readonly sessions = new Map<string, SessionActivity>()
+  /** permissionID -> sessionID */
+  private readonly permissions = new Map<string, string>()
+  private readonly errors = new Map<string, NodeJS.Timeout>()
+
+  private readonly errorHoldMs: number
+  private readonly onExpire: (() => void) | undefined
+
+  constructor(options: StateTrackerOptions = {}) {
+    this.errorHoldMs = options.errorHoldMs ?? 10_000
+    this.onExpire = options.onExpire
+  }
+
+  /** Feed an event in. Returns true if it was relevant to the lighting state. */
+  handle(event: OpencodeEvent): boolean {
+    const data = event.data
+
+    switch (event.type) {
+      case "session.status": {
+        const sessionID = readString(data, "sessionID")
+        const status = readString(readProp(data, "status"), "type")
+        if (!sessionID) return false
+        if (status === "busy" || status === "retry" || status === "idle") {
+          this.sessions.set(sessionID, status)
+          if (status === "busy") this.clearError(sessionID)
+          return true
+        }
+        return false
+      }
+
+      case "session.idle": {
+        const sessionID = readString(data, "sessionID")
+        if (!sessionID) return false
+        this.sessions.set(sessionID, "idle")
+        this.clearError(sessionID)
+        return true
+      }
+
+      // V1 called this "session.error".
+      case "session.execution.failed": {
+        const sessionID = readString(data, "sessionID") ?? "__global__"
+        this.raiseError(sessionID)
+        return true
+      }
+
+      /*
+       * V2 announces a scheduled retry in its own event rather than only as a
+       * session.status transition. Marking the session here means the retry
+       * color shows even if the status event is coalesced away.
+       */
+      case "session.retry.scheduled": {
+        const sessionID = readString(data, "sessionID")
+        if (!sessionID) return false
+        this.sessions.set(sessionID, "retry")
+        return true
+      }
+
+      // V1 called this "permission.updated".
+      case "permission.asked": {
+        const permissionID = readString(data, "id")
+        const sessionID = readString(data, "sessionID") ?? ""
+        if (!permissionID) return false
+        this.permissions.set(permissionID, sessionID)
+        return true
+      }
+
+      // V2 identifies the answered request as `requestID`, not `permissionID`.
+      case "permission.replied": {
+        const permissionID = readString(data, "requestID")
+        if (!permissionID) return false
+        return this.permissions.delete(permissionID)
+      }
+
+      // V2 flattens the session reference; V1 nested it under `info.id`.
+      case "session.deleted": {
+        const sessionID = readString(data, "sessionID")
+        if (!sessionID) return false
+        this.forget(sessionID)
+        return true
+      }
+
+      default:
+        return false
+    }
+  }
+
+  resolve(): LightingState {
+    let winner: LightingState = "idle"
+
+    const consider = (candidate: LightingState) => {
+      if (PRIORITY[candidate] > PRIORITY[winner]) winner = candidate
+    }
+
+    if (this.errors.size > 0) consider("error")
+    if (this.permissions.size > 0) consider("permission")
+    for (const activity of this.sessions.values()) {
+      if (activity === "retry") consider("retry")
+      else if (activity === "busy") consider("busy")
+    }
+
+    return winner
+  }
+
+  private raiseError(sessionID: string): void {
+    this.clearError(sessionID)
+    const timer = setTimeout(() => {
+      this.errors.delete(sessionID)
+      this.onExpire?.()
+    }, this.errorHoldMs)
+    timer.unref?.()
+    this.errors.set(sessionID, timer)
+  }
+
+  private clearError(sessionID: string): void {
+    const timer = this.errors.get(sessionID)
+    if (timer) {
+      clearTimeout(timer)
+      this.errors.delete(sessionID)
+    }
+  }
+
+  private forget(sessionID: string): void {
+    this.sessions.delete(sessionID)
+    this.clearError(sessionID)
+    for (const [permissionID, owner] of this.permissions) {
+      if (owner === sessionID) this.permissions.delete(permissionID)
+    }
+  }
+
+  dispose(): void {
+    for (const timer of this.errors.values()) clearTimeout(timer)
+    this.errors.clear()
+    this.sessions.clear()
+    this.permissions.clear()
+  }
+}
+
+/*---------------------------------------------------------------------------*\
+| Defensive property access                                                   |
+\*---------------------------------------------------------------------------*/
+
+function readProp(source: unknown, key: string): unknown {
+  if (typeof source !== "object" || source === null) return undefined
+  return (source as Record<string, unknown>)[key]
+}
+
+function readString(source: unknown, key: string): string | undefined {
+  const value = readProp(source, key)
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}