cerebras-cli 1.0.0

package/src/cli/cmd/tui/context/sdk.tsx

@@ -0,0 +1,75 @@
+import { createOpencodeClient, type Event } from "@opencode-ai/sdk/v2"
+import { createSimpleContext } from "./helper"
+import { createGlobalEmitter } from "@solid-primitives/event-bus"
+import { batch, onCleanup, onMount } from "solid-js"
+import { iife } from "@/util/iife"
+
+export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
+  name: "SDK",
+  init: (props: { url: string }) => {
+    const abort = new AbortController()
+    const sdk = createOpencodeClient({
+      baseUrl: props.url,
+      signal: abort.signal,
+    })
+
+    const emitter = createGlobalEmitter<{
+      [key in Event["type"]]: Extract<Event, { type: key }>
+    }>()
+
+    onMount(async () => {
+      while (true) {
+        if (abort.signal.aborted) break
+        const events = await sdk.event.subscribe(
+          {},
+          {
+            signal: abort.signal,
+          },
+        )
+        let queue: Event[] = []
+        let timer: Timer | undefined
+        let last = 0
+
+        const flush = () => {
+          if (queue.length === 0) return
+          const events = queue
+          queue = []
+          timer = undefined
+          last = Date.now()
+          // Batch all event emissions so all store updates result in a single render
+          batch(() => {
+            for (const event of events) {
+              emitter.emit(event.type, event)
+            }
+          })
+        }
+
+        for await (const event of events.stream) {
+          queue.push(event)
+          const elapsed = Date.now() - last
+
+          if (timer) continue
+          // If we just flushed recently (within 16ms), batch this with future events
+          // Otherwise, process immediately to avoid latency
+          if (elapsed < 16) {
+            timer = setTimeout(flush, 16)
+            continue
+          }
+          flush()
+        }
+
+        // Flush any remaining events
+        if (timer) clearTimeout(timer)
+        if (queue.length > 0) {
+          flush()
+        }
+      }
+    })
+
+    onCleanup(() => {
+      abort.abort()
+    })
+
+    return { client: sdk, event: emitter }
+  },
+})

package/src/cli/cmd/tui/context/sync.tsx

