@telsoncc/opencode-commandcode 1.0.5 → 1.1.0

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-09-25
+
+## [1.0.6] - 2026-09-24
+
 ## [1.0.5] - 2026-09-24
 
 ## [1.0.4] - 2026-09-23

package/_version.txt

@@ -1 +1 @@
-1.65.0
+1.65.2

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-09-24T11:09:40.846Z",
-  "pluginVersion": "1.0.5",
-  "commandCodeVersion": "1.65.0",
-  "commandCodeTarball": "https://registry.npmjs.org/command-code/-/command-code-1.65.0.tgz",
+  "generatedAt": "2026-09-24T21:10:50.082Z",
+  "pluginVersion": "1.1.0",
+  "commandCodeVersion": "1.65.2",
+  "commandCodeTarball": "https://registry.npmjs.org/command-code/-/command-code-1.65.2.tgz",
   "modelCount": 81,
   "reasoningModelCount": 68,
   "extraction": {

package/models.json

@@ -671,9 +671,9 @@
     ],
     "tool_call": true,
     "cost": {
-      "input": 0.3,
-      "output": 1.2,
-      "cache_read": 0.006
+      "input": 0.15,
+      "output": 0.6,
+      "cache_read": 0.003
     },
     "limit": {
       "context": 1000000,
@@ -2349,7 +2349,7 @@
       "cache_read": 0.02
     },
     "limit": {
-      "context": 1000000,
+      "context": 262144,
       "output": 131072
     },
     "attachment": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telsoncc/opencode-commandcode",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Command Code API provider for opencode — use Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, MiniMax, and Step models via Command Code",
   "keywords": [
     "ai",

package/plugin-opencode2.ts

@@ -3,7 +3,13 @@ import {
   COMMANDCODE_INTEGRATION_ID,
   applyIntegration,
   applyProviderInventory,
+  attachRemoteRefreshRunner,
+  isRemoteSyncDisabled,
   loadCatalogForV2,
+  persistRefreshedModels,
+  refreshCatalogFromRemote,
+  writeRemoteRefreshSummary,
+  type RemoteRefreshResult,
   type V2SetupContext,
 } from "./src/opencode2.js";
 import type { ModelEntry } from "./src/catalog.js";
@@ -15,7 +21,9 @@ import type { ModelEntry } from "./src/catalog.js";
  * Models register in memory via `ctx.provider.transform` + `editor.add` +
  * `reload()` — nothing is written into `opencode.json`. Auth registers a
  * `commandcode` integration (API key via `/connect`, `COMMANDCODE_API_KEY`
- * env fallback).
+ * env fallback). After startup the inventory refreshes itself from the live
+ * availability API every 6h (opt out with `disableModelSync` in
+ * `~/.config/opencode/opencode-commandcode.json`).
  *
  * Dual export: `{ id, setup, server }`. OpenCode 2.0 loads this module and
  * calls `setup()`; OpenCode 1.18.29+ prefers `exports["./server"]` and calls
@@ -39,7 +47,9 @@ export async function setup(ctx: V2SetupContext): Promise<() => Promise<void>> {
   );
 
   const catalog = loadCatalogForV2();
