oc-go-usage-display 1.0.2 → 2.0.0

package/dist/plugins/oc-go-usage-display.kilo.ts

@@ -0,0 +1,678 @@
+// oc-go-usage-display: kilo server plugin bundle (self-contained)
+
+// src/index.ts
+import { tool } from "@kilocode/plugin";
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+
+// src/helpers.ts
+import * as fs2 from "node:fs";
+
+// 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();
+}
+function resolveUsageHost() {
+  return true ? "kilo" : "opencode";
+}
+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 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 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
+  };
+}
+
+// src/helpers.ts
+function formatWindow(window) {
+  if (!window) return "n/a";
+  return `${window.percent}%`;
+}
+function formatServerLine(snapshot) {
+  if (snapshot.apiUnavailable || !snapshot.rolling && !snapshot.weekly && !snapshot.monthly) {
+    const reason = snapshot.apiError ?? "unknown error";
+    return `Go n/a (${reason})`;
+  }
+  const rollingReset = formatResetDuration(snapshot.rolling?.resetInSec ?? null) ?? snapshot.rolling?.resetText ?? null;
+  const rollingText = snapshot.rolling === null ? "5h n/a" : `5h ${snapshot.rolling.percent}%${rollingReset ? ` (reset ${rollingReset})` : ""}`;
+  return `Go ${rollingText} | 7d ${formatWindow(snapshot.weekly)} | 30d ${formatWindow(snapshot.monthly)}`;
+}
+function fileConfigPath(host = "opencode") {
+  return safeJoinPath(resolveHostRoots(host).configDir, "oc-go-usage-display.json");
+}
+function readFileConfig(host = "opencode") {
+  let raw;
+  try {
+    raw = fs2.readFileSync(fileConfigPath(host), "utf8");
+  } catch {
+    return { workspaceId: null, authCookie: null };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { workspaceId: null, authCookie: null };
+  }
+  if (!isRecord(parsed)) return { workspaceId: null, authCookie: null };
+  return {
+    workspaceId: toNonEmptyString(parsed.workspaceId),
+    authCookie: toNonEmptyString(parsed.authCookie)
+  };
+}
+function isMalformedAuthCookie(cookie) {
+  return /[\r\n;,\t\0"]/.test(cookie);
+}
+function hasMalformedAuthCookie(fileConfig = readFileConfig(), host = resolveUsageHost()) {
+  const raw = toNonEmptyString(hostEnv(host, "AUTH_COOKIE")) ?? fileConfig.authCookie;
+  if (!raw) return false;
+  return isMalformedAuthCookie(raw);
+}
+var ALLOWED_REDIRECT_HOSTS = /* @__PURE__ */ new Set(["opencode.ai", "auth.opencode.ai"]);
+var MAX_REDIRECT_HOPS = 3;
+function isAllowedHttpsUrl(url) {
+  return url.protocol === "https:" && url.username === "" && url.password === "" && url.port === "" && ALLOWED_REDIRECT_HOSTS.has(url.hostname);
+}
+function resolveRedirectUrl(fromUrl, location) {
+  let base;
+  try {
+    base = new URL(fromUrl);
+  } catch {
+    return null;
+  }
+  if (!isAllowedHttpsUrl(base)) return null;
+  let next;
+  try {
+    next = new URL(location, base);
+  } catch {
+    return null;
+  }
+  return isAllowedHttpsUrl(next) ? next : null;
+}
+function redirectTargetHost(fromUrl, location) {
+  try {
+    const host = new URL(location, fromUrl).host;
+    return host.length > 0 ? host : null;
+  } catch {
+    return null;
+  }
+}
+function resolveAllowedRedirect(fromUrl, location, hopsFollowed) {
+  if (hopsFollowed >= MAX_REDIRECT_HOPS) {
+    return { follow: false, reason: `too many redirects (limit ${MAX_REDIRECT_HOPS})` };
+  }
+  if (location === null || location.trim().length === 0) {
+    return { follow: false, reason: "redirect without a Location header" };
+  }
+  const next = resolveRedirectUrl(fromUrl, location);
+  if (next === null) {
+    const host = redirectTargetHost(fromUrl, location);
+    return {
+      follow: false,
+      reason: `redirect blocked (target not allowed${host ? `: ${host}` : ""})`
+    };
+  }
+  return { follow: true, url: next.toString() };
+}
+var COUNT_FORMAT = new Intl.NumberFormat("en-US");
+var CURRENCY_FORMAT = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+
+// src/index.ts
+var API_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+var CACHE_TTL_MS = 6e4;
+var FETCH_TIMEOUT_MS = 1e4;
+var WINDOW_KEYS = ["rolling", "weekly", "monthly"];
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var HOST = resolveUsageHost();
+var DISK_CACHE_PATH = safeJoinPath(
+  resolveHostRoots(HOST).configDir,
+  "oc-go-usage-display-cache.json"
+);
+function resolveCredentials(fileConfig = readFileConfig(HOST)) {
+  if (hostEnv(HOST, "MOCK") === "1") return { kind: "mock" };
+  const apiKey = toNonEmptyString(hostEnv(HOST, "API_KEY"));
+  if (apiKey) return { kind: "apiKey", apiKey };
+  const authJsonKey = readAuthJsonApiKey(HOST);
+  if (authJsonKey) return { kind: "apiKey", apiKey: authJsonKey };
+  const workspaceId = toNonEmptyString(hostEnv(HOST, "WORKSPACE_ID")) ?? fileConfig.workspaceId;
+  const authCookie = toNonEmptyString(hostEnv(HOST, "AUTH_COOKIE")) ?? fileConfig.authCookie;
+  if (workspaceId && authCookie) {
+    if (isMalformedAuthCookie(authCookie)) return { kind: "none" };
+    return { kind: "cookie", workspaceId, authCookie };
+  }
+  return { kind: "none" };
+}
+var memoryCache = null;
+function isFresh(at, now) {
+  return at <= now && now - at < CACHE_TTL_MS;
+}
+function readDiskCache(now) {
+  let raw;
+  try {
+    raw = fs3.readFileSync(DISK_CACHE_PATH, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) return null;
+  const at = toFiniteNumber(parsed.at);
+  if (at === null || !isFresh(at, now)) return null;
+  if (!isRecord(parsed.snapshot)) return null;
+  const snapshot = parsed.snapshot;
+  if (!("rolling" in snapshot && "weekly" in snapshot && "monthly" in snapshot)) return null;
+  const windows = {
+    rolling: null,
+    weekly: null,
+    monthly: null
+  };
+  for (const key of WINDOW_KEYS) {
+    const cachedWindow = snapshot[key];
+    if (cachedWindow === null) continue;
+    const window = extractWindow(cachedWindow);
+    if (window === null) return null;
+    windows[key] = window;
+  }
+  return { ...snapshot, ...windows };
+}
+function writeDiskCache(snapshot) {
+  try {
+    fs3.mkdirSync(path2.dirname(DISK_CACHE_PATH), { recursive: true });
+    fs3.writeFileSync(
+      DISK_CACHE_PATH,
+      JSON.stringify({ at: Date.now(), snapshot }),
+      "utf8"
+    );
+  } catch {
+  }
+}
+async function fetchWithTimeout(url, init, read) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    return await read(response, controller.signal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchViaApiKey(apiKey) {
+  try {
+    return await fetchWithTimeout(
+      API_USAGE_URL,
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: "application/json"
+        }
+      },
+      async (response, signal) => {
+        if (response.status === 401 || response.status === 403) {
+          return unavailableSnapshot("API key rejected (401/403)");
+        }
+        if (!response.ok) {
+          return unavailableSnapshot(`upstream returned HTTP ${response.status}`);
+        }
+        let payload;
+        try {
+          payload = await response.json();
+        } catch {
+          return unavailableSnapshot(
+            signal.aborted ? "request failed" : "unexpected API response shape"
+          );
+        }
+        return extractSnapshotFromApiPayload(payload) ?? unavailableSnapshot("unexpected API response shape");
+      }
+    );
+  } catch {
+    return unavailableSnapshot("request failed");
+  }
+}
+var USAGE_KEYS = {
+  rolling: "rollingUsage",
+  weekly: "weeklyUsage",
+  monthly: "monthlyUsage"
+};
+var DOM_ORDER = ["rolling", "weekly", "monthly"];
+var LOGIN_TITLE_MARKER = "<title>OpenAuth</title>";
+function isLoginPage(finalUrl, html) {
+  let host = "";
+  let pathname = "";
+  try {
+    const parsed = new URL(finalUrl);
+    host = parsed.hostname;
+    pathname = parsed.pathname;
+  } catch {
+  }
+  if (host === "auth.opencode.ai") return true;
+  if (host === "opencode.ai" && pathname.startsWith("/auth")) return true;
+  return html.includes(LOGIN_TITLE_MARKER);
+}
+function isNoSubscription(html) {
+  if (!html.includes('data-slot="subscribe-button"')) return false;
+  return /lite\s*:\s*null/.test(html) && /liteSubscriptionID\s*:\s*null/.test(html);
+}
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractUsageBlock(html, key) {
+  const pattern = new RegExp(`${escapeRegex(key)}\\s*:\\s*(?:\\$R\\[\\d+\\]\\s*=\\s*)?\\{`);
+  const match = pattern.exec(html);
+  if (!match || match.index === void 0) return null;
+  const braceStart = match.index + match[0].length - 1;
+  let depth = 0;
+  for (let i = braceStart; i < html.length; i++) {
+    if (html[i] === "{") depth += 1;
+    else if (html[i] === "}") {
+      depth -= 1;
+      if (depth === 0) return html.slice(braceStart, i + 1);
+    }
+  }
+  return null;
+}
+function parseIntField(block, field) {
+  const match = new RegExp(`${escapeRegex(field)}\\s*:\\s*(-?\\d+)`).exec(block);
+  const digits = match?.[1];
+  return digits === void 0 ? null : Number.parseInt(digits, 10);
+}
+function parseStrField(block, field) {
+  const match = new RegExp(`${escapeRegex(field)}\\s*:\\s*"([^"]*)"`).exec(block);
+  return match?.[1] ?? null;
+}
+function parseInlineUsage(html) {
+  const result = {};
+  for (const [name, key] of Object.entries(USAGE_KEYS)) {
+    const window = name;
+    const block = extractUsageBlock(html, key);
+    if (!block) continue;
+    const percent = parseIntField(block, "usagePercent");
+    if (percent === null) continue;
+    const status = parseStrField(block, "status");
+    result[window] = {
+      percent,
+      status,
+      limited: isLimitedStatus(status),
+      resetInSec: parseIntField(block, "resetInSec"),
+      resetText: null
+    };
+  }
+  return result;
+}
+function cleanResetText(raw) {
+  const cleaned = raw.replace(/<!--[\s\S]*?-->/g, "").replace(/\s+/g, " ").trim();
+  return cleaned || null;
+}
+function parseDomUsage(html) {
+  const result = {};
+  const itemStarts = [];
+  for (const match of html.matchAll(/data-slot="usage-item"/g)) {
+    if (match.index !== void 0) itemStarts.push(match.index);
+  }
+  for (let idx = 0; idx < DOM_ORDER.length; idx++) {
+    const window = DOM_ORDER[idx];
+    const start = itemStarts[idx];
+    if (window === void 0 || start === void 0) break;
+    const nextStart = itemStarts[idx + 1];
+    const segment = html.slice(start, nextStart !== void 0 ? nextStart : start + 800);
+    const valueMatch = /data-slot="usage-value">\s*(?:<!--[\s\S]*?-->)?\s*(\d+)/s.exec(segment) ?? /width:\s*(\d+)%/.exec(segment);
+    const percent = valueMatch?.[1];
+    if (percent === void 0) continue;
+    const resetMatch = /data-slot="reset-time">\s*([\s\S]*?)<\/span>/.exec(segment);
+    const resetText = resetMatch?.[1];
+    result[window] = {
+      percent: Number.parseInt(percent, 10),
+      status: null,
+      limited: false,
+      resetInSec: null,
+      resetText: resetText !== void 0 ? cleanResetText(resetText) : null
+    };
+  }
+  return result;
+}
+function parseScrapedUsage(html) {
+  const inline = parseInlineUsage(html);
+  if (Object.keys(inline).length === 3) return inline;
+  return { ...parseDomUsage(html), ...inline };
+}
+async function fetchViaCookie(workspaceId, authCookie) {
+  const workspaceUrl = `https://opencode.ai/workspace/${encodeURIComponent(workspaceId)}/go`;
+  let currentUrl = workspaceUrl;
+  let hopsFollowed = 0;
+  for (; ; ) {
+    let hop;
+    try {
+      hop = await fetchWithTimeout(
+        currentUrl,
+        {
+          redirect: "manual",
+          headers: {
+            Cookie: `auth=${authCookie}`,
+            "User-Agent": "oc-go-usage-display-plugin",
+            Accept: "text/html,application/xhtml+xml"
+          }
+        },
+        async (response) => {
+          if (REDIRECT_STATUSES.has(response.status)) {
+            return { kind: "redirect", location: response.headers.get("location") };
+          }
+          return { kind: "body", status: response.status, html: await response.text() };
+        }
+      );
+    } catch {
+      return unavailableSnapshot("request failed");
+    }
+    if (hop.kind === "redirect") {
+      const decision = resolveAllowedRedirect(currentUrl, hop.location, hopsFollowed);
+      if (!decision.follow) return unavailableSnapshot(decision.reason);
+      currentUrl = decision.url;
+      hopsFollowed += 1;
+      continue;
+    }
+    const { status, html } = hop;
+    if (isLoginPage(currentUrl, html)) {
+      return unavailableSnapshot("login expired (refresh auth cookie)");
+    }
+    if (status !== 200) {
+      return unavailableSnapshot(`upstream returned HTTP ${status}`);
+    }
+    const usages = parseScrapedUsage(html);
+    if (Object.keys(usages).length === 0) {
+      if (isNoSubscription(html)) return unavailableSnapshot("no OpenCode Go subscription");
+      return unavailableSnapshot("usage markup not recognized");
+    }
+    return {
+      rolling: usages.rolling ?? null,
+      weekly: usages.weekly ?? null,
+      monthly: usages.monthly ?? null,
+      source: "scrape",
+      fetchedAt: Date.now()
+    };
+  }
+}
+async function getUsageSnapshot() {
+  const now = Date.now();
+  if (hostEnv(HOST, "MOCK") === "1") {
+    return mockSnapshot();
+  }
+  if (memoryCache && isFresh(memoryCache.at, now)) return memoryCache.snapshot;
+  const diskCached = readDiskCache(now);
+  if (diskCached) {
+    memoryCache = { at: now, snapshot: diskCached };
+    return diskCached;
+  }
+  const fileConfig = readFileConfig(HOST);
+  const credentials = resolveCredentials(fileConfig);
+  if (credentials.kind === "mock") {
+    return mockSnapshot();
+  }
+  if (credentials.kind === "none") {
+    const workspaceId = toNonEmptyString(hostEnv(HOST, "WORKSPACE_ID")) ?? fileConfig.workspaceId;
+    if (workspaceId && hasMalformedAuthCookie(fileConfig)) {
+      return unavailableSnapshot("not configured (malformed auth cookie)");
+    }
+    return unavailableSnapshot(`not configured (set ${hostEnvName(HOST, "API_KEY")})`);
+  }
+  const snapshot = credentials.kind === "apiKey" ? await fetchViaApiKey(credentials.apiKey) : await fetchViaCookie(credentials.workspaceId, credentials.authCookie);
+  if (!snapshot.apiUnavailable) {
+    memoryCache = { at: now, snapshot };
+    writeDiskCache(snapshot);
+  }
+  return snapshot;
+}
+function sanitizeHooks(hooks) {
+  if (!isRecord(hooks)) return {};
+  const clean = {};
+  for (const [key, value] of Object.entries(hooks)) {
+    if (value === null || value === void 0) continue;
+    if (key === "tool" && isRecord(value)) {
+      const tools = {};
+      for (const [name, definition] of Object.entries(value)) {
+        if (definition === null || definition === void 0) continue;
+        tools[name] = definition;
+      }
+      clean[key] = tools;
+      continue;
+    }
+    clean[key] = value;
+  }
+  return clean;
+}
+async function logServerError(input, message) {
+  try {
+    const client = input?.client;
+    await client?.app?.log?.({
+      service: "oc-go-usage-display",
+      level: "error",
+      message
+    });
+  } catch {
+  }
+}
+var server = async (input, _options) => {
+  try {
+    return sanitizeHooks({
+      tool: {
+        go_usage: tool({
+          description: "Show OpenCode Go subscription usage: rolling 5h, weekly, and monthly windows. Takes no arguments.",
+          args: {},
+          execute: async () => {
+            try {
+              const snapshot = await getUsageSnapshot().catch(
+                () => unavailableSnapshot("request failed")
+              );
+              const line = formatServerLine(snapshot);
+              return `${line}
+${JSON.stringify(snapshot, null, 2)}`;
+            } catch (error) {
+              const snapshot = unavailableSnapshot("request failed");
+              void logServerError(
+                input,
+                `go_usage tool execution failed: ${errorMessage(error)}`
+              );
+              return `${formatServerLine(snapshot)}
+${JSON.stringify(snapshot, null, 2)}`;
+            }
+          }
+        })
+      }
+    });
+  } catch (error) {
+    void logServerError(
+      input,
+      `Go usage plugin failed to initialize: ${errorMessage(error)}; continuing without hooks`
+    );
+    return {};
+  }
+};
+var index_default = { id: "oc-go-usage-display", server };
+export {
+  index_default as default
+};