@@ -0,0 +1,374 @@
+import type {
+  Message,
+  Agent,
+  Provider,
+  Session,
+  Part,
+  Config,
+  Todo,
+  Command,
+  Permission,
+  LspStatus,
+  McpStatus,
+  FormatterStatus,
+  SessionStatus,
+  ProviderListResponse,
+  ProviderAuthMethod,
+  VcsInfo,
+} from "@opencode-ai/sdk/v2"
+import { createStore, produce, reconcile } from "solid-js/store"
+import { useSDK } from "@tui/context/sdk"
+import { Binary } from "@opencode-ai/util/binary"
+import { createSimpleContext } from "./helper"
+import type { Snapshot } from "@/snapshot"
+import { useExit } from "./exit"
+import { batch, onMount } from "solid-js"
+import { Log } from "@/util/log"
+import { RateLimit } from "@/ratelimit"
+
+export const { use: useSync, provider: SyncProvider } = createSimpleContext({
+  name: "Sync",
+  init: () => {
+    const [store, setStore] = createStore<{
+      status: "loading" | "partial" | "complete"
+      provider: Provider[]
+      provider_default: Record<string, string>
+      provider_next: ProviderListResponse
+      provider_auth: Record<string, ProviderAuthMethod[]>
+      agent: Agent[]
+      command: Command[]
+      permission: {
+        [sessionID: string]: Permission[]
+      }
+      config: Config
+      session: Session[]
+      session_status: {
+        [sessionID: string]: SessionStatus
+      }
+      session_diff: {
+        [sessionID: string]: Snapshot.FileDiff[]
+      }
+      todo: {
+        [sessionID: string]: Todo[]
+      }
+      message: {
+        [sessionID: string]: Message[]
+      }
+      part: {
+        [messageID: string]: Part[]
+      }
+      lsp: LspStatus[]
+      mcp: {
+        [key: string]: McpStatus
+      }
+      formatter: FormatterStatus[]
+      vcs: VcsInfo | undefined
+      ratelimit: {
+        [providerID: string]: RateLimit.Info
+      }
+    }>({
+      provider_next: {
+        all: [],
+        default: {},
+        connected: [],
+      },
+      provider_auth: {},
+      config: {},
+      status: "loading",
+      agent: [],
+      permission: {},
+      command: [],
+      provider: [],
+      provider_default: {},
+      session: [],
+      session_status: {},
+      session_diff: {},
+      todo: {},
+      message: {},
+      part: {},
+      lsp: [],
+      mcp: {},
+      formatter: [],
+      vcs: undefined,
+      ratelimit: {},
+    })
+
+    const sdk = useSDK()
+
+    sdk.event.listen((e) => {
+      const event = e.details
+      switch (event.type) {
+        case "permission.updated": {
+          const permissions = store.permission[event.properties.sessionID]
+          if (!permissions) {
+            setStore("permission", event.properties.sessionID, [event.properties])
+            break
+          }
+          const match = Binary.search(permissions, event.properties.id, (p) => p.id)
+          setStore(
+            "permission",
+            event.properties.sessionID,
+            produce((draft) => {
+              if (match.found) {
+                draft[match.index] = event.properties
+                return
+              }
+              draft.push(event.properties)
+            }),
+          )
+          break
+        }
+
+        case "permission.replied": {
+          const permissions = store.permission[event.properties.sessionID]
+          const match = Binary.search(permissions, event.properties.permissionID, (p) => p.id)
+          if (!match.found) break
+          setStore(
+            "permission",
+            event.properties.sessionID,
+            produce((draft) => {
+              draft.splice(match.index, 1)
+            }),
+          )
+          break
+        }
+
+        case "todo.updated":
+          setStore("todo", event.properties.sessionID, event.properties.todos)
+          break
+
+        case "session.diff":
+          setStore("session_diff", event.properties.sessionID, event.properties.diff)
+          break
+
+        case "session.deleted": {
+          const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
+          if (result.found) {
+            setStore(
+              "session",
+              produce((draft) => {
+                draft.splice(result.index, 1)
+              }),
+            )
+          }
+          break
+        }
+        case "session.updated": {
+          const result = Binary.search(store.session, event.properties.info.id, (s) => s.id)
+          if (result.found) {
+            setStore("session", result.index, reconcile(event.properties.info))
+            break
+          }
+          setStore(
+            "session",
+            produce((draft) => {
+              draft.splice(result.index, 0, event.properties.info)
+            }),
+          )
+          break
+        }
+
+        case "session.status": {
+          setStore("session_status", event.properties.sessionID, event.properties.status)
+          break
+        }
+
+        case "message.updated": {
+          const messages = store.message[event.properties.info.sessionID]
+          if (!messages) {
+            setStore("message", event.properties.info.sessionID, [event.properties.info])
+            break
+          }
+          const result = Binary.search(messages, event.properties.info.id, (m) => m.id)
+          if (result.found) {
+            setStore("message", event.properties.info.sessionID, result.index, reconcile(event.properties.info))
+            break
+          }
+          setStore(
+            "message",
+            event.properties.info.sessionID,
+            produce((draft) => {
+              draft.splice(result.index, 0, event.properties.info)
+              if (draft.length > 100) draft.shift()
+            }),
+          )
+          break
+        }
+        case "message.removed": {
+          const messages = store.message[event.properties.sessionID]
+          const result = Binary.search(messages, event.properties.messageID, (m) => m.id)
+          if (result.found) {
+            setStore(
+              "message",
+              event.properties.sessionID,
+              produce((draft) => {
+                draft.splice(result.index, 1)
+              }),
+            )
+          }
+          break
+        }
+        case "message.part.updated": {
+          const parts = store.part[event.properties.part.messageID]
+          if (!parts) {
+            setStore("part", event.properties.part.messageID, [event.properties.part])
+            break
+          }
+          const result = Binary.search(parts, event.properties.part.id, (p) => p.id)
+          if (result.found) {
+            setStore("part", event.properties.part.messageID, result.index, reconcile(event.properties.part))
+            break
+          }
+          setStore(
+            "part",
+            event.properties.part.messageID,
+            produce((draft) => {
+              draft.splice(result.index, 0, event.properties.part)
+            }),
+          )
+          break
+        }
+
+        case "message.part.removed": {
+          const parts = store.part[event.properties.messageID]
+          const result = Binary.search(parts, event.properties.partID, (p) => p.id)
+          if (result.found)
+            setStore(
+              "part",
+              event.properties.messageID,
+              produce((draft) => {
+                draft.splice(result.index, 1)
+              }),
+            )
+          break
+        }
+
+        case "lsp.updated": {
+          sdk.client.lsp.status().then((x) => setStore("lsp", x.data!))
+          break
+        }
+
+        case "vcs.branch.updated": {
+          setStore("vcs", { branch: event.properties.branch })
+          break
+        }
+      }
+
+      // Handle ratelimit.update separately since it's not in generated SDK types yet
+      if ((event.type as string) === "ratelimit.update") {
+        const props = event.properties as unknown as { providerID?: string; info?: RateLimit.Info }
+        if (props.providerID && props.info) {
+          setStore("ratelimit", props.providerID, props.info)
+        }
+      }
+    })
+
+    const exit = useExit()
+
+    async function bootstrap() {
+      // blocking
+      await Promise.all([
+        sdk.client.config.providers({}, { throwOnError: true }).then((x) => {
+          batch(() => {
+            setStore("provider", x.data!.providers)
+            setStore("provider_default", x.data!.default)
+          })
+        }),
+        sdk.client.provider.list({}, { throwOnError: true }).then((x) => {
+          batch(() => {
+            setStore("provider_next", x.data!)
+          })
+        }),
+        sdk.client.app.agents({}, { throwOnError: true }).then((x) => setStore("agent", x.data ?? [])),
+        sdk.client.config.get({}, { throwOnError: true }).then((x) => setStore("config", x.data!)),
+      ])
+        .then(() => {
+          if (store.status !== "complete") setStore("status", "partial")
+          // non-blocking
+          Promise.all([
+            sdk.client.session.list().then((x) =>
+              setStore(
+                "session",
+                (x.data ?? []).toSorted((a, b) => a.id.localeCompare(b.id)),
+              ),
+            ),
+            sdk.client.command.list().then((x) => setStore("command", x.data ?? [])),
+            sdk.client.lsp.status().then((x) => setStore("lsp", x.data!)),
+            sdk.client.mcp.status().then((x) => setStore("mcp", x.data!)),
+            sdk.client.formatter.status().then((x) => setStore("formatter", x.data!)),
+            sdk.client.session.status().then((x) => setStore("session_status", x.data!)),
+            sdk.client.provider.auth().then((x) => setStore("provider_auth", x.data ?? {})),
+            sdk.client.vcs.get().then((x) => setStore("vcs", x.data)),
+          ]).then(() => {
+            setStore("status", "complete")
+          })
+        })
+        .catch(async (e) => {
+          Log.Default.error("tui bootstrap failed", {
+            error: e instanceof Error ? e.message : String(e),
+            name: e instanceof Error ? e.name : undefined,
+            stack: e instanceof Error ? e.stack : undefined,
+          })
+          await exit(e)
+        })
+    }
+
+    onMount(() => {
+      bootstrap()
+    })
+
+    const fullSyncedSessions = new Set<string>()
+    const result = {
+      data: store,
+      set: setStore,
+      get status() {
+        return store.status
+      },
+      get ready() {
+        return store.status !== "loading"
+      },
+      session: {
+        get(sessionID: string) {
+          const match = Binary.search(store.session, sessionID, (s) => s.id)
+          if (match.found) return store.session[match.index]
+          return undefined
+        },
+        status(sessionID: string) {
+          const session = result.session.get(sessionID)
+          if (!session) return "idle"
+          if (session.time.compacting) return "compacting"
+          const messages = store.message[sessionID] ?? []
+          const last = messages.at(-1)
+          if (!last) return "idle"
+          if (last.role === "user") return "working"
+          return last.time.completed ? "idle" : "working"
+        },
+        async sync(sessionID: string) {
+          if (fullSyncedSessions.has(sessionID)) return
+          const [session, messages, todo, diff] = await Promise.all([
+            sdk.client.session.get({ sessionID }, { throwOnError: true }),
+            sdk.client.session.messages({ sessionID, limit: 100 }),
+            sdk.client.session.todo({ sessionID }),
+            sdk.client.session.diff({ sessionID }),
+          ])
+          setStore(
+            produce((draft) => {
+              const match = Binary.search(draft.session, sessionID, (s) => s.id)
+              if (match.found) draft.session[match.index] = session.data!
+              if (!match.found) draft.session.splice(match.index, 0, session.data!)
+              draft.todo[sessionID] = todo.data ?? []
+              draft.message[sessionID] = messages.data!.map((x) => x.info)
+              for (const message of messages.data!) {
+                draft.part[message.info.id] = message.parts
+              }
+              draft.session_diff[sessionID] = diff.data ?? []
+            }),
+          )
+          fullSyncedSessions.add(sessionID)
+        },
+      },
+      bootstrap,
+    }
+    return result
+  },
+})

