opencode-ufr 0.2.9 → 0.2.10

package/src/daemon/vpn/manager.ts

@@ -10,13 +10,11 @@ import { TcpStack } from "./stack"
 import { startProxy, type ProxyHandle } from "./proxy"
 import {
   authenticate,
-  fetchTunnelConfig,
   openTunnel,
   VpnChallengeError,
   type TunnelHandle,
 } from "./fortinet"
 import type { Transport } from "../transport"
-import { isVpnPage } from "../../shared/vpn"
 
 export type VpnState = {
   mode: "off" | "connecting" | "up" | "failed"
@@ -78,8 +76,12 @@ export class VpnManager {
       name: "vpn",
       fetch: async (url, init) => {
         const path = await untilAborted(this.ensurePath(), init?.signal)
-        if (path === "vpn" && this.proxy) {
-          return await fetch(url, { ...init, proxy: `http://127.0.0.1:${this.proxy.port}` } as RequestInit)
+        if (path === "vpn") {
+          const proxy = this.proxy
+          // ensurePath answered "vpn" but teardown nulled the proxy meanwhile:
+          // fail fast instead of silently falling through to a direct fetch
+          if (!proxy) throw new Error("the vpn tunnel went down while the request was starting — retry")
+          return await fetch(url, { ...init, proxy: `http://127.0.0.1:${proxy.port}` } as RequestInit)
         }
         return await f(url, init)
       },
@@ -115,7 +117,7 @@ export class VpnManager {
     }
     // 2. tunnel needed — do we have a login?
     if (!this.o.credentials) {
-      this.setState("failed", "off campus and no uni login stored — run `ufr login add <user>`")
+      this.setState("failed", "off campus and no uni login stored — add the uni login in opencode's /connect (Uni Freiburg)")
       return "failed"
     }
     // 3. bring the tunnel up
@@ -123,6 +125,7 @@ export class VpnManager {
       await this.open()
       return "vpn"
     } catch (e) {
+      if (this.stopped) return "failed" // shutting down: don't overwrite the stopped state
       const msg = (e as Error).message
       this.setState("failed", msg)
       this.scheduleReconnect(msg)
@@ -144,11 +147,7 @@ export class VpnManager {
         this.directOk = true
         return "direct"
       }
-      if (type.includes("text/html")) {
-        const html = await res.text().catch(() => "")
-        this.directOk = false
-        return isVpnPage(html) ? "tunnel-needed" : "tunnel-needed"
-      }
+      // HTML or anything unexpected: the tunnel is the only path left
       this.directOk = false
       return "tunnel-needed"
     } catch {
@@ -172,7 +171,8 @@ export class VpnManager {
     }).catch((e) => {
       throw signal.aborted ? new Error(`the uni VPN gateway did not answer within ${Math.ceil(loginMs / 1000)} s`) : e
     })
-    if (this.remoteIp === null) this.remoteIp = await resolveIp(this.o.upstreamHost)
+    // fresh per attempt: the DNS answer can change with the route
+    this.remoteIp = await resolveIp(this.o.upstreamHost)
 
     this.setState("connecting", "negotiating PPP")
     let sendIp: (datagram: Uint8Array) => void = () => {}
@@ -185,13 +185,23 @@ export class VpnManager {
         sendIp = (datagram) => ppp.sendIp(datagram)
       },
       onEstablished: (cfg) => {
+        if (this.stopped) return // stop() mid-connect: the tunnel is closed below; don't start the proxy
+        // parseTunnelConfig validates innerIp; this is a non-throwing assertion so a
+        // malformed value can never surface as a "tunnel framing error"
+        let local: Ipv4
+        try {
+          local = ipv4Parse(cfg.innerIp)
+        } catch {
+          this.o.log(`tunnel established with an invalid inner ip ("${cfg.innerIp}") — ignored`)
+          return
+        }
         if (!stackRef) {
-          stackRef = new TcpStack({ local: ipv4Parse(cfg.innerIp), sink: (pkt) => sendIp(pkt), opts: { mss: Math.min(cfg.mru - 40, 1360) } }, this.o.log)
+          stackRef = new TcpStack({ local, sink: (pkt) => sendIp(pkt), opts: { mss: Math.min(cfg.mru - 40, 1360) } }, this.o.log)
           this.stack = stackRef
           this.proxy = startProxy({ stack: stackRef, remoteIp: this.remoteIp!, log: this.o.log })
           this.o.log(`proxy listening on 127.0.0.1:${this.proxy.port}`)
         } else {
-          stackRef.setLocal(ipv4Parse(cfg.innerIp))
+          stackRef.setLocal(local)
         }
         this.reconnectAttempt = 0
         this.setState("up", `tunnel up (inner ip ${cfg.innerIp})`, cfg.innerIp, this.proxy?.port)
@@ -204,11 +214,21 @@ export class VpnManager {
       },
       onIp: (datagram) => stackRef?.receive(datagram),
     })
+    if (this.stopped) {
+      // stop() ran while the connect was in flight: the tunnel came up after the
+      // teardown — close it instead of leaking a live session
+      await tunnel.close()
+      throw new Error("stopped")
+    }
     this.tunnel = tunnel
 
     // wait for the XML phase + PPP/ICCP negotiation to finish
     const deadline = Date.now() + ESTABLISH_TIMEOUT_MS
     while (this.state.mode !== "up") {
+      if (this.stopped) {
+        await tunnel.close()
+        throw new Error("stopped")
+      }
       if (Date.now() > deadline) {
         await tunnel.close()
         throw new Error("the tunnel did not come up within 30 s")
@@ -271,8 +291,22 @@ function untilAborted<T>(p: Promise<T>, signal?: AbortSignal | null): Promise<T>
   })
 }
 
-async function resolveIp(host: string): Promise<Ipv4> {
+const RESOLVE_TIMEOUT_MS = 10_000
+
+/** Resolve the upstream host to an IPv4, with a deadline (a hung resolver must not stall the connect forever). */
+async function resolveIp(host: string, timeoutMs = RESOLVE_TIMEOUT_MS): Promise<Ipv4> {
   const { lookup } = await import("node:dns/promises")
-  const res = await lookup(host, { family: 4 })
-  return ipv4Parse(res.address)
+  let timer: ReturnType<typeof setTimeout> | null = null
+  try {
+    const res = await Promise.race([
+      lookup(host, { family: 4 }),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`DNS lookup for ${host} did not answer within ${Math.ceil(timeoutMs / 1000)} s`)), timeoutMs)
+        timer.unref?.()
+      }),
+    ])
+    return ipv4Parse(res.address)
+  } finally {
+    if (timer) clearTimeout(timer)
+  }
 }

