opencode-ultracode 0.1.0

package/src/tui/requests.ts

@@ -0,0 +1,265 @@
+// Pending permission / question requests, tracked in the TUI process.
+//
+// opencode's own permission dialog lives in the `session` route; while one of
+// our workflow routes is on screen nothing surfaces a sub-agent that is blocked
+// on "may I read this folder?" — the agent just sits there as "running". This
+// module follows the server's pending requests (initial list + live events,
+// re-listed periodically as a safety net) so the views can flag the agent and
+// let the user answer from inside /workflows.
+
+import { batch, createMemo, createSignal } from "solid-js"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import type { PermissionRequest, QuestionRequest } from "@opencode-ai/sdk/v2"
+import type { AgentState, RunState } from "../shared/state.ts"
+
+export type PendingRequest =
+  | { kind: "permission"; id: string; sessionID: string; at: number; req: PermissionRequest }
+  | { kind: "question"; id: string; sessionID: string; at: number; req: QuestionRequest }
+
+export type PermissionReply = "once" | "always" | "reject"
+
+export interface RequestStore {
+  /** every pending request the server knows about, oldest first */
+  all: () => PendingRequest[]
+  forSession: (sessionID: string | undefined) => PendingRequest[]
+  forAgent: (agent: AgentState | undefined) => PendingRequest[]
+  /** agents of this run that are blocked on a request, in spawn order */
+  waitingAgents: (run: RunState) => AgentState[]
+  /** requests that belong to no workflow agent (e.g. the main session) */
+  unattributed: (runs: RunState[]) => PendingRequest[]
+
+  replyPermission: (id: string, reply: PermissionReply) => Promise<boolean>
+  replyQuestion: (id: string, answers: string[][]) => Promise<boolean>
+  rejectQuestion: (id: string) => Promise<boolean>
+
+  /** register a callback for requests that appear after startup */
+  onNew: (fn: (p: PendingRequest) => void) => void
+}
+
+const RELIST_MS = 5000
+
+export function createRequestStore(api: TuiPluginApi, onDispose: (fn: () => void) => void): RequestStore {
+  const [pending, setPending] = createSignal<Record<string, PendingRequest>>({})
+  const listeners: Array<(p: PendingRequest) => void> = []
+  // ids we answered but the server has not yet confirmed gone — hidden from
+  // the views so a double keypress cannot answer twice
+  const answered = new Set<string>()
+  let seeded = false
+
+  function requestRender(): void {
+    try {
+      api.renderer?.requestRender?.()
+    } catch {}
+  }
+
+  const add = (p: PendingRequest, announce: boolean) => {
+    if (answered.has(p.id)) return
+    let isNew = false
+    setPending((cur) => {
+      if (cur[p.id]) return cur
+      isNew = true
+      return { ...cur, [p.id]: p }
+    })
+    if (isNew) {
+      requestRender()
+      if (announce) for (const fn of listeners) fn(p)
+    }
+  }
+  const remove = (id: string) => {
+    answered.delete(id)
+    setPending((cur) => {
+      if (!cur[id]) return cur
+      const next = { ...cur }
+      delete next[id]
+      return next
+    })
+    requestRender()
+  }
+
+  const wrapPermission = (req: PermissionRequest, at: number): PendingRequest => ({ kind: "permission", id: req.id, sessionID: req.sessionID, at, req })
+  const wrapQuestion = (req: QuestionRequest, at: number): PendingRequest => ({ kind: "question", id: req.id, sessionID: req.sessionID, at, req })
+
+  // --- full re-list: startup seed + periodic safety net -------------------------
+
+  async function relist(): Promise<void> {
+    let perms: PermissionRequest[] = []
+    let questions: QuestionRequest[] = []
+    let ok = false
+    try {
+      const [p, q] = await Promise.all([api.client.permission.list(), api.client.question.list()])
+      perms = ((p as any)?.data ?? []) as PermissionRequest[]
+      questions = ((q as any)?.data ?? []) as QuestionRequest[]
+      ok = !(p as any)?.error && !(q as any)?.error
+    } catch {
+      return
+    }
+    if (!ok) return
+    const now = Date.now()
+    const live = new Set<string>()
+    batch(() => {
+      for (const r of perms) {
+        live.add(r.id)
+        add(wrapPermission(r, pending()[r.id]?.at ?? now), seeded)
+      }
+      for (const r of questions) {
+        live.add(r.id)
+        add(wrapQuestion(r, pending()[r.id]?.at ?? now), seeded)
+      }
+      // anything the server no longer lists was answered elsewhere (main session dialog, another client)
+      for (const id of Object.keys(pending())) if (!live.has(id)) remove(id)
+    })
+    seeded = true
+  }
+
+  relist().catch(() => {})
+  const timer = setInterval(() => {
+    relist().catch(() => {})
+  }, RELIST_MS)
+  onDispose(() => clearInterval(timer))
+
+  // --- live events ------------------------------------------------------------------
+
+  const subs: Array<() => void> = []
+  try {
+    subs.push(api.event.on("permission.asked", (e) => add(wrapPermission(e.properties, Date.now()), true)))
+    subs.push(api.event.on("permission.replied", (e) => remove(e.properties.requestID)))
+    subs.push(api.event.on("question.asked", (e) => add(wrapQuestion(e.properties, Date.now()), true)))
+    subs.push(api.event.on("question.replied", (e) => remove(e.properties.requestID)))
+    subs.push(api.event.on("question.rejected", (e) => remove(e.properties.requestID)))
+  } catch {}
+  onDispose(() => {
+    for (const off of subs) {
+      try {
+        off()
+      } catch {}
+    }
+  })
+
+  // --- derived --------------------------------------------------------------------------
+
+  const all = createMemo(() => Object.values(pending()).sort((a, b) => a.at - b.at))
+  const bySession = createMemo(() => {
+    const m = new Map<string, PendingRequest[]>()
+    for (const p of all()) {
+      const list = m.get(p.sessionID)
+      if (list) list.push(p)
+      else m.set(p.sessionID, [p])
+    }
+    return m
+  })
+
+  const forSession = (sessionID: string | undefined): PendingRequest[] => (sessionID ? bySession().get(sessionID) ?? [] : [])
+  const forAgent = (agent: AgentState | undefined): PendingRequest[] => {
+    if (!agent || agent.status !== "running") return []
+    return forSession(agent.sessionId)
+  }
+
+  // --- replies ---------------------------------------------------------------------------
+
+  const markAnswered = (id: string) => {
+    answered.add(id)
+    setPending((cur) => {
+      if (!cur[id]) return cur
+      const next = { ...cur }
+      delete next[id]
+      return next
+    })
+    requestRender()
+  }
+  const unmark = (id: string, p: PendingRequest | undefined) => {
+    answered.delete(id)
+    if (p) add(p, false)
+  }
+
+  return {
+    all,
+    forSession,
+    forAgent,
+    waitingAgents: (run) => {
+      const sessions = bySession()
+      if (!sessions.size) return []
+      const out: AgentState[] = []
+      for (const id of run.agentOrder) {
+        const a = run.agents[id]
+        if (a && a.status === "running" && a.sessionId && sessions.has(a.sessionId)) out.push(a)
+      }
+      return out
+    },
+    unattributed: (runs) => {
+      const owned = new Set<string>()
+      for (const r of runs) for (const id of r.agentOrder) {
+        const s = r.agents[id]?.sessionId
+        if (s) owned.add(s)
+      }
+      return all().filter((p) => !owned.has(p.sessionID))
+    },
+
+    replyPermission: async (id, reply) => {
+      const prev = pending()[id]
+      markAnswered(id)
+      try {
+        const res: any = await api.client.permission.reply({ requestID: id, reply })
+        if (res?.error) throw new Error(errText(res.error))
+        return true
+      } catch (e) {
+        unmark(id, prev)
+        api.ui.toast({ variant: "error", message: `Could not send reply: ${errText(e)}` })
+        return false
+      }
+    },
+    replyQuestion: async (id, answers) => {
+      const prev = pending()[id]
+      markAnswered(id)
+      try {
+        const res: any = await api.client.question.reply({ requestID: id, answers })
+        if (res?.error) throw new Error(errText(res.error))
+        return true
+      } catch (e) {
+        unmark(id, prev)
+        api.ui.toast({ variant: "error", message: `Could not send answer: ${errText(e)}` })
+        return false
+      }
+    },
+    rejectQuestion: async (id) => {
+      const prev = pending()[id]
+      markAnswered(id)
+      try {
+        const res: any = await api.client.question.reject({ requestID: id })
+        if (res?.error) throw new Error(errText(res.error))
+        return true
+      } catch (e) {
+        unmark(id, prev)
+        api.ui.toast({ variant: "error", message: `Could not reject: ${errText(e)}` })
+        return false
+      }
+    },
+
+    onNew: (fn) => {
+      listeners.push(fn)
+    },
+  }
+}
+
+/** one-line description of what the request is asking for */
+export function describeRequest(p: PendingRequest): string {
+  if (p.kind === "permission") {
+    const pats = p.req.patterns?.filter(Boolean) ?? []
+    return pats.length ? `${p.req.permission}: ${pats.join(", ")}` : p.req.permission
+  }
+  const q = p.req.questions?.[0]
+  const more = (p.req.questions?.length ?? 0) - 1
+  return q ? `${q.header || "question"}: ${q.question}${more > 0 ? ` (+${more} more)` : ""}` : "question"
+}
+
+function errText(e: unknown): string {
+  if (e instanceof Error) return e.message
+  if (typeof e === "string") return e
+  const any = e as any
+  if (any?.data?.message) return String(any.data.message)
+  if (any?.message) return String(any.message)
+  try {
+    return JSON.stringify(e)
+  } catch {
+    return String(e)
+  }
+}

