@jeffreyjyz/opencode-command-code 0.1.6 → 0.2.0

package/dist/cli.d.ts

@@ -0,0 +1,19 @@
+/** Shell-words split: whitespace-separated, with single/double quoting and
+ * backslash escapes ("--tz +05:30", arg='a b'). Unterminated quotes close at
+ * end of input. */
+export declare function splitCliArgs(input: string): string[];
+/** argv for a cmduse invocation: the default one-shot dashboard plus any
+ * pass-through flags, or a subcommand invocation ("plans",
+ * "--tz +05:30 daily") passed through untouched. */
+export declare function buildCmduseArgs(arg: string): string[];
+export type RunOptions = {
+    signal?: AbortSignal;
+    /** Extra env for the child (CMD_API_KEY when the plugin resolved one). */
+    env?: Record<string, string>;
+    /** Overridable for tests. */
+    candidates?: readonly string[];
+};
+/** Run cmduse and return its plain-text stdout. Tries PATH, then common
+ * homebrew locations; every candidate failing with ENOENT yields a single
+ * install-hint error. */
+export declare function runCmduse(arg: string, opts?: RunOptions): Promise<string>;

package/dist/gating.d.ts

@@ -10,6 +10,9 @@ export declare const PLAN_RULES: Record<string, {
  * category rules. Empirically probed — the CLI bundle misses these because it
  * tracks category via serving lane, not per-model plan entitlements. */
 export declare const HARD_BLOCKED: Record<string, string[]>;
+/** canonical known model ids (lowercase compare) */
+declare const KNOWN_MODELS: string[];
+export { KNOWN_MODELS };
 /** ISO timestamp the snapshot was extracted (absent on pre-metadata files). */
 export declare const GATE_EXTRACTED_AT: string | undefined;
 /** Command Code CLI version the snapshot was scraped from. */

package/dist/index.d.ts

@@ -1,3 +1,9 @@
-import type { Plugin } from "@opencode-ai/plugin";
-export declare const CommandCodePlugin: Plugin;
-export default CommandCodePlugin;
+import type { Plugin as PluginV1 } from "@opencode-ai/plugin";
+export declare const CommandCodePlugin: PluginV1;
+declare const _default: {
+    /** v1 entrypoint (opencode >=1.18.29 object entrypoints). */
+    server: PluginV1;
+    id: string;
+    setup: (context: import("@opencode/plugin/promise/plugin").Context) => Promise<import("@opencode/plugin/promise/plugin").Cleanup | void> | import("@opencode/plugin/promise/plugin").Cleanup | void;
+};
+export default _default;

package/dist/index.js

@@ -42,13 +42,124 @@ async function credits(key) {
     windowLimits: r.windowLimits
   };
 }
-async function usageSummary(key) {
-  return getJson("/alpha/usage/summary", key);
-}
 async function providerModels(key) {
   return getJson("/provider/v1/models", key, 15000);
 }
 
