feat(quota): read OpenCode Go remaining from official /zen/go/v1/usage

Shipped 2026-08-11 in anomalyco/opencode#16513. percent is used
0-100 across rolling/weekly/monthly. No invented numbers.

Author: Adam-Dalloul

src-tauri/src/commands/subscription_quota.rs

@@ -17,7 +17,12 @@
 //! plan usage is the same DashboardService RPC the official CLI/IDE client
 //! already ships: `GetCurrentPeriodUsage` on `api2.cursor.sh`, authenticated
 //! with the cursor-agent login token (`%APPDATA%\Cursor\auth.json` or
-//! `CURSOR_API_KEY`). Gemini / OpenCode still have no remaining-quota command.
+//! `CURSOR_API_KEY`).
+//!
+//! OpenCode Go remaining is official
+//! `GET https://opencode.ai/zen/go/v1/usage` (anomalyco/opencode#16513,
+//! live 2026-08-11) with the Go API key from `auth.json`. Gemini still
+//! has no remaining-quota command. OpenCode `stats` is session history.
 
 use std::fs;
 use std::path::Path;
@@ -488,6 +493,7 @@ pub fn extra_homes_in(
         "codex" => "codex-",
         "grok" => "grok-",
         "cursor" => "cursor-",
+        "opencode" => "opencode-",
         _ => return Vec::new(),
     };
     let Some(root) = root else {
@@ -670,6 +676,144 @@ pub async fn subscription_quota_cursor() -> Result<OfficialQuotaRead, AppCommand
     Ok(read_cursor_subscription_quota_core().await)
 }
 
