@telsoncc/opencode-commandcode 1.0.0

package/src/manifest.ts

@@ -0,0 +1,172 @@
+import { writeFileSync } from "fs";
+
+export type CatalogStatus = "healthy" | "degraded" | "broken";
+export type CostCatalogBest = "cli" | "docs" | "thirdParty" | "free" | "fallback" | "missing";
+
+export type CostSources = {
+  cli: number;
+  officialDocs: number;
+  thirdParty: number;
+  free: number;
+  fallback: number;
+  unmatched: number;
+};
+
+export type UnavailableEntry = {
+  id: string;
+  reason: "not-listed-by-provider-api";
+};
+
+export type CatalogReview = {
+  thirdParty: string[];
+  free: string[];
+  unmatched: string[];
+  unavailable?: UnavailableEntry[];
+};
+
+export type CatalogManifest = {
+  schemaVersion: 1;
+  generatedAt: string;
+  pluginVersion: string;
+  commandCodeVersion: string;
+  commandCodeTarball: string;
+  modelCount: number;
+  reasoningModelCount: number;
+  extraction: {
+    modelCatalog: "ok" | "failed";
+    costCatalog: CostCatalogBest;
+    costCatalogError: string | null;
+  };
+  costSources: CostSources;
+  review?: CatalogReview;
+  status: CatalogStatus;
+};
+
+export type BuildManifestInput = {
+  pluginVersion: string;
+  commandCodeVersion: string;
+  commandCodeTarball: string;
+  modelCount: number;
+  reasoningModelCount: number;
+  modelCatalogOk: boolean;
+  costSources: CostSources;
+  review?: CatalogReview;
+  generatedAt: string;
+  costCatalogError?: string | null;
+};
+
+export function withUnavailableIds(
+  review: CatalogReview | undefined,
+  unavailable: string[],
+): CatalogReview | undefined {
+  const entries: UnavailableEntry[] = [...unavailable]
+    .sort()
+    .map((id) => ({ id, reason: "not-listed-by-provider-api" as const }));
+  if (entries.length === 0) return review;
+  return { ...(review ?? { thirdParty: [], free: [], unmatched: [] }), unavailable: entries };
+}
+
+/** Update only the embedded plugin version; reject a missing target version. */
+export function withPluginVersion(manifest: CatalogManifest, version: string): CatalogManifest {
+  if (!version || typeof version !== "string" || version.trim().length === 0) {
+    throw new Error("target plugin version must be a non-empty string");
+  }
+  return { ...manifest, pluginVersion: version };
+}
+
+export function bumpPatch(version: string): string {
+  const parts = version.split(".");
+  const patch = Number(parts[2] ?? "0");
+  return `${parts[0] ?? "0"}.${parts[1] ?? "0"}.${patch + 1}`;
+}
+
+export function meetsModelCountFloor(modelCount: number, lastSuccessful: number | null): boolean {
+  const floor = Math.max(20, Math.floor((lastSuccessful ?? 20) * 0.5));
+  // ponytail: when there is no prior catalog, lastSuccessful is null and the floor is 20
+  return modelCount >= (lastSuccessful === null ? 20 : floor);
+}
+
+export function bestCostCatalog(sources: CostSources): CostCatalogBest {
+  if (sources.cli > 0) return "cli";
+  if (sources.officialDocs > 0) return "docs";
+  if (sources.thirdParty > 0) return "thirdParty";
+  if (sources.free > 0) return "free";
+  if (sources.fallback > 0) return "fallback";
+  return "missing";
+}
+
+export function catalogStatus(modelCatalogOk: boolean, sources: CostSources): CatalogStatus {
+  if (!modelCatalogOk) return "broken";
+  if (sources.unmatched > 0) return "degraded";
+  return "healthy";
+}
+
+export function commandCodeTarballUrl(version: string): string {
+  return `https://registry.npmjs.org/command-code/-/command-code-${version}.tgz`;
+}
+
+export function buildManifest(input: BuildManifestInput): CatalogManifest {
+  const status = catalogStatus(input.modelCatalogOk, input.costSources);
+  return {
+    schemaVersion: 1,
+    generatedAt: input.generatedAt,
+    pluginVersion: input.pluginVersion,
+    commandCodeVersion: input.commandCodeVersion,
+    commandCodeTarball: input.commandCodeTarball,
+    modelCount: input.modelCount,
+    reasoningModelCount: input.reasoningModelCount,
+    extraction: {
+      modelCatalog: input.modelCatalogOk ? "ok" : "failed",
+      costCatalog: bestCostCatalog(input.costSources),
+      costCatalogError: input.costCatalogError ?? null,
+    },
+    costSources: { ...input.costSources },
+    ...(input.review ? { review: input.review } : {}),
+    status,
+  };
+}
+
+export function writeManifest(path: string, manifest: CatalogManifest): void {
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+}
+
+export function lastSuccessfulModelCount(manifest: CatalogManifest | null): number | null {
+  if (!manifest) return null;
+  if (manifest.status === "broken") return null;
+  return manifest.modelCount;
+}
+
+export function countCostSources(input: {
+  modelIds: string[];
+  cliIds: Set<string>;
+  officialDocIds: Set<string>;
+  thirdPartyIds: Set<string>;
+  freeIds: Set<string>;
+  fallbackIds?: Set<string>;
+}): CostSources {
+  const fallbackIds = input.fallbackIds ?? new Set<string>();
+  const sources: CostSources = {
+    cli: 0,
+    officialDocs: 0,
+    thirdParty: 0,
+    free: 0,
+    fallback: 0,
+    unmatched: 0,
+  };
+  for (const id of input.modelIds) {
+    if (input.cliIds.has(id)) sources.cli++;
+    else if (input.officialDocIds.has(id)) sources.officialDocs++;
+    else if (input.thirdPartyIds.has(id)) sources.thirdParty++;
+    else if (input.freeIds.has(id)) sources.free++;
+    else if (fallbackIds.has(id)) sources.fallback++;
+    else sources.unmatched++;
+  }
+  return sources;
+}
+
+export function bumpPackageVersionField(pkgJson: string): { json: string; version: string } {
+  const pkg = JSON.parse(pkgJson) as { version: string };
+  const version = bumpPatch(pkg.version);
+  const json = pkgJson.replace(/("version"\s*:\s*")([^"]+)(")/, `$1${version}$3`);
+  return { json, version };
+}

package/src/model.ts

@@ -0,0 +1,168 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3StreamResult,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3Content,
+  LanguageModelV3Usage,
+  LanguageModelV3FinishReason,
+} from "@ai-sdk/provider";
+import { buildRequest } from "./convert.js";
+import { parseStreamEvents } from "./stream.js";
+
+const DEFAULT_BASE_URL = "https://api.commandcode.ai";
+// x-command-code-version must match the Command Code CLI version for API compatibility
+const CC_VERSION = "0.26.20";
+
+export interface CommandCodeModelOptions {
+  apiKey: string;
+  baseURL?: string;
+  headers?: Record<string, string>;
+}
+
+export class CommandCodeLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = "v3" as const;
+  readonly provider = "commandcode";
+  readonly modelId: string;
+  supportedUrls: Record<string, RegExp[]> = {};
+
+  private opts: CommandCodeModelOptions;
+
+  constructor(modelId: string, opts: CommandCodeModelOptions) {
+    this.modelId = modelId;
+    this.opts = opts;
+  }
+
+  private get baseURL(): string {
+    return this.opts.baseURL ?? DEFAULT_BASE_URL;
+  }
+
+  private buildHeaders(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.opts.apiKey}`,
+      "x-command-code-version": CC_VERSION,
+      "x-cli-environment": "production",
+      "x-project-slug": "opencode",
+      ...this.opts.headers,
+    };
+  }
+
+  async doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
+    const body = buildRequest(this.modelId, options);
+    const requestBody = JSON.stringify(body);
+
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(new Error("Request timed out after 5 minutes")),
+      300_000,
+    );
+    const userSignal = options.abortSignal;
+    if (userSignal) {
+      const onAbort = () => controller.abort(userSignal.reason);
+      userSignal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    try {
+      const response = await fetch(`${this.baseURL}/alpha/generate`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: requestBody,
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        let errorMessage = `Command Code API error: ${response.status} ${response.statusText}`;
+        try {
+          const parsed = JSON.parse(errorBody);
+          if (parsed.error?.message) errorMessage = parsed.error.message;
+          else if (parsed.message) errorMessage = parsed.message;
+        } catch {
+          // intentionally silent: error body is not JSON
+        }
+        throw new Error(`${errorMessage} [model=${this.modelId}]`);
+      }
+
+      if (!response.body) {
+        throw new Error(`Command Code API returned no body [model=${this.modelId}]`);
+      }
+
+      const responseHeaders: Record<string, string> = {};
+      response.headers.forEach((v, k) => {
+        responseHeaders[k] = v;
+      });
+
+      return {
+        stream: parseStreamEvents(response.body as ReadableStream<Uint8Array>),
+        request: { body: requestBody },
+        response: { headers: responseHeaders },
+      };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
+    const { stream } = await this.doStream(options);
+
+    const textParts: string[] = [];
+    const reasoningParts: string[] = [];
+    const content: LanguageModelV3Content[] = [];
+    let finishReason: LanguageModelV3FinishReason = { unified: "stop", raw: "stop" };
+    let usage: LanguageModelV3Usage = {
+      inputTokens: {
+        total: undefined,
+        noCache: undefined,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+      },
+      outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    };
+
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        switch (value.type) {
+          case "text-delta":
+            textParts.push(value.delta);
+            break;
+          case "reasoning-delta":
+            reasoningParts.push(value.delta);
+            break;
+          case "tool-call":
+            content.push({
+              type: "tool-call",
+              toolCallId: value.toolCallId,
+              toolName: value.toolName,
+              input: value.input,
+            });
+            break;
+          case "finish":
+            finishReason = value.finishReason;
+            usage = value.usage;
+            break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+      stream.cancel();
+    }
+
+    const text = textParts.join("");
+    if (text) content.unshift({ type: "text", text });
+
+    const reasoning = reasoningParts.join("");
+    if (reasoning) content.unshift({ type: "reasoning", text: reasoning });
+
+    return {
+      content,
+      finishReason,
+      usage,
+      warnings: [],
+    };
+  }
+}

package/src/opencode2.ts

@@ -0,0 +1,336 @@
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { toConfigKey, loadCatalogFromLocalCommandCode, type ModelEntry } from "./catalog.js";
+import {
+  readCatalogCache,
+  writeCatalogCache,
+  writeStartupSummary,
+  pluginStateDir,
+  type StartupSummary,
+} from "./startup.js";
+import type { CatalogManifest } from "./manifest.js";
+
+// OpenCode 2.0 support: in-memory provider inventory + integration.
+//
+// The 2.0 host API is duck-typed on purpose (mirrors
+// oakimov/cursor-opencode-provider `src/opencode2/types.ts`): importing
+// `@opencode/plugin` as a runtime dependency would force a plugin bump on
+// every OpenCode release. These shapes only cover what this plugin publishes
+// or calls; extra host fields are ignored at runtime.
+
+export const COMMANDCODE_PROVIDER_ID = "commandcode";
+export const COMMANDCODE_INTEGRATION_ID = "commandcode";
+export const COMMANDCODE_PROVIDER_NAME = "Command Code";
+export const COMMANDCODE_BASE_URL = "https://api.commandcode.ai/provider/v1";
+export const COMMANDCODE_PACKAGE = "@opencode/ai/providers/openai-compatible";
+export const COMMANDCODE_ENV_NAMES = ["COMMANDCODE_API_KEY"];
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const MODELS_PATH = join(MODULE_DIR, "..", "models.json");
+const VERSION_PATH = join(MODULE_DIR, "..", "_version.txt");
+const MANIFEST_PATH = join(MODULE_DIR, "..", "manifest.json");
+
+export type V2Cost = {
+  tier?: { type: "context"; size: number };
+  input: number;
+  output: number;
+  cache: { read: number; write: number };
+};
+
+export type V2Variant = {
+  id: string;
+  settings?: Record<string, unknown>;
+};
+
+export type V2ModelInfo = {
+  id: string;
+  /** Wire id sent to the provider. Lets one upstream model back one entry. */
+  modelID: string;
+  providerID: string;
+  name: string;
+  capabilities: { tools: boolean; input: string[]; output: string[] };
+  limit: { context: number; output: number };
+  variants: V2Variant[];
+  status: "active";
+  enabled: true;
+  time: { released: number };
+  cost: V2Cost[];
+  settings?: Record<string, unknown>;
+};
+
+export type V2ProviderInfo = {
+  id: string;
+  name: string;
+  activation: "enabled";
+  package: string;
+  integrationID: string;
+  settings: Record<string, unknown>;
+};
+
+export interface V2ProviderEditor {
+  add(input: {
+    info: V2ProviderInfo;
+    models: readonly V2ModelInfo[];
+    sourceConnection?: unknown;
+  }): void;
+}
+
+export interface V2IntegrationDraft {
+  update(id: string, update: (integration: { id: string; name: string }) => void): void;
+  readonly method: {
+    update(
+      input:
+        | { readonly integrationID: string; readonly method: { type: "key"; label?: string } }
+        | { readonly integrationID: string; readonly method: { type: "env"; names: string[] } },
+    ): void;
+  };
+}
+
+export interface V2SetupContext {
+  readonly provider: {
+    readonly transform: (
+      callback: (editor: V2ProviderEditor) => void,
+    ) => Promise<{ dispose: () => Promise<void> }>;
+    readonly reload: () => Promise<void>;
+  };
+  readonly integration: {
+    readonly transform: (
+      callback: (draft: V2IntegrationDraft) => void,
+    ) => Promise<{ dispose: () => Promise<void> }>;
+    readonly connection: {
+      readonly active: (integrationID: string) => Promise<unknown>;
+    };
+  };
+  readonly event?: {
+    readonly subscribe: (...args: unknown[]) => AsyncIterable<{ type?: unknown }>;
+  };
+}
+
+interface PluginFileConfig {
+  disableModelSync?: boolean;
+  commandCodePackagePath?: string;
+  debugStartupLogs?: boolean;
+}
+
+function loadPluginFileConfig(): PluginFileConfig {
+  const dir = join(homedir(), ".config", "opencode");
+  const configPath = [
+    join(dir, "opencode-commandcode.json"),
+    join(dir, "commandcode-go-opencode-provider.json"),
+  ].find((p) => existsSync(p));
+  if (!configPath) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function modelEntryToV2(entry: ModelEntry): V2ModelInfo {
+  const rawInput = entry.modalities?.input?.filter(
+    (m): m is string => typeof m === "string" && m.length > 0,
+  ) ?? ["text"];
+  const input = rawInput.length > 0 ? [...rawInput] : ["text"];
+  const variants: V2Variant[] = (entry.reasoningEfforts ?? []).map((effort) => ({
+    id: effort,
+    settings: { reasoningEffort: effort },
+  }));
+  return {
+    id: toConfigKey(entry.id),
+    modelID: entry.id,
+    providerID: COMMANDCODE_PROVIDER_ID,
+    name: entry.name,
+    capabilities: { tools: entry.tool_call, input, output: ["text"] },
+    limit: { context: entry.limit.context, output: entry.limit.output },
+    variants,
+    status: "active",
+    enabled: true,
+    // The bundled catalog carries no release dates; 0 sorts these last in the
+    // picker, so filter by provider "Command Code" (same convention as the
+    // cursor provider plugin).
+    time: { released: 0 },
+    cost: [
+      {
+        input: entry.cost.input,
+        output: entry.cost.output,
+        cache: { read: entry.cost.cache_read ?? 0, write: entry.cost.cache_write ?? 0 },
+      },
+    ],
+  };
+}
+
+export function buildV2Models(entries: ModelEntry[]): V2ModelInfo[] {
+  return entries.map(modelEntryToV2);
+}
+
+export function buildProviderInfo(): V2ProviderInfo {
+  return {
+    id: COMMANDCODE_PROVIDER_ID,
+    name: COMMANDCODE_PROVIDER_NAME,
+    activation: "enabled",
+    package: COMMANDCODE_PACKAGE,
+    integrationID: COMMANDCODE_INTEGRATION_ID,
+    settings: { baseURL: COMMANDCODE_BASE_URL },
+  };
+}
+
+/**
+ * Publish the catalog into the live provider inventory. A no-op while empty
+ * so a failed load keeps the last successful inventory (same convention as
+ * the cursor provider plugin).
+ */
+export function applyProviderInventory(
+  editor: V2ProviderEditor,
+  models: ModelEntry[],
+  sourceConnection?: unknown,
+): void {
+  if (models.length === 0) return;
+  editor.add({
+    info: buildProviderInfo(),
+    models: buildV2Models(models),
+    ...(sourceConnection === undefined ? {} : { sourceConnection }),
+  });
+}
+
+/** Register the `commandcode` integration: API-key entry plus env fallback. */
+export function applyIntegration(draft: V2IntegrationDraft): void {
+  draft.update(COMMANDCODE_INTEGRATION_ID, (integration) => {
+    integration.id = COMMANDCODE_INTEGRATION_ID;
+    integration.name = COMMANDCODE_PROVIDER_NAME;
+  });
+  draft.method.update({
+    integrationID: COMMANDCODE_INTEGRATION_ID,
+    method: { type: "key", label: "API Key" },
+  });
+  draft.method.update({
+    integrationID: COMMANDCODE_INTEGRATION_ID,
+    method: { type: "env", names: [...COMMANDCODE_ENV_NAMES] },
+  });
+}
+
+function loadBundledModels(): ModelEntry[] | null {
+  try {
+    const parsed = JSON.parse(readFileSync(MODELS_PATH, "utf-8")) as unknown;
+    if (!Array.isArray(parsed) || parsed.length === 0) return null;
+    return parsed as ModelEntry[];
+  } catch {
+    return null;
+  }
+}
+
+function readBundledManifest(): CatalogManifest | null {
+  if (!existsSync(MANIFEST_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(MANIFEST_PATH, "utf-8")) as CatalogManifest;
+  } catch {
+    return null;
+  }
+}
+
+function readBundledVersion(): string | null {
+  const manifest = readBundledManifest();
+  if (manifest?.commandCodeVersion) return manifest.commandCodeVersion;
+  if (!existsSync(VERSION_PATH)) return null;
+  try {
+    const first = readFileSync(VERSION_PATH, "utf-8").split("\n")[0]?.trim();
+    return first || null;
+  } catch {
+    return null;
+  }
+}
+
+export type V2CatalogSource = "bundled" | "cache" | "opt-in-local";
+
+export interface LoadedV2Catalog {
+  models: ModelEntry[];
+  source: V2CatalogSource;
+  commandCodeVersion: string | null;
+  degraded: boolean;
+  degradedReason: string | null;
+}
+
+/**
+ * Catalog resolution shared with the V1 `config` hook in `plugin.ts`:
+ * opt-in local `command-code` scrape first, then the bundled `models.json`,
+ * then the last-good cache. Always refreshes the cache and `startup.json`
+ * when models resolve. Keep the two in sync when this changes.
+ */
+export function loadCatalogForV2(): LoadedV2Catalog {
+  const pluginCfg = loadPluginFileConfig();
+  const debug = pluginCfg.debugStartupLogs === true;
+  const override =
+    pluginCfg.commandCodePackagePath?.trim() || process.env.COMMANDCODE_PACKAGE_PATH?.trim() || "";
+
+  let models: ModelEntry[] = [];
+  // Mirrors the V1 `config` hook: stays "bundled" when nothing resolves.
+  let source: V2CatalogSource = "bundled";
+  let commandCodeVersion: string | null = null;
+  let degraded = false;
+  let degradedReason: string | null = null;
+
+  if (override) {
+    const localCatalog = loadCatalogFromLocalCommandCode({ packagePath: override });
+    if (localCatalog && localCatalog.models.length > 0) {
+      models = localCatalog.models;
+      source = "opt-in-local";
+      commandCodeVersion = localCatalog.version;
+    }
+  }
+
+  if (models.length === 0) {
+    const bundled = loadBundledModels();
+    if (bundled) {
+      models = bundled;
+      source = "bundled";
+      commandCodeVersion = readBundledVersion();
+      const manifest = readBundledManifest();
+      if (manifest?.status === "degraded" || manifest?.status === "broken") {
+        degraded = true;
+        degradedReason =
+          manifest.status === "broken"
+            ? "bundled catalog marked broken"
+            : "bundled catalog has models with no listed price";
+      }
+    } else {
+      const cached = readCatalogCache();
+      if (cached) {
+        models = cached;
+        source = "cache";
+        degraded = true;
+        degradedReason = "bundled models.json unreadable; using last-good cache";
+      } else {
+        degraded = true;
+        degradedReason = "no bundled catalog and no cache";
+      }
+    }
+  }
+
+  if (models.length > 0) {
+    try {
+      writeCatalogCache(pluginStateDir(), models);
+    } catch {
+      // ignore cache write
+    }
+  }
+
+  const summary: StartupSummary = {
+    catalogSource: source,
+    commandCodeVersion,
+    modelCount: models.length,
+    reasoningModelCount: models.filter((m) => m.reasoning).length,
+    degraded,
+    degradedReason,
+  };
+  try {
+    writeStartupSummary(pluginStateDir(), summary);
+  } catch {
+    // ignore
+  }
+  if (debug) {
+    console.warn("[commandcode]", JSON.stringify(summary));
+  }
+
+  return { models, source, commandCodeVersion, degraded, degradedReason };
+}

package/src/publish-policy.ts

@@ -0,0 +1,32 @@
+export type CatalogSyncDecision = {
+  extract: boolean;
+  publishRetry: boolean;
+  exit: boolean;
+};
+
+export type PublishDecision = "publish" | "skip-no-token" | "skip-already-published";
+
+export function decideCatalogSync(input: {
+  force: boolean;
+  latestCommandCodeVersion: string;
+  bundledCommandCodeVersion: string | null;
+  pluginVersion: string;
+  publishedPluginVersions: string[];
+}): CatalogSyncDecision {
+  const published = input.publishedPluginVersions.includes(input.pluginVersion);
+  if (input.force || input.latestCommandCodeVersion !== input.bundledCommandCodeVersion) {
+    return { extract: true, publishRetry: false, exit: false };
+  }
+  if (!published) return { extract: false, publishRetry: true, exit: false };
+  return { extract: false, publishRetry: false, exit: true };
+}
+
+export function decidePublish(input: {
+  pluginVersion: string;
+  publishedPluginVersions: string[];
+  npmTokenSet: boolean;
+}): PublishDecision {
+  if (input.publishedPluginVersions.includes(input.pluginVersion)) return "skip-already-published";
+  if (!input.npmTokenSet) return "skip-no-token";
+  return "publish";
+}