opencode-ufr 0.2.10 → 0.2.12

package/dist/tui.js

@@ -0,0 +1,180 @@
+// @bun
+// src/plugin/tui.staged.build.js
+import { insert as _$insert } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { Plugin } from "@opencode/plugin/tui";
+import { For, Show, createSignal, onCleanup, onMount } from "solid-js";
+
+// src/shared/fs.ts
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+async function readText(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return null;
+    throw e;
+  }
+}
+async function readJson(file) {
+  const text = await readText(file);
+  if (text === null)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/shared/daemon-client.ts
+async function readDaemonInfo(paths) {
+  const j = await readJson(paths.daemonFile);
+  if (j === null || typeof j.port !== "number" || typeof j.version !== "string")
+    return null;
+  return { port: j.port, pid: typeof j.pid === "number" ? j.pid : 0, version: j.version };
+}
+async function daemonRequest(paths, f, path, method = "GET") {
+  const info = await readDaemonInfo(paths);
+  const token = (await readText(paths.tokenFile))?.trim();
+  if (!info?.port || !token)
+    return null;
+  try {
+    return await f(`http://127.0.0.1:${info.port}${path}`, {
+      method,
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(5000)
+    });
+  } catch {
+    return null;
+  }
+}
+
+// src/shared/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var APP = "opencode-ufr";
+function resolvePaths(env = process.env, platform = process.platform, home = homedir()) {
+  let configDir, stateDir, cacheDir, dataDir;
+  if (env.OPENCODE_UFR_HOME) {
+    const base = env.OPENCODE_UFR_HOME;
+    configDir = join(base, "config");
+    stateDir = join(base, "state");
+    cacheDir = join(base, "cache");
+    dataDir = join(base, "data");
+  } else if (platform === "win32") {
+    const roaming = env.APPDATA ?? join(home, "AppData", "Roaming");
+    const local = env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+    configDir = join(roaming, APP);
+    stateDir = join(local, APP, "state");
+    cacheDir = join(local, APP, "cache");
+    dataDir = join(local, APP, "data");
+  } else {
+    configDir = join(env.XDG_CONFIG_HOME ?? join(home, ".config"), APP);
+    stateDir = join(env.XDG_STATE_HOME ?? join(home, ".local", "state"), APP);
+    cacheDir = join(env.XDG_CACHE_HOME ?? join(home, ".cache"), APP);
+    dataDir = join(env.XDG_DATA_HOME ?? join(home, ".local", "share"), APP);
+  }
+  return {
+    configDir,
+    stateDir,
+    cacheDir,
+    dataDir,
+    configFile: join(configDir, "config.json"),
+    daemonFile: join(stateDir, "daemon.json"),
+    tokenFile: join(stateDir, "token"),
+    lockFile: join(stateDir, "daemon.lock"),
+    logFile: join(stateDir, "daemon.log"),
+    statsDb: join(dataDir, "stats.db"),
+    ufrModelsCache: join(cacheDir, "ufr-models.json")
+  };
+}
+
+// src/plugin/tui.staged.build.js
+var POLL_MS = 1000;
+function fmtTokens(v) {
+  return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(v);
+}
+function fmtMoney(v) {
+  return `$${v.toFixed(2)}`;
+}
+function keyLine(k, s) {
+  const spend = s.spendToday?.[k.alias] ?? 0;
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(s.dailyBudgetUsd ?? 0)}`;
+  if (k.invalid)
+    line += " invalid";
+  else if (k.blockedBy === "budget")
+    line += " budget";
+  else if (k.blockedBy === "rate")
+    line += " rate";
+  return line;
+}
+function RatesLine(props) {
+  const [status, setStatus] = createSignal(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) {
+        setStatus(null);
+        return;
+      }
+      setStatus(await res.json());
+    } finally {
+      busy = false;
+    }
+  };
+  let timer;
+  onMount(() => {
+    poll();
+    timer = setInterval(() => void poll(), POLL_MS);
+  });
+  onCleanup(() => clearInterval(timer));
+  const label = () => {
+    const r = status()?.rates;
+    if (!r)
+      return null;
+    return `UFR ${r.reqPerSec} req/s \xB7 ${fmtTokens(r.tokensOutPerSec)} tok/s out \xB7 ${fmtTokens(r.tokensInPerSec)} tok/s in`;
+  };
+  return _$createComponent(Show, {
+    get when() {
+      return status();
+    },
+    get children() {
+      return [_$createComponent(For, {
+        get each() {
+          return status().keys ?? [];
+        },
+        children: (k) => (() => {
+          var _el$2 = _$createElement("text");
+          _$insert(_el$2, () => keyLine(k, status()));
+          return _el$2;
+        })()
+      }), (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, label);
+        return _el$;
+      })()];
+    }
+  });
+}
+var tui_staged_build_default = Plugin.define({
+  id: "opencode-ufr.stats",
+  setup(context) {
+    const paths = resolvePaths();
+    return context.ui.slot({
+      append: "sidebar.content",
+      render: () => _$createComponent(RatesLine, {
+        paths
+      })
+    });
+  }
+});
+export {
+  tui_staged_build_default as default
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Uni Freiburg (UFR) Open WebUI models in opencode — local gateway with key pool, UFR-aware rate limiting, circuit breaker and fallbacks",
   "license": "MIT",
   "type": "module",
   "main": "./src/plugin/index.ts",
   "exports": {
     ".": "./src/plugin/index.ts",
-    "./tui": "./src/plugin/tui.tsx"
+    "./tui": "./dist/tui.js"
   },
   "dependencies": {
     "@opencode/plugin": "^2.0.23"
@@ -19,6 +19,7 @@
   },
   "files": [
     "src",
+    "dist",
     "skills",
     "models.json",
     "README.md",
@@ -38,14 +39,18 @@
     "open-webui"
   ],
   "scripts": {
+    "build:tui": "bun scripts/build-tui.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "bun run typecheck && bun test"
+    "prepublishOnly": "bun run build:tui && bun run typecheck && bun test"
   },
   "devDependencies": {
+    "@babel/core": "7.28.0",
+    "@babel/preset-typescript": "7.27.1",
     "@opentui/core": "^0.5.14",
     "@opentui/solid": "^0.5.14",
     "@types/bun": "^1.3.0",
+    "babel-preset-solid": "1.9.12",
     "solid-js": "^1.9.15",
     "typescript": "^5.9.0"
   }

package/src/daemon/keypool.ts

@@ -1,9 +1,18 @@
+import { startOfLocalDay } from "../shared/time"
 import { SlidingWindow } from "./window"
 
 export type KeyInfo = { alias: string; secret: string }
 export type Acquired = { kind: "ok"; alias: string; secret: string; waitMs: number; at: number }
 export type NotAcquired = { kind: "none"; reason: "no_keys" | "all_tried" | "exhausted"; retryAfterMs: number }
-export type KeySnapshot = { alias: string; used: number; cap: number; blockedForMs: number; invalid: boolean }
+export type KeySnapshot = {
+  alias: string
+  used: number
+  cap: number
+  blockedForMs: number
+  /** Why the key is blocked right now: a daily-budget 429 or a bucket 429; null when usable. */
+  blockedBy: "budget" | "rate" | null
+  invalid: boolean
+}
 
 /** A 401 can be transient (portal hiccup, short-lived token rotation): the key
  *  is skipped for this long, then retried — instead of being dead until restart. */
@@ -12,6 +21,8 @@ export const INVALID_KEY_TTL_MS = 10 * 60_000
 type Slot = KeyInfo & {
   window: SlidingWindow
   blockedUntil: number
+  /** What blocked the key: a daily-budget 429 or a bucket 429 (null until one fires). */
+  blockedBy: "budget" | "rate" | null
   /** Until when the key is considered invalid (0 = valid); a transient 401 expires. */
   invalidUntil: number
   recent429: { at: number; model: string }[]
@@ -29,6 +40,7 @@ export class KeyPool {
       ...k,
       window: new SlidingWindow({ cap: o.cap, windowMs: o.windowMs, maxWaitMs: o.maxWaitMs, now: o.now }),
       blockedUntil: 0,
+      blockedBy: null,
       invalidUntil: 0,
       recent429: [],
     }))
@@ -92,10 +104,34 @@ export class KeyPool {
     const acrossModels = new Set(s.recent429.map((e) => e.model)).size >= 2
     if (usedHalf || acrossModels) {
       // UFR frees a slot at first admission + window; rejected calls do not count.
-      s.blockedUntil = Math.max(s.blockedUntil, (s.window.oldest() ?? now) + this.o.windowMs, now + 1_000)
+      const until = Math.max(s.blockedUntil, (s.window.oldest() ?? now) + this.o.windowMs, now + 1_000)
+      // Only the block that actually extends the deadline owns the cause: a rate
+      // block on top of a longer budget block must not relabel it "rate".
+      if (until > s.blockedUntil) {
+        s.blockedUntil = until
+        s.blockedBy = "rate"
+      }
     }
   }
 
+  /**
+   * UFR's daily-budget 429 (the `budget_exceeded` marker) means this key's $ cap
+   * is spent for the day: block it until the next local midnight — UFR's own
+   * reset time is unknown, and midnight is the same assumption the spend-today
+   * stats already make. A bucket 429 carries the identical body (2026-10-07), so
+   * a merely rate-limited key can end up budget-blocked; that only costs until
+   * midnight and is safe. Never shortens an existing block.
+   */
+  onBudgetExhausted(alias: string): void {
+    const s = this.find(alias)
+    if (!s) return
+    const now = this.o.now()
+    // startOfLocalDay(now) at exactly midnight would be now itself — +24h always
+    // lands in the future, so the block can never be already expired.
+    s.blockedUntil = Math.max(s.blockedUntil, startOfLocalDay(now) + 24 * 3_600_000)
+    s.blockedBy = "budget"
+  }
+
   onInvalid(alias: string): void {
     const s = this.find(alias)
     if (s) s.invalidUntil = this.o.now() + INVALID_KEY_TTL_MS
@@ -108,6 +144,10 @@ export class KeyPool {
       used: s.window.inWindow(),
       cap: this.o.cap,
       blockedForMs: Math.max(0, s.blockedUntil - now),
+      // The cause is derived from the current time, not stored state: a block
+      // whose deadline has passed reports as unblocked even if the slot still
+      // carries a stale blockedBy.
+      blockedBy: s.blockedUntil > now ? s.blockedBy : null,
       invalid: s.invalidUntil > now,
     }))
   }

package/src/daemon/router.ts

@@ -238,8 +238,12 @@ export class Router {
         return Response.json(json)
       }
       case "rate_limited":
+        // Same body as a bucket 429 — the `budget_exceeded` marker is the only
+        // tell (text/plain, 2026-09-28); a merely rate-limited key that carries
+        // it is budget-blocked until midnight, which is safe.
+        if (r.body.includes("budget_exceeded")) this.d.keys.onBudgetExhausted(k.alias)
+        else this.d.keys.onRateLimited(k.alias, group)
         // A wall on the exact model the script asked for — honest breaker signal.
-        this.d.keys.onRateLimited(k.alias, group)
         this.d.breakers.get(group).onRateLimited()
         this.record(t0, group, k.alias, 429, null, 1, "upstream_rate_limited", true)
         return new Response(r.body, { status: 429, headers: { "content-type": "application/json" } })
@@ -318,8 +322,15 @@ export class Router {
         if (k.reason === "exhausted") {
           breakers.get(model).onOtherFailure() // model's probe (if any) got no outcome
           if (rateLimitedHere) giveUp(model) // the wall counts toward the breaker threshold even here
+          // The two messages tell the user very different remedies: wait a minute
+          // vs. wait for midnight. The pool alone cannot tell why a key is
+          // blocked, so read it off the snapshot's budget marker.
+          const budgeted = keys.snapshot().some((s) => s.blockedBy === "budget")
           return fail(429, "key_pool_exhausted",
-            `every UFR key is at its limit of ${config.limits.keyRpm} requests per ${config.limits.keyWindowS} s`, k.retryAfterMs)
+            budgeted
+              ? "a UFR key has exhausted its daily budget (resets at local midnight)"
+              : `every UFR key is at its limit of ${config.limits.keyRpm} requests per ${config.limits.keyWindowS} s`,
+            k.retryAfterMs)
         }
         // all_tried: every usable key already failed on this model
         if (rateLimitedHere) giveUp(model)
@@ -376,7 +387,12 @@ export class Router {
           this.d.onUpstream?.(true, "")
           return { ok: true, response: r.response, model, keyAlias: k.alias, attempts, upstreamAbort: upstreamAbort ?? undefined }
         case "rate_limited":
-          keys.onRateLimited(k.alias, model)
+          // UFR's daily-budget 429 and its bucket 429 share one body — the
+          // `budget_exceeded` marker is the only tell (text/plain, 2026-09-28).
+          // A bucket 429 carrying it budget-blocks a merely rate-limited key:
+          // acceptable, that clears at midnight too.
+          if (r.body.includes("budget_exceeded")) keys.onBudgetExhausted(k.alias)
+          else keys.onRateLimited(k.alias, model)
           rateLimitedHere = true
           if (tried.size >= Math.min(2, keys.size)) {
             giveUp(model)

package/src/plugin/tui.tsx

@@ -3,13 +3,14 @@
  * 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.
+ * Polls GET /v1/_status every second and appends lines to the right panel:
+ * one compact line per pool key (alias, $ spent today, daily budget in USD,
+ * why it is blocked) above the req/s and tok/s line 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 { For, Show, createSignal, onCleanup, onMount } from "solid-js"
 import { daemonRequest } from "../shared/daemon-client"
 import { resolvePaths, type Paths } from "../shared/paths"
 
@@ -22,6 +23,24 @@ type Rates = {
   tokensOutPerSec: number
 }
 
+/** Per-key line of GET /v1/_status (KeySnapshot in keypool.ts). */
+type KeyStatus = {
+  alias: string
+  used: number
+  cap: number
+  blockedForMs: number
+  blockedBy: "budget" | "rate" | null
+  invalid: boolean
+}
+
+/** GET /v1/_status — only the fields the sidebar consumes. */
+type Status = {
+  rates?: Rates
+  keys?: KeyStatus[]
+  spendToday?: Record<string, number>
+  dailyBudgetUsd?: number
+}
+
 const POLL_MS = 1_000
 
 /** 6743 → "6.7k" — prompt traffic through opencode dwarfs output. */
@@ -29,8 +48,29 @@ function fmtTokens(v: number): string {
   return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(v)
 }
 
+/** 0.4166 → "$0.42" — money is always shown with 2 decimals. */
+function fmtMoney(v: number): string {
+  return `$${v.toFixed(2)}`
+}
+
+/**
+ * One compact line per pool key: `k1 $0.42/$20.00`, with the reason appended when
+ * the key is unusable — `budget` (daily cap hit, resets at local midnight),
+ * `rate` (bucket 429 cool-down) or `invalid` (transient 401). A key with no
+ * entry in spendToday renders as $0.00; healthy keys render too, the user
+ * asked to see every key.
+ */
+function keyLine(k: KeyStatus, s: Status): string {
+  const spend = s.spendToday?.[k.alias] ?? 0
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(s.dailyBudgetUsd ?? 0)}`
+  if (k.invalid) line += " invalid"
+  else if (k.blockedBy === "budget") line += " budget"
+  else if (k.blockedBy === "rate") line += " rate"
+  return line
+}
+
 function RatesLine(props: { paths: Paths }) {
-  const [rates, setRates] = createSignal<Rates | null>(null)
+  const [status, setStatus] = createSignal<Status | null>(null)
   let busy = false
   const poll = async () => {
     if (busy) return
@@ -38,11 +78,10 @@ function RatesLine(props: { paths: Paths }) {
     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
+        setStatus(null) // daemon down, restarting or new token — the lines hide
         return
       }
-      const j = (await res.json()) as { rates?: Rates }
-      setRates(j.rates ?? null)
+      setStatus((await res.json()) as Status)
     } finally {
       busy = false
     }
@@ -54,12 +93,13 @@ function RatesLine(props: { paths: Paths }) {
   })
   onCleanup(() => clearInterval(timer))
   const label = () => {
-    const r = rates()
+    const r = status()?.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()}>
+    <Show when={status()}>
+      <For each={status()!.keys ?? []}>{(k) => <text>{keyLine(k, status()!)}</text>}</For>
       <text>{label()}</text>
     </Show>
   )