+// src/cli.ts
+import { spawn } from "child_process";
+var CANDIDATES = ["cmduse", "/opt/homebrew/bin/cmduse", "/usr/local/bin/cmduse"];
+var DEFAULT_ARGS = ["-1", "--plain"];
+var SUBCOMMANDS = new Set([
+  "plans",
+  "models",
+  "daily",
+  "hourly",
+  "model",
+  "session",
+  "statusline",
+  "config"
+]);
+function splitCliArgs(input) {
+  const out = [];
+  let cur = "";
+  let has = false;
+  let quote;
+  for (let i = 0;i < input.length; i++) {
+    const ch = input[i] ?? "";
+    if (quote) {
+      if (ch === quote) {
+        quote = undefined;
+      } else if (ch === "\\" && quote === '"' && i + 1 < input.length) {
+        cur += input[++i];
+      } else {
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      has = true;
+    } else if (ch === "\\") {
+      if (i + 1 < input.length)
+        cur += input[++i];
+      has = true;
+    } else if (/\s/.test(ch)) {
+      if (has)
+        out.push(cur);
+      cur = "";
+      has = false;
+    } else {
+      cur += ch;
+      has = true;
+    }
+  }
+  if (has)
+    out.push(cur);
+  return out;
+}
+function buildCmduseArgs(arg) {
+  const tokens = splitCliArgs(arg);
+  if (!tokens.length)
+    return DEFAULT_ARGS;
+  if (tokens.some((t) => SUBCOMMANDS.has(t)))
+    return tokens;
+  return [...DEFAULT_ARGS, ...tokens];
+}
+function stderrTail(text) {
+  const lines = text.trimEnd().split(`
+`);
+  return lines.slice(-3).join(`
+`).slice(-400);
+}
+function runOnce(bin, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, {
+      env: { ...process.env, ...opts.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const out = [];
+    const err = [];
+    const onAbort = () => child.kill("SIGTERM");
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (d) => out.push(d));
+    child.stderr.on("data", (d) => err.push(d));
+    child.on("error", (e) => {
+      opts.signal?.removeEventListener("abort", onAbort);
+      reject(e);
+    });
+    child.on("close", (code, signal) => {
+      opts.signal?.removeEventListener("abort", onAbort);
+      const stdout = Buffer.concat(out).toString("utf8");
+      if (opts.signal?.aborted) {
+        reject(new Error("cmduse invocation aborted"));
+      } else if (code === 0) {
+        resolve(stdout);
+      } else {
+        const why = signal ? `killed by ${signal}` : `exit ${code}`;
+        const tail = stderrTail(Buffer.concat(err).toString("utf8"));
+        reject(new Error(`cmduse ${args.join(" ")}: ${why}${tail ? `
+${tail}` : ""}`));
+      }
+    });
+  });
+}
+async function runCmduse(arg, opts = {}) {
+  const args = buildCmduseArgs(arg);
+  const candidates = opts.candidates ?? CANDIDATES;
+  let last;
+  for (const bin of candidates) {
+    try {
+      return await runOnce(bin, args, opts);
+    } catch (e) {
+      last = e;
+      if (e?.code !== "ENOENT")
+        throw e;
+    }
+  }
+  throw new Error(`cmduse binary not found (install: brew install JeffreyJYZ/tap/cmduse)${last instanceof Error && last.message !== last.name ? ` \u2014 ${last.message}` : ""}`, { cause: last });
+}
+
 // src/key.ts
 import { readFile } from "fs/promises";
 import { homedir } from "os";
