@gururea/opencode-commandcode-provider 0.1.0 → 0.2.1

package/README.md

@@ -1,4 +1,4 @@
-# opencode-commandcode
+# @gururea/opencode-commandcode-provider
 
 An [opencode](https://opencode.ai) plugin that adds the [Command Code](https://commandcode.ai) provider to the interface and its authentication to the `/connect` dialog.
 
@@ -11,7 +11,7 @@ Add the plugin to your `opencode.json`:
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-commandcode"]
+  "plugin": ["@gururea/opencode-commandcode-provider"]
 }
 ```
 
@@ -25,12 +25,17 @@ Restart opencode, then:
 
 ## What the plugin does
 
-- **Registers the provider.** The plugin injects a `commandcode` custom provider into the opencode config (`@ai-sdk/openai-compatible`, base URL `https://api.commandcode.ai/provider/v1`). The model catalog is fetched live from the Provider API at startup; if the endpoint is unreachable, a built-in fallback catalog is used so the provider still appears.
+- **Registers the provider.** The plugin injects a `commandcode` custom provider into the opencode config (`@ai-sdk/openai-compatible`, base URL `https://api.commandcode.ai/provider/v1`).
+- **Live model discovery with caching.** The catalog is fetched from the Provider API at every startup. A successful fetch is cached to disk (`~/.cache/opencode/commandcode-models.json`) so the next start is fast and works offline; if both the endpoint and the cache are unavailable, a built-in fallback catalog keeps the provider visible.
 - **Adds authentication.** The `/connect` dialog gets two methods via the plugin `auth` hook:
   - **Browser login:** opens `commandcode.ai/studio/auth/cli` and receives the API key through a local callback server (fall back to pasting the key if the transfer fails).
   - **API key:** the standard key-paste dialog.
+- **`commandcode_quota` tool / `/commandcode-quota`.** Reports your account usage and quota: remaining and used credits, plan, billing-period usage (cost, requests, tokens), and the 5-hour and weekly usage windows.
+- **`commandcode_status` tool / `/commandcode-status`.** Shows plugin diagnostics: catalog source (live/cache/fallback), model count, last fetch time, endpoint, zero-data-retention setting, and version.
 - Command Code API keys (`user_...`) do not expire, so they are stored once and reused.
 
+> The plugin installs the `commandcode-quota.md` and `commandcode-status.md` slash-command files into your project's `.opencode/command/` directory on startup, so the `/commandcode-quota` and `/commandcode-status` commands appear in the TUI autocomplete. The commands invoke the corresponding tools registered by the plugin.
+
 ## Environment variables
 
 | Variable | Purpose |
@@ -38,6 +43,8 @@ Restart opencode, then:
 | `COMMAND_CODE_API_KEY` / `COMMANDCODE_API_KEY` | API key used as a fallback when no auth is stored via `/connect` |
 | `COMMANDCODE_API_BASE` | Override the provider API base URL (default `https://api.commandcode.ai/provider/v1`) |
 | `COMMANDCODE_MODELS_URL` | Override the model catalog URL (default `<api base>/models`) |
+| `COMMANDCODE_MODELS_CACHE` | Override the model cache path (default `~/.cache/opencode/commandcode-models.json`) |
+| `COMMANDCODE_MODELS_TIMEOUT_MS` | Model catalog fetch timeout (default `10000` ms) |
 | `CMD_ZDR=1` / `COMMANDCODE_ZDR=1` | Send the `x-cmd-zdr: 1` zero-data-retention header |
 
 ## Scope

package/command/commandcode-quota.md

@@ -0,0 +1,5 @@
+---
+description: Show Command Code account usage and quota (credits, plan, usage)
+---
+
+Use the **commandcode_quota** tool to fetch and report the user's Command Code account usage and quota. Summarize the credits remaining and used, the plan, the billing-period usage (cost, requests, tokens), and the 5-hour and weekly usage windows. If no API key is configured, tell the user to run `/connect` and select Command Code.

package/command/commandcode-status.md

@@ -0,0 +1,5 @@
+---
+description: Show Command Code plugin diagnostics (catalog source, model count, endpoint)
+---
+
+Use the **commandcode_status** tool to fetch and report the Command Code plugin diagnostics: the model catalog source (live/cache/fallback), model count, when the catalog was last fetched, the API endpoint, the zero-data-retention setting, and the plugin version.

package/dist/index.js

@@ -1,3 +1,7 @@
+// src/index.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
 // src/auth.ts
 import { randomBytes } from "crypto";
 
@@ -233,10 +237,554 @@ function createAuthHook(options = {}) {
   };
 }
 
