opencode-ufr 0.2.9 → 0.2.10

package/src/shared/config.ts

@@ -1,4 +1,5 @@
 import { readText, writeFileAtomic } from "./fs"
+import { VPN_PASS, VPN_USER } from "./secrets"
 
 export type Config = {
   schema: 1
@@ -32,10 +33,10 @@ export const DEFAULTS: Config = {
   upstream: { baseUrl: "https://openwebui.uni-freiburg.de/api", requestTimeoutS: 600 },
   keys: [],
   limits: {
-    keyRpm: 18,
+    keyRpm: 19,
     keyWindowS: 60,
     keyMaxWaitS: 60,
-    poolPerHour: 800,
+    poolPerHour: 0, // 0 = pool limiter off. The old ~900/h model-group wall is gone (verified 2026-10-06); set a number to re-enable.
     poolWindowS: 3600,
     poolMaxWaitS: 20,
     maxUpstreamAttempts: 4,
@@ -48,6 +49,26 @@ export const DEFAULTS: Config = {
 
 export class ConfigError extends Error {}
 
+/**
+ * Keys previous versions accepted and silently ignored. A legacy config must
+ * not brick startup over them: they are dropped (with a warning) instead of
+ * rejected, so the next saveConfig writes them out of the file for good.
+ */
+const REMOVED: Record<string, string> = {
+  catalog: "obsolete — models.json ships with the package; remove this key",
+}
+
+function deleteKey(obj: Record<string, unknown>, path: string): void {
+  const parts = path.split(".")
+  const last = parts.pop()!
+  let o: unknown = obj
+  for (const k of parts) {
+    if (!isObj(o)) return
+    o = o[k]
+  }
+  if (isObj(o)) delete o[last]
+}
+
 type Rule = "int>=0" | "int>=1" | "num>=0" | "bool" | "str" | "port|null" | "aliases" | "int>=1[]" | "transport" | "vpnMode"
 
 const RULES: Record<string, Rule> = {
@@ -128,12 +149,19 @@ function valid(v: unknown, rule: Rule): boolean {
   }
 }
 
-export function mergeConfig(raw: unknown): Config {
+export function mergeConfig(raw: unknown, warn?: (msg: string) => void): Config {
   if (raw !== undefined && !isObj(raw)) throw new ConfigError("config: the top level must be a JSON object")
   if (isObj(raw) && raw.schema !== undefined && raw.schema !== 1) {
     throw new ConfigError(`config: unsupported schema ${JSON.stringify(raw.schema)} (this version reads schema 1)`)
   }
   const cfg = deepMerge(structuredClone(DEFAULTS), raw ?? {}) as Config
+  for (const [key, why] of Object.entries(REMOVED)) {
+    if (get(cfg, key) === undefined) continue
+    deleteKey(cfg as unknown as Record<string, unknown>, key)
+    warn?.(`config: dropping removed key "${key}" — ${why}`)
+  }
+  // Type validation first: a present-but-mistyped section (e.g. "limits": null)
+  // must be reported as a type error, not as an unknown key.
   for (const [path, rule] of Object.entries(RULES)) {
     const v = get(cfg, path)
     if (!valid(v, rule)) throw new ConfigError(`config: ${path} is invalid (${JSON.stringify(v)}), expected ${rule}`)
@@ -143,10 +171,31 @@ export function mergeConfig(raw: unknown): Config {
       throw new ConfigError(`config: ${path} is too large (${JSON.stringify(v)}), ${what} at most ${max}`)
     }
   }
+  const unknown = unknownKeys(cfg as unknown as Record<string, unknown>)
+  if (unknown.length > 0) {
+    throw new ConfigError(`config: unknown key ${unknown.map((k) => JSON.stringify(k)).join(", ")} (typo?)`)
+  }
   if (new Set(cfg.keys).size !== cfg.keys.length) throw new ConfigError("config: keys contains duplicate aliases")
+  if (cfg.keys.includes(VPN_USER) || cfg.keys.includes(VPN_PASS)) {
+    throw new ConfigError(
+      `config: keys must not use the reserved names "${VPN_USER}" and "${VPN_PASS}" — they hold the uni login in the same keyring`,
+    )
+  }
   return { ...cfg, schema: 1 }
 }
 
+/** Paths in the merged config that no rule covers — almost always a typo (e.g. "keyrpm" for "keyRpm"). */
+function unknownKeys(obj: Record<string, unknown>, prefix = ""): string[] {
+  const out: string[] = []
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k
+    if (path === "schema" || Object.hasOwn(RULES, path)) continue // schema is checked above
+    if (isObj(v) && Object.keys(RULES).some((p) => p.startsWith(`${path}.`))) out.push(...unknownKeys(v, path))
+    else out.push(path)
+  }
+  return out
+}
+
 export async function loadConfig(file: string): Promise<Config> {
   const text = await readText(file)
   if (text === null) return structuredClone(DEFAULTS)
@@ -156,7 +205,7 @@ export async function loadConfig(file: string): Promise<Config> {
   } catch (e) {
     throw new ConfigError(`config: ${file} is not valid JSON (${(e as Error).message})`)
   }
-  return mergeConfig(raw)
+  return mergeConfig(raw, (m) => console.warn(`[opencode-ufr] ${m}`))
 }
 
 export async function saveConfig(file: string, cfg: Config): Promise<void> {

package/src/shared/connect.ts

@@ -1,7 +1,6 @@
 /**
  * Shared connect logic: parsing key lists and applying credentials to the
- * keyring + config. Used by the CLI (`ufr connect`) and by the plugin's
- * /connect integration watcher.
+ * keyring + config. Used by the plugin's /connect integration watcher.
  */
 
 import { loadConfig, saveConfig } from "./config"
@@ -65,7 +64,7 @@ export async function applyConnect(
     return { aliases: [], removedAliases: [], loginStored: false, changed: false, errors }
   }
   if (input.login && !EMAIL_RE.test(input.login.trim())) {
-    errors.push(`"${input.login}" does not look like a uni login`)
+    errors.push(`"${input.login.trim()}" does not look like a uni login`)
     return { aliases: [], removedAliases: [], loginStored: false, changed: false, errors }
   }
 
@@ -83,7 +82,7 @@ export async function applyConnect(
     }
   }
   const aliases: { alias: string; key: string }[] = []
-  let changed = beforeKeys !== [...custom, ...wanted].join("\n") || removedAliases.length > 0
+  let changed = beforeKeys !== [...custom, ...wanted].join("\n")
   for (let i = 0; i < keys.length; i++) {
     const alias = wanted[i]!
     if ((await o.secrets.get(alias)) !== keys[i]!) changed = true

package/src/shared/daemon-client.ts

@@ -0,0 +1,29 @@
+import type { FetchLike } from "../daemon/catalog-source"
+import { readJson, readText } from "./fs"
+import type { Paths } from "./paths"
+
+/** What daemon.json holds (written by the daemon at startup). */
+export type DaemonInfo = { port: number; pid: number; version: string }
+
+/** Runtime-checked read of daemon.json — the one parser for that file (used by the plugin and the daemon itself). */
+export async function readDaemonInfo(paths: Paths): Promise<DaemonInfo | null> {
+  const j = (await readJson(paths.daemonFile)) as Record<string, unknown> | null
+  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 }
+}
+
+/** A request to the running daemon, or null if none answers. */
+export async function daemonRequest(paths: Paths, f: FetchLike, path: string, method = "GET"): Promise<Response | null> {
+  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(5_000),
+    })
+  } catch {
+    return null
+  }
+}

package/src/shared/errors.ts

@@ -2,5 +2,5 @@
 export function errorResponse(status: number, type: string, message: string, retryAfterMs?: number): Response {
   const headers: Record<string, string> = { "content-type": "application/json" }
   if (retryAfterMs !== undefined && retryAfterMs > 0) headers["retry-after"] = String(Math.max(1, Math.ceil(retryAfterMs / 1000)))
-  return new Response(JSON.stringify({ error: { message, type, code: status } }), { status, headers })
+  return new Response(JSON.stringify({ error: { message, type } }), { status, headers })
 }

package/src/shared/fs.ts

@@ -1,12 +1,17 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { dirname } from "node:path"
 
 /** Write via a temp file + rename, so readers never see half a file. */
 export async function writeFileAtomic(file: string, data: string, mode?: number): Promise<void> {
   await mkdir(dirname(file), { recursive: true })
   const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`
-  await writeFile(tmp, data, mode === undefined ? {} : { mode })
-  await rename(tmp, file)
+  try {
+    await writeFile(tmp, data, mode === undefined ? {} : { mode })
+    await rename(tmp, file)
+  } catch (e) {
+    await rm(tmp, { force: true }) // don't leak the temp file when the write or rename fails
+    throw e
+  }
 }
 
 /** File contents, or null if it does not exist. Other errors propagate. */

package/src/shared/keys.ts

@@ -0,0 +1,65 @@
+/**
+ * Key lifecycle used by the plugin's /connect watcher: applying a key change
+ * to a running gateway and wiping everything on provider removal.
+ */
+
+import type { FetchLike } from "../daemon/catalog-source"
+import { daemonRequest } from "./daemon-client"
+import { loadConfig, saveConfig } from "./config"
+import type { Paths } from "./paths"
+import { VPN_PASS, VPN_USER, type SecretStore } from "./secrets"
+
+/** A running gateway read its keys at start: stop it while idle so opencode starts it with the new set. */
+export async function applyKeyChange(d: { paths: Paths; fetch: FetchLike; log: (m: string) => void }): Promise<void> {
+  const res = await daemonRequest(d.paths, d.fetch, "/v1/_status")
+  if (!res?.ok) return // not running — it reads the keys when opencode next starts it
+  const j = (await res.json().catch(() => null)) as { inFlight?: unknown } | null
+  const inFlight = j !== null && typeof j.inFlight === "number" ? j.inFlight : null
+  if (inFlight === null) {
+    d.log("couldn't read gateway state — not stopping")
+    return
+  }
+  if (inFlight !== 0) {
+    d.log("the gateway is answering a request right now — it picks up the new keys on its next restart")
+    return
+  }
+  const stopped = await daemonRequest(d.paths, d.fetch, "/v1/_shutdown", "POST")
+  d.log(stopped?.ok ? "gateway stopped — it restarts with the new keys when opencode next needs it"
+    : "could not stop the gateway — it picks up the new keys on its next restart")
+}
+
+export type DisconnectResult = { removed: string[]; loginRemoved: boolean }
+
+/** Managed aliases key1…keyN are swept up to this n: a crash between secrets.set and saveConfig can orphan higher numbers than the current config lists. */
+const MANAGED_SWEEP = 32
+
+/**
+ * Provider-removal cleanup: delete every stored key alias and the uni login
+ * from the keyring, clear config.keys, and stop an idle gateway (it reads its
+ * keys at start, so a later start serves nothing). Idempotent.
+ */
+export async function disconnectAll(d: {
+  paths: Paths
+  secrets: SecretStore
+  fetch: FetchLike
+  log: (m: string) => void
+}): Promise<DisconnectResult> {
+  const cfg = await loadConfig(d.paths.configFile)
+  const removed: string[] = []
+  for (const alias of cfg.keys) {
+    if (await d.secrets.delete(alias)) removed.push(alias)
+  }
+  // Also sweep managed names the config may no longer list (a crash between
+  // secrets.set and saveConfig) — deletions of absent names report false.
+  for (let n = 1; n <= MANAGED_SWEEP; n++) {
+    const alias = `key${n}`
+    if (!cfg.keys.includes(alias) && (await d.secrets.delete(alias))) removed.push(alias)
+  }
+  const userRemoved = await d.secrets.delete(VPN_USER)
+  const passRemoved = await d.secrets.delete(VPN_PASS)
+  const loginRemoved = userRemoved || passRemoved
+  cfg.keys = []
+  await saveConfig(d.paths.configFile, cfg)
+  await applyKeyChange(d)
+  return { removed, loginRemoved }
+}

package/src/shared/models-file.ts

@@ -34,7 +34,7 @@ function fail(path: string, why: string): never {
 export function validateModelsFile(x: unknown): ModelsFile {
   if (!isObj(x)) fail("(root)", "must be an object")
   if (x.schema !== 1) fail("schema", `must be 1 (got ${JSON.stringify(x.schema)})`)
-  if (typeof x.updated !== "string") fail("updated", "must be a date string")
+  if (typeof x.updated !== "string" || Number.isNaN(Date.parse(x.updated))) fail("updated", "must be a date string")
   const d = x.defaults
   if (!isObj(d) || !posInt(d.context) || !posInt(d.max_output)) fail("defaults", "needs positive integers context and max_output")
   const fb = x.fallbacks

package/src/shared/secrets.ts

@@ -12,15 +12,11 @@ export const VPN_PASS = "vpn-pass"
 
 export class SecretStoreError extends Error {}
 
-type Backend = {
-  get(o: { service: string; name: string }): Promise<string | null>
-  set(o: { service: string; name: string; value: string }): Promise<void>
-  delete(o: { service: string; name: string }): Promise<boolean>
-}
+type Backend = Pick<typeof Bun.secrets, "get" | "set" | "delete">
 
 /** UFR keys in the OS keyring: macOS Keychain, Windows Credential Manager, libsecret on Linux. */
 export class KeyringStore implements SecretStore {
-  constructor(private readonly backend: Backend = Bun.secrets as unknown as Backend) {}
+  constructor(private readonly backend: Backend = Bun.secrets) {}
 
   private async run<T>(what: string, fn: () => Promise<T>): Promise<T> {
     try {

package/bin/ufr.ts

@@ -1,4 +0,0 @@
-#!/usr/bin/env bun
-import { main } from "../src/cli/index"
-
-process.exit(await main(process.argv.slice(2)))

package/src/cli/catalog.ts

@@ -1,44 +0,0 @@
-import type { UfrModel } from "../daemon/catalog"
-import { BUNDLED_MODELS, loadBundledModels, loadUfrModels } from "../daemon/catalog-source"
-import { loadConfig } from "../shared/config"
-import type { ModelsFile } from "../shared/models-file"
-import type { CliDeps } from "./index"
-
-export function diffCatalog(ufr: UfrModel[], file: ModelsFile) {
-  const served = new Set(ufr.map((u) => u.id))
-  const aliasSpellings = new Set(Object.keys(file.aliases))
-  const canonical = ufr.filter((u) => !aliasSpellings.has(u.id))
-  return {
-    added: canonical.filter((u) => !file.models[u.id]).map((u) => u.id),
-    gone: Object.keys(file.models).filter((id) => !served.has(id)),
-    vision: canonical
-      .filter((u) => file.models[u.id]?.vision !== undefined && file.models[u.id]!.vision !== u.vision)
-      .map((u) => ({ id: u.id, ufr: u.vision, ours: file.models[u.id]!.vision! })),
-    unpriced: canonical.filter((u) => !file.models[u.id]?.price).map((u) => u.id),
-  }
-}
-
-export async function cmdCatalogDiff(d: CliDeps): Promise<number> {
-  const cfg = await loadConfig(d.paths.configFile)
-  const alias = cfg.keys[0]
-  const key = alias ? await d.secrets.get(alias) : null
-  if (!key) {
-    d.io.err("catalog diff needs a key — run `ufr keys add <alias>`\n")
-    return 1
-  }
-  const log = (m: string) => d.io.err(`${m}\n`)
-  const mf = await loadBundledModels({ bundledPath: BUNDLED_MODELS })
-  const ufr = await loadUfrModels({ baseUrl: cfg.upstream.baseUrl, key, cachePath: d.paths.ufrModelsCache, fetch: d.fetch, log })
-  if (ufr.source !== "remote") {
-    d.io.err(`cannot read UFR's live model list: ${ufr.error}\n`)
-    return 1
-  }
-  const diff = diffCatalog(ufr.models, mf.file)
-  d.io.out(`models.json from ${mf.source}, ${ufr.models.length} models at UFR\n`)
-  for (const id of diff.added) d.io.out(`+ ${id}  (new at UFR, no models.json entry)\n`)
-  for (const id of diff.gone) d.io.out(`- ${id}  (in models.json, no longer at UFR)\n`)
-  for (const v of diff.vision) d.io.out(`~ ${v.id}  vision: UFR says ${v.ufr}, models.json says ${v.ours}\n`)
-  for (const id of diff.unpriced) d.io.out(`$ ${id}  (no price — cost unknown)\n`)
-  if (!diff.added.length && !diff.gone.length) d.io.out("no models added or removed\n")
-  return diff.added.length || diff.gone.length ? 1 : 0
-}

