@jeffreyjyz/opencode-command-code 0.5.18 → 0.5.20

package/README.md

@@ -0,0 +1,84 @@
+# @jeffreyjyz/opencode-command-code
+
+Command Code providers, a live gated model list and a usage sidebar for opencode, with all usage rendering delegated to the `cmduse` CLI.
+
+[![npm](https://img.shields.io/npm/v/@jeffreyjyz/opencode-command-code?style=flat-square)](https://www.npmjs.com/package/@jeffreyjyz/opencode-command-code) [![CI](https://img.shields.io/github/actions/workflow/status/JeffreyJYZ/cmdcode-tools/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/JeffreyJYZ/cmdcode-tools/actions/workflows/ci.yml) [![license](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)
+
+## What it is
+
+One package, both opencode plugin APIs: v1 hosts call the default export's `server()` hook map, v2 hosts decode `{ id, setup }` and call `setup(context)`. The two halves are independent implementations sharing one CLI layer, and neither reimplements usage math — every window figure comes from the `cmduse` binaries.
+
+It registers two provider lanes against `api.commandcode.ai`:
+
+- `command-code-anthropic` — Claude models on the Anthropic wire.
+- `command-code-openai` — everything else on the OpenAI-compatible wire, where the reasoning text is round-tripped through `reasoning_content` so a compaction or model switch doesn't get rejected.
+
+The model list is fetched live from Command Code's listing API, split by wire, and gated to your plan (`core/gating.json` in the repo is the source of truth). The picker never waits on the network: a static seed from the known-model table, then the last live list cached on disk, paint instantly and the live fetch merges over them — union by model id, so a gated or partial response can never make a model vanish. On v2 hosts the fetch then repeats on an interval, and a tick only touches the provider registry when the model ids actually changed.
+
+Each model is registered with Command Code's published $/1M rates, so opencode's own cost display works for a subscription provider instead of showing $0. Vision support and reasoning-effort variants come from a generated catalog, because the listing API publishes no capabilities.
+
+Credentials resolve in one order everywhere: `CMD_API_KEY`, then the key `/connect` stored in opencode's credential store, then `~/.commandcode/auth.json` from `cmd login`.
+
+## Install
+
+Add the plugin to `opencode.json` (v2 hosts use `plugins`; v1's singular `plugin` is auto-normalized):
+
+```json
+{
+  "plugins": ["@jeffreyjyz/opencode-command-code"]
+}
+```
+
+Usage rendering needs the `cmduse` CLI on `PATH` — it owns the plan table, the window math and the formatting:
+
+```sh
+brew install JeffreyJYZ/tap/cmduse
+```
+
+The sidebar's per-model catalog (tier, rates, allowance, deals) comes from `mpc`, which is optional: without it the section keeps the model name and the store-backed rows and simply omits the catalog rows.
+
+```sh
+bun add -g @jeffreyjyz/mpc
+```
+
+## Usage
+
+Run `/connect`, choose **Command Code** and paste an API key (create one at commandcode.ai/settings/keys), or use the `CMD_API_KEY` env method, or log in once with `cmd login`. With no credential at all the providers register as `auto`, so a later `/connect` lights them up without a restart.
+
+One caveat on the v1 half: its `/connect` entry is bound to the Anthropic lane (opencode's plugin API allows one auth hook per provider id), so the OpenAI lane shares the key through the resolved `options.apiKey` — a `/connect`-only v1 setup needs `cmd login` or `CMD_API_KEY` for that lane.
+
+While a session uses a Command Code, OpenCode Go/Zen or Volcengine ARK model, the sidebar grows one section for that family — plain text unless you ask for colour. Write `~/.config/opencode/command-code.json`:
+
+```json
+{ "colors": true, "ocPlan": "go-plus" }
+```
+
+`CMD_COLORS=1` (or `0`) and `CMD_OC_PLAN=go|go-plus` override it for a single run. `ocPlan` only matters on the Go side: the two Go plans share token prices but grant different per-model limits and nothing local records which one you have. The file is re-read every few seconds, so a flip lands on the next poll.
+
+What the section shows:
+
+- plan, price, monthly credits used, and the 5-hour / weekly windows with used / cap, percent used, elapsed share, reset countdown and a `cap in …` pace estimate; an over-cap window is flagged `LIMIT EXCEEDED`
+- this period's requests and spend, the active model's tier, allowance and $/M rates, its `Usage (this model)` share, any running `Deal`, and this session's own totals
+- on OpenCode Go/Zen and ARK sessions, the same shape from `ocuse` and `arkuse` instead — account meters where the provider publishes them, per-model spend from opencode's own store
+
+Usage comes from `cmduse` polled every 5 seconds, read from opencode's message store for the per-model and per-session rows, and cached from `mpc` for the catalog. Every block remembers its last reading, so a remount, a session switch or a network outage repaints instead of blanking; the model figure is keyed by model and session, so switching models never shows the previous model's numbers.
+
+## Commands
+
+Each command passes its arguments through to the CLI that owns it, and each has an agent-facing tool of the same name, so the model can fetch the same text without you typing a slash command.
+
+| Command | Tool | Spawns |
+|---|---|---|
+| `/cmd-usage` | `cmd_usage` | `cmduse` — plan, credits, windows, billing period; `plans` for the plan table |
+| `/ocuse-usage` | `ocuse_usage` | `ocuse` — OpenCode Go/Zen meters and per-model spend; empty args mean `-1` |
+| `/arkuse-usage` | `arkuse_usage` | `arkuse` — Volcengine ARK Agent Plan meters in AFP; empty args mean `-1` |
+| — | `mpc_prices` | `mpc` — per-model price comparison across Command Code and OpenCode Go plans |
+
+A bare `ocuse` or `arkuse` is a live watch loop that would never return to the dialog, so an empty argument means the one-shot dashboard.
+
+## Links
+
+- [Source (GitHub)](https://github.com/JeffreyJYZ/cmdcode-tools/tree/main/opencode-plugin)
+- [npm](https://www.npmjs.com/package/@jeffreyjyz/opencode-command-code)
+- [`cmduse` CLI](https://github.com/JeffreyJYZ/cmdcode-tools/tree/main/cmduse) — the usage renderer this plugin spawns
+- [MIT license](LICENSE)

package/dist/index.js

@@ -2414,7 +2414,7 @@ function superRefine(fn) {
 // package.json
 var package_default = {
   name: "@jeffreyjyz/opencode-command-code",
-  version: "0.5.18",
+  version: "0.5.20",
   description: "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
   type: "module",
   main: "dist/index.js",

package/dist/sidebar/ark.d.ts

@@ -22,6 +22,15 @@ export interface ArkModel {
     weekly: ArkTotals;
     month: ArkTotals;
 }
+/** This store's own view of one window (`arkuse`'s `windows` block): AFP against
+ *  the plan's published quota, the percentage that yields, and the boundary the
+ *  row counts down to. Present even when no meter answered, which is what keeps
+ *  a panel row from degrading to AFP alone. */
+export interface ArkWindow {
+    quota?: number;
+    percent?: number;
+    resetAt?: number;
+}
 export interface ArkUsage {
     plan: string;
     profile?: string;
@@ -34,6 +43,11 @@ export interface ArkUsage {
     weekly: ArkTotals;
     month: ArkTotals;
     daily?: ArkTotals;
+    windows?: {
+        fiveHour?: ArkWindow;
+        weekly?: ArkWindow;
+        monthly?: ArkWindow;
+    };
     account?: {
         fiveHour: ArkMeter;
         daily?: ArkMeter;

package/dist/sidebar/rows.d.ts

@@ -30,6 +30,17 @@ export declare function pctTone(pct: number): Tone;
 export declare function separator(): SidebarRow;
 /** Truncate to `width`, ellipsis included. */
 export declare function clip(text: string, width?: number): string;
+/**
+ * Whether a usage-API reason is worth a row in the panel.
+ *
+ * Only a reason that names something the user can fix is: a missing or expired
+ * key, a missing CLI/profile, a rejected request. Everything else — a dropped
+ * connection, a DNS blip, a timeout — is transport, heals on the next poll, and
+ * used to make an `usage API: …` line pop in and out of the sidebar every few
+ * seconds. The pattern list is a whitelist on purpose: a new transport wording
+ * must stay quiet by default.
+ */
+export declare function actionableAccountError(reason: string | undefined): boolean;
 /** Value budget for a labelled row: the panel draws `label: value`. */
 export declare function valueWidth(label: string): number;
 /** How the panel splits a row: a muted label (or banner) and a toned value. */

package/dist/sidebar/useRows.d.ts

@@ -45,4 +45,19 @@ export declare function seededZen(): ZenUsage | undefined;
 export declare function rememberArk(usage: ArkUsage): void;
 /** The remembered ARK snapshot, or undefined on the first panel. */
 export declare function seededArk(): ArkUsage | undefined;
+/** The account half both panels share. */
+export type Accounted = {
+    account?: unknown;
+    accountError?: string;
+};
+/**
+ * Keep the previous account meters when this poll only failed on the wire.
+ *
+ * ocuse/arkuse answer with `accountError` and no `account` for *any* failure, so
+ * one dropped request blinked the whole meter block to the local estimate and
+ * back 5s later. Only a reason the user can act on may drop the old numbers;
+ * a transport fault keeps them, unlabelled, because the next poll restores them
+ * anyway.
+ */
+export declare function keepAccount<T extends Accounted>(next: T, last: Accounted | undefined): T;
 export declare function useRows(activeModelId: () => string | undefined, providerID: () => string | undefined, sessionID: () => string | undefined): import("solid-js").Accessor<SidebarRow[]>;

package/dist/tui.js

@@ -675,6 +675,11 @@ function separator() {
 function clip(text, width = ROW_WIDTH) {
   return text.length <= width ? text : `${text.slice(0, width - 1)}\u2026`;
 }
+function actionableAccountError(reason) {
+  if (!reason)
+    return false;
+  return /api_key_expired|no Go key|no agent-plan|not found on PATH|HTTP 40[13]|invalid.*key|unauthori[sz]ed/i.test(reason);
+}
 function valueWidth(label) {
   return ROW_WIDTH - label.length - 2;
 }
@@ -2146,6 +2151,16 @@ function meter(value) {
     resetAt: typeof v.resetAt === "number" ? v.resetAt : undefined
   };
 }
+function storeWindow(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const v = value;
+  return {
+    quota: typeof v.quota === "number" ? v.quota : undefined,
+    percent: typeof v.percent === "number" ? v.percent : undefined,
+    resetAt: typeof v.resetAt === "number" ? v.resetAt : undefined
+  };
+}
 function parseArkJson(text) {
   let body;
   try {
@@ -2167,6 +2182,7 @@ function parseArkJson(text) {
     });
   }
   const summary = body.summary ?? {};
+  const windows = body.windows ?? {};
   return {
     plan: typeof body.plan === "string" ? body.plan : "medium",
     profile: typeof body.profile === "string" ? body.profile : undefined,
@@ -2180,6 +2196,11 @@ function parseArkJson(text) {
     weekly: totals(body.weekly),
     month: totals(body.monthly),
     daily: body.daily ? totals(body.daily) : undefined,
+    windows: body.windows ? {
+      fiveHour: storeWindow(windows.fiveHour),
+      weekly: storeWindow(windows.weekly),
+      monthly: storeWindow(windows.monthly)
+    } : undefined,
     account: body.account ? {
       fiveHour: meter(account.fiveHour),
       daily: account.daily ? meter(account.daily) : undefined,
@@ -2233,16 +2254,28 @@ function meterRows(label, meter, local, now, durSecs) {
     exceeded: pct >= 100 || meter.status !== "ok"
   }, now, durSecs, `${afp(local.afp)} local${local.requests > 0 ? ` \xB7 ${count(local.requests)} req` : ""}`, (used, cap) => `${brief(used)}/${brief(cap)} (${pctText}%)`);
 }
-function localRows(label, totals) {
-  const detail = totals.requests > 0 ? ` \xB7 ${count(totals.requests)} req` : "";
-  return [[label, `${afp(totals.afp)}${detail}`, "base"]];
+function localRows(label, totals, window, now, durSecs) {
+  const quota = window?.quota;
+  const percent = window?.percent;
+  if (typeof quota !== "number" || quota <= 0 || typeof percent !== "number") {
+    const detail = totals.requests > 0 ? ` \xB7 ${count(totals.requests)} req` : "";
+    return [[label, `${afp(totals.afp)}${detail}`, "base"]];
+  }
+  const pctText = percent.toFixed(1);
+  return windowRows(label, {
+    cap: quota,
+    used: totals.afp,
+    resetAt: window?.resetAt,
+    sharePct: percent,
+    exceeded: percent >= 100
+  }, now, durSecs, `${count(totals.requests)} req`, (used, cap) => `${brief(used)}/${brief(cap)} (${pctText}% est.)`);
 }
 function arkRows(usage, fallbackName) {
   if (!usage)
     return [];
   const now = Date.now();
   const rows = [["Plan", clip(`${usage.plan} \xB7 AFP plan${usage.profile ? ` \xB7 ${usage.profile}` : ""}`, valueWidth("Plan")), "base", true]];
-  if (usage.accountError) {
+  if (usage.accountError && actionableAccountError(usage.accountError)) {
     rows.push(["", clip(`usage API: ${usage.accountError}`, valueWidth("")), "warn"]);
   }
   const period = monthPeriod(usage);
@@ -2255,9 +2288,10 @@ function arkRows(usage, fallbackName) {
     rows.push(...meterRows("Weekly", account.weekly, usage.weekly, now, WEEKLY_SECS));
     rows.push(...meterRows("Monthly", account.monthly, usage.month, now, period?.durSecs ?? 0));
   } else {
-    rows.push(...localRows("5-hour", usage.fiveHour));
-    rows.push(...localRows("Weekly", usage.weekly));
-    rows.push(...localRows("Monthly", usage.month));
+    const windows = usage.windows;
+    rows.push(...localRows("5-hour", usage.fiveHour, windows?.fiveHour, now, FIVE_HOUR_SECS));
+    rows.push(...localRows("Weekly", usage.weekly, windows?.weekly, now, WEEKLY_SECS));
+    rows.push(...localRows("Monthly", usage.month, windows?.monthly, now, period?.durSecs ?? 0));
   }
   const yuan = typeof usage.summary.yuan === "number" ? ` (${money(usage.summary.yuan)})` : "";
   rows.push(["Period", clip(`${count(usage.summary.requests)} requests \xB7 ${afp(usage.summary.afp)}${yuan}`, valueWidth("Period")), "base"]);
@@ -2390,7 +2424,7 @@ function zenRows(usage, meta, modelUsage, session, fallbackName, windows) {
   const now = Date.now();
   const oc = meta?.oc;
   const rows = [["Plan", `${oc?.plan ?? "Go"} \xB7 limits per model`, "base"]];
-  if (usage.accountError) {
+  if (usage.accountError && actionableAccountError(usage.accountError)) {
     rows.push(["", clip(`usage API: ${usage.accountError}`, valueWidth("")), "warn"]);
   }
   const mine = usage.models.get(modelKey(fallbackName ?? "")) ?? (meta ? usage.models.get(modelKey(meta.name)) : undefined);
@@ -2820,6 +2854,17 @@ function rememberArk(usage) {
 function seededArk() {
   return lastArk;
 }
+function keepAccount(next, last) {
+  if (next.account || !last?.account)
+    return next;
+  if (actionableAccountError(next.accountError))
+    return next;
+  return {
+    ...next,
+    account: last.account,
+    accountError: undefined
+  };
+}
 function useRows(activeModelId, providerID, sessionID) {
   const [usage, setUsage] = createSignal(seededRows());
   const [zen, setZen] = createSignal(seededZen());
@@ -2874,13 +2919,13 @@ function useRows(activeModelId, providerID, sessionID) {
         setUsage(usageRows(snapshot));
         refreshModelUsage(activeModelId());
       } else if (kind === "go" || kind === "zen") {
-        const snapshot = await loadZen(loadPrefs().ocPlan);
+        const snapshot = keepAccount(await loadZen(loadPrefs().ocPlan), lastZen);
         rememberZen(snapshot);
         setZen(snapshot);
         refreshModelUsage(activeModelId());
         refreshModelWindows(activeModelId());
       } else if (kind === "ark") {
-        const snapshot = await loadArk();
+        const snapshot = keepAccount(await loadArk(), lastArk);
         rememberArk(snapshot);
         setArk(snapshot);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jeffreyjyz/opencode-command-code",
-	"version": "0.5.18",
+	"version": "0.5.20",
 	"description": "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
 	"type": "module",
 	"main": "dist/index.js",