package/src/daemon/vpn/proxy.ts

@@ -57,7 +57,9 @@ export function startProxy(o: {
           return
         }
         const port = Number(m[2])
-        if (!allowedPorts.includes(port) || !m[1]!.toLowerCase().endsWith(suffix)) {
+        const host = m[1]!.toLowerCase()
+        // exact match or a subdomain — a bare endsWith would let evil-uni-freiburg.de through
+        if (!allowedPorts.includes(port) || (host !== suffix && !host.endsWith(`.${suffix}`))) {
           // the tunnel only carries traffic to the uni host
           log(`proxy: refusing CONNECT ${m[1]}:${port}`)
           socket.write("HTTP/1.1 403 Forbidden\r\n\r\n")

package/src/plugin/connect.ts

@@ -2,14 +2,14 @@
  * The /connect integration: opencode's built-in provider-connect panel lists
  * the "unifreiburg" integration; this plugin replaces its key method with one
  * that shows the optional uni-login form (login + password) alongside the API
- * key(s). When the user submits, opencode stores a Credential with the form
+ * key. When the user submits, opencode stores a Credential with the form
  * answers; this module watches for it and applies it to the keyring + config,
  * then restarts the gateway so the keys go live.
  */
 
 import { applyConnect, splitKeys } from "../shared/connect"
 import type { Paths } from "../shared/paths"
-import { applyKeyChange, disconnectAll } from "../cli/keys"
+import { applyKeyChange, disconnectAll } from "../shared/keys"
 
 export const UFR_INTEGRATION_ID = "unifreiburg"
 
@@ -56,14 +56,14 @@ export async function registerConnect(d: ConnectDeps): Promise<ConnectRegistrati
   }
 
   // Replace the key method of the unifreiburg integration with ours: the
-  // standard API-key(s) prompt plus the optional uni-login form.
+  // standard API-key prompt plus the optional uni-login form.
   await ctx.integration.transform((editor: any) => {
     if (typeof editor?.method?.update !== "function") return
     editor.method.update({
       integrationID: UFR_INTEGRATION_ID,
       method: {
         type: "key",
-        label: "API keys (comma-separated)",
+        label: "API key",
         form: [
           {
             key: "login",

package/src/plugin/ensure-daemon.ts

@@ -1,9 +1,10 @@
 import { spawn } from "node:child_process"
 import { mkdirSync } from "node:fs"
-import { readJson, readText } from "../shared/fs"
+import { readText } from "../shared/fs"
+import { readDaemonInfo, type DaemonInfo } from "../shared/daemon-client"
 import type { Paths } from "../shared/paths"
 
-export type DaemonInfo = { port: number; pid: number; version: string }
+export type { DaemonInfo }
 export type Conn = { port: number; token: string }
 type FetchLike = (url: string, init?: RequestInit) => Promise<Response>
 
@@ -18,11 +19,6 @@ export function isNewer(a: string, b: string): boolean {
   return false
 }
 
-export async function readDaemonInfo(paths: Paths): Promise<DaemonInfo | null> {
-  const j = (await readJson(paths.daemonFile)) as Partial<DaemonInfo> | null
-  return j && typeof j.port === "number" && typeof j.version === "string" ? { port: j.port, pid: j.pid ?? 0, version: j.version } : null
-}
-
 async function readToken(paths: Paths): Promise<string | null> {
   return (await readText(paths.tokenFile))?.trim() || null
 }
@@ -31,7 +27,7 @@ async function readToken(paths: Paths): Promise<string | null> {
 export async function ensureDaemon(o: {
   paths: Paths
   version: string
-  spawn: () => void
+  spawn: (onError: (e: Error) => void) => void
   fetch?: FetchLike
   sleep?: (ms: number) => Promise<void>
   timeoutMs?: number
@@ -40,10 +36,13 @@ export async function ensureDaemon(o: {
   const f: FetchLike = o.fetch ?? ((u, i) => fetch(u, i))
   const sleep = o.sleep ?? ((ms: number) => Bun.sleep(ms))
   const now = o.now ?? Date.now
-  const health = async (port: number) => {
+  const health = async (port: number): Promise<{ version: string } | null> => {
     try {
       const r = await f(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2_000) })
-      return r.ok ? ((await r.json()) as { version?: string }) : null
+      if (!r.ok) return null
+      const h = (await r.json()) as { version?: unknown }
+      // Only reuse a daemon that identifies itself — a 200 without a version could be anything on that port.
+      return typeof h.version === "string" ? { version: h.version } : null
     } catch {
       return null
     }
@@ -59,27 +58,56 @@ export async function ensureDaemon(o: {
     const h = await health(info.port)
     const token = await readToken(o.paths)
     if (h && token) {
-      if (!h.version || !isNewer(o.version, h.version)) return { port: info.port, token }
-      const st = (await f(`http://127.0.0.1:${info.port}/v1/_status`, authed(token))
-        .then((r) => (r.ok ? r.json() : null))
-        .catch(() => null)) as { inFlight?: number } | null
-      if (!st || (st.inFlight ?? 0) > 0) return { port: info.port, token } // upgrade later, never mid-request
-      await f(`http://127.0.0.1:${info.port}/v1/_shutdown`, authed(token, "POST")).catch(() => null)
-      for (let i = 0; i < 25 && (await health(info.port)); i++) await sleep(200)
+      if (!isNewer(o.version, h.version)) return { port: info.port, token }
+      const res = await f(`http://127.0.0.1:${info.port}/v1/_status`, authed(token)).catch(() => null)
+      if (res !== null && !res.ok && (res.status === 401 || res.status === 403)) {
+        // The stored token is rejected — handing the conn back would only serve
+        // 401s, and this daemon can be neither stopped nor replaced without a
+        // valid token. Fail with the reason instead of pretending success.
+        throw new Error(
+          "the running opencode-ufr gateway rejects the stored token — restart it or remove the opencode-ufr state directory",
+        )
+      }
+      // Any other non-ok answer (a 503 while the daemon restarts, say) is not a
+      // token rejection: it lands in the couldn't-verify path below.
+      const st = res !== null ? ((await res.json().catch(() => null)) as { inFlight?: unknown } | null) : null
+      const inFlight = st !== null && typeof st.inFlight === "number" ? st.inFlight : null
+      if (inFlight === null) {
+        // Couldn't verify (transport hiccup on the probe, or a non-ok _status
+        // above) — not confirmed idle: fall through to the spawn path below
+        // instead of trusting the guess. Spawning while the old daemon still
+        // holds the lock is safe: the child cannot take over and exits quietly
+        // (no error event — only a failed exec fires one), and the health poll
+        // below keeps answering with the running daemon's conn either way.
+      } else if (inFlight > 0) {
+        return { port: info.port, token } // upgrade later, never mid-request
+      } else {
+        await f(`http://127.0.0.1:${info.port}/v1/_shutdown`, authed(token, "POST")).catch(() => null)
+        for (let i = 0; i < 25 && (await health(info.port)); i++) await sleep(200)
+      }
     }
   }
 
-  o.spawn()
+  const spawnError: { message: string | null } = { message: null }
+  o.spawn((e) => {
+    spawnError.message = e.message
+  })
   // Startup can take up to ~35 s: two catalog fetches (models.json, UFR /api/models)
   // with 15 s and 20 s timeouts before /health answers.
   const timeoutMs = o.timeoutMs ?? 40_000
   const deadline = now() + timeoutMs
   while (now() < deadline) {
+    if (spawnError.message !== null) {
+      throw new Error(`the opencode-ufr gateway failed to start (${spawnError.message}) — see daemon.log`)
+    }
     await sleep(200)
     const next = await readDaemonInfo(o.paths)
     const token = await readToken(o.paths)
     if (next && token && (await health(next.port))) return { port: next.port, token }
   }
+  if (spawnError.message !== null) {
+    throw new Error(`the opencode-ufr gateway failed to start (${spawnError.message}) — see daemon.log`)
+  }
   throw new Error(`the opencode-ufr gateway did not start within ${Math.round(timeoutMs / 1000)} s — see daemon.log`)
 }
 
@@ -88,7 +116,7 @@ export async function ensureDaemon(o: {
  * It runs in `cwd` (the state directory), never in the spawning project: Bun auto-loads
  * .env / bunfig.toml from the working directory, and on Windows the folder would stay locked.
  */
-export function spawnDaemon(entry: string, cwd: string): void {
+export function spawnDaemon(entry: string, cwd: string, onError?: (e: Error) => void): void {
   mkdirSync(cwd, { recursive: true })
   const child = spawn(process.execPath, [entry], {
     cwd,
@@ -97,5 +125,6 @@ export function spawnDaemon(entry: string, cwd: string): void {
     windowsHide: true,
     env: { ...process.env, BUN_BE_BUN: "1" },
   })
+  if (onError) child.on("error", (e) => onError(e instanceof Error ? e : new Error(String(e))))
   child.unref()
 }

package/src/plugin/index.ts

@@ -1,14 +1,43 @@
 import { fileURLToPath } from "node:url"
 import type { OpencodeStamp } from "../daemon/catalog"
-import { daemonRequest } from "../cli/daemon-client"
+import { daemonRequest } from "../shared/daemon-client"
+import { disconnectAll } from "../shared/keys"
 import { type Paths, resolvePaths } from "../shared/paths"
-import { KeyringStore } from "../shared/secrets"
+import { KeyringStore, type SecretStore } from "../shared/secrets"
 import { VERSION } from "../shared/version"
 import { type Conn, ensureDaemon, spawnDaemon } from "./ensure-daemon"
 import { registerConnect, UFR_INTEGRATION_ID } from "./connect"
 import { toModelInfo } from "./model-info"
 
 const DAEMON_ENTRY = fileURLToPath(new URL("../daemon/main.ts", import.meta.url))
+const PDF2MD_SCRIPT = fileURLToPath(new URL("../client/pdf2md.ts", import.meta.url))
+const PDF2MD_SKILL = fileURLToPath(new URL("../../skills/pdf2md/SKILL.md", import.meta.url))
+
+/**
+ * Registers the pdf2md skill with opencode (V2 plugins can add skills via a
+ * transform). The SKILL.md ships with the package; the script path is baked in
+ * at registration time because it depends on where npm cached the package.
+ */
+async function registerSkill(ctx: any): Promise<void> {
+  if (typeof ctx?.skill?.transform !== "function") return // older opencode — no skills
+  try {
+    const raw = await Bun.file(PDF2MD_SKILL).text()
+    const content = raw.replace("{{PDF2MD_SCRIPT}}", PDF2MD_SCRIPT)
+    await ctx.skill.transform((editor: any) => {
+      editor.add({
+        id: "ufr-pdf2md",
+        name: "PDF to Markdown",
+        description:
+          "Convert a PDF to clean Markdown using UFR vision models — OCR with tables, math, circuit diagrams, refinement and cross-page table merging, all rate-limit-safe through the local gateway.",
+        path: PDF2MD_SKILL,
+        content,
+      })
+    })
+    log("registered skill ufr-pdf2md")
+  } catch (e) {
+    log(`skill registration failed: ${(e as Error).message}`)
+  }
+}
 
 // opencode takes a request's key from the provider's integration (default: the one with the provider's
 // id), and a key credential there replaces settings.apiKey. The /connect credential on "unifreiburg"
@@ -20,7 +49,11 @@ function log(msg: string): void {
 }
 
 async function connect(paths: Paths): Promise<Conn> {
-  return ensureDaemon({ paths, version: VERSION, spawn: () => spawnDaemon(DAEMON_ENTRY, paths.stateDir) })
+  return ensureDaemon({
+    paths,
+    version: VERSION,
+    spawn: (onError) => spawnDaemon(DAEMON_ENTRY, paths.stateDir, onError),
+  })
 }
 
 /** Whether this opencode exposes the integration API (needed to see connection state). */
@@ -39,18 +72,22 @@ async function registerProvider(
   try {
     conn = await connect(paths)
   } catch (e) {
-    log(`${(e as Error).message} — run \`ufr status\``)
+    log(`${(e as Error).message} — see daemon.log in the opencode-ufr state directory`)
     return false
   }
   const list = await fetch(`http://127.0.0.1:${conn.port}/v1/models`, {
     headers: { Authorization: `Bearer ${conn.token}` },
     signal: AbortSignal.timeout(10_000),
   })
-    .then(async (r) => (r.ok ? ((await r.json()) as { data: { id: string; opencode: OpencodeStamp }[] }).data : []))
-    .catch(() => [])
+    .then(async (r) => (r.ok ? ((await r.json()) as { data: { id: string; opencode: OpencodeStamp }[] }).data : null))
+    .catch(() => null)
+  if (list === null) {
+    log("gateway unreachable — retrying")
+    return false
+  }
   if (list.length === 0) {
     // Never register an empty provider: it breaks the whole model picker.
-    log("no models available — run `ufr setup`, connect to the uni VPN, then `ufr status` for details")
+    log("no models available — connect to the uni VPN off campus, then restart opencode")
     return false
   }
   if (typeof ctx?.provider?.transform !== "function") {
@@ -92,50 +129,88 @@ export async function heartbeat(ctx: any, paths: Paths): Promise<void> {
   if (!ok) await connect(paths).catch((e) => log(`gateway restart failed: ${(e as Error).message}`))
 }
 
-export default {
-  id: "opencode-ufr",
-  async setup(ctx: any) {
-    const options = (ctx?.options ?? {}) as Record<string, unknown>
-    const providerId = typeof options.providerId === "string" ? options.providerId : "unifreiburg"
-    const providerName = typeof options.providerName === "string" ? options.providerName : "Uni Freiburg"
-    const paths = resolvePaths()
+/**
+ * The plugin entry point. `inject.secrets` exists for tests only — production
+ * always uses the OS keyring.
+ */
+export async function setupPlugin(ctx: any, inject: { secrets?: SecretStore } = {}): Promise<() => void> {
+  const options = (ctx?.options ?? {}) as Record<string, unknown>
+  const providerId = typeof options.providerId === "string" ? options.providerId : "unifreiburg"
+  const providerName = typeof options.providerName === "string" ? options.providerName : "Uni Freiburg"
+  const paths = resolvePaths()
+  const secrets = inject.secrets ?? new KeyringStore()
 
-    let registered = false
-    const registerProviderFn = async (): Promise<boolean> => {
-      if (registered) return true
-      registered = await registerProvider(ctx, providerId, providerName, paths)
-      return registered
-    }
+  let registered = false
+  const registerProviderFn = async (): Promise<boolean> => {
+    if (registered) return true
+    registered = await registerProvider(ctx, providerId, providerName, paths)
+    return registered
+  }
 
-    // /connect integration first: it is the only way to connect when no
-    // provider is registered yet, so it must exist even while disconnected.
-    const stopConnect = await registerConnect({
-      ctx,
-      paths,
-      secrets: new KeyringStore(),
-      log,
-      register: registerProviderFn,
-      providerRegistered: false,
-    }).catch((e) => {
-      log(`/connect integration failed: ${(e as Error).message}`)
-      return { stop: () => {}, applyNow: async () => false }
-    })
+  // /connect integration first: it is the only way to connect when no
+  // provider is registered yet, so it must exist even while disconnected.
+  const stopConnect = await registerConnect({
+    ctx,
+    paths,
+    secrets,
+    log,
+    register: registerProviderFn,
+    providerRegistered: false,
+  }).catch((e) => {
+    log(`/connect integration failed: ${(e as Error).message}`)
+    return { stop: () => {}, applyNow: async () => false }
+  })
 
-    // The provider is registered only while the integration is connected:
-    // removing it in opencode must remove the models too.
-    if (!hasIntegration(ctx)) {
-      await registerProviderFn() // old opencode without the integration API — register as before
+  // The provider is registered only while the integration is connected:
+  // removing it in opencode must remove the models too.
+  if (!hasIntegration(ctx)) {
+    await registerProviderFn() // old opencode without the integration API — register as before
+  } else {
+    const connection = await ctx.integration.connection.active(UFR_INTEGRATION_ID).catch(() => undefined)
+    if (connection) {
+      // Registering can block ~80 s (daemon boot + watcher retries) — never
+      // stall opencode startup: run the first registration in the background;
+      // the /connect watcher (polling every few seconds) completes it if needed.
+      log("unifreiburg connected — registering the provider in the background")
+      void registerProviderFn().catch((e) => log(`provider registration failed: ${(e as Error).message}`))
     } else {
-      const connection = await ctx.integration.connection.active(UFR_INTEGRATION_ID).catch(() => undefined)
-      if (connection) await registerProviderFn()
-      else log(`${providerId} not connected — open /connect in opencode to set it up`)
+      // A removal while opencode was closed leaves the keyring untouched (the
+      // watcher only sees the transition while opencode runs) — wipe it here.
+      // A failing loadConfig (a broken config.json) must not reject setupPlugin:
+      // the plugin still has to load so /connect can repair the setup.
+      const r = await disconnectAll({ paths, secrets, fetch: (u, i) => fetch(u, i), log }).catch((e) => {
+        log(`cleanup of the removed connection failed: ${(e as Error).message}`)
+        return { removed: [], loginRemoved: false }
+      })
+      if (r.removed.length > 0 || r.loginRemoved) {
+        log(`unifreiburg was removed in opencode — wiped what was left: ${r.removed.join(", ")}${r.loginRemoved ? " + uni login" : ""}`)
+      }
+      log(`${providerId} not connected — open /connect in opencode to set it up`)
     }
+  }
 
-    const beat = setInterval(() => void heartbeat(ctx, paths), 60_000)
-    ;(beat as { unref?: () => void }).unref?.()
-    return () => {
-      clearInterval(beat)
-      stopConnect.stop()
-    }
+  // The pdf2md skill is independent of the connection state — register it always.
+  await registerSkill(ctx)
+
+  // One heartbeat at a time: a slow one (daemon boot) must not pile up or race the /connect watcher.
+  let beating = false
+  const beat = setInterval(() => {
+    if (beating) return
+    beating = true
+    void heartbeat(ctx, paths).finally(() => {
+      beating = false
+    })
+  }, 60_000)
+  ;(beat as { unref?: () => void }).unref?.()
+  return () => {
+    clearInterval(beat)
+    stopConnect.stop()
+  }
+}
+
+export default {
+  id: "opencode-ufr",
+  async setup(ctx: any) {
+    return setupPlugin(ctx)
   },
 }

package/src/plugin/tui.tsx

@@ -0,0 +1,77 @@
+/**
+ * TUI contribution: live gateway throughput in opencode's sidebar. Loaded by
+ * opencode's CLI because package.json exports "./tui" — the server plugin
+ * (index.ts) needs no changes for this to load.
+ *
+ * Polls GET /v1/_status every second and appends one line to the right
+ * panel: req/s and tok/s over the gateway's rolling 60 s window. Status
+ * polls don't reset the daemon's idle timer (see server.ts), so leaving the
+ * panel open never keeps the gateway alive.
+ */
+import { Plugin } from "@opencode/plugin/tui"
+import { createSignal, onCleanup, onMount, Show } from "solid-js"
+import { daemonRequest } from "../shared/daemon-client"
+import { resolvePaths, type Paths } from "../shared/paths"
+
+/** The rates block of GET /v1/_status (see StatusJson in daemon.ts). */
+type Rates = {
+  windowMs: number
+  requests: number
+  reqPerSec: number
+  tokensInPerSec: number
+  tokensOutPerSec: number
+}
+
+const POLL_MS = 1_000
+
+/** 6743 → "6.7k" — prompt traffic through opencode dwarfs output. */
+function fmtTokens(v: number): string {
+  return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(v)
+}
+
+function RatesLine(props: { paths: Paths }) {
+  const [rates, setRates] = createSignal<Rates | null>(null)
+  let busy = false
+  const poll = async () => {
+    if (busy) return
+    busy = true
+    try {
+      const res = await daemonRequest(props.paths, (u, i) => fetch(u, i), "/v1/_status")
+      if (!res?.ok) {
+        setRates(null) // daemon down, restarting or new token — the line hides
+        return
+      }
+      const j = (await res.json()) as { rates?: Rates }
+      setRates(j.rates ?? null)
+    } finally {
+      busy = false
+    }
+  }
+  let timer: ReturnType<typeof setInterval> | undefined
+  onMount(() => {
+    void poll()
+    timer = setInterval(() => void poll(), POLL_MS)
+  })
+  onCleanup(() => clearInterval(timer))
+  const label = () => {
+    const r = rates()
+    if (!r) return null
+    return `UFR ${r.reqPerSec} req/s · ${fmtTokens(r.tokensOutPerSec)} tok/s out · ${fmtTokens(r.tokensInPerSec)} tok/s in`
+  }
+  return (
+    <Show when={label()}>
+      <text>{label()}</text>
+    </Show>
+  )
+}
+
+export default Plugin.define({
+  id: "opencode-ufr.stats",
+  setup(context) {
+    const paths = resolvePaths()
+    return context.ui.slot({
+      append: "sidebar.content",
+      render: () => <RatesLine paths={paths} />,
+    })
+  },
+})