package/src/cli/connect.ts

@@ -1,146 +0,0 @@
-import { parseArgs } from "node:util"
-import { ALIAS_RE, loadConfig, saveConfig } from "../shared/config"
-import { VPN_PASS, VPN_USER } from "../shared/secrets"
-import { checkKey, type Check } from "./ufr-check"
-import { applyKeyChange } from "./keys"
-import type { CliDeps } from "./index"
-
-const LABEL: Record<Check | "missing", string> = {
-  ok: "ok",
-  invalid: "INVALID (UFR says 401)",
-  vpn: "not verified — not on the uni VPN",
-  unreachable: "not verified — UFR unreachable",
-  rate_limited: "ok (currently rate-limited)",
-  missing: "MISSING in keyring",
-}
-
-const PLUGIN_SPEC = "github:FinleyLaempe/opencode-ufr"
-
-/** Splits a key list on commas AND newlines, trims whitespace, drops empties. */
-export function splitKeys(spec: string): string[] {
-  return spec
-    .split(/[,\n\r]+/)
-    .map((k) => k.trim())
-    .filter((k) => k.length > 0)
-}
-
-/** Auto-aliases key1…keyN, skipping numbers already in use. */
-export function nextAliases(existing: string[], count: number): string[] {
-  const used = new Set(existing)
-  const out: string[] = []
-  for (let n = 1; out.length < count; n++) {
-    const alias = `key${n}`
-    if (!used.has(alias)) {
-      used.add(alias)
-      out.push(alias)
-    }
-  }
-  return out
-}
-
-async function storeKey(d: CliDeps, alias: string, key: string): Promise<{ stored: boolean; check: Check }> {
-  const cfg = await loadConfig(d.paths.configFile)
-  const check = await checkKey(d.fetch, cfg.upstream.baseUrl, key)
-  if (check === "invalid") return { stored: false, check }
-  if (check !== "ok" && check !== "rate_limited") {
-    const why = check === "vpn" ? "not on the uni VPN" : "UFR unreachable"
-    if (!(await d.io.confirm(`could not verify this key (${why}). Store it anyway?`))) return { stored: false, check }
-  }
-  await d.secrets.set(alias, key)
-  if (!cfg.keys.includes(alias)) {
-    cfg.keys.push(alias)
-    await saveConfig(d.paths.configFile, cfg)
-  }
-  return { stored: true, check }
-}
-
-async function stopIdleGateway(d: CliDeps): Promise<void> {
-  await applyKeyChange({ paths: d.paths, fetch: d.fetch, log: (m) => d.io.out(m + "\n") })
-}
-
-/**
- * ufr connect — one command for everything: uni login (optional) + API keys.
- * Interactive when arguments are missing; fully non-interactive with flags
- * (what the /connect slash command uses).
- */
-export async function cmdConnect(d: CliDeps, args: string[]): Promise<number> {
-  const { values } = parseArgs({
-    args,
-    options: {
-      login: { type: "string" },
-      password: { type: "string" },
-      keys: { type: "string" },
-    },
-    allowPositionals: true,
-  })
-
-  const io = d.io
-  const cfg = await loadConfig(d.paths.configFile)
-
-  // keys -------------------------------------------------------------------
-  let keySpec = values.keys
-  if (keySpec === undefined && d.io.isTTY) {
-    keySpec = await io.prompt("UFR API keys (comma-separated or one per line; Open WebUI → Settings → Account → API keys): ")
-  }
-  const keys = splitKeys(keySpec ?? "")
-  if (keys.length === 0) {
-    io.err("no keys given — usage: ufr connect [--login <user> --password <pass>] --keys \"<key1>,<key2>\"\n")
-    return 2
-  }
-  const aliases = nextAliases(cfg.keys, keys.length)
-
-  // --- login (optional) ------------------------------------------------------
-  let user = values.login
-  let pass = values.password
-  if (user === undefined && d.io.isTTY) {
-    user = (await io.prompt("Uni login for the built-in VPN, e.g. xx0000@uni-freiburg.de (empty to skip): ")).trim()
-  }
-  if (user) {
-    if (!/^[^\s@]+@[^\s@]+$/.test(user)) {
-      io.err(`"${user}" does not look like a uni login (expected e.g. xx0000@uni-freiburg.de)\n`)
-      return 2
-    }
-    if (pass === undefined) {
-      if (d.io.isTTY) pass = await io.prompt(`Uni password for ${user}: `, { secret: true })
-      else {
-        io.err("--password is required when --login is given non-interactively\n")
-        return 2
-      }
-    }
-    if (!pass) {
-      io.err("no password entered\n")
-      return 2
-    }
-  }
-
-  // --- store everything -------------------------------------------------------
-  let bad = 0
-  for (let i = 0; i < keys.length; i++) {
-    const alias = aliases[i]!
-    const r = await storeKey(d, alias, keys[i]!)
-    if (r.stored) io.out(`${alias}\t${LABEL[r.check]}\n`)
-    else {
-      bad++
-      io.err(`${alias}\t${LABEL[r.check]} — not stored\n`)
-    }
-  }
-  if (bad === keys.length) return 1
-
-  if (user && pass) {
-    await d.secrets.set(VPN_USER, user)
-    await d.secrets.set(VPN_PASS, pass)
-    io.out(`login\tstored for ${user} (used by the built-in VPN)\n`)
-  }
-
-  await stopIdleGateway(d)
-  if (d.io.isTTY) {
-    if (await io.confirm(`register the plugin with opencode now (\`opencode plugin add ${PLUGIN_SPEC}\`)?`)) {
-      const code = await d.runOpencode(["plugin", "add", PLUGIN_SPEC])
-      if (code !== 0) io.err(`opencode plugin add exited with ${code} — add "${PLUGIN_SPEC}" to "plugins" in opencode.json yourself\n`)
-    }
-  } else {
-    io.out(`register the provider in opencode if not done yet: opencode plugin add ${PLUGIN_SPEC}\n`)
-  }
-  io.out(`done — ${keys.length - bad}/${keys.length} key(s) stored${user ? ", uni login stored" : ""}\n`)
-  return bad > 0 ? 1 : 0
-}

