@danielbdev/opencode-go-usage 0.1.3 → 0.1.4

package/README.md

@@ -34,7 +34,7 @@ Two entrypoints in one package:
 
 | Entrypoint | Role |
 | ---------- | ---- |
-| `src/index.ts` (`@opencode/plugin`) | Server plugin. Resolves the `opencode-go` credential, reads the usage endpoint with a 5-minute cache, and publishes the snapshot over RPC. |
+| `src/index.ts` (`@opencode/plugin`) | Server plugin. Resolves the `opencode-go` credential, reads the usage endpoint with a 5-minute cache, re-reads once a settled turn has moved usage, and publishes the snapshot over RPC. |
 | `src/tui.tsx` (`@opencode/plugin/tui`) | TUI plugin. Renders the sidebar section and the `/usage` command. |
 
 The credential never leaves the server process. The TUI plugin **cannot** read a credential — the
@@ -63,7 +63,9 @@ This endpoint is **live but undocumented**. Two consequences the code respects:
 - Because the endpoint can change without notice, every failure degrades to an explicit state
   (`Usage unavailable: ...`) instead of breaking the TUI.
 
-The plugin mirrors the endpoint exactly; its own 5-minute cache is the only staleness it can add.
+The plugin mirrors the endpoint exactly. The 5-minute cache bounds how stale a background reading can
+be; a settled turn re-reads sooner, throttled to at most one read per minute so rapid turns cannot hammer
+the endpoint.
 
 ## Security
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielbdev/opencode-go-usage",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "OpenCode V2 plugin that shows the OpenCode Go subscription usage in the session sidebar",
   "license": "MIT",

package/src/core/resync.test.ts

@@ -0,0 +1,42 @@
+import { test } from "node:test"
+import assert from "node:assert/strict"
+
+import { createResyncGate } from "./resync.ts"
+
+const MINUTE = 60_000
+
+test("the gate opens on the first call and then holds for the whole window", () => {
+  let clock = 1_000_000
+  const allow = createResyncGate(MINUTE, () => clock)
+
+  assert.equal(allow(), true)
+
+  clock += MINUTE - 1
+  assert.equal(allow(), false)
+})
+
+test("the gate reopens once the window has elapsed", () => {
+  let clock = 1_000_000
+  const allow = createResyncGate(MINUTE, () => clock)
+
+  assert.equal(allow(), true)
+
+  clock += MINUTE
+  assert.equal(allow(), true)
+
+  // ...and closes again immediately after opening
+  assert.equal(allow(), false)
+})
+
+test("a burst of settled turns opens the gate exactly once", () => {
+  let clock = 1_000_000
+  const allow = createResyncGate(MINUTE, () => clock)
+
+  const openedAt: number[] = []
+  for (let turn = 0; turn < 10; turn++) {
+    if (allow()) openedAt.push(turn)
+    clock += 100 // turns settling back to back
+  }
+
+  assert.deepEqual(openedAt, [0])
+})

package/src/core/resync.ts

@@ -0,0 +1,21 @@
+/**
+ * Gate for the settled-turn resync.
+ *
+ * A turn that settled is when usage actually moves, so it is the signal worth
+ * re-reading on. The endpoint is undocumented and reports only three windows, so
+ * the read is gated rather than free: `allow()` returns true at most once per
+ * `minMs` and false for every turn in between.
+ *
+ * It lives here, next to the model, so the gate is testable without a host. The
+ * clock is injectable for the same reason.
+ */
+export function createResyncGate(minMs: number, now: () => number = Date.now): () => boolean {
+  let lastAllowed = Number.NEGATIVE_INFINITY
+
+  return () => {
+    const at = now()
+    if (at - lastAllowed < minMs) return false
+    lastAllowed = at
+    return true
+  }
+}

package/src/core/usage.ts

@@ -26,7 +26,7 @@
  * (bump this line alongside the manifest) instead of adding a JSON import to
  * the server plugin's load path.
  */
-export const USER_AGENT = "opencode-go-usage/0.1.3"
+export const USER_AGENT = "opencode-go-usage/0.1.4"
 
 export const WINDOW_KEYS = ["rolling", "weekly", "monthly"] as const
 

package/src/index.ts

@@ -1,5 +1,6 @@
 import { Plugin } from "@opencode/plugin"
 
+import { createResyncGate } from "./core/resync.ts"
 import { errorSnapshot, parseUsage, USER_AGENT, type UsageSnapshot } from "./core/usage.ts"
 import { UsageRpc } from "./rpc.ts"
 
@@ -10,6 +11,9 @@ const USAGE_URL = "https://opencode.ai/inference/go/v1/usage"
 const REFRESH_MS = 5 * 60_000
 const REQUEST_TIMEOUT_MS = 10_000
 
+/** A settled turn moves usage; re-read on that signal, at most once per minute. */
+const RESYNC_MIN_MS = 60_000
+
 /**
  * Server plugin.
  *
@@ -104,7 +108,25 @@ export default Plugin.define({
       void refresh()
     }, REFRESH_MS)
 
+    // A settled turn is when usage actually moves, and the cache lives in this
+    // half, so the trigger belongs here: the refreshed snapshot goes out over
+    // `updated` and the TUI keeps working unchanged. The gate keeps quick
+    // successive turns from hammering an undocumented endpoint.
+    const controller = new AbortController()
+    const allowed = createResyncGate(RESYNC_MIN_MS)
+
+    void (async () => {
+      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+        if (event.type !== "session.execution.succeeded") continue
+        if (!allowed()) continue
+        void refresh()
+      }
+    })().catch(() => {
+      // A closed subscription is not a reason to fail the plugin.
+    })
+
     return () => {
+      controller.abort()
       clearInterval(timer)
     }
   },