oc-go-usage-display 1.0.2 → 2.0.0

package/dist/plugins/oc-go-usage-display.tsx

@@ -0,0 +1,1018 @@
+// oc-go-usage-display: opencode tui plugin bundle (self-contained)
+
+// src/tui.tsx
+import { For as For2, Show as Show2, createMemo as createMemo2, createSignal as createSignal2 } from "solid-js";
+
+// src/shared.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function resolveHomedir() {
+  const envHome = process.env.HOME;
+  if (envHome && envHome.length > 0) return envHome;
+  return os.homedir();
+}
+var ENV_PREFIX = {
+  opencode: "OPENCODE_OC_GO_",
+  kilo: "KILO_OC_GO_"
+};
+function hostEnvName(host, suffix) {
+  return `${ENV_PREFIX[host]}${suffix}`;
+}
+function hostEnv(host, suffix, env = process.env) {
+  return env?.[hostEnvName(host, suffix)];
+}
+function homedirOrEmpty(homedir2) {
+  try {
+    return homedir2();
+  } catch {
+    return "";
+  }
+}
+function resolveHostRoots(host, env = process.env, homedir2 = resolveHomedir) {
+  const home = homedirOrEmpty(homedir2);
+  const configRoot = toNonEmptyString(env.XDG_CONFIG_HOME) ?? safeJoinPath(home, ".config");
+  const dataRoot = toNonEmptyString(env.XDG_DATA_HOME) ?? safeJoinPath(home, ".local", "share");
+  if (host === "kilo") {
+    return {
+      configDir: toNonEmptyString(env.KILO_CONFIG_DIR) ?? safeJoinPath(configRoot, "kilo"),
+      dataDir: safeJoinPath(dataRoot, "kilo")
+    };
+  }
+  return {
+    configDir: safeJoinPath(configRoot, "opencode"),
+    dataDir: safeJoinPath(dataRoot, "opencode")
+  };
+}
+var CONFIG_DIR = resolveHostRoots("opencode").configDir;
+function toPathSegment(value) {
+  if (typeof value === "string") return value;
+  try {
+    return String(value);
+  } catch {
+    return "";
+  }
+}
+function safeJoinPath(base, ...segments) {
+  return path.join(toPathSegment(base), ...segments.map(toPathSegment));
+}
+function authJsonPaths(host = "opencode", env = process.env, homedir2 = resolveHomedir) {
+  const roots = resolveHostRoots(host, env, homedir2);
+  return [safeJoinPath(roots.dataDir, "auth.json"), safeJoinPath(roots.configDir, "auth.json")];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+function toUsageCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(value, 0);
+}
+function toNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function errorMessage(error) {
+  if (error === null || error === void 0) return "unknown error";
+  if (error instanceof Error) {
+    return toNonEmptyString(error.message) ?? toNonEmptyString(error.name) ?? "unknown error";
+  }
+  try {
+    return toNonEmptyString(String(error)) ?? "unknown error";
+  } catch {
+    return "unknown error";
+  }
+}
+var GO_PROVIDER_ID = "opencode-go";
+var KILO_MODEL_NAME_MAX_CHARS = 19;
+var SIDEBAR_COLLAPSED_GLYPH = "\u25B6";
+var SIDEBAR_EXPANDED_GLYPH = "\u25BE";
+var OPENCODE_MODEL_NAME_MAX_CHARS = 12;
+var PERCENT_CELL_WIDTH = 5;
+var TOP_GO_MODELS_LIMIT = 3;
+var GO_MODEL_MIX_NAME_MAX_CHARS = 6;
+var GO_MODEL_MIX_BUDGET = 28;
+var GO_MODEL_MIX_SEPARATOR = "\xB7";
+var TOP_GO_MODELS_LABEL = "Top Go models";
+var MODELS_EMPTY_LABEL = "No model usage yet";
+var SECONDS_PER_MINUTE = 60;
+var SECONDS_PER_HOUR = 3600;
+var SECONDS_PER_DAY = 86400;
+var SECONDS_PER_WEEK = 604800;
+function formatResetDuration(totalSec) {
+  if (totalSec === null || !Number.isFinite(totalSec) || totalSec < 0) return null;
+  const sec = Math.floor(totalSec);
+  if (sec >= SECONDS_PER_WEEK) {
+    const weeks = Math.floor(sec / SECONDS_PER_WEEK);
+    const days = Math.floor(sec % SECONDS_PER_WEEK / SECONDS_PER_DAY);
+    return `${weeks}w ${days}d`;
+  }
+  if (sec >= SECONDS_PER_DAY) {
+    const days = Math.floor(sec / SECONDS_PER_DAY);
+    const hours2 = Math.floor(sec % SECONDS_PER_DAY / SECONDS_PER_HOUR);
+    return `${days}d ${hours2}h`;
+  }
+  const hours = Math.floor(sec / SECONDS_PER_HOUR);
+  const minutes = Math.floor(sec % SECONDS_PER_HOUR / SECONDS_PER_MINUTE);
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${sec}s`;
+}
+function readAuthJsonApiKey(host = "opencode", env = process.env, homedir2 = resolveHomedir) {
+  for (const authPath of authJsonPaths(host, env, homedir2)) {
+    let raw;
+    try {
+      raw = fs.readFileSync(authPath, "utf8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const goEntry = parsed["opencode-go"];
+    const fallbackEntry = parsed["opencode"];
+    const goKey = isRecord(goEntry) ? toNonEmptyString(goEntry.key) : null;
+    if (goKey) return goKey;
+    const fallbackKey = isRecord(fallbackEntry) ? toNonEmptyString(fallbackEntry.key) : null;
+    if (fallbackKey) return fallbackKey;
+  }
+  return null;
+}
+function usableCountdown(seconds) {
+  if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) return null;
+  return seconds;
+}
+function secondsUntilReset(resetsAt, now) {
+  const instant = toNonEmptyString(resetsAt);
+  if (instant === null) return null;
+  return usableCountdown(Math.round((Date.parse(instant) - now) / 1e3));
+}
+var LIMITED_STATUSES = /* @__PURE__ */ new Set(["rate-limited", "limited", "exhausted", "capped"]);
+function isLimitedStatus(status) {
+  if (status === null) return false;
+  const normalized = status.trim().toLowerCase().replace(/[\s_]+/g, "-");
+  return LIMITED_STATUSES.has(normalized);
+}
+function extractWindow(candidate, now = Date.now()) {
+  if (!isRecord(candidate)) return null;
+  const percent = toFiniteNumber(
+    candidate.percent ?? candidate.usagePercent ?? candidate.usedPercent ?? candidate.value ?? candidate.usage
+  );
+  if (percent === null) return null;
+  const status = toNonEmptyString(candidate.status);
+  const resetInSec = usableCountdown(candidate.resetInSec ?? candidate.resetInSeconds) ?? secondsUntilReset(candidate.resetsAt, now);
+  const resetText = toNonEmptyString(candidate.resetText ?? candidate.reset ?? null);
+  return { percent: Math.round(percent), status, limited: isLimitedStatus(status), resetInSec, resetText };
+}
+function extractSnapshotFromApiPayload(payload, now = Date.now()) {
+  if (!isRecord(payload)) return null;
+  const containers = [payload];
+  for (const key of ["usage", "data", "go"]) {
+    if (isRecord(payload[key])) containers.push(payload[key]);
+  }
+  for (const container of containers) {
+    if (!isRecord(container)) continue;
+    const rolling = extractWindow(container.rolling ?? container.rollingUsage ?? container["5h"], now);
+    const weekly = extractWindow(container.weekly ?? container.weeklyUsage ?? container["7d"], now);
+    const monthly = extractWindow(container.monthly ?? container.monthlyUsage ?? container["30d"], now);
+    if (rolling !== null || weekly !== null || monthly !== null) {
+      return {
+        rolling,
+        weekly,
+        monthly,
+        source: "api",
+        fetchedAt: now
+      };
+    }
+  }
+  return null;
+}
+function mockSnapshot() {
+  return {
+    rolling: { percent: 42, status: "active", limited: false, resetInSec: 7543, resetText: null },
+    weekly: { percent: 15, status: "active", limited: false, resetInSec: null, resetText: null },
+    monthly: { percent: 61, status: "active", limited: false, resetInSec: null, resetText: null },
+    source: "mock",
+    fetchedAt: Date.now()
+  };
+}
+function unavailableSnapshot(error) {
+  return {
+    rolling: null,
+    weekly: null,
+    monthly: null,
+    source: "unavailable",
+    fetchedAt: Date.now(),
+    apiUnavailable: true,
+    apiError: error
+  };
+}
+var EMPTY_TOKENS = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+function parseUsageTokens(candidate) {
+  if (!isRecord(candidate)) return { ...EMPTY_TOKENS, cache: { ...EMPTY_TOKENS.cache } };
+  const cache = isRecord(candidate.cache) ? candidate.cache : {};
+  return {
+    input: toUsageCount(candidate.input),
+    output: toUsageCount(candidate.output),
+    reasoning: toUsageCount(candidate.reasoning),
+    cache: { read: toUsageCount(cache.read), write: toUsageCount(cache.write) }
+  };
+}
+function parseUsageTotals(candidate) {
+  if (!isRecord(candidate)) return { steps: 0, cost: 0, tokens: { ...EMPTY_TOKENS, cache: { ...EMPTY_TOKENS.cache } } };
+  return {
+    steps: toUsageCount(candidate.steps),
+    cost: toUsageCount(candidate.cost),
+    tokens: parseUsageTokens(candidate.tokens)
+  };
+}
+function addUsageTokens(left, right) {
+  return {
+    input: left.input + right.input,
+    output: left.output + right.output,
+    reasoning: left.reasoning + right.reasoning,
+    cache: { read: left.cache.read + right.cache.read, write: left.cache.write + right.cache.write }
+  };
+}
+function aggregateModelUsageFromMessages(messages) {
+  const byModel = /* @__PURE__ */ new Map();
+  const sessionIDs = [];
+  for (const entry of messages) {
+    if (!isRecord(entry) || entry.role !== "assistant") continue;
+    const providerID = toNonEmptyString(entry.providerID);
+    const modelID = toNonEmptyString(entry.modelID);
+    if (providerID === null || modelID === null) continue;
+    const parsed = parseUsageTotals(entry);
+    const key = `${providerID}/${modelID}`;
+    const existing = byModel.get(key);
+    if (existing === void 0) {
+      byModel.set(key, {
+        providerID,
+        modelID,
+        steps: 1,
+        cost: parsed.cost,
+        tokens: { ...parsed.tokens, cache: { ...parsed.tokens.cache } }
+      });
+    } else {
+      existing.steps += 1;
+      existing.cost += parsed.cost;
+      existing.tokens = addUsageTokens(existing.tokens, parsed.tokens);
+    }
+    const sessionID = toNonEmptyString(entry.sessionID);
+    if (sessionID !== null && !sessionIDs.includes(sessionID)) sessionIDs.push(sessionID);
+  }
+  const models = [...byModel.values()];
+  const totals = models.reduce(
+    (sum, model) => ({
+      steps: sum.steps + model.steps,
+      cost: sum.cost + model.cost,
+      tokens: addUsageTokens(sum.tokens, model.tokens)
+    }),
+    { steps: 0, cost: 0, tokens: { ...EMPTY_TOKENS, cache: { ...EMPTY_TOKENS.cache } } }
+  );
+  return { sessionIDs, totals, models };
+}
+
+// src/helpers.ts
+function isDisplayMode(value) {
+  return value === "sidebar" || value === "statusline" || value === "both";
+}
+function providerIdFromModel(model) {
+  if (typeof model !== "string" || model.length === 0) return void 0;
+  const provider = model.split("/")[0];
+  return provider !== void 0 && provider.length > 0 ? provider : void 0;
+}
+function resolveProviderId(state, sessionId, fallback) {
+  try {
+    const fromSession = state?.session?.get?.(sessionId)?.model?.providerID;
+    if (typeof fromSession === "string" && fromSession.length > 0) return fromSession;
+  } catch {
+  }
+  try {
+    const fromConfig = providerIdFromModel(state?.config?.model);
+    if (fromConfig !== void 0) return fromConfig;
+  } catch {
+  }
+  return fallback;
+}
+function surfaceSelectionFromDisplayMode(mode) {
+  return { sidebar: mode !== "statusline", statusline: mode !== "sidebar" };
+}
+function parseBooleanFlag(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+    return null;
+  }
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return true;
+  if (normalized === "0" || normalized === "false") return false;
+  return null;
+}
+function isSnapshotEmpty(snapshot) {
+  return snapshot.rolling === null && snapshot.weekly === null && snapshot.monthly === null;
+}
+function relevantReset(snapshot) {
+  const rows = buildPlanRows(snapshot);
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const row = rows[i];
+    if (row?.reset != null) return { label: row.label, text: row.reset };
+  }
+  return soonestReset(snapshot);
+}
+function soonestReset(snapshot) {
+  const windows = [
+    ["5h", snapshot.rolling],
+    ["7d", snapshot.weekly],
+    ["30d", snapshot.monthly]
+  ];
+  let soonest = null;
+  for (const [name, window] of windows) {
+    if (window === null) continue;
+    const seconds = window.resetInSec;
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) continue;
+    if (soonest !== null && seconds >= soonest.seconds) continue;
+    soonest = { label: name, seconds };
+  }
+  if (soonest === null) return null;
+  const text = formatResetDuration(soonest.seconds);
+  return text === null ? null : { label: soonest.label, text };
+}
+function formatStatusline(snapshot) {
+  const rolling = snapshot.rolling === null ? "5h n/a" : `5h ${snapshot.rolling.percent}%`;
+  const weekly = snapshot.weekly === null ? "7d n/a" : `7d ${snapshot.weekly.percent}%`;
+  const monthly = snapshot.monthly === null ? "30d n/a" : `30d ${snapshot.monthly.percent}%`;
+  const windows = `Go ${rolling} | ${weekly} | ${monthly}`;
+  const reset = relevantReset(snapshot);
+  return reset === null ? windows : `${windows} \xB7 resets in ${reset.text}`;
+}
+var WARNING_PERCENT = 75;
+var ERROR_PERCENT = 90;
+function usageMeterSeverity(window) {
+  if (window.limited) return "error";
+  return meterSeverityForPercent(window.percent);
+}
+function meterSeverityForPercent(percent) {
+  if (!Number.isFinite(percent)) return "muted";
+  if (percent >= ERROR_PERCENT) return "error";
+  if (percent >= WARNING_PERCENT) return "warning";
+  return "muted";
+}
+function meterFillPercent(percent) {
+  if (!Number.isFinite(percent)) return 0;
+  return Math.min(Math.max(percent, 0), 100);
+}
+function buildPlanRows(snapshot) {
+  const windows = [
+    ["5h", snapshot.rolling],
+    ["7d", snapshot.weekly],
+    ["30d", snapshot.monthly]
+  ];
+  const rows = [];
+  for (const [label, window] of windows) {
+    if (window === null) continue;
+    rows.push({
+      label,
+      percent: window.percent,
+      severity: usageMeterSeverity(window),
+      // A countdown only tells the user something once the window is capped;
+      // before that the schedule is noise, and the header rows already show it.
+      reset: window.limited ? formatResetDuration(window.resetInSec) ?? window.resetText : null
+    });
+  }
+  return rows;
+}
+var COUNT_FORMAT = new Intl.NumberFormat("en-US");
+var CURRENCY_FORMAT = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+function formatUsageCount(value) {
+  return COUNT_FORMAT.format(toUsageCount(value));
+}
+function formatUsageCost(value) {
+  return CURRENCY_FORMAT.format(toUsageCount(value));
+}
+function usageTokenCount(tokens) {
+  return toUsageCount(tokens.input) + toUsageCount(tokens.output) + toUsageCount(tokens.reasoning) + toUsageCount(tokens.cache.read) + toUsageCount(tokens.cache.write);
+}
+function goSharePercent(modelTokens, totalGoTokens) {
+  const total = toUsageCount(totalGoTokens);
+  if (total === 0) return 0;
+  return toUsageCount(modelTokens) / total * 100;
+}
+function truncateModelName(value, max = KILO_MODEL_NAME_MAX_CHARS) {
+  if (value.length <= max) return value;
+  const budget = Math.max(max - 1, 0);
+  return `${value.slice(0, budget)}\u2026`;
+}
+function displayModelName(name) {
+  return name.trim().replace(/^[^:]+:\s+/, "").replace(/^[^/\s]+\/(?=[^/]+$)/, "").replace(/\s*\([^)]*%\s*off[^)]*\)\s*$/i, "").replace(/^([A-Za-z]{2,})(?=\d)/, "$1 ").replace(/\s+/g, " ");
+}
+function modelDisplayName(catalogName, modelID, max = KILO_MODEL_NAME_MAX_CHARS) {
+  const raw = toNonEmptyString(catalogName) ?? toNonEmptyString(modelID) ?? "";
+  return truncateModelName(displayModelName(raw), max);
+}
+function shortModelName(value, max = GO_MODEL_MIX_NAME_MAX_CHARS) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.length === 0) return "";
+  const head = trimmed.split(/[-._/]/)[0] ?? trimmed;
+  return truncateModelName(head, max);
+}
+var PLAN_LABEL_WIDTH = 3;
+function formatPercentCell(percent, width = PERCENT_CELL_WIDTH) {
+  const cells = Math.max(Math.floor(width), 1);
+  const rounded = Number.isFinite(percent) ? Math.round(percent) : 0;
+  return `${`${rounded}%`}`.padStart(cells, " ");
+}
+function formatTokenCount(value) {
+  const count = toUsageCount(value);
+  if (count >= 1e9) return `${trimTrailingZeros((count / 1e9).toFixed(2))}B`;
+  if (count >= 1e6) return `${trimTrailingZeros((count / 1e6).toFixed(2))}M`;
+  if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
+  return COUNT_FORMAT.format(count);
+}
+function trimTrailingZeros(value) {
+  return value.replace(/\.?0+$/, "");
+}
+function weightGoModels(models, limit = TOP_GO_MODELS_LIMIT) {
+  const goModels = models.filter((model) => model.providerID === GO_PROVIDER_ID);
+  const goTokens = goModels.reduce((sum, model) => sum + usageTokenCount(model.tokens), 0);
+  const ranked = [...goModels].sort(
+    (left, right) => usageTokenCount(right.tokens) - usageTokenCount(left.tokens) || toUsageCount(right.steps) - toUsageCount(left.steps) || left.modelID.localeCompare(right.modelID)
+  );
+  const top = ranked.slice(0, Math.max(Math.floor(limit), 0));
+  const listedTokens = top.reduce((sum, model) => sum + usageTokenCount(model.tokens), 0);
+  return {
+    models: top.map((model) => {
+      const tokens = usageTokenCount(model.tokens);
+      const share = goSharePercent(tokens, goTokens);
+      return {
+        providerID: model.providerID,
+        modelID: model.modelID,
+        tokens,
+        share,
+        steps: toUsageCount(model.steps),
+        cost: toUsageCount(model.cost)
+      };
+    }),
+    goModels: goModels.length,
+    goTokens,
+    listedTokens,
+    listedShare: goSharePercent(listedTokens, goTokens),
+    otherCount: Math.max(goModels.length - top.length, 0),
+    steps: goModels.reduce((sum, model) => sum + toUsageCount(model.steps), 0),
+    cost: goModels.reduce((sum, model) => sum + toUsageCount(model.cost), 0)
+  };
+}
+function buildModelMixSummary(entries, budget = GO_MODEL_MIX_BUDGET) {
+  const first = entries[0];
+  if (first === void 0) return "";
+  const parts = [];
+  let used = 0;
+  for (const entry of entries) {
+    const part = `${entry.name} ${Math.round(entry.share)}%`;
+    const width = part.length + (parts.length === 0 ? 0 : GO_MODEL_MIX_SEPARATOR.length);
+    if (parts.length > 0 && used + width > budget) break;
+    parts.push(part);
+    used += width;
+  }
+  return parts.join(GO_MODEL_MIX_SEPARATOR);
+}
+function buildGoModelFooters(weights) {
+  if (weights.models.length === 0) return [];
+  return [
+    `${formatTokenCount(weights.listedTokens)} of ${formatTokenCount(weights.goTokens)} Go tokens`,
+    `${formatUsageCount(weights.steps)} steps \xB7 ${formatUsageCost(weights.cost)}`
+  ];
+}
+
+// src/tui-shared.tsx
+import { For, Show, createEffect, createMemo, createSignal } from "solid-js";
+import { jsx, jsxs } from "@opentui/solid/jsx-runtime";
+var API_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+var POLL_INTERVAL_MS = 6e4;
+var EVENT_TTL_MS = 15e3;
+var DEBOUNCE_MS = 5e3;
+var FETCH_TIMEOUT_MS = 1e4;
+var LOG_SERVICE = "oc-go-usage-display";
+var KV_DISPLAY_KEY = "display";
+var KV_COLLAPSED_SIDEBAR_KEY = "collapsed_sidebar";
+var KV_COLLAPSED_STATUSLINE_KEY = "collapsed_statusline";
+var KV_COLLAPSED_LEGACY_KEY = "collapsed";
+function reactiveChild(accessor) {
+  return accessor;
+}
+function meterColor(theme, severity) {
+  if (severity === "error") return theme.current.error;
+  if (severity === "warning") return theme.current.warning;
+  return theme.current.textMuted;
+}
+async function logUsageError(api, message) {
+  try {
+    await api.client.app.log({ service: LOG_SERVICE, level: "error", message });
+  } catch {
+  }
+}
+async function fetchJsonWithTimeout(url, apiKey) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+    });
+    if (response.status === 401 || response.status === 403) return { __rejected: true };
+    if (!response.ok) return null;
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function loadUsageSnapshot(host) {
+  if (hostEnv(host, "MOCK") === "1") return mockSnapshot();
+  const apiKey = toNonEmptyString(hostEnv(host, "API_KEY")) ?? readAuthJsonApiKey(host);
+  if (apiKey === null) return null;
+  const payload = await fetchJsonWithTimeout(API_USAGE_URL, apiKey);
+  if (payload === null) return null;
+  if (isRecord(payload) && payload.__rejected === true) {
+    return unavailableSnapshot("API key rejected (401/403)");
+  }
+  return extractSnapshotFromApiPayload(payload);
+}
+function createUsageStore(api, host) {
+  const [snapshot, setSnapshot] = createSignal(null);
+  let cachedAt = 0;
+  let lastFetchAt = 0;
+  let refreshInFlight = false;
+  async function refresh(ttlOverride) {
+    if (refreshInFlight) return;
+    const effectiveTtl = ttlOverride ?? POLL_INTERVAL_MS;
+    if (ttlOverride !== void 0) {
+      if (Date.now() - lastFetchAt < DEBOUNCE_MS) return;
+      if (Date.now() - cachedAt < effectiveTtl && snapshot() !== null) return;
+    } else if (Date.now() - cachedAt < POLL_INTERVAL_MS && snapshot() !== null) {
+      return;
+    }
+    refreshInFlight = true;
+    try {
+      const next = await loadUsageSnapshot(host);
+      if (next === null) {
+        if (snapshot() === null) {
+          await logUsageError(api, "Go usage unavailable (not configured or request failed)");
+        }
+        return;
+      }
+      cachedAt = Date.now();
+      setSnapshot(next);
+    } catch {
+    } finally {
+      lastFetchAt = Date.now();
+      refreshInFlight = false;
+    }
+  }
+  return {
+    snapshot,
+    refresh: () => refresh(),
+    refreshSafely: (ttlOverride) => {
+      void refresh(ttlOverride).catch(() => {
+      });
+    }
+  };
+}
+function resolveSurfaceSelection(options, api, host) {
+  if (options !== void 0) {
+    const sidebarOption = parseBooleanFlag(options.sidebar);
+    const statuslineOption = parseBooleanFlag(options.statusline);
+    if (sidebarOption !== null || statuslineOption !== null) {
+      return { sidebar: sidebarOption ?? true, statusline: statuslineOption ?? true };
+    }
+    if (isDisplayMode(options.display)) return surfaceSelectionFromDisplayMode(options.display);
+  }
+  const sidebarEnv = parseBooleanFlag(hostEnv(host, "SIDEBAR"));
+  const statuslineEnv = parseBooleanFlag(hostEnv(host, "STATUSLINE"));
+  if (sidebarEnv !== null || statuslineEnv !== null) {
+    return { sidebar: sidebarEnv ?? true, statusline: statuslineEnv ?? true };
+  }
+  const displayEnv = toNonEmptyString(hostEnv(host, "DISPLAY"));
+  if (displayEnv !== null && isDisplayMode(displayEnv)) {
+    return surfaceSelectionFromDisplayMode(displayEnv);
+  }
+  try {
+    const stored = api.kv.get(KV_DISPLAY_KEY, "both");
+    if (isDisplayMode(stored)) return surfaceSelectionFromDisplayMode(stored);
+  } catch {
+  }
+  return { sidebar: true, statusline: true };
+}
+function readCollapsedFlag(api, key) {
+  try {
+    return api.kv.get(key, false) === true;
+  } catch {
+    return false;
+  }
+}
+function migrateLegacyCollapsedFlag(api) {
+  let legacyCollapsed = false;
+  try {
+    legacyCollapsed = api.kv.get(KV_COLLAPSED_LEGACY_KEY, false) === true;
+  } catch {
+    return;
+  }
+  if (!legacyCollapsed) return;
+  try {
+    api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, true);
+    api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, true);
+    api.kv.set(KV_COLLAPSED_LEGACY_KEY, false);
+  } catch {
+  }
+}
+function createCollapseState(api) {
+  migrateLegacyCollapsedFlag(api);
+  const [isSidebarCollapsed, setIsSidebarCollapsed] = createSignal(
+    readCollapsedFlag(api, KV_COLLAPSED_SIDEBAR_KEY)
+  );
+  const [isStatuslineCollapsed, setIsStatuslineCollapsed] = createSignal(
+    readCollapsedFlag(api, KV_COLLAPSED_STATUSLINE_KEY)
+  );
+  return {
+    isSidebarCollapsed,
+    isStatuslineCollapsed,
+    toggleSidebar() {
+      try {
+        const next = !isSidebarCollapsed();
+        setIsSidebarCollapsed(next);
+        api.kv.set(KV_COLLAPSED_SIDEBAR_KEY, next);
+      } catch {
+      }
+    },
+    toggleStatusline() {
+      try {
+        const next = !isStatuslineCollapsed();
+        setIsStatuslineCollapsed(next);
+        api.kv.set(KV_COLLAPSED_STATUSLINE_KEY, next);
+      } catch {
+      }
+    }
+  };
+}
+function isGoUsageProvider(providerId) {
+  return providerId === GO_PROVIDER_ID;
+}
+function makeProviderResolver(state, fallback) {
+  return (sessionId) => resolveProviderId(state, sessionId, fallback());
+}
+function readModelDisplayName(source, providerID, modelID) {
+  try {
+    const provider = source.state?.provider?.find((entry) => entry.id === providerID);
+    return toNonEmptyString(provider?.models?.[modelID]?.name);
+  } catch {
+    return null;
+  }
+}
+var MIN_METER_WIDTH = 6;
+function MeterBar(props) {
+  const fill = createMemo(() => meterFillPercent(props.percent));
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", flexGrow: 1, flexShrink: 1, minWidth: MIN_METER_WIDTH, children: [
+    /* @__PURE__ */ jsx("box", { width: `${fill()}%`, backgroundColor: meterColor(props.theme, props.severity) }),
+    /* @__PURE__ */ jsx("box", { flexGrow: 1, backgroundColor: props.theme.current.backgroundElement })
+  ] });
+}
+function GoPlanRow(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs("box", { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx("box", { width: PLAN_LABEL_WIDTH, marginRight: 1, flexShrink: 0, flexDirection: "row", children: /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: props.row.label }) }),
+      /* @__PURE__ */ jsx(MeterBar, { theme: props.theme, percent: props.row.percent, severity: props.row.severity }),
+      /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", flexShrink: 0, children: formatPercentCell(props.row.percent) })
+    ] }),
+    /* @__PURE__ */ jsx(Show, { when: props.row.reset, children: (reset) => /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+      "resets in ",
+      reset()
+    ] }) })
+  ] });
+}
+function SectionHeader(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "row", gap: 1, flexShrink: 0, onMouseDown: props.onToggle, children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, wrapMode: "none", flexShrink: 0, children: reactiveChild(() => props.expanded() ? SIDEBAR_EXPANDED_GLYPH : SIDEBAR_COLLAPSED_GLYPH) }),
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, wrapMode: "none", children: /* @__PURE__ */ jsx("b", { children: reactiveChild(() => {
+      const count = props.count();
+      return count === null ? props.label : `${props.label} (${count})`;
+    }) }) })
+  ] });
+}
+function CollapsibleSection(props) {
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(
+      SectionHeader,
+      {
+        theme: props.theme,
+        label: props.label,
+        count: props.count,
+        expanded: props.expanded,
+        onToggle: props.onToggle
+      }
+    ),
+    /* @__PURE__ */ jsx("box", { flexDirection: "column", gap: 1, children: reactiveChild(() => props.expanded() ? props.body() : null) })
+  ] });
+}
+function GoUsageBlock(props) {
+  createEffect(() => {
+    const snapshot = props.snapshot();
+    if (snapshot !== null && snapshot.source === "unavailable") {
+      void logUsageError(
+        props.api,
+        snapshot.apiError ? `Go usage unavailable (${snapshot.apiError})` : "Go usage snapshot unavailable"
+      );
+    }
+  });
+  const body = createMemo(() => {
+    const snapshot = props.snapshot();
+    if (snapshot === null) {
+      return /* @__PURE__ */ jsx("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: "Go loading\u2026" });
+    }
+    if (snapshot.source === "unavailable") {
+      return /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+        "Go n/a (",
+        snapshot.apiError ?? "unavailable",
+        ")"
+      ] });
+    }
+    const planRows = buildPlanRows(snapshot).map((row) => ({ ...row, reset: null }));
+    return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Show, { when: props.resetLine === void 0 ? null : props.resetLine(), children: (reset) => /* @__PURE__ */ jsxs("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: [
+        reset().label,
+        " resets in ",
+        reset().text
+      ] }) }),
+      /* @__PURE__ */ jsx(For, { each: planRows, children: (row) => /* @__PURE__ */ jsx(GoPlanRow, { theme: props.theme, row }) })
+    ] });
+  });
+  return /* @__PURE__ */ jsxs("box", { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx("text", { fg: props.theme.current.text, children: /* @__PURE__ */ jsx("b", { children: "Go Usage" }) }),
+    reactiveChild(body)
+  ] });
+}
+function GoStatusline(props) {
+  return /* @__PURE__ */ jsx(Show, { when: props.snapshot(), fallback: null, children: (snapshot) => {
+    if (isSnapshotEmpty(snapshot())) return null;
+    return /* @__PURE__ */ jsx("text", { children: formatStatusline(snapshot()) });
+  } });
+}
+
+// src/tui.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "@opentui/solid/jsx-runtime";
+var HOST = "opencode";
+var SLOT_ORDER = 50;
+async function initializeTui(api, options) {
+  const surfaces = resolveSurfaceSelection(options, api, HOST);
+  const usageStore = createUsageStore(api, HOST);
+  const collapse = createCollapseState(api);
+  const [activeProviderId, setActiveProviderId] = createSignal2(void 0);
+  try {
+    const modelString = api.state?.config?.model;
+    if (typeof modelString === "string" && modelString.length > 0) {
+      const providerPart = modelString.split("/")[0];
+      if (providerPart !== void 0 && providerPart.length > 0) setActiveProviderId(providerPart);
+    }
+  } catch {
+  }
+  const resolveActiveProviderId = makeProviderResolver(api.state, activeProviderId);
+  const [stateToken, setStateToken] = createSignal2(0);
+  function readSessionMessages(sessionId) {
+    if (sessionId.length === 0) return [];
+    try {
+      return api.state.session.messages(sessionId);
+    } catch {
+      return [];
+    }
+  }
+  function WeightedModelRow(props) {
+    const rounded = createMemo2(() => Math.round(props.model.share));
+    const name = createMemo2(
+      () => modelDisplayName(
+        readModelDisplayName(api, props.model.providerID, props.model.modelID),
+        props.model.modelID,
+        OPENCODE_MODEL_NAME_MAX_CHARS
+      )
+    );
+    return /* @__PURE__ */ jsxs2("box", { flexDirection: "row", gap: 1, flexShrink: 0, children: [
+      /* @__PURE__ */ jsx2("text", { fg: props.theme.current.text, wrapMode: "none", flexShrink: 0, children: name() }),
+      /* @__PURE__ */ jsx2(
+        MeterBar,
+        {
+          theme: props.theme,
+          percent: props.model.share,
+          severity: meterSeverityForPercent(rounded())
+        }
+      ),
+      /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", flexShrink: 0, children: formatPercentCell(rounded()) })
+    ] });
+  }
+  function TopGoModelsSection(props) {
+    const [isExpanded, setIsExpanded] = createSignal2(false);
+    const weights = createMemo2(() => weightGoModels(props.usage()?.models ?? []));
+    const rows = () => weights().models;
+    const mix = createMemo2(
+      () => buildModelMixSummary(
+        rows().map((model) => ({
+          name: shortModelName(
+            modelDisplayName(
+              readModelDisplayName(api, model.providerID, model.modelID),
+              model.modelID,
+              OPENCODE_MODEL_NAME_MAX_CHARS
+            )
+          ),
+          share: model.share
+        }))
+      )
+    );
+    const body = createMemo2(() => /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, paddingTop: 1, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsx2(For2, { each: rows(), children: (model) => /* @__PURE__ */ jsx2(WeightedModelRow, { theme: props.theme, model }) }),
+      /* @__PURE__ */ jsx2(For2, { each: buildGoModelFooters(weights()), children: (line) => /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: line }) })
+    ] }));
+    const section = createMemo2(() => {
+      if (weights().goModels === 0) {
+        return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx2("text", { fg: props.theme.current.text, wrapMode: "none", children: /* @__PURE__ */ jsx2("b", { children: TOP_GO_MODELS_LABEL }) }),
+          /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", children: MODELS_EMPTY_LABEL })
+        ] });
+      }
+      return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx2(
+          CollapsibleSection,
+          {
+            theme: props.theme,
+            label: TOP_GO_MODELS_LABEL,
+            count: () => weights().goModels,
+            expanded: isExpanded,
+            onToggle: () => setIsExpanded((current) => !current),
+            body
+          }
+        ),
+        /* @__PURE__ */ jsx2(Show2, { when: !isExpanded(), children: /* @__PURE__ */ jsx2("text", { fg: props.theme.current.textMuted, wrapMode: "none", paddingLeft: 2, children: reactiveChild(mix) }) })
+      ] });
+    });
+    return /* @__PURE__ */ jsx2("box", { flexDirection: "column", children: reactiveChild(section) });
+  }
+  function GoSidebarPanel(props) {
+    const planResetLine = createMemo2(() => {
+      const snapshot = usageStore.snapshot();
+      if (snapshot === null || snapshot.source === "unavailable") return null;
+      return relevantReset(snapshot);
+    });
+    const sessionUsage = createMemo2(() => {
+      stateToken();
+      return aggregateModelUsageFromMessages(readSessionMessages(props.sessionId));
+    });
+    return /* @__PURE__ */ jsxs2("box", { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx2(
+        GoUsageBlock,
+        {
+          api,
+          theme: props.theme,
+          snapshot: usageStore.snapshot,
+          resetLine: planResetLine
+        }
+      ),
+      /* @__PURE__ */ jsx2(TopGoModelsSection, { theme: props.theme, usage: sessionUsage })
+    ] });
+  }
+  if (surfaces.sidebar) {
+    try {
+      api.slots.register({
+        order: SLOT_ORDER,
+        slots: {
+          sidebar_content(ctx, props) {
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (api.route.current.name !== "session") return null;
+              if (collapse.isSidebarCollapsed()) return null;
+              return /* @__PURE__ */ jsx2(GoSidebarPanel, { theme: ctx.theme, sessionId: props.session_id });
+            } catch {
+              return null;
+            }
+          }
+        }
+      });
+    } catch {
+    }
+  }
+  if (surfaces.statusline) {
+    try {
+      api.slots.register({
+        order: SLOT_ORDER,
+        slots: {
+          session_prompt_right(_ctx, props) {
+            try {
+              if (props.session_id.length === 0) return null;
+              if (!isGoUsageProvider(resolveActiveProviderId(props.session_id))) return null;
+              if (collapse.isStatuslineCollapsed()) return null;
+              return /* @__PURE__ */ jsx2(GoStatusline, { snapshot: usageStore.snapshot });
+            } catch {
+              return null;
+            }
+          }
+        }
+      });
+    } catch {
+    }
+  }
+  let unregisterToggleCommand = () => {
+  };
+  try {
+    const unregister = api.command?.register(() => [
+      {
+        title: "Go usage: toggle sidebar",
+        value: "oc-go-usage-display.toggle-sidebar",
+        category: "Go",
+        onSelect: () => collapse.toggleSidebar()
+      },
+      {
+        title: "Go usage: toggle statusline",
+        value: "oc-go-usage-display.toggle-statusline",
+        category: "Go",
+        onSelect: () => collapse.toggleStatusline()
+      }
+    ]);
+    if (typeof unregister === "function") unregisterToggleCommand = unregister;
+  } catch {
+  }
+  let unsubscribeSession = () => {
+  };
+  let unsubscribeMessage = () => {
+  };
+  try {
+    const unsubscribe = api.event.on("session.updated", (event) => {
+      const providerId = event?.properties?.info?.model?.providerID;
+      if (providerId !== void 0) setActiveProviderId(providerId);
+      usageStore.refreshSafely(0);
+    });
+    if (typeof unsubscribe === "function") unsubscribeSession = unsubscribe;
+  } catch {
+  }
+  try {
+    const unsubscribe = api.event.on("message.updated", () => {
+      usageStore.refreshSafely(EVENT_TTL_MS);
+      setStateToken((current) => current + 1);
+    });
+    if (typeof unsubscribe === "function") unsubscribeMessage = unsubscribe;
+  } catch {
+  }
+  let pollTimer = null;
+  try {
+    pollTimer = setInterval(() => usageStore.refreshSafely(), POLL_INTERVAL_MS);
+  } catch {
+  }
+  try {
+    api.lifecycle.onDispose(() => {
+      if (pollTimer !== null) {
+        try {
+          clearInterval(pollTimer);
+        } catch {
+        }
+      }
+      for (const teardown of [unsubscribeSession, unsubscribeMessage, unregisterToggleCommand]) {
+        try {
+          teardown();
+        } catch {
+        }
+      }
+    });
+  } catch {
+    if (pollTimer !== null) {
+      try {
+        clearInterval(pollTimer);
+      } catch {
+      }
+    }
+  }
+  await usageStore.refresh();
+}
+var goUsageTui = async (api, options) => {
+  try {
+    await initializeTui(api, options);
+  } catch (error) {
+    void logUsageError(
+      api,
+      `Go usage TUI failed to initialize: ${errorMessage(error)}; continuing without display`
+    );
+  }
+};
+var tui_default = { id: "oc-go-usage-display", tui: goUsageTui };
+export {
+  tui_default as default
+};