package/src/cli/context-probe.ts

@@ -1,96 +0,0 @@
-import { BUNDLED_MODELS, loadBundledModels } from "../daemon/catalog-source"
-import { applyProbeResults, formatProbeReport, probeAllContexts } from "../daemon/probe-all"
-import { VpnManager } from "../daemon/vpn/manager"
-import { loadConfig } from "../shared/config"
-import { VPN_PASS, VPN_USER } from "../shared/secrets"
-import type { CliDeps } from "./index"
-
-/**
- * ufr context-probe — measure every UFR model's context limit with one of the
- * stored keys. Rejected probes are free and don't consume the key's bucket;
- * the report flags values that drifted from models.json. `--write` patches
- * the local models.json copy (the repo copy when run from a checkout).
- *
- * `--vpn` routes the probes through the built-in Fortinet tunnel with the
- * stored uni login (vpn-login/vpn-pass) — for off campus machines without
- * their own VPN connection.
- */
-export async function cmdContextProbe(d: CliDeps, args: string[]): Promise<number> {
-  const write = args.includes("--write")
-  const viaVpn = args.includes("--vpn")
-  const cfg = await loadConfig(d.paths.configFile)
-  const alias = cfg.keys[0]
-  if (!alias) {
-    d.io.err("no stored key — run `ufr connect` first\n")
-    return 2
-  }
-  const key = await d.secrets.get(alias)
-  if (!key) {
-    d.io.err(`key "${alias}" is configured but missing from the keyring\n`)
-    return 2
-  }
-  let fetch = d.fetch
-  let vpn: { stop(): Promise<void> } | null = null
-  if (viaVpn) {
-    const [user, pass] = await Promise.all([d.secrets.get(VPN_USER), d.secrets.get(VPN_PASS)])
-    if (!user || !pass) {
-      d.io.err("no stored uni login — run `ufr login` or `ufr connect --login …` first\n")
-      return 2
-    }
-    const manager = new VpnManager({
-      gateway: cfg.vpn.gateway,
-      upstreamHost: new URL(cfg.upstream.baseUrl).hostname,
-      baseUrl: cfg.upstream.baseUrl,
-      credentials: { user, pass },
-      mode: "always",
-      log: (m) => d.io.out(`${m}\n`),
-      fetch: d.fetch,
-    })
-    vpn = manager
-    fetch = manager.transport().fetch
-  }
-  const { file } = await loadBundledModels({})
-  d.io.out(`probing ${cfg.keys.length} key(s) via "${alias}"${viaVpn ? " through the built-in VPN" : ""} — rejected probes are free, this takes a few minutes\n`)
-  try {
-    const rows = await probeAllContexts({
-      baseUrl: cfg.upstream.baseUrl,
-      key,
-      fetch,
-      file,
-      log: (m) => d.io.out(`${m}\n`),
-    })
-    d.io.out("\n" + formatProbeReport(rows) + "\n")
-    return await report(d, file, rows, write)
-  } finally {
-    if (vpn) await vpn.stop()
-  }
-}
-
-async function report(
-  d: CliDeps,
-  file: Awaited<ReturnType<typeof loadBundledModels>>["file"],
-  rows: Awaited<ReturnType<typeof probeAllContexts>>,
-  write: boolean,
-): Promise<number> {
-  if (write) {
-    const date = new Date().toISOString().slice(0, 10)
-    const { file: updated, changed } = applyProbeResults(file, rows, date)
-    if (changed.length === 0) {
-      d.io.out("\nmodels.json is already current — nothing written\n")
-    } else {
-      await Bun.write(BUNDLED_MODELS, JSON.stringify(updated, null, 2) + "\n")
-      d.io.out(`\n${BUNDLED_MODELS} updated (${changed.length}):\n`)
-      for (const c of changed) d.io.out(`  ${c.id}: ${c.from ?? "—"} -> ${c.to}\n`)
-      d.io.out("\nIf this is a repo checkout: commit models.json (PR welcome per README).\n")
-      d.io.out("On an installed copy this patches your local file until the next plugin/CLI update;\n")
-      d.io.out("upstream fixes reach everyone through models.json PRs and releases.\n")
-    }
-  } else {
-    const needsUpdate = rows.filter((r) => r.how === "error-named" && r.probed !== null && r.probed !== r.known)
-    if (needsUpdate.length > 0) {
-      d.io.out("\nrun `ufr context-probe --write` to patch your local models.json, or PR the values upstream\n")
-      return 1
-    }
-  }
-  return 0
-}

package/src/cli/daemon-client.ts

@@ -1,19 +0,0 @@
-import type { FetchLike } from "../daemon/catalog-source"
-import { readJson, readText } from "../shared/fs"
-import type { Paths } from "../shared/paths"
-
-/** A request to the running daemon, or null if none answers. */
-export async function daemonRequest(paths: Paths, f: FetchLike, path: string, method = "GET"): Promise<Response | null> {
-  const info = (await readJson(paths.daemonFile)) as { port?: number } | null
-  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(5_000),
-    })
-  } catch {
-    return null
-  }
-}