+// src/commands.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var QUOTA_TEMPLATE = `---
+description: Show Command Code account usage and quota (credits, plan, usage)
+---
+
+Use the **commandcode_quota** tool to fetch and report the user's Command Code account usage and quota. Summarize the credits remaining and used, the plan, the billing-period usage (cost, requests, tokens), and the 5-hour and weekly usage windows. If no API key is configured, tell the user to run \`/connect\` and select Command Code.
+`;
+var STATUS_TEMPLATE = `---
+description: Show Command Code plugin diagnostics (catalog source, model count, endpoint)
+---
+
+Use the **commandcode_status** tool to fetch and report the Command Code plugin diagnostics: the model catalog source (live/cache/fallback), model count, when the catalog was last fetched, the API endpoint, the zero-data-retention setting, and the plugin version.
+`;
+var COMMANDS = [
+  { name: "commandcode-quota.md", content: QUOTA_TEMPLATE },
+  { name: "commandcode-status.md", content: STATUS_TEMPLATE }
+];
+async function installCommandFiles(directory) {
+  if (!directory) return;
+  const commandDir = join(directory, ".opencode", "command");
+  await mkdir(commandDir, { recursive: true });
+  for (const command of COMMANDS) {
+    const target = join(commandDir, command.name);
+    try {
+      const existing = await readFile(target, "utf-8");
+      if (existing === command.content) continue;
+      return;
+    } catch {
+    }
+    await writeFile(target, command.content, "utf-8");
+  }
+}
+
+// src/quota-tool.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/api-key.ts
+import { existsSync, readFileSync } from "fs";
+var PROVIDER_ID = "commandcode";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function authKey(record) {
+  const type = record.type;
+  if (type === "api") return typeof record.key === "string" ? record.key : void 0;
+  if (type === "oauth") return typeof record.access === "string" ? record.access : void 0;
+  if (type === "wellknown") {
+    return typeof record.token === "string" ? record.token : typeof record.key === "string" ? record.key : void 0;
+  }
+  return void 0;
+}
+function credentialFromAuthJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) return void 0;
+    const entry = parsed[PROVIDER_ID];
+    if (!isRecord(entry)) return void 0;
+    return authKey(entry);
+  } catch {
+    return void 0;
+  }
+}
+function defaultAuthPath() {
+  return `${process.env.HOME ?? ""}/.local/share/opencode/auth.json`;
+}
+function readCommandCodeKey(options = {}) {
+  const env = options.env ?? process.env;
+  if (env.COMMAND_CODE_API_KEY) return env.COMMAND_CODE_API_KEY;
+  if (env.COMMANDCODE_API_KEY) return env.COMMANDCODE_API_KEY;
+  const authContent = options.authContent ?? env.OPENCODE_AUTH_CONTENT;
+  if (authContent) {
+    const fromContent = credentialFromAuthJson(authContent);
+    if (fromContent) return fromContent;
+  }
+  const authPath = options.authPath ?? defaultAuthPath();
+  try {
+    if (!existsSync(authPath)) return void 0;
+    const raw = readFileSync(authPath, "utf-8");
+    return credentialFromAuthJson(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/redact.ts
+function redactBearer(value) {
+  return value.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]");
+}
+function redactCredentials(value) {
+  return value.replace(
+    /\b(?:api[-_ ]?key|apikey|access[-_ ]?token|refresh[-_ ]?token|token|secret|password|authorization)\s*[=:]\s*[^\s,;&)]+/gi,
+    (match) => {
+      const separatorIndex = match.search(/[=:]/);
+      return separatorIndex < 0 ? "[redacted]" : `${match.slice(0, separatorIndex + 1)}[redacted]`;
+    }
+  );
+}
+function redactUserTokens(value) {
+  return value.replace(/\b(?:user|cc)_[A-Za-z0-9_-]{8,}\b/gi, "[redacted]");
+}
+function redactQuerySecrets(value) {
+  return value.replace(
+    /([?&](?:api[-_ ]?key|apikey|access_token|refresh_token|token|secret|password)=)[^&#\s]+/gi,
+    "$1[redacted]"
+  );
+}
+function redactStandaloneSecrets(value) {
+  return value.replace(
+    /\b(?:sk|rk|ghp|github_pat|xox[baprs])[-_A-Za-z0-9]{16,}\b|\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    "[redacted]"
+  );
+}
+function redactCommandCodeErrorText(value) {
+  return redactStandaloneSecrets(
+    redactQuerySecrets(redactUserTokens(redactCredentials(redactBearer(value))))
+  );
+}
+
+// src/quota.ts
+var DEFAULT_API_BASE = "https://api.commandcode.ai";
+var QUOTA_TIMEOUT_MS = 15e3;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function normalizeResetAt(value) {
+  let timestamp;
+  if (typeof value === "number" && Number.isFinite(value)) timestamp = value;
+  if (typeof value === "string" && value.length > 0) {
+    const trimmed = value.trim();
+    timestamp = /^\d+$/.test(trimmed) ? Number(trimmed) : Date.parse(trimmed);
+  }
+  if (timestamp === void 0 || !Number.isFinite(timestamp) || timestamp < 0) return null;
+  return timestamp >= 1e12 ? Math.round(timestamp / 1e3) : timestamp;
+}
+function windowLimitsFromCredits(value) {
+  if (!isRecord2(value)) return [];
+  const limits = [];
+  for (const [window, entry] of [
+    ["fiveHour", value.fiveHour],
+    ["weekly", value.weekly]
+  ]) {
+    if (!isRecord2(entry)) continue;
+    const used = numberValue(entry.used);
+    const cap = numberValue(entry.cap);
+    if (used === void 0 || cap === void 0 || used === 0 && cap === 0) continue;
+    limits.push({ window, used, cap, resetAt: normalizeResetAt(entry.resetAt) });
+  }
+  return limits;
+}
+function parseCredits(value) {
+  if (!isRecord2(value) || !isRecord2(value.credits)) return null;
+  const credits = value.credits;
+  const monthlyCredits = numberValue(credits.monthlyCredits);
+  const purchasedCredits = numberValue(credits.purchasedCredits);
+  const freeCredits = numberValue(credits.freeCredits);
+  if (monthlyCredits === void 0 && purchasedCredits === void 0 && freeCredits === void 0) {
+    return null;
+  }
+  const monthly = monthlyCredits ?? 0;
+  const purchased = purchasedCredits ?? 0;
+  const free = freeCredits ?? 0;
+  return {
+    monthlyCredits: monthly,
+    purchasedCredits: purchased,
+    freeCredits: free,
+    remainingCredits: monthly + purchased + free,
+    windowLimits: windowLimitsFromCredits(value.windowLimits)
+  };
+}
+function parseSubscription(value) {
+  if (!isRecord2(value) || !isRecord2(value.data)) return null;
+  const data = value.data;
+  const planId = stringValue(data.planId);
+  const status = stringValue(data.status);
+  const currentPeriodStart = stringValue(data.currentPeriodStart);
+  const currentPeriodEnd = stringValue(data.currentPeriodEnd);
+  if (!planId && !status && !currentPeriodStart && !currentPeriodEnd) return null;
+  return {
+    planId: planId ?? null,
+    status: status ?? null,
+    currentPeriodStart: currentPeriodStart ?? null,
+    currentPeriodEnd: currentPeriodEnd ?? null
+  };
+}
+function parseSummary(value) {
+  if (!isRecord2(value)) return null;
+  const totalCost = numberValue(value.totalCost);
+  const totalCount = numberValue(value.totalCount);
+  if (totalCost === void 0 || totalCount === void 0) return null;
+  const totalTokens = numberValue(value.totalTokens) ?? numberValue(value.tokens);
+  return { totalCost, totalCount, ...totalTokens === void 0 ? {} : { totalTokens } };
+}
+function parseWhoami(value) {
+  if (!isRecord2(value)) return null;
+  const org = isRecord2(value.org) ? value.org : void 0;
+  const user = isRecord2(value.user) ? value.user : void 0;
+  const login = (org ? stringValue(org.login) : void 0) ?? (user ? stringValue(user.userName) ?? stringValue(user.name) : void 0);
+  if (!login) return null;
+  const orgId = org ? stringValue(org.id) : void 0;
+  const keyName = user ? stringValue(user.keyName) ?? stringValue(user.displayName) : void 0;
+  return { login, orgId: orgId ?? null, ...keyName ? { keyName } : {} };
+}
+function buildUrl(path, params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value) search.set(key, value);
+  }
+  const query = search.toString();
+  return `${path}${query ? `?${query}` : ""}`;
+}
+function isHttpError(value) {
+  return isRecord2(value) && value.__httpError === true && typeof value.message === "string" && typeof value.status === "number" && typeof value.body === "string";
+}
+function isQuotaError(value) {
+  return isRecord2(value) && value.__quotaError === true && (value.kind === "timeout" || value.kind === "network");
+}
+function isBlockingHttpError(error) {
+  return error.status === 401 || error.status === 403;
+}
+function httpFailure(error, context) {
+  const detail = error.body.trim().slice(0, 200);
+  return {
+    ok: false,
+    error: {
+      kind: "http",
+      message: redactCommandCodeErrorText(
+        `${context} request failed (${error.status}): ${detail || error.message}`
+      )
+    }
+  };
+}
+var QuotaTimeoutError = class extends Error {
+};
+async function fetchCommandCodeQuota(options) {
+  if (!options.apiKey) {
+    return { ok: false, error: { message: "No Command Code API key found", kind: "config" } };
+  }
+  const baseUrl = options.baseUrl ?? DEFAULT_API_BASE;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? QUOTA_TIMEOUT_MS;
+  const overallController = new AbortController();
+  const overallTimer = setTimeout(() => overallController.abort(), timeoutMs);
+  const headers = {
+    accept: "application/json",
+    Authorization: `Bearer ${options.apiKey}`,
+    ...options.extraHeaders
+  };
+  const request = async (path) => {
+    if (overallController.signal.aborted) throw new QuotaTimeoutError();
+    try {
+      const response = await fetchImpl(`${baseUrl}${path}`, {
+        method: "GET",
+        headers,
+        signal: overallController.signal
+      });
+      if (!response.ok) {
+        return {
+          __httpError: true,
+          message: response.status === 401 || response.status === 403 ? "Command Code rejected the API key" : response.statusText,
+          status: response.status,
+          body: await response.text().catch(() => "")
+        };
+      }
+      return await response.json();
+    } catch (error) {
+      if (overallController.signal.aborted) throw new QuotaTimeoutError();
+      throw error;
+    }
+  };
+  const safeRequest = async (path) => {
+    try {
+      return await request(path);
+    } catch (error) {
+      return {
+        __quotaError: true,
+        kind: error instanceof QuotaTimeoutError ? "timeout" : "network"
+      };
+    }
+  };
+  try {
+    const whoamiRaw = await request("/alpha/whoami");
+    if (isHttpError(whoamiRaw)) return httpFailure(whoamiRaw, "whoami");
+    const account = parseWhoami(whoamiRaw);
+    if (!account) {
+      return {
+        ok: false,
+        error: { kind: "http", message: "Command Code returned an unrecognized account response" }
+      };
+    }
+    const orgId = account.orgId ?? void 0;
+    const [creditsRaw, subscriptionRaw] = await Promise.all([
+      safeRequest(buildUrl("/alpha/billing/credits", { orgId })),
+      safeRequest(buildUrl("/alpha/billing/subscriptions", { orgId }))
+    ]);
+    if (isHttpError(creditsRaw) && isBlockingHttpError(creditsRaw)) {
+      return httpFailure(creditsRaw, "credits");
+    }
+    if (isHttpError(subscriptionRaw) && isBlockingHttpError(subscriptionRaw)) {
+      return httpFailure(subscriptionRaw, "subscription");
+    }
+    const unavailable = [];
+    const credits = isHttpError(creditsRaw) || isQuotaError(creditsRaw) ? null : parseCredits(creditsRaw);
+    if (!credits) unavailable.push("credits");
+    const subscription = isHttpError(subscriptionRaw) || isQuotaError(subscriptionRaw) ? null : parseSubscription(subscriptionRaw);
+    if (!subscription) unavailable.push("subscription");
+    const summaryRaw = await safeRequest(
+      buildUrl("/alpha/usage/summary", {
+        orgId,
+        since: subscription?.currentPeriodStart ?? void 0
+      })
+    );
+    if (isHttpError(summaryRaw) && isBlockingHttpError(summaryRaw)) {
+      return httpFailure(summaryRaw, "summary");
+    }
+    const summary = isHttpError(summaryRaw) || isQuotaError(summaryRaw) ? null : parseSummary(summaryRaw);
+    if (!summary) unavailable.push("usage");
+    if (!credits && !subscription && !summary) {
+      return {
+        ok: false,
+        error: {
+          kind: overallController.signal.aborted ? "timeout" : "http",
+          message: overallController.signal.aborted ? "Command Code quota request timed out" : "Command Code returned no recognized usage data for the account"
+        }
+      };
+    }
+    return {
+      ok: true,
+      quota: {
+        account,
+        credits,
+        subscription,
+        summary,
+        ...unavailable.length > 0 ? { unavailable } : {}
+      }
+    };
+  } catch (error) {
+    if (error instanceof QuotaTimeoutError || overallController.signal.aborted) {
+      return {
+        ok: false,
+        error: { message: "Command Code quota request timed out", kind: "timeout" }
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        message: redactCommandCodeErrorText(
+          `Failed to fetch Command Code quota: ${errorMessage(error)}`
+        ),
+        kind: "network"
+      }
+    };
+  } finally {
+    clearTimeout(overallTimer);
+  }
+}
+
+// src/quota-format.ts
+function formatWindowLimits(limits, now = Date.now) {
+  const labels = {
+    fiveHour: "5-hour",
+    weekly: "Weekly"
+  };
+  return limits.map((limit) => {
+    const used = limit.used.toFixed(2);
+    const cap = limit.cap.toFixed(2);
+    const percent = limit.cap > 0 ? Math.round(limit.used / limit.cap * 100) : 0;
+    const reset = limit.resetAt === null ? "" : ` (resets ${formatResetClock(limit.resetAt, now)})`;
+    return `${labels[limit.window]}: ${used} / ${cap} credits (${percent}% used)${reset}`;
+  });
+}
+function formatResetClock(resetAtSeconds, now) {
+  const date = new Date(resetAtSeconds * 1e3);
+  if (Number.isNaN(date.getTime())) return "unknown";
+  const diffMs = date.getTime() - now();
+  if (diffMs <= 0) return "soon";
+  const minutes = Math.ceil(diffMs / 6e4);
+  if (minutes < 60) return `in ${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours < 24) {
+    return remainingMinutes > 0 ? `in ${hours}h ${remainingMinutes}m` : `in ${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  return days === 1 ? "in 1 day" : `in ${days} days`;
+}
+function creditsDetail(credits) {
+  if (!credits) return void 0;
+  const parts = [
+    `monthly $${credits.monthlyCredits.toFixed(2)}`,
+    `purchased $${credits.purchasedCredits.toFixed(2)}`
+  ];
+  if (credits.freeCredits > 0) parts.push(`free $${credits.freeCredits.toFixed(2)}`);
+  return `Sources: ${parts.join(" / ")}`;
+}
+function subscriptionLine(subscription) {
+  const plan = (subscription.planId ?? "Unknown").replace(/[_-]+/g, " ").trim();
+  const status = subscription.status ? ` (${subscription.status})` : "";
+  return `Plan: ${plan}${status}`;
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e9) return `${(tokens / 1e9).toFixed(1)}B`;
+  if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+  if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(1)}k`;
+  return String(tokens);
+}
+function formatQuota(quota, now = Date.now) {
+  const lines = [];
+  const remaining = quota.credits?.remainingCredits ?? 0;
+  const spent = quota.summary?.totalCost ?? 0;
+  const pool = remaining + spent;
+  if (quota.credits || quota.summary) {
+    lines.push("Credits");
+    lines.push(`  Remaining: $${remaining.toFixed(2)} of $${pool.toFixed(2)}`);
+    lines.push(`  Used: $${spent.toFixed(2)}`);
+    lines.push(`  ${pool > 0 ? Math.round(spent / pool * 100) : 0}% used`);
+  }
+  const detail = creditsDetail(quota.credits);
+  if (detail) lines.push(detail);
+  if (quota.subscription) lines.push(subscriptionLine(quota.subscription));
+  if (quota.summary) {
+    lines.push("");
+    lines.push(quota.subscription?.currentPeriodStart ? "Usage (billing period)" : "Usage");
+    lines.push(`  Cost: $${quota.summary.totalCost.toFixed(2)}`);
+    lines.push(`  Requests: ${quota.summary.totalCount.toLocaleString("en-US")}`);
+    if (quota.summary.totalTokens !== void 0) {
+      lines.push(`  Tokens: ${formatTokens(quota.summary.totalTokens)}`);
+    }
+  }
+  lines.push("");
+  lines.push("Account");
+  lines.push(`  ${quota.account.keyName ?? quota.account.login}`);
+  const limits = quota.credits?.windowLimits ?? [];
+  if (limits.length > 0) {
+    lines.push("");
+    lines.push("Usage windows:");
+    lines.push(...formatWindowLimits(limits, now).map((line) => `  ${line}`));
+  }
+  if ((quota.unavailable?.length ?? 0) > 0) {
+    lines.push("");
+    lines.push(`Unavailable: ${quota.unavailable?.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("Full detail: https://commandcode.ai/usage");
+  return lines.join("\n");
+}
+
+// src/quota-tool.ts
+function createQuotaTool({ apiBase, extraHeaders, client, readKey }) {
+  const resolveKey = readKey ?? readCommandCodeKey;
+  const showToast = (message, variant) => {
+    client.tui.showToast({ body: { message, variant } }).catch(() => {
+    });
+  };
+  return {
+    commandcode_quota: tool({
+      description: "Show the user's Command Code account usage and quota: remaining and used credits, plan, billing-period usage, and usage windows.",
+      args: {},
+      async execute() {
+        const apiKey = resolveKey();
+        if (!apiKey) {
+          showToast(
+            "Command Code quota needs an API key. Run /connect and select Command Code.",
+            "error"
+          );
+          return {
+            title: "Command Code quota",
+            output: "No Command Code API key found. Run /connect and authenticate first."
+          };
+        }
+        const result = await fetchCommandCodeQuota({
+          apiKey,
+          baseUrl: apiBase,
+          extraHeaders
+        });
+        if (!result.ok) {
+          showToast(result.error.message, "error");
+          return { title: "Command Code quota", output: result.error.message };
+        }
+        const output = formatQuota(result.quota);
+        showToast("Command Code quota loaded.", "success");
+        return { title: "Command Code quota", output };
+      }
+    })
+  };
+}
+
+// src/status-tool.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+
+// src/status.ts
+function formatStatus(input) {
+  const lines = [
+    "Command Code plugin status",
+    `  Source: ${input.source}`,
+    `  Models: ${input.modelCount}`,
+    `  Fetched: ${input.fetchedAt === void 0 ? "n/a" : new Date(input.fetchedAt).toISOString()}`,
+    `  Endpoint: ${input.apiBase}`,
+    `  Zero-data-retention: ${input.zdr ? "on" : "off"}`,
+    `  Version: ${input.version}`
+  ];
+  return lines.join("\n");
+}
+
+// src/status-tool.ts
+function createStatusTool({
+  apiBase,
+  zdr,
+  version,
+  modelsInfo
+}) {
+  return {
+    commandcode_status: tool2({
+      description: "Show Command Code plugin diagnostics: the model catalog source (live/cache/fallback), model count, cache time, endpoint, and zero-data-retention setting.",
+      args: {},
+      async execute() {
+        const output = formatStatus({
+          source: modelsInfo.source,
+          modelCount: modelsInfo.modelCount,
+          fetchedAt: modelsInfo.fetchedAt,
+          apiBase,
+          zdr,
+          version
+        });
+        return { title: "Command Code status", output };
+      }
+    })
+  };
+}
+
 // src/models.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
 var DEFAULT_PROVIDER_API_BASE = "https://api.commandcode.ai/provider/v1";
 var DEFAULT_MODELS_URL = `${DEFAULT_PROVIDER_API_BASE}/models`;
 var DEFAULT_MODELS_TIMEOUT_MS = 1e4;
+var DEFAULT_MODELS_TTL_MS = 24 * 60 * 60 * 1e3;
+var MODEL_CACHE_VERSION = 1;
 var DEFAULT_MAX_OUTPUT_TOKENS = 65536;
 var ZERO_MODEL_COST = {
   input: 0,
@@ -327,10 +875,10 @@ var MODEL_COSTS = {
 function modelCost(id) {
   return MODEL_COSTS[id] ?? ZERO_MODEL_COST;
 }
-function isOpenAiCompatibleModel(id) {
-  return !id.startsWith("claude-");
+function isAnthropicModel(id) {
+  return id.startsWith("claude-");
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(record, key) {
@@ -348,11 +896,11 @@ function positiveNumberField(record, key) {
   return value;
 }
 function commandCodeModelsFromApiResponse(value) {
-  if (!isRecord(value)) throw new Error("Expected models response to be an object");
+  if (!isRecord3(value)) throw new Error("Expected models response to be an object");
   if (value.object !== "list") throw new Error("Expected models response object to be 'list'");
   if (!Array.isArray(value.data)) throw new Error("Expected models response data to be an array");
   const models = value.data.map((entry) => {
-    if (!isRecord(entry)) throw new Error("Expected model entry to be an object");
+    if (!isRecord3(entry)) throw new Error("Expected model entry to be an object");
     return {
       id: stringField(entry, "id"),
       name: stringField(entry, "name"),
@@ -365,11 +913,11 @@ function commandCodeModelsFromApiResponse(value) {
 function outputLimitForModel(id, contextLength) {
   return Math.min(contextLength, DEFAULT_MAX_OUTPUT_TOKENS);
 }
-function toProviderModelMap(models) {
+function toProviderModelMap(models, providerBaseUrl2 = DEFAULT_PROVIDER_API_BASE) {
   const map = {};
   for (const model of models) {
-    if (!isOpenAiCompatibleModel(model.id)) continue;
     const cost = modelCost(model.id);
+    const anthropic = isAnthropicModel(model.id);
     map[model.id] = {
       name: model.name,
       limit: {
@@ -381,11 +929,15 @@ function toProviderModelMap(models) {
         output: cost.output,
         cache_read: cost.cacheRead,
         cache_write: cost.cacheWrite
-      }
+      },
+      ...anthropic ? { reasoning: true, provider: { npm: "@ai-sdk/anthropic", api: providerBaseUrl2 } } : {}
     };
   }
   return map;
 }
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 async function runWithTimeout(operation, timeoutMs, externalSignal) {
   const controller = new AbortController();
   let timer;
@@ -432,10 +984,110 @@ async function fetchCommandCodeModels(options = {}) {
   );
   return commandCodeModelsFromApiResponse(body);
 }
+function cacheIsFresh(cachedAt, now, ttlMs) {
+  return now - cachedAt < ttlMs;
+}
+function commandCodeModelsFromCache(value) {
+  if (!isRecord3(value)) throw new Error("Expected model cache to be an object");
+  if (value.version !== MODEL_CACHE_VERSION) {
+    throw new Error(`Expected model cache version ${MODEL_CACHE_VERSION}`);
+  }
+  if (!Array.isArray(value.models)) throw new Error("Expected cached models to be an array");
+  const models = value.models.map((entry) => {
+    if (!isRecord3(entry)) throw new Error("Expected cached model entry to be an object");
+    return {
+      id: stringField(entry, "id"),
+      name: stringField(entry, "name"),
+      contextLength: positiveNumberField(entry, "contextLength")
+    };
+  });
+  if (models.length === 0) throw new Error("Expected cached models to be non-empty");
+  return models;
+}
+async function readCommandCodeModelsCache(cachePath) {
+  const contents = await readFile2(cachePath, "utf-8");
+  return commandCodeModelsFromCache(JSON.parse(contents));
+}
+async function writeCommandCodeModelsCache(cachePath, models, fetchedAt = Date.now()) {
+  await mkdir2(dirname(cachePath), { recursive: true });
+  const temporaryPath = `${cachePath}.${process.pid}.tmp`;
+  try {
+    await writeFile2(
+      temporaryPath,
+      `${JSON.stringify({ version: MODEL_CACHE_VERSION, fetchedAt, models }, null, 2)}
+`,
+      { encoding: "utf-8", mode: 384 }
+    );
+    await rename(temporaryPath, cachePath);
+  } finally {
+    try {
+      await rm(temporaryPath, { force: true });
+    } catch {
+    }
+  }
+}
+async function loadCommandCodeModels(options) {
+  const cachePath = options.cachePath;
+  const ttlMs = options.ttlMs ?? DEFAULT_MODELS_TTL_MS;
+  const now = options.now ?? Date.now;
+  try {
+    const models = await fetchCommandCodeModels(options);
+    const fetchedAt = now();
+    try {
+      await writeCommandCodeModelsCache(cachePath, models, fetchedAt);
+      return { models, source: "live", fetchedAt };
+    } catch (error) {
+      return {
+        models,
+        source: "live",
+        fetchedAt,
+        warning: `Loaded the live Command Code model catalog but could not write the cache at ${cachePath}: ${errorMessage2(error)}`
+      };
+    }
+  } catch (liveError) {
+    if (options.signal?.aborted) throw liveError;
+    try {
+      const cachedAt = await cachedTimestamp(cachePath);
+      const models = await readCommandCodeModelsCache(cachePath);
+      const stale = cachedAt !== null && !cacheIsFresh(cachedAt, now(), ttlMs);
+      return {
+        models,
+        source: "cache",
+        fetchedAt: cachedAt ?? void 0,
+        warning: stale ? `Could not refresh the Command Code model catalog (${errorMessage2(liveError)}). Using a stale cached catalog from ${cachePath}.` : `Could not refresh the Command Code model catalog (${errorMessage2(liveError)}). Using the cached catalog from ${cachePath}.`
+      };
+    } catch (cacheError) {
+      const fallback = options.fallbackModels ?? [];
+      return {
+        models: fallback,
+        source: "fallback",
+        warning: `Could not refresh the Command Code model catalog (${errorMessage2(liveError)}) and no valid cached catalog is available at ${cachePath} (${errorMessage2(cacheError)}). Using the built-in fallback catalog.`
+      };
+    }
+  }
+}
+async function cachedTimestamp(cachePath) {
+  try {
+    const contents = await readFile2(cachePath, "utf-8");
+    const parsed = JSON.parse(contents);
+    if (!isRecord3(parsed)) return null;
+    return typeof parsed.fetchedAt === "number" && Number.isFinite(parsed.fetchedAt) ? parsed.fetchedAt : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/index.ts
-var PROVIDER_ID = "commandcode";
+var PROVIDER_ID2 = "commandcode";
+var PLUGIN_VERSION = "0.2.0";
 var FALLBACK_MODELS = [
+  { id: "claude-sonnet-5", name: "Claude Sonnet 5", contextLength: 1e6 },
+  { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", contextLength: 1e6 },
+  { id: "claude-fable-5", name: "Claude Fable 5", contextLength: 1e6 },
+  { id: "claude-opus-5", name: "Claude Opus 5", contextLength: 1e6 },
+  { id: "claude-opus-4-8", name: "Claude Opus 4.8", contextLength: 1e6 },
+  { id: "claude-opus-4-7", name: "Claude Opus 4.7", contextLength: 1e6 },
+  { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", contextLength: 2e5 },
   { id: "gpt-5.6-sol", name: "GPT-5.6 Sol", contextLength: 105e4 },
   { id: "gpt-5.6-terra", name: "GPT-5.6 Terra", contextLength: 105e4 },
   { id: "gpt-5.6-luna", name: "GPT-5.6 Luna", contextLength: 105e4 },
@@ -498,33 +1150,63 @@ function zeroDataRetentionHeaders() {
   }
   return void 0;
 }
-async function loadProviderModels(modelsUrl, log) {
-  try {
-    const models = await fetchCommandCodeModels({ url: modelsUrl });
-    return toProviderModelMap(models);
-  } catch (error) {
-    const fallback = toProviderModelMap(FALLBACK_MODELS);
-    const message = error instanceof Error ? error.message : String(error);
-    log(`Could not fetch the Command Code model catalog (${message}). Using the built-in fallback catalog.`);
-    return fallback;
-  }
-}
 function providerBaseUrl() {
   const configured = process.env.COMMANDCODE_API_BASE;
   if (configured && configured.length > 0) return configured;
   return DEFAULT_PROVIDER_API_BASE;
 }
-var CommandCodePlugin = async ({ client }) => {
+function modelsCachePath() {
+  const configured = process.env.COMMANDCODE_MODELS_CACHE;
+  if (configured && configured.length > 0) return configured;
+  return join2(homedir(), ".cache", "opencode", "commandcode-models.json");
+}
+async function loadProviderModels(modelsUrl, cachePath, providerBaseUrl2, logWarn, logInfo) {
+  const result = await loadCommandCodeModels({
+    url: modelsUrl,
+    cachePath,
+    fallbackModels: FALLBACK_MODELS,
+    timeoutMs: getModelsTimeoutMs()
+  });
+  if (result.warning) logWarn(result.warning);
+  else logInfo(`Loaded ${result.models.length} Command Code models from ${result.source}`);
+  return {
+    modelMap: toProviderModelMap(result.models, providerBaseUrl2),
+    modelsInfo: {
+      source: result.source,
+      modelCount: result.models.length,
+      fetchedAt: result.fetchedAt
+    }
+  };
+}
+function getModelsTimeoutMs() {
+  const raw = process.env.COMMANDCODE_MODELS_TIMEOUT_MS;
+  if (!raw) return DEFAULT_MODELS_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MODELS_TIMEOUT_MS;
+}
+var CommandCodePlugin = async ({ client, directory }) => {
   const apiBase = providerBaseUrl();
   const modelsUrl = process.env.COMMANDCODE_MODELS_URL ?? `${apiBase}/models`;
-  const models = await loadProviderModels(modelsUrl, (message) => {
-    client.app.log({ body: { service: "opencode-commandcode", level: "warn", message } }).catch(() => {
-    });
+  const cachePath = modelsCachePath();
+  installCommandFiles(directory).catch(() => {
   });
+  const { modelMap: models, modelsInfo } = await loadProviderModels(
+    modelsUrl,
+    cachePath,
+    apiBase,
+    (message) => {
+      client.app.log({ body: { service: "opencode-commandcode", level: "warn", message } }).catch(() => {
+      });
+    },
+    (message) => {
+      client.app.log({ body: { service: "opencode-commandcode", level: "info", message } }).catch(() => {
+      });
+    }
+  );
   return {
     config: async (cfg) => {
       cfg.provider ??= {};
-      cfg.provider[PROVIDER_ID] = {
+      cfg.provider[PROVIDER_ID2] = {
         npm: "@ai-sdk/openai-compatible",
         name: "Command Code",
         env: ["COMMAND_CODE_API_KEY", "COMMANDCODE_API_KEY"],
@@ -534,8 +1216,34 @@ var CommandCodePlugin = async ({ client }) => {
         },
         models
       };
+      cfg.command ??= {};
+      cfg.command["commandcode-quota"] = {
+        description: "Show Command Code account usage and quota (credits, plan, usage)",
+        template: "Use the commandcode_quota tool to fetch and report the user's Command Code account usage and quota. Summarize credits remaining and used, the plan, billing-period usage (cost, requests, tokens), and the 5-hour and weekly usage windows."
+      };
+      cfg.command["commandcode-status"] = {
+        description: "Show Command Code plugin diagnostics (catalog source, model count, endpoint)",
+        template: "Use the commandcode_status tool to fetch and report the Command Code plugin diagnostics: catalog source (live/cache/fallback), model count, last fetch time, API endpoint, zero-data-retention setting, and plugin version."
+      };
+      client.app.log({
+        body: {
+          service: "opencode-commandcode",
+          level: "info",
+          message: `Registered Command Code provider with ${Object.keys(models).length} models (source: ${modelsInfo.source})`
+        }
+      }).catch(() => {
+      });
     },
-    auth: createAuthHook()
+    auth: createAuthHook(),
+    tool: {
+      ...createQuotaTool({ apiBase, extraHeaders: zeroDataRetentionHeaders(), client }),
+      ...createStatusTool({
+        apiBase,
+        zdr: zeroDataRetentionHeaders() !== void 0,
+        version: PLUGIN_VERSION,
+        modelsInfo
+      })
+    }
   };
 };
 var index_default = CommandCodePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gururea/opencode-commandcode-provider",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "OpenCode plugin that adds the Command Code (commandcode.ai) provider and its authentication to the interface.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,11 +13,12 @@
   },
   "files": [
     "dist",
+    "command",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist",
+    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist --external @opencode-ai/plugin --external zod",
     "test": "node --import tsx --test tests/*.test.ts",
     "typecheck": "tsc --noEmit",
     "prepare": "npm run build"