+pub fn opencode_go_key_from_auth_json(text: &str) -> Option<String> {
+    let value: Value = serde_json::from_str(text).ok()?;
+    let obj = value.as_object()?;
+    // `opencode-go` wins when present, but a plain `opencode` entry is the
+    // common single-account shape, so a missing provider skips to the next one
+    // instead of ending the search.
+    for provider in ["opencode-go", "opencode"] {
+        let Some(entry) = obj.get(provider).and_then(Value::as_object) else {
+            continue;
+        };
+        let Some(key) = entry.get("key").and_then(Value::as_str) else {
+            continue;
+        };
+        if !key.is_empty() {
+            return Some(key.to_string());
+        }
+    }
+    None
+}
+
+fn opencode_auth_path() -> Option<std::path::PathBuf> {
+    Some(crate::parsers::opencode::resolve_opencode_base_dir().join("auth.json"))
+}
+
+fn read_opencode_go_key(path: &Path) -> Option<String> {
+    let text = fs::read_to_string(path).ok()?;
+    opencode_go_key_from_auth_json(&text)
+}
+
+fn opencode_go_key_from_env_or_file() -> Option<String> {
+    for name in ["OPENCODE_GO_API_KEY", "OPENCODE_API_KEY"] {
+        if let Ok(key) = std::env::var(name) {
+            let trimmed = key.trim();
+            if !trimmed.is_empty() {
+                return Some(trimmed.to_string());
+            }
+        }
+    }
+    let path = opencode_auth_path()?;
+    read_opencode_go_key(&path)
+}
+
+fn opencode_payload_has_usage(payload: &Value) -> bool {
+    let usage = payload.get("usage").unwrap_or(payload);
+    ["rolling", "weekly", "monthly"].iter().any(|window| {
+        usage
+            .get(*window)
+            .and_then(|w| w.get("percent").or_else(|| w.get("usagePercent")))
+            .is_some()
+    })
+}
+
+async fn fetch_opencode_go_usage(token: &str) -> Result<Value, AppCommandError> {
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(10))
+        .build()
+        .map_err(|err| {
+            AppCommandError::new(AppErrorCode::NetworkError, "HTTP client")
+                .with_detail(err.to_string())
+        })?;
+    let response = client
+        .get("https://opencode.ai/zen/go/v1/usage")
+        .header("Authorization", format!("Bearer {token}"))
+        .header("Accept", "application/json")
+        .header("User-Agent", "codeg")
+        .send()
+        .await
+        .map_err(|err| {
+            AppCommandError::new(AppErrorCode::NetworkError, "OpenCode usage request failed")
+                .with_detail(err.to_string())
+        })?;
+    let status = response.status();
+    if !status.is_success() {
+        return Err(AppCommandError::new(
+            AppErrorCode::ExternalCommandFailed,
+            format!("OpenCode usage HTTP {status}"),
+        ));
+    }
+    response.json::<Value>().await.map_err(|err| {
+        AppCommandError::new(AppErrorCode::ExternalCommandFailed, "OpenCode usage JSON")
+            .with_detail(err.to_string())
+    })
+}
+
+pub async fn read_opencode_subscription_quota_core() -> OfficialQuotaRead {
+    let extra_slots = extra_opencode_slots().await;
+    let Some(token) = opencode_go_key_from_env_or_file() else {
+        return OfficialQuotaRead {
+            family: "opencode",
+            payload: None,
+            extra_slots,
+            unavailable_reason: Some("OpenCode Go is not signed in".into()),
+        };
+    };
+    match fetch_opencode_go_usage(&token).await {
+        Ok(payload) if opencode_payload_has_usage(&payload) => OfficialQuotaRead {
+            family: "opencode",
+            payload: Some(payload),
+            extra_slots,
+            unavailable_reason: None,
+        },
+        Ok(_) => OfficialQuotaRead {
+            family: "opencode",
+            payload: None,
+            extra_slots,
+            unavailable_reason: Some("OpenCode usage payload missing windows".into()),
+        },
+        Err(err) => OfficialQuotaRead {
+            family: "opencode",
+            payload: None,
+            extra_slots,
+            unavailable_reason: Some(err.message),
+        },
+    }
+}
+
+async fn extra_opencode_slots() -> Vec<OfficialQuotaSlot> {
+    let mut slots = Vec::new();
+    for (label, home) in extra_homes_for_family("opencode") {
+        let path = home.join("auth.json");
+        let Some(token) = read_opencode_go_key(&path) else {
+            continue;
+        };
+        if let Ok(payload) = fetch_opencode_go_usage(&token).await {
+            if opencode_payload_has_usage(&payload) {
+                slots.push(OfficialQuotaSlot { label, payload });
+            }
+        }
+    }
+    slots
+}
+
+#[cfg(feature = "tauri-runtime")]
+#[cfg_attr(feature = "tauri-runtime", tauri::command)]
+pub async fn subscription_quota_opencode() -> Result<OfficialQuotaRead, AppCommandError> {
+    Ok(read_opencode_subscription_quota_core().await)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -767,6 +911,7 @@ mod tests {
         fs::create_dir_all(root.join("claude-3")).unwrap();
         fs::create_dir_all(root.join("codex-2")).unwrap();
         fs::create_dir_all(root.join("cursor-2")).unwrap();
+        fs::create_dir_all(root.join("opencode-2")).unwrap();
         fs::write(root.join("claude-ignore"), "").unwrap();
         let claude = extra_homes_in(Some(root.clone()), "claude");
         let names: Vec<_> = claude.iter().map(|(n, _)| n.as_str()).collect();
@@ -777,6 +922,9 @@ mod tests {
         let cursor = extra_homes_in(Some(root.clone()), "cursor");
         assert_eq!(cursor.len(), 1);
         assert_eq!(cursor[0].0, "cursor-2");
+        let opencode = extra_homes_in(Some(root.clone()), "opencode");
+        assert_eq!(opencode.len(), 1);
+        assert_eq!(opencode[0].0, "opencode-2");
         assert!(extra_homes_in(Some(root.clone()), "grok").is_empty());
         let _ = fs::remove_dir_all(&root);
     }
@@ -798,4 +946,22 @@ mod tests {
         );
         assert!(cursor_access_token_from_auth_json("{}").is_none());
     }
+
+    #[test]
+    fn reads_opencode_go_key_without_logging_it() {
+        let text = r#"{
+            "opencode": { "type": "api", "key": "zen-key" },
+            "opencode-go": { "type": "api", "key": "go-key" }
+        }"#;
+        assert_eq!(
+            opencode_go_key_from_auth_json(text).as_deref(),
+            Some("go-key")
+        );
+        assert_eq!(
+            opencode_go_key_from_auth_json(r#"{"opencode":{"type":"api","key":"zen-only"}}"#)
+                .as_deref(),
+            Some("zen-only")
+        );
+        assert!(opencode_go_key_from_auth_json("{}").is_none());
+    }
 }

