@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/builtin-addons/coding-agents/providers/opencode.ts

@@ -0,0 +1,636 @@
+// ponytail: talks to the `opencode serve` HTTP API directly — no SDK
+// dependency. Endpoints on this fork (anomalyco): GET /session,
+// GET /session/<id>/message (real per-session status lives here as message
+// `parts[].state.status`), GET /event (SSE; /global/events is v1.x only).
+// The old /session/status `attention` flag is still honored when present.
+import type { Agent, AgentProvider, AgentStatus } from "../shared/state.js"
+import {
+  opencodeEventToStatus,
+  type OpencodeEvent,
+  type OpencodeSessionStatus,
+} from "../shared/opencode-status.js"
+import {
+  readOpenCodeInstances,
+  type OpenCodeInstance,
+} from "./opencode-instances.js"
+
+// ponytail: "live" window — only sessions updated within this are surfaced.
+const RECENT_WINDOW_MS = 6 * 60 * 60 * 1000
+
+// ponytail: how many trailing messages to fetch per session for status. A
+// mid-turn session's newest message streams with finish==null and empty parts,
+// so the previous message(s) carry the live tool state — 6 is enough to see
+// the open tool while the response streams.
+const STATUS_MESSAGE_LIMIT = 6
+
+interface OpencodeSessionLike {
+  readonly id: string
+  readonly title?: string
+  readonly directory?: string
+  readonly cost?: number
+  readonly contextTokens?: number
+  readonly contextPercent?: number
+  readonly agent?: string
+  readonly model?: { readonly id?: string; readonly providerID?: string }
+  readonly tokens?: TokenUsage
+  readonly time?: { readonly updated?: number; readonly created?: number }
+}
+
+type SessionStatusEntry = OpencodeSessionStatus & { attention?: boolean }
+
+interface MessagePart {
+  readonly type?: string
+  readonly id?: string
+  readonly callID?: string
+  readonly tool_use_id?: string
+  readonly tool?: string
+  readonly state?: { readonly status?: string; readonly title?: string }
+}
+
+interface TokenUsage {
+  readonly input?: number
+  readonly output?: number
+  readonly reasoning?: number
+  readonly cache?: { readonly read?: number; readonly write?: number }
+}
+
+interface ProviderModelLike {
+  readonly limit?: { readonly context?: number }
+}
+
+interface ProviderLike {
+  readonly id?: string
+  readonly models?: Readonly<Record<string, ProviderModelLike>>
+}
+
+interface MessageLike {
+  readonly info?: {
+    readonly role?: string
+    readonly tokens?: TokenUsage
+    readonly cost?: number
+    readonly finish?: string | null
+    readonly modelID?: string
+    readonly providerID?: string
+  }
+  readonly finish?: string | null
+  readonly cost?: number
+  readonly parts?: readonly MessagePart[]
+}
+
+export interface OpencodeHttpApi {
+  listSessions(signal: AbortSignal): Promise<ReadonlyArray<OpencodeSessionLike>>
+  sessionStatus(
+    signal: AbortSignal,
+  ): Promise<Record<string, SessionStatusEntry>>
+  sessionMessages(
+    signal: AbortSignal,
+    id: string,
+    limit: number,
+  ): Promise<ReadonlyArray<MessageLike>>
+  providerModels?: (signal: AbortSignal) => Promise<readonly ProviderLike[]>
+  eventStream(
+    signal: AbortSignal,
+  ): Promise<AsyncIterable<OpencodeEvent | unknown>>
+}
+
+export const OPENCODE_LOGO =
+  "addon://coding-agents/assets/opencode-dark-square.svg"
+
+// ponytail: every request gets a hard timeout — the opencode serve process
+// can wedge (accepting connections, never answering) and an un-timed fetch
+// would freeze the poll loop forever (observed live: daemon count froze for
+// 25+ minutes with zero poll completions).
+const DEFAULT_REQUEST_TIMEOUT_MS = 5_000
+
+const requestSignal = (signal: AbortSignal, timeoutMs: number): AbortSignal =>
+  AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
+
+// Bounds any api call (including injected test doubles) so a wedged server
+// can never leave a poll pending forever. The default httpApi additionally
+// aborts the underlying fetch via requestSignal.
+const withTimeout = <T>(p: Promise<T>, timeoutMs: number): Promise<T> => {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  return Promise.race([
+    p,
+    new Promise<never>((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error("opencode request timed out")),
+        timeoutMs,
+      )
+    }),
+  ]).finally(() => {
+    if (timer !== undefined) clearTimeout(timer)
+  })
+}
+
+const requestJson = async <T>(
+  baseUrl: string,
+  path: string,
+  signal: AbortSignal,
+  timeoutMs: number,
+): Promise<T> => {
+  const res = await fetch(`${baseUrl}${path}`, {
+    signal: requestSignal(signal, timeoutMs),
+  })
+  if (!res.ok) {
+    throw new Error(`opencode ${path} → HTTP ${res.status}`)
+  }
+  return (await res.json()) as T
+}
+
+const httpApi = (baseUrl: string, timeoutMs: number): OpencodeHttpApi => ({
+  listSessions: (signal) => requestJson(baseUrl, "/session", signal, timeoutMs),
+  sessionStatus: (signal) =>
+    requestJson<Record<string, SessionStatusEntry>>(
+      baseUrl,
+      "/session/status",
+      signal,
+      timeoutMs,
+    ),
+  sessionMessages: (signal, id, limit) =>
+    requestJson<ReadonlyArray<MessageLike>>(
+      baseUrl,
+      `/session/${encodeURIComponent(id)}/message?limit=${limit}`,
+      signal,
+      timeoutMs,
+    ),
+  providerModels: async (signal) => {
+    const response = await requestJson<{ all?: readonly ProviderLike[] }>(
+      baseUrl,
+      "/provider",
+      signal,
+      timeoutMs,
+    )
+    return response.all ?? []
+  },
+  eventStream: async (signal) => streamEvents(baseUrl, signal, timeoutMs),
+})
+
+// ponytail: minimal SSE reader over fetch's streaming body. opencode
+// emits `data: <json>\n\n` frames; we only need the data payloads.
+async function* streamEvents(
+  baseUrl: string,
+  signal: AbortSignal,
+  timeoutMs: number,
+): AsyncIterable<OpencodeEvent | unknown> {
+  // ponytail: the anomalyco fork serves the event stream at /event;
+  // v1.x uses /global/events. Either path can 200 with an HTML fallback, so
+  // validate the first chunk is a `data:` frame before committing.
+  for (const path of ["/event", "/global/events"] as const) {
+    try {
+      const attempt = await fetch(`${baseUrl}${path}`, {
+        signal: requestSignal(signal, timeoutMs),
+        headers: { Accept: "text/event-stream" },
+      })
+      if (!attempt.ok || attempt.body === null) continue
+      const reader = attempt.body.getReader()
+      const first = await reader.read()
+      reader.releaseLock()
+      if (first.done || !first.value || !startsDataFrame(first.value)) {
+        await attempt.body.cancel().catch(() => {})
+        continue
+      }
+      const res = attempt
+      void res
+      const decoder = new TextDecoder()
+      let buffer = new TextDecoder().decode(first.value as Uint8Array, {
+        stream: true,
+      })
+      const body = res.body as ReadableStream<Uint8Array>
+      for await (const chunk of body) {
+        buffer += decoder.decode(chunk as Uint8Array, { stream: true })
+        let idx: number
+        while ((idx = buffer.indexOf("\n\n")) !== -1) {
+          const frame = buffer.slice(0, idx)
+          buffer = buffer.slice(idx + 2)
+          for (const line of frame.split("\n")) {
+            if (!line.startsWith("data:")) continue
+            const payload = line.slice(5).trim()
+            if (payload.length === 0) continue
+            try {
+              yield JSON.parse(payload) as OpencodeEvent
+            } catch {
+              // non-JSON frame — ignore
+            }
+          }
+        }
+      }
+      return
+    } catch {
+      continue
+    }
+  }
+}
+
+const startsDataFrame = (chunk: Uint8Array): boolean =>
+  String.fromCharCode(...chunk.slice(0, 32)).includes("data:")
+
+// ponytail: this fork's /session/status is empty even mid-turn, so live
+// status comes from the trailing message parts. A `tool` part with
+// state.status "pending" means the agent is waiting on the user (permission
+// prompt or a `question`) → waiting_for_human; "running" → running. The
+// newest message of an in-flight turn streams with finish==null and (often)
+// empty parts — that's still "running". Otherwise the turn has finished.
+const statusFromMessages = (
+  messages: ReadonlyArray<MessageLike>,
+): AgentStatus | null => {
+  const completedTools = new Set<string>()
+  for (const message of messages) {
+    for (const part of message.parts ?? []) {
+      if (part.type !== "tool_result") continue
+      const id = part.id ?? part.callID ?? part.tool_use_id
+      if (id !== undefined) completedTools.add(id)
+    }
+  }
+
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const m = messages[i]
+    const parts = m?.parts ?? []
+    for (const p of parts) {
+      if (p?.type !== "tool") continue
+      const id = p.id ?? p.callID ?? p.tool_use_id
+      if (id !== undefined && completedTools.has(id)) continue
+      const st = p.state?.status
+      if (st === "pending") return "waiting_for_human"
+      if (st === "running") return "running"
+    }
+  }
+  const last = messages[messages.length - 1]
+  if (last === undefined) return null
+  // ponytail: an in-flight turn streams with finish==null and empty parts —
+  // that's still "running". A finished turn carries a real finish value.
+  if (last.finish === null || last.info?.finish === null) return "running"
+  return "idle"
+}
+
+const tokenTotal = (tokens: TokenUsage | undefined): number | undefined => {
+  if (tokens === undefined) return undefined
+  const values = [
+    tokens.input,
+    tokens.output,
+    tokens.reasoning,
+    tokens.cache?.read,
+    tokens.cache?.write,
+  ]
+  let total = 0
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) total += value
+  }
+  return total > 0 ? total : undefined
+}
+
+const latestAssistantTokens = (
+  messages: ReadonlyArray<MessageLike>,
+): number | undefined => {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const info = messages[i]?.info
+    if (info?.role !== "assistant" || (info.tokens?.output ?? 0) <= 0) {
+      continue
+    }
+    return tokenTotal(info.tokens)
+  }
+  return undefined
+}
+
+const messageCost = (messages: ReadonlyArray<MessageLike>): number =>
+  messages.reduce((sum, message) => {
+    const cost = message.info?.cost ?? message.cost
+    return sum + (typeof cost === "number" && Number.isFinite(cost) ? cost : 0)
+  }, 0)
+
+// ponytail: the /session list omits sessions owned by other opencode
+// processes (verified live), but /session/<id>/message still answers. The
+// newest assistant message carries modelID/providerID, enough to resolve a
+// context limit and derive a percent for instance-only agents.
+const latestMessageModel = (
+  messages: ReadonlyArray<MessageLike>,
+): { providerID: string; modelID: string } | null => {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const info = messages[i]?.info
+    const providerID = info?.providerID
+    const modelID = info?.modelID
+    if (
+      typeof providerID === "string" &&
+      providerID.length > 0 &&
+      typeof modelID === "string" &&
+      modelID.length > 0
+    ) {
+      return { providerID, modelID }
+    }
+  }
+  return null
+}
+
+// ponytail: the fork's /session/status is usually empty, so live status comes
+// from the message parts; when a message-derived status is idle, fall back to
+// whatever the status map reported (map status is authoritative when present).
+const combineStatus = (
+  fromMap: AgentStatus,
+  fromMessages: AgentStatus | null,
+): AgentStatus => fromMessages ?? fromMap
+
+export class OpenCodeProvider implements AgentProvider {
+  readonly id = "opencode" as const
+  readonly displayName = "OpenCode"
+  readonly logoPath = OPENCODE_LOGO
+
+  readonly #api: OpencodeHttpApi
+  readonly #apiFactory: (baseUrl: string, timeoutMs: number) => OpencodeHttpApi
+  readonly #recentWindowMs: number
+  readonly #requestTimeoutMs: number
+
+  constructor(opts: {
+    baseUrl: string
+    apiFactory?: (baseUrl: string, timeoutMs: number) => OpencodeHttpApi
+    recentWindowMs?: number
+    requestTimeoutMs?: number
+  }) {
+    this.#requestTimeoutMs = opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
+    this.#apiFactory = opts.apiFactory ?? httpApi
+    this.#api = this.#apiFactory(opts.baseUrl, this.#requestTimeoutMs)
+    this.#recentWindowMs = opts.recentWindowMs ?? RECENT_WINDOW_MS
+  }
+
+  async fetchSnapshot(signal: AbortSignal): Promise<readonly Agent[]> {
+    if (signal.aborted) return []
+    const instances = await readOpenCodeInstances()
+    try {
+      const [sessions, statusMap, providers] = await Promise.all([
+        withTimeout(this.#api.listSessions(signal), this.#requestTimeoutMs),
+        withTimeout(this.#api.sessionStatus(signal), this.#requestTimeoutMs),
+        withTimeout(
+          this.#api.providerModels?.(signal).catch(() => []) ??
+            Promise.resolve([]),
+          this.#requestTimeoutMs,
+        ).catch(() => [] as readonly ProviderLike[]),
+      ])
+      const contextLimits = new Map<string, number>()
+      for (const provider of providers) {
+        for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+          const context = model.limit?.context
+          if (provider.id !== undefined && typeof context === "number") {
+            contextLimits.set(`${provider.id}:${modelId}`, context)
+          }
+        }
+      }
+      const now = Date.now()
+      const recent = sessions
+        .filter((s) => (s.time?.updated ?? 0) >= now - this.#recentWindowMs)
+        .sort((a, b) => (b.time?.updated ?? 0) - (a.time?.updated ?? 0))
+      const agents = await this.#withMessages(
+        recent,
+        statusMap,
+        signal,
+        contextLimits,
+      )
+      const bySessionId = new Map(
+        instances.flatMap((instance) =>
+          instance.sessionId === undefined
+            ? []
+            : [[instance.sessionId, instance] as const],
+        ),
+      )
+      const represented = new Set<string>()
+      const merged = agents.map((session) => {
+        const instance = bySessionId.get(session.sessionId)
+        if (instance === undefined) return session
+        represented.add(instance.instanceId)
+        return {
+          ...session,
+          instanceId: instance.instanceId,
+          pid: instance.pid,
+          status: instance.status,
+          directory: instance.cwd,
+          updatedAt: instance.updatedAt,
+        }
+      })
+      return [
+        ...merged,
+        ...(await this.#instanceAgents(
+          instances.filter((instance) => !represented.has(instance.instanceId)),
+          contextLimits,
+          signal,
+        )),
+      ]
+    } catch (err) {
+      if (signal.aborted) return []
+      console.warn(
+        "[coding-agents] opencode snapshot failed:",
+        err instanceof Error ? err.message : String(err),
+      )
+      return instances.map(toInstanceAgent)
+    }
+  }
+
+  // ponytail: instances whose session is missing from the /session list get
+  // their metrics (tokens, cost, context %) derived from the message
+  // endpoint, which answers even when the list omits the session.
+  async #instanceAgents(
+    instances: ReadonlyArray<OpenCodeInstance>,
+    contextLimits: ReadonlyMap<string, number>,
+    signal: AbortSignal,
+  ): Promise<readonly Agent[]> {
+    const out: Agent[] = []
+    for (const instance of instances) {
+      if (instance.sessionId === undefined || signal.aborted) {
+        out.push(toInstanceAgent(instance))
+        continue
+      }
+      try {
+        const messages = await withTimeout(
+          this.#api.sessionMessages(
+            signal,
+            instance.sessionId,
+            STATUS_MESSAGE_LIMIT,
+          ),
+          this.#requestTimeoutMs,
+        )
+        const contextTokens = latestAssistantTokens(messages)
+        let cost: number | undefined
+        const derivedCost = messageCost(messages)
+        if (derivedCost > 0) cost = derivedCost
+        let contextPercent: number | undefined
+        const model = latestMessageModel(messages)
+        const limit =
+          model !== null
+            ? contextLimits.get(`${model.providerID}:${model.modelID}`)
+            : undefined
+        if (contextTokens !== undefined && limit !== undefined) {
+          contextPercent = Math.round((contextTokens / limit) * 100)
+        }
+        out.push({
+          ...toInstanceAgent(instance),
+          ...(cost !== undefined ? { cost } : {}),
+          ...(contextTokens !== undefined ? { contextTokens } : {}),
+          ...(contextPercent !== undefined ? { contextPercent } : {}),
+        })
+      } catch {
+        out.push(toInstanceAgent(instance))
+      }
+    }
+    return out
+  }
+
+  async #withMessages(
+    recent: ReadonlyArray<OpencodeSessionLike>,
+    statusMap: Record<string, SessionStatusEntry>,
+    signal: AbortSignal,
+    contextLimits: ReadonlyMap<string, number>,
+  ): Promise<readonly Agent[]> {
+    const out: Agent[] = []
+    for (const s of recent) {
+      const fromMap = toStatusFromMap(s, statusMap)
+      let status = fromMap
+      let contextTokens = tokenTotal(s.tokens)
+      let cost =
+        typeof s.cost === "number" && Number.isFinite(s.cost)
+          ? s.cost
+          : undefined
+      if (status !== "waiting_for_human") {
+        try {
+          const messages = await withTimeout(
+            this.#api.sessionMessages(signal, s.id, STATUS_MESSAGE_LIMIT),
+            this.#requestTimeoutMs,
+          )
+          status = combineStatus(fromMap, statusFromMessages(messages))
+          contextTokens = latestAssistantTokens(messages) ?? contextTokens
+          if (cost === undefined) {
+            const derivedCost = messageCost(messages)
+            if (derivedCost > 0) cost = derivedCost
+          }
+        } catch {
+          // keep derived status; message endpoint may 4xx for closed sessions
+        }
+      }
+      const contextLimit =
+        s.model?.providerID !== undefined && s.model.id !== undefined
+          ? contextLimits.get(`${s.model.providerID}:${s.model.id}`)
+          : undefined
+      const contextPercent =
+        contextTokens !== undefined && contextLimit !== undefined
+          ? Math.round((contextTokens / contextLimit) * 100)
+          : undefined
+      out.push(
+        toAgent(s, status, {
+          ...(s.directory !== undefined ? { directory: s.directory } : {}),
+          ...(cost !== undefined ? { cost } : {}),
+          ...(contextTokens !== undefined ? { contextTokens } : {}),
+          ...(contextPercent !== undefined ? { contextPercent } : {}),
+        }),
+      )
+    }
+    return out
+  }
+
+  subscribe(signal: AbortSignal, onChange: () => void): () => void {
+    let cancelled = false
+    const setCancelled = (): void => {
+      cancelled = true
+    }
+    signal.addEventListener("abort", setCancelled)
+    const noop = (): void => {}
+
+    const run = async () => {
+      outer: while (!cancelled && !signal.aborted) {
+        try {
+          const sub = await this.#api.eventStream(signal)
+          try {
+            for await (const raw of sub) {
+              if (cancelled || signal.aborted) break
+              const evt = raw as OpencodeEvent
+              if (!evt || typeof evt !== "object") continue
+              if (!("type" in evt)) continue
+              const mapped = opencodeEventToStatus(evt)
+              if (mapped) {
+                onChange()
+              }
+            }
+          } finally {
+            noop()
+          }
+          if (cancelled || signal.aborted) break outer
+          await new Promise<void>((resolve) => {
+            if (signal.aborted) {
+              resolve()
+              return
+            }
+            const t = setTimeout(resolve, 50)
+            signal.addEventListener("abort", () => {
+              clearTimeout(t)
+              resolve()
+            })
+          })
+        } catch {
+          await new Promise((resolve) => {
+            const t = setTimeout(resolve, 3000)
+            signal.addEventListener("abort", () => {
+              clearTimeout(t)
+              resolve(undefined)
+            })
+          })
+        }
+      }
+    }
+
+    void run()
+    return () => {
+      cancelled = true
+    }
+  }
+}
+
+const toStatusFromMap = (
+  s: OpencodeSessionLike,
+  statusMap: Record<string, SessionStatusEntry>,
+): AgentStatus => {
+  const status = statusMap[s.id]
+  let normalizedStatus: AgentStatus = "idle"
+  if (status?.type === "busy") normalizedStatus = "running"
+  else if (status?.type === "retry") normalizedStatus = "waiting"
+  // ponytail: opencode v1.1+ surfaces an `attention` boolean on
+  // /session/status entries when the assistant needs human input — trust
+  // it over our inference since it comes from the source itself.
+  if (status?.attention === true) normalizedStatus = "waiting_for_human"
+  return normalizedStatus
+}
+
+const toAgent = (
+  s: OpencodeSessionLike,
+  status: AgentStatus,
+  extra: {
+    directory?: string
+    cost?: number
+    contextTokens?: number
+    contextPercent?: number
+  },
+): Agent => ({
+  sessionId: s.id,
+  providerId: "opencode",
+  title: s.title && s.title.length > 0 ? s.title : "Untitled session",
+  status,
+  ...(extra.directory !== undefined ? { directory: extra.directory } : {}),
+  ...(extra.cost !== undefined && Number.isFinite(extra.cost)
+    ? { cost: extra.cost }
+    : {}),
+  ...(extra.contextTokens !== undefined && Number.isFinite(extra.contextTokens)
+    ? { contextTokens: extra.contextTokens }
+    : {}),
+  ...(extra.contextPercent !== undefined &&
+  Number.isFinite(extra.contextPercent)
+    ? { contextPercent: extra.contextPercent }
+    : {}),
+  ...(s.time?.created !== undefined ? { createdAt: s.time.created } : {}),
+  updatedAt: s.time?.updated ?? s.time?.created ?? 0,
+})
+
+const toInstanceAgent = (instance: OpenCodeInstance): Agent => ({
+  sessionId: instance.sessionId ?? `instance:${instance.instanceId}`,
+  instanceId: instance.instanceId,
+  pid: instance.pid,
+  providerId: "opencode",
+  title: "OpenCode",
+  status: instance.status,
+  directory: instance.cwd,
+  updatedAt: instance.updatedAt,
+  createdAt: instance.updatedAt,
+})