package/src/tui/store.ts

@@ -0,0 +1,266 @@
+// TUI store: polls /tmp/opencode-workflows/<project>/<id>/state.json and exposes the
+// run list as a fine-grained Solid store. Changed files are merged with
+// `reconcile`, so only the cells whose values actually changed re-render —
+// rows are never torn down and rebuilt on a tick, which keeps the view calm.
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { batch, createMemo, createSignal } from "solid-js"
+import { createStore as createSolidStore, reconcile } from "solid-js/store"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import { controlPath, runsRoot, workflowRoot, type RunState } from "../shared/state.ts"
+
+export interface WorkflowStore {
+  /** all runs, newest first (fine-grained proxies — read fields inside JSX) */
+  runs: () => RunState[]
+  runById: (runId: string) => RunState | undefined
+  activeRun: () => RunState | undefined
+  activeRunId: () => string | undefined
+  openRun: (runId: string) => void
+  closeRun: () => void
+
+  selPhase: () => number
+  setSelPhase: (i: number) => void
+  selAgent: () => string | undefined
+  setSelAgent: (id: string | undefined) => void
+  expandActivity: () => boolean
+  toggleExpand: () => void
+  fullPrompt: () => boolean
+  toggleFullPrompt: () => void
+
+  /** wall clock, refreshed every second while something is running */
+  now: () => number
+  /** animated spinner frame for running items */
+  spinner: () => string
+  /** terminal size, refreshed on resize */
+  size: () => { width: number; height: number }
+  /** true when a run claims to be live but its state file stopped updating */
+  isStale: (run: RunState) => boolean
+
+  runsDir: () => string
+  control: (runId: string, action: "pause" | "resume" | "stop") => void
+  /** a control.json the engine has not consumed yet (e.g. resume waiting for the server plugin) */
+  pendingControl: (runId: string) => "pause" | "resume" | "stop" | undefined
+  deleteRun: (runId: string) => void
+  saveScript: (run: RunState) => string | undefined
+  markNotified: (runId: string) => void
+  wasNotified: (runId: string) => boolean
+}
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+const POLL_MS = 250
+
+export function isLive(status: string | undefined): boolean {
+  return status === "running" || status === "paused" || status === "pending"
+}
+
+/** the engine heartbeats state.json every ~2s; a live run whose file is
+ *  this old has lost its engine (opencode crashed or was closed) */
+export const STALE_AFTER_MS = 20_000
+
+export function createStore(api: TuiPluginApi, onDispose?: (fn: () => void) => void): WorkflowStore {
+  const root = () => api.state.path.worktree || api.state.path.directory
+  const runsDir = () => runsRoot(root())
+  const dispose = onDispose ?? (() => {})
+
+  const [state, setState] = createSolidStore<{ runs: Record<string, RunState> }>({ runs: {} })
+  const [order, setOrder] = createSignal<string[]>([], { equals: (a, b) => a.length === b.length && a.every((v, i) => v === b[i]) })
+  const mtimes = new Map<string, number>()
+  const [written, setWritten] = createSignal<Record<string, number>>({})
+
+  const [activeId, setActiveId] = createSignal<string | undefined>(undefined)
+  const [selPhase, setSelPhase] = createSignal(0)
+  const [selAgent, setSelAgent] = createSignal("")
+  const [expand, setExpand] = createSignal(false)
+  const [fullPrompt, setFullPrompt] = createSignal(false)
+  const [now, setNow] = createSignal(Date.now())
+  const [frame, setFrame] = createSignal(0)
+  const [size, setSize] = createSignal({ width: api.renderer?.terminalWidth ?? 120, height: api.renderer?.terminalHeight ?? 40 })
+  const notified = new Set<string>()
+
+  function requestRender(): void {
+    try {
+      api.renderer?.requestRender?.()
+    } catch {}
+  }
+
+  // --- polling -------------------------------------------------------------
+
+  function refresh(): void {
+    let names: string[] = []
+    try {
+      names = readdirSync(runsDir()).filter((n) => n.startsWith("run_"))
+    } catch {
+      names = []
+    }
+    const seen = new Set(names)
+    let changed = false
+    const parsed: Array<[string, RunState]> = []
+    for (const n of names) {
+      const p = join(runsDir(), n, "state.json")
+      try {
+        const st = statSync(p)
+        if (mtimes.get(n) === st.mtimeMs) continue
+        // the engine writes with writeFileSync (not atomic) — a half-written
+        // file fails to parse; keep the previous state and retry next tick
+        const json = JSON.parse(readFileSync(p, "utf8")) as RunState
+        if (!json || typeof json !== "object" || !json.runId) continue
+        mtimes.set(n, st.mtimeMs)
+        parsed.push([n, json])
+      } catch {}
+    }
+    const gone = [...mtimes.keys()].filter((k) => !seen.has(k))
+    if (!parsed.length && !gone.length) return
+
+    batch(() => {
+      for (const [n, json] of parsed) {
+        // merge: true → keyless arrays (phases, activity, liveFeed) merge by
+        // index instead of being replaced, so their rows keep identity
+        setState("runs", n, reconcile(json, { key: "id", merge: true }))
+        changed = true
+      }
+      for (const k of gone) {
+        mtimes.delete(k)
+        setState("runs", k, undefined as any)
+        changed = true
+      }
+      const ids = Object.keys(state.runs).filter((k) => state.runs[k])
+      ids.sort((a, b) => (state.runs[b]?.startedAt ?? 0) - (state.runs[a]?.startedAt ?? 0))
+      setOrder(ids)
+      setWritten(Object.fromEntries(mtimes))
+    })
+    if (changed) requestRender()
+  }
+
+  const pollTimer = setInterval(() => {
+    try {
+      refresh()
+    } catch {}
+  }, POLL_MS)
+  dispose(() => clearInterval(pollTimer))
+  refresh()
+
+  // --- clock + spinner ------------------------------------------------------
+  // The spinner only animates while a run is live; otherwise the screen is
+  // fully static and no frames are drawn.
+
+  const anyLive = createMemo(() => order().some((id) => isLive(state.runs[id]?.status)))
+  const clock = setInterval(() => {
+    setNow(Date.now())
+    if (anyLive()) requestRender()
+  }, 1000)
+  dispose(() => clearInterval(clock))
+
+  let spinTimer: ReturnType<typeof setInterval> | null = null
+  const spinTick = () => {
+    if (!anyLive()) return
+    setFrame((f) => (f + 1) % SPINNER.length)
+    requestRender()
+  }
+  spinTimer = setInterval(spinTick, 120)
+  dispose(() => spinTimer && clearInterval(spinTimer))
+
+  // --- resize ---------------------------------------------------------------
+
+  const onResize = () => {
+    try {
+      setSize({ width: api.renderer.terminalWidth, height: api.renderer.terminalHeight })
+    } catch {}
+  }
+  try {
+    api.renderer?.on?.("resize", onResize)
+    dispose(() => {
+      try {
+        api.renderer?.off?.("resize", onResize)
+      } catch {}
+    })
+  } catch {}
+
+  // --- derived --------------------------------------------------------------
+
+  const runs = createMemo(() => order().map((id) => state.runs[id]).filter(Boolean) as RunState[])
+  const activeRun = createMemo(() => {
+    const id = activeId()
+    return id ? state.runs[id] : undefined
+  })
+
+  return {
+    runs,
+    runById: (id) => state.runs[id],
+    activeRun,
+    activeRunId: activeId,
+    openRun: (runId) => {
+      batch(() => {
+        setActiveId(runId)
+        setSelPhase(0)
+        setSelAgent("")
+        setExpand(false)
+        setFullPrompt(false)
+      })
+    },
+    closeRun: () => setActiveId(undefined),
+
+    selPhase,
+    setSelPhase: (i) => setSelPhase(i),
+    selAgent: () => selAgent() || undefined,
+    setSelAgent: (id) => setSelAgent(id ?? ""),
+    expandActivity: expand,
+    toggleExpand: () => setExpand((v) => !v),
+    fullPrompt,
+    toggleFullPrompt: () => setFullPrompt((v) => !v),
+
+    now,
+    spinner: () => SPINNER[frame()] ?? SPINNER[0],
+    size,
+    isStale: (run) => {
+      if (!isLive(run.status)) return false
+      const at = written()[run.runId]
+      return at != null && now() - at > STALE_AFTER_MS
+    },
+
+    runsDir,
+    control: (runId, action) => {
+      try {
+        mkdirSync(join(runsDir(), runId), { recursive: true })
+        writeFileSync(controlPath(runsDir(), runId), JSON.stringify({ action, at: Date.now() }))
+      } catch {}
+    },
+    pendingControl: (runId) => {
+      now() // re-evaluate each clock tick
+      try {
+        const raw = readFileSync(controlPath(runsDir(), runId), "utf8")
+        const a = JSON.parse(raw)?.action
+        return a === "pause" || a === "resume" || a === "stop" ? a : undefined
+      } catch {
+        return undefined
+      }
+    },
+    deleteRun: (runId) => {
+      try {
+        rmSync(join(runsDir(), runId), { recursive: true, force: true })
+        refresh()
+      } catch {}
+    },
+    saveScript: (run) => {
+      try {
+        const src = join(runsDir(), run.runId, "script.js")
+        if (!existsSync(src)) return undefined
+        const destDir = workflowRoot(root())
+        mkdirSync(destDir, { recursive: true })
+        const dest = join(destDir, `${safe(run.name)}.js`)
+        writeFileSync(dest, readFileSync(src, "utf8"))
+        return dest
+      } catch {
+        return undefined
+      }
+    },
+    markNotified: (id) => {
+      notified.add(id)
+    },
+    wasNotified: (id) => notified.has(id),
+  }
+}
+
+function safe(n: string): string {
+  return n.replace(/[^a-zA-Z0-9_-]/g, "-")
+}