opencode-providers-balances 0.1.1 → 0.1.2

package/README.md

@@ -107,7 +107,7 @@ balance (AITUNNEL).
 
 | Field | Required | Description |
 | --- | --- | --- |
-| `id` | yes | Stable id; used for `disable` and as the default env prefix. |
+| `id` | yes | Stable id; used for `disable` and as the base of the default env var (sanitized — see `env`). |
 | `label` | yes | Sidebar label. |
 | `url` | yes | Balance endpoint. |
 | `jsonPath` | no | Dot path into the JSON body. Numeric segments index arrays, e.g. `balance_infos.0.total_balance`. The value must be a number (or numeric string) and is formatted with two decimals. |
@@ -115,7 +115,7 @@ balance (AITUNNEL).
 | `prefixFrom` | no | Derive the prefix from a value: `{ path, map, fallback? }`, e.g. `{ "path": "currency", "map": { "USD": "$" } }`. Takes precedence over `prefix`. |
 | `require` | no | Gate the row: `{ path, equals }`; hidden unless the value at `path` strictly equals `equals`. |
 | `authScheme` | no | Authorization scheme, default `Bearer`. |
-| `env` | no | Env var holding the key, default `<ID>_API_KEY`. |
+| `env` | no | Env var holding the key, default `<SANITIZED_ID>_API_KEY` — the id uppercased with runs of non-alphanumerics turned into `_` (e.g. `router-ai` → `ROUTER_AI_API_KEY`). |
 | `key` | no | Literal key (discouraged — prefer env/integration). |
 | `integration` | no | Id in the V2 SQLite `credential` table. |
 | `configProvider` | no | Provider id in `opencode.jsonc` whose `settings.apiKey` to use. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-providers-balances",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "OpenCode TUI plugin that shows provider account balances in the session sidebar. Providers are configured entirely in opencode.jsonc.",
   "keywords": [
     "opencode",

package/providers.ts

@@ -11,7 +11,7 @@
 
 import { readFileSync, existsSync } from "node:fs"
 import { homedir } from "node:os"
-import { join } from "node:path"
+import { join, resolve } from "node:path"
 import { createRequire } from "node:module"
 
 // ---------------------------------------------------------------------------
@@ -58,7 +58,7 @@ export interface Provider {
  *   - `prefix` / `prefixFrom`   fixed or value-derived display prefix.
  */
 export interface ProviderConfig {
-  /** Stable id; also the default env prefix and `disable` key. */
+  /** Stable id; also the base of the default env var and the `disable` key. */
   id: string
   /** Sidebar label. */
   label: string
@@ -66,7 +66,7 @@ export interface ProviderConfig {
   url: string
   /** Authorization scheme; defaults to `Bearer`. */
   authScheme?: string
-  /** Env var holding the key; defaults to `<ID>_API_KEY`. */
+  /** Env var holding the key; defaults to `<SANITIZED_ID>_API_KEY`. */
   env?: string
   /** Literal key (discouraged — prefer env/integration). */
   key?: string
@@ -99,8 +99,13 @@ export interface FetchResult {
   value: string
   /** True when the provider is configured but the last refresh failed. */
   stale: boolean
-  /** True when the provider has no usable key — hidden, not rendered. */
-  skipped: boolean
+  /**
+   * True when the provider must not be rendered: no usable key, a failed
+   * `require` gate, or a response with no numeric value. Distinguishing this
+   * from `stale` keeps an intentionally unavailable provider from showing a
+   * previous balance marked stale.
+   */
+  hidden: boolean
 }
 
 export interface BalanceState {
@@ -122,10 +127,21 @@ export function jsonPathGet(body: unknown, path: string): unknown {
   return cur
 }
 
-/** Coerce a value to a finite number, or null. */
+/**
+ * Coerce a value to a finite number, or null. Only a real number or a non-blank
+ * numeric string counts; `null`, booleans, arrays, objects and blank strings are
+ * rejected rather than coerced (so `Number(null) === 0` can't masquerade as a
+ * zero balance).
+ */
 function num(v: unknown): number | null {
-  const n = typeof v === "number" ? v : Number(v)
-  return Number.isFinite(n) ? n : null
+  if (typeof v === "number") return Number.isFinite(v) ? v : null
+  if (typeof v === "string") {
+    const t = v.trim()
+    if (!t) return null
+    const n = Number(t)
+    return Number.isFinite(n) ? n : null
+  }
+  return null
 }
 
 /** Build a formatter from the declarative rules in a spec. */
@@ -150,27 +166,67 @@ function buildFormatter(spec: ProviderConfig): (body: unknown) => string | null
 
 let configCache: { at: number; data: Record<string, unknown> | null } | null = null
 
+/**
+ * Root directories OpenCode uses for global state, honoring the XDG base
+ * directories exactly like OpenCode's own `roots()`: `$XDG_CONFIG_HOME` and
+ * `$XDG_DATA_HOME`, falling back to `~/.config` and `~/.local/share` when unset
+ * or empty.
+ */
+export function opencodeRoots(app = "opencode"): { config: string; data: string } {
+  const home = homedir()
+  const configHome = process.env.XDG_CONFIG_HOME || join(home, ".config")
+  const dataHome = process.env.XDG_DATA_HOME || join(home, ".local", "share")
+  return { config: join(configHome, app), data: join(dataHome, app) }
+}
+
+/**
+ * Candidate global config files in precedence order, honoring OpenCode's
+ * `OPENCODE_CONFIG` (explicit file) and `OPENCODE_CONFIG_DIR` (config directory
+ * override) before the XDG-derived default.
+ */
+export function configFilePaths(): string[] {
+  const dir = process.env.OPENCODE_CONFIG_DIR || opencodeRoots().config
+  const files = ["opencode.jsonc", "opencode.json"].map((name) => join(dir, name))
+  const explicit = process.env.OPENCODE_CONFIG
+  return explicit ? [explicit, ...files] : files
+}
+
 function readConfig(): Record<string, unknown> | null {
   const now = Date.now()
   if (configCache && now - configCache.at < CONFIG_CACHE_MS) return configCache.data
   let data: Record<string, unknown> | null = null
-  for (const name of ["opencode.jsonc", "opencode.json"]) {
-    const p = join(homedir(), ".config/opencode", name)
-    if (!existsSync(p)) continue
+  const inline = process.env.OPENCODE_CONFIG_CONTENT
+  if (inline) {
     try {
-      data = parseJsonc(readFileSync(p, "utf8"))
-      break
+      data = parseJsonc(inline)
     } catch {}
   }
+  if (!data) {
+    for (const p of configFilePaths()) {
+      if (!existsSync(p)) continue
+      try {
+        data = parseJsonc(readFileSync(p, "utf8"))
+        break
+      } catch {}
+    }
+  }
   configCache = { at: now, data }
   return data
 }
 
-/** Strip JSONC comments without corrupting string values. */
-function parseJsonc(raw: string): Record<string, unknown> {
+/**
+ * Parse JSONC: strip line/block comments and trailing commas, then hand the
+ * result to `JSON.parse`. Comments and commas inside string values are left
+ * intact. Only `"` delimits strings, matching JSONC.
+ */
+export function parseJsonc(raw: string): Record<string, unknown> {
+  return JSON.parse(stripTrailingCommas(stripComments(raw))) as Record<string, unknown>
+}
+
+/** Remove line and block comments, ignoring any that appear inside strings. */
+function stripComments(raw: string): string {
   let out = ""
   let inString = false
-  let quote = ""
   for (let i = 0; i < raw.length; i++) {
     const ch = raw[i]
     const next = raw[i + 1]
@@ -179,14 +235,13 @@ function parseJsonc(raw: string): Record<string, unknown> {
       if (ch === "\\") {
         out += next ?? ""
         i++
-      } else if (ch === quote) {
+      } else if (ch === '"') {
         inString = false
       }
       continue
     }
-    if (ch === '"' || ch === "'") {
+    if (ch === '"') {
       inString = true
-      quote = ch
       out += ch
       continue
     }
@@ -203,8 +258,38 @@ function parseJsonc(raw: string): Record<string, unknown> {
     }
     out += ch
   }
-  out = out.replace(/,(\s*[}\]])/g, "$1")
-  return JSON.parse(out) as Record<string, unknown>
+  return out
+}
+
+/** Drop commas that precede a closing brace/bracket, ignoring string values. */
+function stripTrailingCommas(s: string): string {
+  let out = ""
+  let inString = false
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (inString) {
+      out += ch
+      if (ch === "\\") {
+        out += s[i + 1] ?? ""
+        i++
+      } else if (ch === '"') {
+        inString = false
+      }
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      out += ch
+      continue
+    }
+    if (ch === ",") {
+      let j = i + 1
+      while (j < s.length && /\s/.test(s[j])) j++
+      if (s[j] === "}" || s[j] === "]") continue
+    }
+    out += ch
+  }
+  return out
 }
 
 // ---------------------------------------------------------------------------
@@ -279,9 +364,17 @@ function allIntegrationKeys(): Record<string, string> {
   return keyCache.keys
 }
 
+/** Path to the SQLite credential store, or null when no persistent DB is used. */
+export function databasePath(): string | null {
+  const override = process.env.OPENCODE_DB
+  const dataDir = opencodeRoots().data
+  if (override) return override === ":memory:" ? null : resolve(dataDir, override)
+  return join(dataDir, "opencode.db")
+}
+
 function readAllCredentials(): Record<string, string> {
-  const path = join(homedir(), ".local/share/opencode/opencode.db")
-  if (!existsSync(path)) return {}
+  const path = databasePath()
+  if (!path || !existsSync(path)) return {}
   const driver = loadSqlite()
   if (!driver) return {}
   let db: any
@@ -330,7 +423,7 @@ function extractKey(v: unknown): string | null {
 }
 
 /** Resolve a provider's key from the first source that has one. */
-export function keyForProvider(p: Provider): string | null {
+function keyForProvider(p: Provider): string | null {
   if (p.literalKey?.trim()) return p.literalKey.trim()
   if (p.integration) {
     const k = allIntegrationKeys()[p.integration]
@@ -349,6 +442,21 @@ export function keyForProvider(p: Provider): string | null {
 // Provider construction
 // ---------------------------------------------------------------------------
 
+/**
+ * Derive a conventional, settable env var name from a provider id:
+ * uppercase, runs of characters that are not `A-Z0-9` collapsed to `_`, and a
+ * leading `_` added when the result would otherwise start with a digit. So
+ * `router-ai` -> `ROUTER_AI_API_KEY` rather than `ROUTER-AI_API_KEY`.
+ */
+function defaultEnvVar(id: string): string {
+  const base = id
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+  const safe = base === "" ? "PROVIDER" : /^[0-9]/.test(base) ? `_${base}` : base
+  return `${safe}_API_KEY`
+}
+
 /** Convert a declarative spec into an executable provider. */
 function toProvider(spec: ProviderConfig): Provider {
   return {
@@ -356,7 +464,7 @@ function toProvider(spec: ProviderConfig): Provider {
     label: spec.label,
     url: spec.url,
     authScheme: spec.authScheme,
-    env: spec.env ?? `${spec.id.toUpperCase()}_API_KEY`,
+    env: spec.env ?? defaultEnvVar(spec.id),
     integration: spec.integration,
     configProvider: spec.configProvider,
     literalKey: spec.key,
@@ -394,7 +502,7 @@ export function buildProviders(options?: BalancesOptions): Provider[] {
 export async function fetchProvider(p: Provider): Promise<FetchResult> {
   const key = keyForProvider(p)
   // Hidden rather than stale when unconfigured.
-  if (!key) return { value: "", stale: false, skipped: true }
+  if (!key) return { value: "", stale: false, hidden: true }
 
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS)
@@ -404,11 +512,13 @@ export async function fetchProvider(p: Provider): Promise<FetchResult> {
       headers: { Authorization: `${scheme} ${key}` },
       signal: ctrl.signal,
     })
-    if (!res.ok) return { value: "", stale: true, skipped: false }
+    if (!res.ok) return { value: "", stale: true, hidden: false }
     const value = p.format(await res.json())
-    return value ? { value, stale: false, skipped: false } : { value: "", stale: true, skipped: false }
+    // A response that parses but yields no value hides the row; it is not a
+    // failed fetch, so it must not resurface as a stale balance.
+    return value ? { value, stale: false, hidden: false } : { value: "", stale: false, hidden: true }
   } catch {
-    return { value: "", stale: true, skipped: false }
+    return { value: "", stale: true, hidden: false }
   } finally {
     clearTimeout(timer)
   }
@@ -416,7 +526,7 @@ export async function fetchProvider(p: Provider): Promise<FetchResult> {
 
 /**
  * Merge fresh results into state. Successful values replace; a failed refresh
- * keeps the previous value marked stale; a skipped provider is removed.
+ * keeps the previous value marked stale; a hidden provider is removed.
  */
 export function collect(
   state: Map<ProviderKey, BalanceState>,
@@ -425,7 +535,7 @@ export function collect(
 ): void {
   providers.forEach((p, i) => {
     const fresh = results[i]
-    if (!fresh || fresh.skipped) {
+    if (!fresh || fresh.hidden) {
       state.delete(p.id)
       return
     }
@@ -439,12 +549,25 @@ export function collect(
   })
 }
 
-export function renderRows(state: Map<ProviderKey, BalanceState>, providers: Provider[]): string[] {
-  const rows: string[] = []
+/** One renderable balance line: a provider that currently has a value. */
+export interface BalanceRow {
+  id: ProviderKey
+  label: string
+  value: string
+  stale: boolean
+}
+
+/** Providers with a current value, in provider order. */
+export function balanceRows(state: Map<ProviderKey, BalanceState>, providers: Provider[]): BalanceRow[] {
+  const rows: BalanceRow[] = []
   for (const p of providers) {
     const s = state.get(p.id)
     if (!s?.value) continue
-    rows.push(`${s.stale ? "!" : "•"} ${p.label} ${s.value}`)
+    rows.push({ id: p.id, label: p.label, value: s.value, stale: s.stale })
   }
   return rows
 }
+
+export function renderRows(state: Map<ProviderKey, BalanceState>, providers: Provider[]): string[] {
+  return balanceRows(state, providers).map((r) => `${r.stale ? "!" : "•"} ${r.label} ${r.value}`)
+}

package/tui.tsx

@@ -1,24 +1,21 @@
 /** @jsxImportSource @opentui/solid */
 import { Plugin } from "@opencode/plugin/tui"
-import { createSignal } from "solid-js"
+import { createSignal, For } from "solid-js"
 import {
+  balanceRows,
   buildProviders,
   collect,
   DEFAULT_REFRESH_MINUTES,
   fetchProvider,
   loadOptionsFromConfig,
-  renderRows,
+  type BalanceRow,
   type BalanceState,
   type BalancesOptions,
   type Provider,
   type ProviderKey,
 } from "./providers"
 
-/**
- * Resolve options. OpenCode V2 beta passes plugin options to the server
- * entrypoint but not to the TUI entrypoint, so fall back to reading our own
- * options from opencode.jsonc when the context gives us nothing.
- */
+/** Resolve options, falling back to opencode.jsonc when the context gives none. */
 function resolveOptions(contextOptions: unknown): BalancesOptions {
   const fromContext = (contextOptions ?? {}) as BalancesOptions
   if (Array.isArray(fromContext.providers) && fromContext.providers.length > 0) return fromContext
@@ -34,37 +31,54 @@ function resolveOptions(contextOptions: unknown): BalancesOptions {
 
 export default Plugin.define({
   id: "providers-balances.tui",
-  async setup(context) {
+  setup(context) {
     const options = resolveOptions(context.options)
     const providers: Provider[] = buildProviders(options)
     const refreshMs = Math.max(1, options.refreshMinutes ?? DEFAULT_REFRESH_MINUTES) * 60_000
 
     const state = new Map<ProviderKey, BalanceState>()
-    const [rows, setRows] = createSignal("")
+    const [rows, setRows] = createSignal<BalanceRow[]>([])
+    const [loading, setLoading] = createSignal(providers.length > 0)
+    let stopped = false
 
     async function refresh() {
       const results = await Promise.all(providers.map((p) => fetchProvider(p)))
+      if (stopped) return
       collect(state, providers, results)
-      const list = renderRows(state, providers)
-      setRows(list.length ? `\n${list.join("\n")}` : "")
+      setRows(balanceRows(state, providers))
+      setLoading(false)
     }
 
-    // Fetch before registering so the first render already has values.
-    await refresh()
-
     const unregister = context.ui.slot({
       append: "sidebar.content",
-      render: () => (
-        <text>
-          <b>Balances</b>
-          {rows()}
-        </text>
-      ),
+      // Show a placeholder during the first fetch, then either the rows or
+      // nothing at all (never a bare heading).
+      render: () => {
+        const list = rows()
+        if (!list.length && !loading()) return null
+        return (
+          <text>
+            <b>Balances</b>
+            <For each={list}>
+              {(r) => (
+                <span style={{ fg: r.stale ? context.theme.text.feedback.warning.base : context.theme.text.base }}>
+                  {`\n${r.stale ? "!" : "•"} ${r.label} ${r.value}`}
+                </span>
+              )}
+            </For>
+            {loading() && !list.length ? "\n…" : ""}
+          </text>
+        )
+      },
     })
 
+    // Register first, then fetch in the background: a slow or unreachable
+    // endpoint must not delay setup or the first render.
+    void refresh()
     const timer = setInterval(() => void refresh(), refreshMs)
 
     return () => {
+      stopped = true
       clearInterval(timer)
       unregister()
     }