opencode-ufr 0.2.5 → 0.2.6

package/README.md

@@ -25,20 +25,21 @@ opencode plugin add opencode-ufr     # registers the plugin
 
 ## Updating
 
-opencode loads plugins inside a background server (`opencode serve --service`)
-that keeps running after you close the TUI, and it keeps using the plugin
-version it loaded when it started — a new release only arrives once that server
-restarts:
+opencode installs the plugin once into its cache and does not look for a newer
+version while that copy exists — restarting opencode alone keeps the old one.
+It also loads plugins inside a background server (`opencode serve --service`)
+that keeps running after you close the TUI. To update, remove the cached copy
+and stop that server:
 
 ```bash
-bun add -g opencode-ufr@latest          # update the `ufr` CLI
-pkill -f "opencode serve --service"     # stop opencode's background server
+bun add -g opencode-ufr@latest                      # update the `ufr` CLI
+rm -rf ~/.cache/opencode/npm/opencode-ufr@latest    # opencode's cached plugin copy
+pkill -f "opencode serve --service"                 # opencode's background server
 ```
 
-The next opencode start installs the latest plugin. If it still loads the old
-one, delete opencode's cached copy (`~/.cache/opencode/npm/opencode-ufr@latest`)
-and start opencode again. On Windows, end the `opencode` server process in Task
-Manager instead of `pkill`.
+The next opencode start installs the latest version and replaces the old
+gateway once it is idle. On Windows, end the `opencode` server process in Task
+Manager and delete the `opencode-ufr@latest` folder in opencode's cache.
 
 ## Setup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "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",

package/src/daemon/vpn/fortinet.ts

@@ -126,10 +126,15 @@ export async function authenticate(o: {
   fetch?: typeof fetch
   on2fa?: (challenge: { kind: string; message: string }) => Promise<string> // returns the OTP ("" = FTM push)
   log?: (msg: string) => void
+  /** Deadline for the whole login. Without one a gateway that stops answering stalls it forever. */
+  signal?: AbortSignal
 }): Promise<AuthOutcome> {
   const f = o.fetch ?? fetch
   const log = o.log ?? (() => {})
   const base = o.gateway.replace(/\/$/, "")
+  // Fresh connections only: a pooled socket opened before the user's own VPN changed
+  // the route is dead, and a request on it is never answered.
+  const net = { keepalive: false, signal: o.signal }
 
   // 1. GET / — follow redirects manually (fetch drops intermediate Set-Cookies),
   //    keep the cookie jar: FortiOS binds the logincheck to the login-page session.
@@ -137,7 +142,7 @@ export async function authenticate(o: {
   let jar = ""
   let url = `${base}/`
   for (let hops = 0; hops < 5; hops++) {
-    const res = await f(url, { headers: { "User-Agent": FORTI_UA, ...(jar ? { Cookie: jar } : {}) }, redirect: "manual" })
+    const res = await f(url, { headers: { "User-Agent": FORTI_UA, ...(jar ? { Cookie: jar } : {}) }, redirect: "manual", ...net })
     jar = cookiesFrom(res, jar)
     const body = await res.text().catch(() => "")
     if (res.status >= 300 && res.status < 400) {
@@ -170,6 +175,7 @@ export async function authenticate(o: {
       },
       body: formEncode(body),
       redirect: "manual",
+      ...net,
     })
 
   let res = await post({ username: o.user, credential: o.pass, realm, ajax: "1", just_logged_in: "1" })
@@ -449,6 +455,8 @@ export async function openTunnel(o: {
       await fetch(`${o.gateway.replace(/\/$/, "")}/remote/logout`, {
         headers: { "User-Agent": FORTI_UA, Cookie: o.cookie },
         redirect: "manual",
+        keepalive: false,
+        signal: AbortSignal.timeout(5_000), // a reconnect and the daemon's shutdown wait for this
       })
     } catch { /* best effort */ }
   }

package/src/daemon/vpn/manager.ts

@@ -29,6 +29,7 @@ export type VpnState = {
 
 const DIRECT_CHECK_CACHE_MS = 60_000
 const ESTABLISH_TIMEOUT_MS = 30_000
+const LOGIN_TIMEOUT_MS = 15_000
 const RECONNECT_BASE_MS = 5_000
 const RECONNECT_MAX_MS = 10 * 60_000
 
@@ -58,6 +59,8 @@ export class VpnManager {
       log: (msg: string) => void
       /** Outgoing direct-leg fetch (injectable for tests). */
       fetch?: FetchFn
+      /** Deadline for the gateway login (default 15 s). */
+      loginTimeoutMs?: number
     },
     private readonly now: () => number = Date.now,
   ) {
@@ -74,7 +77,7 @@ export class VpnManager {
     return {
       name: "vpn",
       fetch: async (url, init) => {
-        const path = await this.ensurePath()
+        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)
         }
@@ -133,6 +136,7 @@ export class VpnManager {
         headers: { "User-Agent": "opencode-ufr" },
         signal: AbortSignal.timeout(6_000),
         redirect: "manual",
+        keepalive: false, // measure the current route, not a socket pooled before it changed
       })
       const type = res.headers.get("content-type") ?? ""
       this.directCheckedAt = this.now()
@@ -157,11 +161,16 @@ export class VpnManager {
   private async open(): Promise<void> {
     const creds = this.o.credentials!
     this.setState("connecting", "logging in to the uni VPN")
+    const loginMs = this.o.loginTimeoutMs ?? LOGIN_TIMEOUT_MS
+    const signal = AbortSignal.timeout(loginMs)
     const { cookie } = await authenticate({
       gateway: this.o.gateway,
       user: creds.user,
       pass: creds.pass,
       log: this.o.log,
+      signal,
+    }).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)
 
@@ -251,6 +260,17 @@ export class VpnManager {
   }
 }
 
+/** Waits for a shared attempt, but lets one caller give up on it (the attempt keeps running for the others). */
+function untilAborted<T>(p: Promise<T>, signal?: AbortSignal | null): Promise<T> {
+  if (!signal) return p
+  if (signal.aborted) return Promise.reject(signal.reason)
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(signal.reason)
+    signal.addEventListener("abort", onAbort, { once: true })
+    p.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort))
+  })
+}
+
 async function resolveIp(host: string): Promise<Ipv4> {
   const { lookup } = await import("node:dns/promises")
   const res = await lookup(host, { family: 4 })

package/src/daemon/vpn/ppp.ts

@@ -388,9 +388,10 @@ export class PppSession {
     this.nextId = (this.nextId + 1) & 0xff || 1
   }
 
-  /** Send an IPv4 datagram into the tunnel (protocol 0x0021). */
+  /** Send an IPv4 datagram into the tunnel (protocol 0x0021). A dead link drops it, like a
+   *  downed interface: teardown sends RSTs from timers and socket handlers, where a throw kills the daemon. */
   sendIp(datagram: Uint8Array): void {
-    if (this.dead) throw new Error("ppp link is dead")
+    if (this.dead) return
     this.ev.sendPpp(pppFrame(PPP_IP, datagram))
   }