package/src/cli/cmd/tui/context/theme/aura.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "darkBg": "#0f0f0f",
+    "darkBgPanel": "#15141b",
+    "darkBorder": "#2d2d2d",
+    "darkFgMuted": "#6d6d6d",
+    "darkFg": "#edecee",
+    "purple": "#a277ff",
+    "pink": "#f694ff",
+    "blue": "#82e2ff",
+    "red": "#ff6767",
+    "orange": "#ffca85",
+    "cyan": "#61ffca",
+    "green": "#9dff65"
+  },
+  "theme": {
+    "primary": "purple",
+    "secondary": "pink",
+    "accent": "purple",
+    "error": "red",
+    "warning": "orange",
+    "success": "cyan",
+    "info": "purple",
+    "text": "darkFg",
+    "textMuted": "darkFgMuted",
+    "background": "darkBg",
+    "backgroundPanel": "darkBgPanel",
+    "backgroundElement": "darkBgPanel",
+    "border": "darkBorder",
+    "borderActive": "darkFgMuted",
+    "borderSubtle": "darkBorder",
+    "diffAdded": "cyan",
+    "diffRemoved": "red",
+    "diffContext": "darkFgMuted",
+    "diffHunkHeader": "darkFgMuted",
+    "diffHighlightAdded": "cyan",
+    "diffHighlightRemoved": "red",
+    "diffAddedBg": "#354933",
+    "diffRemovedBg": "#3f191a",
+    "diffContextBg": "darkBgPanel",
+    "diffLineNumber": "darkBorder",
+    "diffAddedLineNumberBg": "#162620",
+    "diffRemovedLineNumberBg": "#26161a",
+    "markdownText": "darkFg",
+    "markdownHeading": "purple",
+    "markdownLink": "pink",
+    "markdownLinkText": "purple",
+    "markdownCode": "cyan",
+    "markdownBlockQuote": "darkFgMuted",
+    "markdownEmph": "orange",
+    "markdownStrong": "purple",
+    "markdownHorizontalRule": "darkFgMuted",
+    "markdownListItem": "purple",
+    "markdownListEnumeration": "purple",
+    "markdownImage": "pink",
+    "markdownImageText": "purple",
+    "markdownCodeBlock": "darkFg",
+    "syntaxComment": "darkFgMuted",
+    "syntaxKeyword": "pink",
+    "syntaxFunction": "purple",
+    "syntaxVariable": "purple",
+    "syntaxString": "cyan",
+    "syntaxNumber": "green",
+    "syntaxType": "purple",
+    "syntaxOperator": "pink",
+    "syntaxPunctuation": "darkFg"
+  }
+}