src-tauri/src/lib.rs

@@ -1360,6 +1360,7 @@ mod tauri_app {
                 subscription_quota_commands::subscription_quota_claude,
                 subscription_quota_commands::subscription_quota_grok,
                 subscription_quota_commands::subscription_quota_cursor,
+                subscription_quota_commands::subscription_quota_opencode,
                 work_task_commands::work_task_list,
                 work_task_commands::work_task_get,
                 work_task_commands::work_task_events,

src-tauri/src/web/handlers/subscription_quota.rs

@@ -4,7 +4,7 @@ use crate::app_error::AppCommandError;
 use crate::commands::subscription_quota::{
     read_claude_subscription_quota_core, read_codex_subscription_quota_core,
     read_cursor_subscription_quota_core, read_grok_subscription_quota_core,
-    OfficialQuotaRead,
+    read_opencode_subscription_quota_core, OfficialQuotaRead,
 };
 
 pub async fn subscription_quota_codex() -> Result<Json<OfficialQuotaRead>, AppCommandError> {
@@ -22,3 +22,7 @@ pub async fn subscription_quota_grok() -> Result<Json<OfficialQuotaRead>, AppCom
 pub async fn subscription_quota_cursor() -> Result<Json<OfficialQuotaRead>, AppCommandError> {
     Ok(Json(read_cursor_subscription_quota_core().await))
 }
+
+pub async fn subscription_quota_opencode() -> Result<Json<OfficialQuotaRead>, AppCommandError> {
+    Ok(Json(read_opencode_subscription_quota_core().await))
+}

src-tauri/src/web/router.rs

@@ -1289,6 +1289,10 @@ pub fn build_router(
             "/subscription_quota_cursor",
             post(handlers::subscription_quota::subscription_quota_cursor),
         )
+        .route(
+            "/subscription_quota_opencode",
+            post(handlers::subscription_quota::subscription_quota_opencode),
+        )
         // ─── Work tasks ───
         .route("/work_task_list", post(handlers::work_task::work_task_list))
         .route("/work_task_get", post(handlers::work_task::work_task_get))

src/components/conversations/session-quota-chip.tsx

@@ -14,6 +14,7 @@ import {
   subscriptionQuotaCodex,
   subscriptionQuotaCursor,
   subscriptionQuotaGrok,
+  subscriptionQuotaOpencode,
 } from "@/lib/api"
 import {
   familyFromAgentType,
@@ -45,7 +46,7 @@ const QUOTA_FETCHERS: Record<
   grok: subscriptionQuotaGrok,
   cursor: subscriptionQuotaCursor,
   gemini: null,
-  opencode: null,
+  opencode: subscriptionQuotaOpencode,
 }
 
 function SessionQuotaChipInner({ family }: { family: IsolatableFamily }) {

src/components/token-usage/subscription-quota-panel.tsx

@@ -8,6 +8,7 @@ import {
   subscriptionQuotaCodex,
   subscriptionQuotaCursor,
   subscriptionQuotaGrok,
+  subscriptionQuotaOpencode,
 } from "@/lib/api"
 import {
   inventory,
@@ -34,12 +35,13 @@ export function SubscriptionQuotaPanel() {
       subscriptionQuotaClaude(),
       subscriptionQuotaGrok(),
       subscriptionQuotaCursor(),
+      subscriptionQuotaOpencode(),
     ])
       .then((results) => {
         if (cancelled) return
         const next: Partial<Record<IsolatableFamily, unknown>> = {}
         const slots: Partial<Record<IsolatableFamily, OfficialQuotaSlot[]>> = {}
-        const [codex, claude, grok, cursor] = results
+        const [codex, claude, grok, cursor, opencode] = results
         if (codex.status === "fulfilled") {
           if (codex.value.payload) next.codex = codex.value.payload
           if (codex.value.extraSlots?.length)
@@ -59,6 +61,11 @@ export function SubscriptionQuotaPanel() {
           if (cursor.value.extraSlots?.length)
             slots.cursor = cursor.value.extraSlots
         }
+        if (opencode.status === "fulfilled") {
+          if (opencode.value.payload) next.opencode = opencode.value.payload
+          if (opencode.value.extraSlots?.length)
+            slots.opencode = opencode.value.extraSlots
+        }
         setOfficial(next)
         setExtraSlots(slots)
       })
@@ -93,7 +100,8 @@ export function SubscriptionQuotaPanel() {
               ) : (row.family === "codex" ||
                   row.family === "claude" ||
                   row.family === "grok" ||
-                  row.family === "cursor") &&
+                  row.family === "cursor" ||
+                  row.family === "opencode") &&
                 !loaded ? (
                 <span className="text-muted-foreground">
                   {t("quotaLoading")}

src/lib/api.ts

@@ -3033,6 +3033,11 @@ export async function subscriptionQuotaCursor(): Promise<OfficialQuotaRead> {
   return getTransport().call("subscription_quota_cursor")
 }
 
+/** Official OpenCode Go `GET /zen/go/v1/usage`. Missing key/plan is null. */
+export async function subscriptionQuotaOpencode(): Promise<OfficialQuotaRead> {
+  return getTransport().call("subscription_quota_opencode")
+}
+
 // Automations
 
 export async function automationList(): Promise<Automation[]> {

src/lib/subscription-quota.test.ts

@@ -213,6 +213,49 @@ describe("subscription quota inventory", () => {
     ])
   })
 
+  it("reads OpenCode Go remaining from official /zen/go/v1/usage", () => {
+    // Shape from anomalyco/opencode#16513 formatUsage().
+    const payload = {
+      usage: {
+        rolling: {
+          status: "ok",
+          percent: 42,
+          resetsAt: "2026-08-16T18:00:00.000Z",
+        },
+        weekly: {
+          status: "ok",
+          percent: 10,
+          resetsAt: "2026-08-20T00:00:00.000Z",
+        },
+        monthly: {
+          status: "ok",
+          percent: 8,
+          resetsAt: "2026-09-01T00:00:00.000Z",
+        },
+      },
+    }
+    const parsed = remainingFromOfficialPayload("opencode", payload)
+    expect(parsed?.remaining).toBe(58)
+    expect(parsed?.source).toBe("opencode /zen/go/v1/usage")
+    expect(parsed?.resetsAt).toBe(
+      Math.floor(Date.parse("2026-08-16T18:00:00.000Z") / 1000)
+    )
+    expect(parsed?.extras?.map((e) => e.label).sort()).toEqual([
+      "monthly",
+      "weekly",
+    ])
+    expect(familyQuota("opencode", payload).kind).toBe("remaining-subscription")
+  })
+
+  it("does not invent OpenCode remaining from session stats", () => {
+    expect(
+      remainingFromOfficialPayload("opencode", {
+        tokens: 1200,
+        cost: 1.2,
+      })
+    ).toBeNull()
+  })
+
   it("does not invent Cursor remaining from about/status identity", () => {
     expect(
       remainingFromOfficialPayload("cursor", {