@@ -351,7 +462,7 @@ function evaluateModelAccess(model, plan) {
     return { allowed: true };
   if (!plan.planId)
     return { allowed: true };
-  const canonical = canonicalizeModelId(model);
+  const canonical = canonicalizeModelId(bareModel(model));
   if ((HARD_BLOCKED[plan.planId] ?? []).some((m) => m.toLowerCase() === canonical.toLowerCase())) {
     return { allowed: false };
   }
@@ -399,7 +510,8 @@ function splitModels(models) {
 async function loadModels(key) {
   warnIfGatingStale();
   let models;
-  if (cache && Date.now() - cache.at < CACHE_TTL_MS) {
+  const fresh = cache && cache.key === key && Date.now() - cache.at < CACHE_TTL_MS;
+  if (fresh) {
     models = cache.models;
   } else {
     try {
@@ -409,9 +521,9 @@ async function loadModels(key) {
         name: m.name ?? m.id,
         contextLength: m.context_length ?? 0
       }));
-      cache = { at: Date.now(), models };
+      cache = { key, at: Date.now(), models };
     } catch (e) {
-      if (cache) {
+      if (cache && cache.key === key) {
         models = cache.models;
       } else {
         throw new Error("Could not fetch Command Code model list (https://api.commandcode.ai/provider/v1/models). Check network/API key.", { cause: e });
@@ -431,252 +543,136 @@ async function loadModels(key) {
   const { claude, open } = splitModels(allowed);
   return { claude, open };
 }
-// ../core/plans.json
-var plans_default = {
-  nameRules: [
-    { needles: ["enterprise"], name: "Enterprise" },
-    { needles: ["provider"], name: "Provider" },
-    { needles: ["team"], name: "Team Pro" },
-    { needles: ["max", "20"], name: "Max 20x" },
-    { needles: ["max"], name: "Max 10x" },
-    { needles: ["goat"], name: "GOAT" },
-    { needles: ["pro"], name: "Pro" },
-    { needles: ["go"], name: "Go" }
-  ],
-  defaultName: "Free",
-  caps: {
-    Enterprise: null,
-    Provider: null,
-    "Team Pro": 40,
-    "Max 20x": 300,
-    "Max 10x": 150,
-    GOAT: 70,
-    Pro: 80,
-    Go: 10,
-    Free: null
-  },
-  plans: [
-    { name: "Go", price: "$1", monthly: "$10", fiveHour: "$3", weekly: "$6" },
-    { name: "GOAT", price: "$10", monthly: "$70", fiveHour: "$14", weekly: "$35" },
-    { name: "Pro", price: "$20", monthly: "$80", fiveHour: "$16", weekly: "$40" },
-    { name: "Provider", price: "$15", monthly: "PAYG", fiveHour: "\u2014", weekly: "\u2014" },
-    { name: "Max 10x", price: "$100", monthly: "$150", fiveHour: "$45", weekly: "$90" },
-    { name: "Max 20x", price: "$200", monthly: "$300", fiveHour: "$90", weekly: "$180" },
-    { name: "Team Pro", price: "$40", monthly: "$40", fiveHour: "$12", weekly: "$24" }
-  ]
-};
 
-// src/usage.ts
-var BAR_WIDTH = 12;
-var FIVE_HOUR_SECS = 5 * 3600;
-var WEEKLY_SECS = 7 * 86400;
-function money(v) {
-  return `$${v.toFixed(2)}`;
-}
-function compact(n) {
-  if (n >= 1e6)
-    return `${(n / 1e6).toFixed(1)}M`;
-  if (n >= 1000)
-    return `${(n / 1000).toFixed(1)}K`;
-  return `${n}`;
-}
-function bar(used, cap) {
-  const pct = cap > 0 ? Math.min(Math.max(used / cap, 0), 1) : 0;
-  const filled = Math.round(pct * BAR_WIDTH);
-  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
-}
-function pctStr(used, cap) {
-  return cap > 0 ? `${Math.round(used / cap * 100)}%` : "\u2014";
-}
-function relTime(resetAtMs, nowSecs) {
-  if (resetAtMs === undefined)
-    return "unknown";
-  const resetSecs = Math.floor(resetAtMs / 1000);
-  if (resetSecs <= nowSecs)
-    return "resetting\u2026";
-  const diff = resetSecs - nowSecs;
-  const d = Math.floor(diff / 86400);
-  const h = Math.floor(diff % 86400 / 3600);
-  const m = Math.floor(diff % 3600 / 60);
-  if (d > 0)
-    return `${d}d ${h}h`;
-  if (h > 0)
-    return `${h}h ${m}m`;
-  if (m > 0)
-    return `${m}m`;
-  return "<1m";
-}
-function duration(secs) {
-  const d = Math.floor(secs / 86400);
-  const h = Math.floor(secs % 86400 / 3600);
-  const m = Math.floor(secs % 3600 / 60);
-  if (d > 0)
-    return `${d}d ${h}h`;
-  if (h > 0)
-    return `${h}h ${m}m`;
-  if (m > 0)
-    return `${m}m`;
-  return "<1m";
-}
-function elapsedPct(resetAtMs, durSecs, nowSecs) {
-  if (resetAtMs === undefined)
-    return;
-  const resetSecs = Math.floor(resetAtMs / 1000);
-  if (resetSecs < durSecs)
-    return;
-  const start = resetSecs - durSecs;
-  if (nowSecs < start)
-    return;
-  const pct = Math.min(Math.max((nowSecs - start) / durSecs * 100, 0), 100);
-  return Math.round(pct);
-}
-function paceEta(resetAtMs, durSecs, used, cap, nowSecs) {
-  if (resetAtMs === undefined)
-    return;
-  const resetSecs = Math.floor(resetAtMs / 1000);
-  if (resetSecs < durSecs)
-    return;
-  const start = resetSecs - durSecs;
-  if (nowSecs <= start || nowSecs >= resetSecs)
-    return;
-  const elapsed = nowSecs - start;
-  if (elapsed / durSecs < 0.1)
-    return;
-  const rate = used / elapsed;
-  if (rate <= 0 || used >= cap)
-    return;
-  const secsToCap = (cap - used) / rate;
-  if (secsToCap >= resetSecs - nowSecs)
-    return;
-  return secsToCap;
-}
-function parseIsoUtc(s) {
-  const m = s.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:?\d{2})?$/);
-  if (!m)
-    return;
-  const [, y, mo, d, h, mi, sec, off] = m;
-  let offsetMs = 0;
-  if (off && off !== "Z") {
-    const sign = off.startsWith("-") ? -1 : 1;
-    const digits = off.slice(1).replace(":", "");
-    const hh = Number(digits.slice(0, 2));
-    const mm = Number(digits.slice(2, 4) || "0");
-    offsetMs = sign * (hh * 60 + mm) * 60000;
-  }
-  return Date.UTC(+y, +mo - 1, +d, +h, +mi, Math.floor(+sec)) - offsetMs;
-}
-function monthlyWindow(cap, remaining, periodStart, periodEnd) {
-  const used = Math.min(Math.max(cap - remaining, 0), cap);
-  const resetAt = periodEnd ? parseIsoUtc(periodEnd) : undefined;
-  const start = periodStart ? parseIsoUtc(periodStart) : undefined;
-  const durSecs = start !== undefined && resetAt !== undefined ? Math.max(Math.floor((resetAt - start) / 1000), 1) : undefined;
-  return { window: { used, cap, resetAt }, durSecs };
-}
-var NAME_RULES = plans_default.nameRules;
-var DEFAULT_NAME = plans_default.defaultName;
-var CAPS = plans_default.caps;
-var PLANS = plans_default.plans;
-function planMonthlyCap(planId) {
-  return CAPS[planName(planId)] ?? undefined;
-}
-function planRuleMatched(planId) {
-  const id = planId.toLowerCase();
-  return NAME_RULES.some((rule) => rule.needles.every((n) => id.includes(n)));
-}
-var unknownPlanWarned = false;
-function warnUnknownPlanOnce(planId) {
-  if (unknownPlanWarned)
-    return;
-  unknownPlanWarned = true;
-  console.warn(`[command-code] unknown plan id '${planId}' \u2014 showing Free; update core/plans.json`);
-}
-function planName(planId) {
-  const id = planId.toLowerCase();
-  for (const rule of NAME_RULES) {
-    if (rule.needles.every((n) => id.includes(n)))
-      return rule.name;
+// src/v2.ts
+import { Plugin } from "@opencode/plugin";
+var PLUGIN_ID = "command-code";
+var PROVIDER_BASE = "https://api.commandcode.ai/provider/v1";
+var LANES = [
+  { id: "command-code-anthropic", name: "Command Code (Anthropic)", pkg: "@opencode/ai/providers/anthropic" },
+  {
+    id: "command-code-openai",
+    name: "Command Code (OpenAI)",
+    pkg: "@opencode/ai/providers/openai-compatible",
+    reasoningField: "reasoning_content"
   }
-  return DEFAULT_NAME;
-}
-function windowLine(label, w, nowSecs, durSecs) {
-  const status = w.exceeded ? " \xB7 **LIMIT EXCEEDED**" : "";
-  const elapsed = durSecs !== undefined ? elapsedPct(w.resetAt, durSecs, nowSecs) : undefined;
-  const thru = elapsed !== undefined ? ` \xB7 window ${elapsed}% elapsed` : "";
-  const eta = durSecs !== undefined ? paceEta(w.resetAt, durSecs, w.used, w.cap, nowSecs) : undefined;
-  const pace = eta !== undefined ? ` \xB7 **on pace to hit cap in ${duration(eta)}**` : "";
-  return `**${label}** \`${bar(w.used, w.cap)}\` ${money(w.used)} of ${money(w.cap)} (${pctStr(w.used, w.cap)}) \xB7 resets in ${relTime(w.resetAt, nowSecs)}${thru}${pace}${status}
-`;
+];
+var TOOL_DESCRIPTION = "Fetch live Command Code plan/usage: plan name, monthly credits, 5-hour & weekly windows, billing-period summary. Pass arg='plans' for the plan comparison table only, or extra cmduse flags (e.g. '--tz +05:30 daily').";
+function toV2Model(m, lane) {
+  const info = {
+    id: m.id,
+    modelID: m.id,
+    providerID: lane.id,
+    name: m.name,
+    capabilities: { tools: true, input: ["text"], output: ["text"] },
+    variants: [],
+    time: { released: 0 },
+    cost: [],
+    status: "active",
+    enabled: true,
+    limit: { context: m.contextLength || 128000, output: 32000 },
+    ...lane.reasoningField ? { compatibility: { reasoningField: lane.reasoningField } } : {}
+  };
+  return info;
 }
-function plansTable(current) {
-  const mine = planName(current);
-  let out = `| Plan | Price | Credits/mo | 5-hour | Weekly |
-|---|---|---|---|---|
-`;
-  for (const { name, price, monthly, fiveHour, weekly } of PLANS) {
-    const mark = name === mine ? "**" : "";
-    out += `| ${mark}${name}${mark} | ${price}/mo | ${monthly} | ${fiveHour} | ${weekly} |
-`;
+function staticSeedModels() {
+  const seed = {
+    "command-code-anthropic": [],
+    "command-code-openai": []
+  };
+  for (const lane of LANES) {
+    const models = KNOWN_MODELS.filter((id) => isClaude(id) === (lane.reasoningField === undefined)).map((id) => toV2Model({ id, name: id, contextLength: 0 }, lane));
+    seed[lane.id] = models;
   }
-  out += "\nWindows throttle only included monthly credits; on-demand (`/extra`) credits are never throttled.\n";
-  return out;
+  return seed;
 }
-async function renderUsage(key) {
-  const nowSecs = Math.floor(Date.now() / 1000);
-  const [sub, cr, summary] = await Promise.all([
-    subscriptions(key),
-    credits(key),
-    usageSummary(key).catch(() => {
+var commandCodeV2 = Plugin.define({
+  id: PLUGIN_ID,
+  async setup(ctx) {
+    let key;
+    try {
+      key = await resolveKey();
+    } catch {}
+    if (!key) {
+      console.warn("[command-code] no API key found \u2014 providers registered disabled. `cmd login` (~/.commandcode/auth.json), CMD_API_KEY, or providers.command-code-*.settings.apiKey in opencode.jsonc, then restart.");
+    }
+    const seed = staticSeedModels();
+    await ctx.provider.transform((editor) => {
+      for (const lane of LANES) {
+        editor.update(lane.id, (provider) => {
+          if (provider.name === provider.id)
+            provider.name = lane.name;
+          if (provider.package === "")
+            provider.package = lane.pkg;
+          provider.activation = key ? "enabled" : "disabled";
+          provider.settings = { ...provider.settings, baseURL: PROVIDER_BASE };
+          if (key && provider.settings.apiKey === undefined)
+            provider.settings.apiKey = key;
+        });
+        editor.models.set(lane.id, seed[lane.id]);
+      }
+    });
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "cmd-usage",
+        description: "Show Command Code plan, credits, and usage windows",
+        execute: async ({ sessionID, prompt }) => {
+          const arg = typeof prompt?.text === "string" ? prompt.text : "";
+          let text;
+          try {
+            text = await runCmduse(arg, { env: key ? { CMD_API_KEY: key } : undefined });
+          } catch (e) {
+            text = `cmd-usage failed: ${e instanceof Error ? e.message : String(e)}`;
+          }
+          await ctx.session.synthetic({ sessionID, text: `**/cmd-usage**
+
+${text}` });
+        }
+      });
+    });
+    await ctx.tool.transform((editor) => {
+      editor.add({
+        name: "cmd_usage",
+        description: TOOL_DESCRIPTION,
+        input: {
+          type: "object",
+          properties: {
+            arg: {
+              type: "string",
+              description: "Optional: 'plans' for the plan table only, or extra cmduse flags (e.g. '--tz +05:30 daily')"
+            }
+          },
+          additionalProperties: false
+        },
+        async execute(input) {
+          const arg = typeof input?.arg === "string" ? input.arg : "";
+          return {
+            content: await runCmduse(arg, { env: key ? { CMD_API_KEY: key } : undefined })
+          };
+        }
+      });
+    });
+    if (!key)
       return;
-    })
-  ]);
-  if (sub.planId && sub.planId !== "free" && !planRuleMatched(sub.planId)) {
-    warnUnknownPlanOnce(sub.planId);
-  }
-  const lines = [];
-  lines.push(`## Command Code \u2014 ${planName(sub.planId)} (${sub.status})
-`);
-  if (sub.currentPeriodEnd)
-    lines.push(`Billing period ends \`${sub.currentPeriodEnd.slice(0, 10)}\`
-`);
-  const cap = planMonthlyCap(sub.planId);
-  if (cap) {
-    lines.push(`**Credits:** ${money(cr.credits.monthlyCredits)} / ${money(cap)} monthly \xB7 ${money(cr.credits.purchasedCredits ?? 0)} purchased \xB7 ${money(cr.credits.freeCredits ?? 0)} free
-`);
-  } else {
-    lines.push(`**Credits remaining:** ${money(cr.credits.monthlyCredits)} monthly \xB7 ${money(cr.credits.purchasedCredits ?? 0)} purchased \xB7 ${money(cr.credits.freeCredits ?? 0)} free
-`);
-  }
-  lines.push("### Usage windows");
-  if (cap) {
-    const { window, durSecs } = monthlyWindow(cap, cr.credits.monthlyCredits, sub.currentPeriodStart, sub.currentPeriodEnd);
-    lines.push(windowLine("Monthly", { ...window, exceeded: false }, nowSecs, durSecs));
-  }
-  const five = cr.windowLimits?.fiveHour;
-  const weekly = cr.windowLimits?.weekly;
-  if (five)
-    lines.push(windowLine("5-hour", five, nowSecs, FIVE_HOUR_SECS));
-  if (weekly)
-    lines.push(windowLine("Weekly", weekly, nowSecs, WEEKLY_SECS));
-  if (!five && !weekly)
-    lines.push(`No rolling windows on this plan (pay-as-you-go credits only).
-`);
-  if (summary) {
-    lines.push("### This billing period");
-    lines.push("| Metric | Value |", "|---|---|");
-    lines.push(`| Requests | ${summary.totalCount ?? "\u2014"} |`);
-    lines.push(`| Cost | ${summary.totalCost !== undefined ? money(summary.totalCost) : "\u2014"} |`);
-    lines.push(`| Tokens in / out | ${summary.totalTokensIn !== undefined ? compact(summary.totalTokensIn) : "\u2014"} / ${summary.totalTokensOut !== undefined ? compact(summary.totalTokensOut) : "\u2014"} |`);
-    lines.push(`| Success rate | ${summary.successRate !== undefined ? `${Math.round(summary.successRate)}%` : "\u2014"} |`);
-    lines.push("");
+    const controller = new AbortController;
+    (async () => {
+      try {
+        const split = await loadModels(key);
+        if (controller.signal.aborted)
+          return;
+        await ctx.provider.transform((editor) => {
+          editor.models.set("command-code-anthropic", split.claude.map((m) => toV2Model(m, LANES[0])));
+          editor.models.set("command-code-openai", split.open.map((m) => toV2Model(m, LANES[1])));
+        });
+      } catch (e) {
+        console.warn("[command-code] live model list unavailable, keeping static seed:", e);
+      }
+    })();
+    return () => controller.abort();
   }
-  lines.push("### All plans");
-  lines.push(plansTable(sub.planId));
-  return lines.join(`
-`);
-}
+});
 
 // src/index.ts
-var PROVIDER_BASE = `${API_BASE}/provider/v1`;
 var MODEL_CAPABILITIES = {
   temperature: true,
   reasoning: true,
@@ -761,15 +757,15 @@ var CommandCodePlugin = async (_input) => {
       const openDefs = split ? toModelDefs(split.open, "command-code-openai", "@ai-sdk/openai-compatible", { field: "reasoning_content" }) : {};
       const userAnthropic = existing("command-code-anthropic");
       cfg.provider["command-code-anthropic"] = {
-        npm: userAnthropic.options ? undefined : "@ai-sdk/anthropic",
-        name: "Command Code (Anthropic)",
+        npm: userAnthropic.npm ?? "@ai-sdk/anthropic",
+        name: userAnthropic.name ?? "Command Code (Anthropic)",
         options: { baseURL: PROVIDER_BASE, ...userAnthropic.options },
         models: { ...claudeDefs, ...userAnthropic.models }
       };
       const userOpenai = existing("command-code-openai");
       cfg.provider["command-code-openai"] = {
-        npm: userOpenai.options ? undefined : "@ai-sdk/openai-compatible",
-        name: userOpenai.options ? undefined : "Command Code (OpenAI)",
+        npm: userOpenai.npm ?? "@ai-sdk/openai-compatible",
+        name: userOpenai.name ?? "Command Code (OpenAI)",
         options: {
           baseURL: PROVIDER_BASE,
           ...openKey ? { apiKey: openKey } : {},
@@ -798,19 +794,20 @@ var CommandCodePlugin = async (_input) => {
       cmd_usage: tool({
         description: "Fetch live Command Code plan/usage: plan name, monthly credits, 5-hour & weekly windows, billing-period summary. Pass arg=plans for the plan comparison table only.",
         args: {
-          arg: tool.schema.string().optional().describe("Optional: 'plans' for the plan table only")
+          arg: tool.schema.string().optional().describe("Optional: 'plans' for the plan table only, or extra cmduse flags")
         },
         async execute(args) {
-          if (args.arg === "plans")
-            return plansTable("");
           const key = await resolveKey();
-          return renderUsage(key);
+          return runCmduse(args.arg ?? "", { env: { CMD_API_KEY: key } });
         }
       })
     }
   };
 };
-var src_default = CommandCodePlugin;
+var src_default = {
+  ...commandCodeV2,
+  server: CommandCodePlugin
+};
 export {
   CommandCodePlugin,
   src_default as default

package/dist/v2.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from "@opencode/plugin";
+import { type CmdModel } from "./models";
+export declare const PLUGIN_ID = "command-code";
+export declare const PROVIDER_BASE = "https://api.commandcode.ai/provider/v1";
+type Lane = {
+    id: "command-code-anthropic" | "command-code-openai";
+    name: string;
+    /** v2 runtime package (first-party, distinct from the v1 `npm` value). */
+    pkg: string;
+    /** Wire field reasoning must round-trip through on the openai-compatible
+     * lane; v2 spells the old `interleaved: {field}` as `compatibility`. */
+    reasoningField?: string;
+};
+export type { Lane };
+/** API/known model → v2 Model.Info. Every Command Code model shares
+ * capabilities and pricing (subscription credits, not per-token); only the
+ * open lane needs the reasoning round-trip field. */
+export declare function toV2Model(m: CmdModel, lane: Lane): unknown;
+/** Instant static seed from gating.json's known model ids, split by wire lane.
+ * Replaced by the gated live list once the background fetch lands; also the
+ * fallback shown when the live fetch fails. */
+export declare function staticSeedModels(): Record<Lane["id"], unknown[]>;
+export declare const commandCodeV2: Plugin.Plugin;

package/package.json

@@ -1,17 +1,18 @@
 {
 	"name": "@jeffreyjyz/opencode-command-code",
-	"version": "0.1.6",
-	"description": "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage.",
+	"version": "0.2.0",
+	"description": "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"scripts": {
-		"build": "bun build src/index.ts --outdir dist --target bun --external @opencode-ai/plugin && tsc -p tsconfig.build.json",
+		"build": "rm -rf dist && bun build src/index.ts --outdir dist --target bun --external @opencode-ai/plugin --external @opencode/plugin && tsc -p tsconfig.build.json",
 		"test": "bun test",
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@opencode-ai/plugin": "*"
+		"@opencode-ai/plugin": "*",
+		"@opencode/plugin": "^2.0.11"
 	},
 	"devDependencies": {
 		"@types/bun": "latest",

package/dist/usage.d.ts

@@ -1,40 +0,0 @@
-import { type Window } from "./api";
-export declare const FIVE_HOUR_SECS: number;
-export declare const WEEKLY_SECS: number;
-export declare function money(v: number): string;
-export declare function compact(n: number): string;
-export declare function bar(used: number, cap: number): string;
-export declare function pctStr(used: number, cap: number): string;
-export declare function relTime(resetAtMs: number | undefined, nowSecs: number): string;
-/** Compact "Xh Ym" / "Xd Yh" for a span of seconds. Pure duration — use this
- * (not relTime) for ETAs/countdowns. Mirrors cmduse_core::duration. */
-export declare function duration(secs: number): string;
-/** % of a rolling window elapsed; window length = durSecs, ends at resetAtMs.
- * undefined when the window hasn't started or the reset is unknown. */
-export declare function elapsedPct(resetAtMs: number | undefined, durSecs: number, nowSecs: number): number | undefined;
-/** Seconds until spend hits cap at the current rate, if before the reset.
- * Suppressed before 10% of the window has elapsed (flat-rate projection is
- * unreliable that early). undefined = no warning. */
-export declare function paceEta(resetAtMs: number | undefined, durSecs: number, used: number, cap: number, nowSecs: number): number | undefined;
-/** ISO 8601 → epoch ms. Handles trailing Z or a ±HH:MM / ±HHMM offset. */
-export declare function parseIsoUtc(s: string): number | undefined;
-/** Assemble the monthly window from the plan cap + subscription period:
- * used = cap − remaining (clamped), reset = period end, durSecs = period
- * length. Mirrors cmduse_core::monthly_window (conformance-pinned). */
-export declare function monthlyWindow(cap: number, remaining: number, periodStart?: string, periodEnd?: string): {
-    window: {
-        used: number;
-        cap: number;
-        resetAt?: number;
-    };
-    durSecs?: number;
-};
-export declare function planMonthlyCap(planId: string): number | undefined;
-/** True when `planId` matched a NAME_RULES entry (not the DEFAULT_NAME
- * fallback). Mirrors cmduse_core::plan_rule_matched. */
-export declare function planRuleMatched(planId: string): boolean;
-export declare function planName(planId: string): string;
-export declare function windowLine(label: string, w: Window, nowSecs: number, durSecs?: number): string;
-export declare function plansTable(current: string): string;
-/** Fetch billing data in parallel and render the markdown dashboard. */
-export declare function renderUsage(key: string): Promise<string>;