fix(catalog): route sync writes through validated artifacts

Author: BrainerVirus

scripts/sync-models.ts

@@ -265,15 +265,19 @@ async function main() {
   console.log("Fetching callable model availability...");
   const availableIds = await fetchAvailabilityIds();
   console.log(`  Callable models: ${availableIds.length}`);
-  const { retained, unavailable } = filterCatalogByAvailability(candidates, availableIds);
-  console.log(`  Retained ${retained.length}, excluded ${unavailable.length} unavailable`);
+  // Enrichment mutates entries in place, so filter the extracted candidates
+  // first and run the floor gate before any cost work or artifact write.
+  const prefiltered = filterCatalogByAvailability(candidates, availableIds);
+  console.log(
+    `  Retained ${prefiltered.retained.length}, excluded ${prefiltered.unavailable.length} unavailable`,
+  );
   const last = lastSuccessfulModelCount(priorManifest);
-  if (!meetsModelCountFloor(retained.length, last)) {
+  if (!meetsModelCountFloor(prefiltered.retained.length, last)) {
     throw new Error(
-      `filtered model count ${retained.length} below floor (lastSuccessful=${last}); leaving generated artifacts unchanged`,
+      `filtered model count ${prefiltered.retained.length} below floor (lastSuccessful=${last}); leaving generated artifacts unchanged`,
     );
   }
-  const entries = retained;
+  const entries = prefiltered.retained;
 
   const cliIds = bundleSource ? cliCostIds(bundleSource) : new Set<string>();
   const docIds = new Set<string>();
@@ -307,48 +311,32 @@ async function main() {
   const modalityFilled = applyModelsDevModalities(entries, modelsDevRows);
   console.log(`  Applied models.dev modalities to ${modalityFilled} models`);
 
-  console.log(`\nWriting ${MODELS_JSON} with ${entries.length} models from ${sourceLabel}...`);
-  writeFileSync(MODELS_JSON, JSON.stringify(entries, null, 2) + "\n", "utf-8");
-  writeFileSync(VERSION_PATH, `${version}\n`, "utf-8");
-
+  // Entries are already filtered above; buildSyncArtifacts re-validates the
+  // floor and returns every generated payload before the first write.
   const pluginVersion = (JSON.parse(readFileSync(PACKAGE_JSON, "utf-8")) as { version: string })
     .version;
-  const unmatchedIds = entries
-    .filter(
-      (e) =>
-        !cliIds.has(e.id) && !docIds.has(e.id) && !freeIds.has(e.id) && !thirdPartyIds.has(e.id),
-    )
-    .map((e) => e.id);
-  const costSources = countCostSources({
-    modelIds: entries.map((e) => e.id),
+  const artifacts = buildSyncArtifacts({
+    candidates: entries,
+    version,
+    sourceLabel,
+    pluginVersion,
+    availableIds,
+    priorManifest,
     cliIds,
-    officialDocIds: docIds,
+    docIds,
     thirdPartyIds,
     freeIds,
+    generatedAt: new Date().toISOString(),
   });
-  writeManifest(
-    MANIFEST_PATH,
-    buildManifest({
-      pluginVersion,
-      commandCodeVersion: version,
-      commandCodeTarball: commandCodeTarballUrl(version),
-      modelCount: entries.length,
-      reasoningModelCount: entries.filter((e) => e.reasoning).length,
-      modelCatalogOk: true,
-      costSources,
-      review: withUnavailableIds(
-        {
-          thirdParty: [...thirdPartyIds],
-          free: [...freeIds],
-          unmatched: unmatchedIds,
-        },
-        unavailable,
-      ),
-      generatedAt: new Date().toISOString(),
-    }),
+
+  console.log(
+    `\nWriting ${MODELS_JSON} with ${artifacts.models.length} models from ${sourceLabel}...`,
   );
+  writeFileSync(MODELS_JSON, JSON.stringify(artifacts.models, null, 2) + "\n", "utf-8");
+  writeFileSync(VERSION_PATH, `${artifacts.version}\n`, "utf-8");
+  writeManifest(MANIFEST_PATH, artifacts.manifest);
 
-  const modelsObj = generateOpencodeModels(entries);
+  const modelsObj = generateOpencodeModels(artifacts.models);
 
   if (shouldUpdateGlobal) {
     console.log("Updating global config...");
@@ -373,4 +361,9 @@ async function main() {
   console.log("\nDone.");
 }
 
-main();
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  });
+}

src/catalog.ts

@@ -783,8 +783,6 @@ export function generateOpencodeModels(entries: ModelEntry[]): Record<string, un
 
 export const MODELS_API_URL = "https://api.commandcode.ai/provider/v1/models";
 
-export const UNAVAILABLE_REASON = "not-listed-by-provider-api";
-
 export interface FilteredCatalog<T extends { id: string }> {
   retained: T[];
   unavailable: string[];
@@ -822,17 +820,6 @@ export function parseAvailabilityIds(payload: unknown): string[] {
   return ids;
 }
 
-/** Exact, case-sensitive intersection of candidate and API IDs. API-only IDs are not synthesized. */
-export function intersectAvailability(
-  candidateIds: string[],
-  availableIds: string[],
-): { retained: string[]; unavailable: string[] } {
-  const available = new Set(availableIds);
-  const retained = candidateIds.filter((id) => available.has(id));
-  const unavailable = candidateIds.filter((id) => !available.has(id)).sort();
-  return { retained, unavailable };
-}
-
 /** Retain only candidates whose exact ID is callable; collect sorted excluded IDs. */
 export function filterCatalogByAvailability<T extends { id: string }>(
   candidates: T[],

tests/unit/catalog.test.ts

@@ -4,7 +4,6 @@ import {
   disambiguateModelNames,
   filterCatalogByAvailability,
   generateOpencodeModels,
-  intersectAvailability,
   loadCatalogFromBundle,
   parseAvailabilityIds,
   resolveCommandCodePackage,
@@ -359,17 +358,6 @@ describe("parseAvailabilityIds", () => {
   });
 });
 
-describe("intersectAvailability", () => {
-  test("retains only exact, case-sensitive matches and sorts exclusions", () => {
-    const result = intersectAvailability(
-      ["claude-sonnet-4-6", "GPT-5.5", "retired-promo"],
-      ["claude-sonnet-4-6", "gpt-5.5"],
-    );
-    expect(result.retained).toEqual(["claude-sonnet-4-6"]);
-    expect(result.unavailable).toEqual(["GPT-5.5", "retired-promo"]);
-  });
-});
-
 describe("filterCatalogByAvailability", () => {
   const entry = (id: string): ModelEntry => ({
     id,
@@ -390,4 +378,21 @@ describe("filterCatalogByAvailability", () => {
     expect(unavailable).toEqual(["retired"]);
     expect(retained.some((e) => e.id === "api-only")).toBe(false);
   });
+
+  test("matching is exact and case-sensitive", () => {
+    const { retained, unavailable } = filterCatalogByAvailability(
+      [entry("claude-sonnet-4-6"), entry("GPT-5.5"), entry("retired-promo")],
+      ["claude-sonnet-4-6", "gpt-5.5"],
+    );
+    expect(retained.map((e) => e.id)).toEqual(["claude-sonnet-4-6"]);
+    expect(unavailable).toEqual(["GPT-5.5", "retired-promo"]);
+  });
+
+  test("CLI-derived and HARDCODED_EXTRAS candidates pass through the same filter", () => {
+    const { retained } = filterCatalogByAvailability(
+      [entry("Qwen/Qwen3.7-Max"), entry("cli-model")],
+      ["Qwen/Qwen3.7-Max", "cli-model"],
+    );
+    expect(retained.map((e) => e.id).sort()).toEqual(["Qwen/Qwen3.7-Max", "cli-model"]);
+  });
 });

tests/unit/release-workflow.test.ts

@@ -1,6 +1,21 @@
 import { expect, test, describe } from "bun:test";
-import { readFileSync } from "fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "os";
 import { join } from "path";
+import { buildManifest, withPluginVersion } from "../../src/manifest.ts";
+
+const buildManifestForVersion = (pluginVersion: string) =>
+  buildManifest({
+    pluginVersion,
+    commandCodeVersion: "1.38.1",
+    commandCodeTarball: "https://registry.npmjs.org/command-code/-/command-code-1.38.1.tgz",
+    modelCount: 2,
+    reasoningModelCount: 1,
+    modelCatalogOk: true,
+    costSources: { cli: 2, officialDocs: 0, thirdParty: 0, free: 0, fallback: 0, unmatched: 0 },
+    generatedAt: "2026-08-28T17:00:00.000Z",
+  });
 
 const ROOT = join(import.meta.dir, "../..");
 const read = (rel: string) => readFileSync(join(ROOT, rel), "utf-8");
@@ -200,18 +215,33 @@ describe("release.config.cjs", () => {
 });
 
 describe("prepare-release-manifest.ts", () => {
-  test("updates only pluginVersion from the release version", () => {
-    const src = read("scripts/prepare-release-manifest.ts");
-    expect(src).toContain("withPluginVersion");
-    expect(src).toContain("process.argv");
+  test("sets only pluginVersion from the release version", () => {
+    expect(read("scripts/prepare-release-manifest.ts")).toContain("withPluginVersion");
+    const manifest = buildManifestForVersion("0.5.0");
+    const updated = withPluginVersion(manifest, "0.6.0");
+    expect(updated.pluginVersion).toBe("0.6.0");
+    expect(updated.modelCount).toBe(manifest.modelCount);
   });
 });
 
 describe("verify-manifest-version.ts", () => {
-  test("guards the packed manifest against the package version", () => {
-    const src = read("scripts/verify-manifest-version.ts");
-    expect(src).toContain("pluginVersion");
-    expect(src).toContain("process.exit");
+  test("exits non-zero for mismatched versions and zero for equal versions", () => {
+    const dir = mkdtempSync(join(tmpdir(), "cc-mmv-"));
+    try {
+      writeFileSync(join(dir, "package.json"), JSON.stringify({ version: "1.0.0" }));
+      writeFileSync(join(dir, "manifest.json"), JSON.stringify({ pluginVersion: "9.9.9" }));
+      expect(spawnSync("bun", ["run", "scripts/verify-manifest-version.ts", dir]).status).not.toBe(
+        0,
+      );
+      writeFileSync(join(dir, "manifest.json"), JSON.stringify({ pluginVersion: "1.0.0" }));
+      const ok = spawnSync("bun", ["run", "scripts/verify-manifest-version.ts", dir], {
+        encoding: "utf-8",
+      });
+      expect(ok.status).toBe(0);
+      expect(ok.stdout).toContain("1.0.0");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
     expect(json<{ scripts?: Record<string, string> }>("package.json").scripts?.prepack).toContain(
       "verify-manifest-version",
     );
@@ -240,5 +270,9 @@ describe("verify-release-candidate.ts", () => {
   test("rejects a packed manifest whose pluginVersion differs from package.json", () => {
     const src = read("scripts/verify-release-candidate.ts");
     expect(src).toContain("pluginVersion");
+    const packed = JSON.parse(read("manifest.json")) as { pluginVersion?: string };
+    expect(packed.pluginVersion).toBe(
+      (JSON.parse(read("package.json")) as { version: string }).version,
+    );
   });
 });

tests/unit/sync-models.test.ts

@@ -93,7 +93,7 @@ describe("buildSyncArtifacts", () => {
     ]);
   });
 
-  test("a validation failure builds nothing and leaves generated artifacts byte-for-byte unchanged", () => {
+  test("buildSyncArtifacts never writes generated artifacts, even on success", () => {
     const dir = mkdtempSync(join(tmpdir(), "cc-sync-"));
     try {
       const modelsPath = join(dir, "models.json");
@@ -107,6 +107,8 @@ describe("buildSyncArtifacts", () => {
         manifest: readFileSync(manifestPath, "utf-8"),
         version: readFileSync(versionPath, "utf-8"),
       };
+      // Throws on the floor (1 retained < 20) — the only path that must not write.
+      // Success returns payloads for main() to write after every build succeeds.
       expect(() =>
         buildSyncArtifacts({
           ...base,