package/src/cli/cmd/tui/context/theme/ayu.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "darkBg": "#0B0E14",
+    "darkBgAlt": "#0D1017",
+    "darkLine": "#11151C",
+    "darkPanel": "#0F131A",
+    "darkFg": "#BFBDB6",
+    "darkFgMuted": "#565B66",
+    "darkGutter": "#6C7380",
+    "darkTag": "#39BAE6",
+    "darkFunc": "#FFB454",
+    "darkEntity": "#59C2FF",
+    "darkString": "#AAD94C",
+    "darkRegexp": "#95E6CB",
+    "darkMarkup": "#F07178",
+    "darkKeyword": "#FF8F40",
+    "darkSpecial": "#E6B673",
+    "darkComment": "#ACB6BF",
+    "darkConstant": "#D2A6FF",
+    "darkOperator": "#F29668",
+    "darkAdded": "#7FD962",
+    "darkRemoved": "#F26D78",
+    "darkAccent": "#E6B450",
+    "darkError": "#D95757",
+    "darkIndentActive": "#6C7380"
+  },
+  "theme": {
+    "primary": "darkEntity",
+    "secondary": "darkConstant",
+    "accent": "darkAccent",
+    "error": "darkError",
+    "warning": "darkSpecial",
+    "success": "darkAdded",
+    "info": "darkTag",
+    "text": "darkFg",
+    "textMuted": "darkFgMuted",
+    "background": "darkBg",
+    "backgroundPanel": "darkPanel",
+    "backgroundElement": "darkBgAlt",
+    "border": "darkGutter",
+    "borderActive": "darkIndentActive",
+    "borderSubtle": "darkLine",
+    "diffAdded": "darkAdded",
+    "diffRemoved": "darkRemoved",
+    "diffContext": "darkComment",
+    "diffHunkHeader": "darkComment",
+    "diffHighlightAdded": "darkString",
+    "diffHighlightRemoved": "darkMarkup",
+    "diffAddedBg": "#20303b",
+    "diffRemovedBg": "#37222c",
+    "diffContextBg": "darkPanel",
+    "diffLineNumber": "darkGutter",
+    "diffAddedLineNumberBg": "#1b2b34",
+    "diffRemovedLineNumberBg": "#2d1f26",
+    "markdownText": "darkFg",
+    "markdownHeading": "darkConstant",
+    "markdownLink": "darkEntity",
+    "markdownLinkText": "darkTag",
+    "markdownCode": "darkString",
+    "markdownBlockQuote": "darkSpecial",
+    "markdownEmph": "darkSpecial",
+    "markdownStrong": "darkFunc",
+    "markdownHorizontalRule": "darkFgMuted",
+    "markdownListItem": "darkEntity",
+    "markdownListEnumeration": "darkTag",
+    "markdownImage": "darkEntity",
+    "markdownImageText": "darkTag",
+    "markdownCodeBlock": "darkFg",
+    "syntaxComment": "darkComment",
+    "syntaxKeyword": "darkKeyword",
+    "syntaxFunction": "darkFunc",
+    "syntaxVariable": "darkEntity",
+    "syntaxString": "darkString",
+    "syntaxNumber": "darkConstant",
+    "syntaxType": "darkSpecial",
+    "syntaxOperator": "darkOperator",
+    "syntaxPunctuation": "darkFg"
+  }
+}