-  const inventory: ModelEntry[] = catalog.models;
+  // Reassigned by the remote refresh below; the provider transform closure
+  // replays against the current value on every reload().
+  let inventory: ModelEntry[] = catalog.models;
   let sourceConnection: unknown;
   const refreshConnection = async (): Promise<void> => {
     try {
@@ -61,6 +71,40 @@ export async function setup(ctx: V2SetupContext): Promise<() => Promise<void>> {
     // Keep the last-good inventory when the reload fails.
   }
 
+  // Live availability refresh: prune ids the API retired and surface new
+  // ones without waiting for an npm publish. The bundled catalog stays as
+  // the offline fallback; models unknown locally are reported, not
+  // published, until a catalog sync extracts their cost data.
+  const sameInventory = (next: ModelEntry[]): boolean =>
+    next.length === inventory.length && next.every((m, i) => m.id === inventory[i]?.id);
+
+  const syncFromRemote = async (): Promise<void> => {
+    if (isRemoteSyncDisabled()) return;
+    let result: RemoteRefreshResult;
+    try {
+      result = await refreshCatalogFromRemote(loadCatalogForV2().models);
+    } catch {
+      return;
+    }
+    writeRemoteRefreshSummary(result, catalog.commandCodeVersion);
+    if (result.models.length === 0 || sameInventory(result.models)) return;
+    inventory = result.models;
+    persistRefreshedModels(inventory);
+    try {
+      await ctx.provider.reload();
+    } catch {
+      // Keep serving the last-good inventory; the next tick retries.
+    }
+  };
+
+  let detachRefresh: (() => void) | null = null;
+  if (!isRemoteSyncDisabled()) {
+    detachRefresh = attachRemoteRefreshRunner(() => syncFromRemote());
+    void syncFromRemote().catch(() => {
+      // Startup already published the bundled inventory.
+    });
+  }
+
   // Rebind the inventory when credentials switch; the transform closure reads
   // the current `inventory`/`sourceConnection` on every replay.
   let stopped = false;
@@ -88,6 +132,7 @@ export async function setup(ctx: V2SetupContext): Promise<() => Promise<void>> {
 
   return async () => {
     stopped = true;
+    detachRefresh?.();
     for (const registration of registrations.reverse()) {
       try {
         await registration.dispose();

package/src/opencode2.ts

@@ -2,7 +2,14 @@ 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 {
+  MODELS_API_URL,
+  filterCatalogByAvailability,
+  parseAvailabilityIds,
+  toConfigKey,
+  loadCatalogFromLocalCommandCode,
+  type ModelEntry,
+} from "./catalog.js";
 import {
   readCatalogCache,
   writeCatalogCache,
@@ -241,7 +248,7 @@ function readBundledVersion(): string | null {
   }
 }
 
-export type V2CatalogSource = "bundled" | "cache" | "opt-in-local";
+export type V2CatalogSource = "bundled" | "cache" | "opt-in-local" | "remote";
 
 export interface LoadedV2Catalog {
   models: ModelEntry[];
@@ -334,3 +341,123 @@ export function loadCatalogForV2(): LoadedV2Catalog {
 
   return { models, source, commandCodeVersion, degraded, degradedReason };
 }
+
+export const REMOTE_SYNC_TIMEOUT_MS = 15_000;
+export const REMOTE_SYNC_INTERVAL_MS = 6 * 3600_000;
+
+export interface RemoteRefreshResult {
+  models: ModelEntry[];
+  unavailable: string[];
+  pendingNew: string[];
+  remoteCount: number;
+}
+
+/** Live availability ids from the Provider API. No auth required. */
+export async function fetchRemoteAvailability(
+  timeoutMs = REMOTE_SYNC_TIMEOUT_MS,
+): Promise<string[]> {
+  const response = await fetch(MODELS_API_URL, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!response.ok) {
+    throw new Error(`availability request failed: HTTP ${response.status}`);
+  }
+  return parseAvailabilityIds(await response.json());
+}
+
+/**
+ * Reconcile a local catalog with live availability: keep the ids the API
+ * still serves, report retired ones, and list remote ids missing locally.
+ * Missing ids are *not* published — they carry no cost/limit data until a
+ * catalog sync extracts them.
+ */
+export function applyRemoteAvailability(
+  base: ModelEntry[],
+  remoteIds: string[],
+): RemoteRefreshResult {
+  const { retained, unavailable } = filterCatalogByAvailability(base, remoteIds);
+  const known = new Set(base.map((m) => m.id));
+  const pendingNew = [...new Set(remoteIds)].filter((id) => !known.has(id)).sort();
+  return { models: retained, unavailable, pendingNew, remoteCount: remoteIds.length };
+}
+
+export async function refreshCatalogFromRemote(
+  base: ModelEntry[],
+  timeoutMs = REMOTE_SYNC_TIMEOUT_MS,
+): Promise<RemoteRefreshResult> {
+  return applyRemoteAvailability(base, await fetchRemoteAvailability(timeoutMs));
+}
+
+export function isRemoteSyncDisabled(): boolean {
+  return loadPluginFileConfig().disableModelSync === true;
+}
+
+/** Overwrite the last-good disk cache with a refreshed inventory. */
+export function persistRefreshedModels(models: ModelEntry[]): void {
+  if (models.length === 0) return;
+  try {
+    writeCatalogCache(pluginStateDir(), models);
+  } catch {
+    // ignore cache write
+  }
+}
+
+export function writeRemoteRefreshSummary(
+  result: RemoteRefreshResult,
+  commandCodeVersion: string | null,
+): void {
+  const summary: StartupSummary = {
+    catalogSource: "remote",
+    commandCodeVersion,
+    modelCount: result.models.length,
+    reasoningModelCount: result.models.filter((m) => m.reasoning).length,
+    degraded: result.models.length === 0,
+    degradedReason:
+      result.models.length === 0 ? "remote availability matched no local models" : null,
+    pendingNewCount: result.pendingNew.length,
+  };
+  try {
+    writeStartupSummary(pluginStateDir(), summary);
+  } catch {
+    // ignore
+  }
+}
+
+const remoteRefreshRunners = new Set<() => Promise<void>>();
+let remoteRefreshTimer: ReturnType<typeof setInterval> | null = null;
+
+export function remoteRefreshRunnerCount(): number {
+  return remoteRefreshRunners.size;
+}
+
+/**
+ * Share one interval across setups in the process. Returns a detach
+ * function; the timer stops after the last runner detaches.
+ */
+export function attachRemoteRefreshRunner(
+  run: () => Promise<void>,
+  intervalMs = REMOTE_SYNC_INTERVAL_MS,
+): () => void {
+  remoteRefreshRunners.add(run);
+  if (!remoteRefreshTimer) {
+    remoteRefreshTimer = setInterval(() => {
+      for (const runner of remoteRefreshRunners) {
+        void runner().catch(() => {
+          // A failed refresh keeps the last inventory; the next tick retries.
+        });
+      }
+    }, intervalMs);
+    remoteRefreshTimer.unref?.();
+  }
+  let detached = false;
+  return () => {
+    if (detached) return;
+    detached = true;
+    remoteRefreshRunners.delete(run);
+    if (remoteRefreshRunners.size === 0 && remoteRefreshTimer) {
+      clearInterval(remoteRefreshTimer);
+      remoteRefreshTimer = null;
+    }
+  };
+}

package/src/startup.ts

@@ -6,12 +6,14 @@ import type { ModelEntry } from "./catalog.js";
 export type { ModelEntry } from "./catalog.js";
 
 export type StartupSummary = {
-  catalogSource: "bundled" | "cache" | "opt-in-local";
+  catalogSource: "bundled" | "cache" | "opt-in-local" | "remote";
   commandCodeVersion: string | null;
   modelCount: number;
   reasoningModelCount: number;
   degraded: boolean;
   degradedReason: string | null;
+  /** Remote ids with no local cost data yet — next catalog sync picks them up. */
+  pendingNewCount?: number;
 };
 
 export function pluginStateDir(): string {