Fix Codex catalog injection on Windows

Codex · Codex · commit 060f51d9a693 · 2026-06-19T23:45:34.000+09:00
diff --git a/src/cli.ts b/src/cli.ts
@@ -37,9 +37,12 @@ async function syncModelsToCodex(port?: number) {
   const { injectCodexConfig } = await import("./codex-inject");
   const result = await injectCodexConfig(p, config);
   try {
-    const { syncCatalogModels } = await import("./codex-catalog");
+    const { invalidateCodexModelsCache, syncCatalogModels } = await import("./codex-catalog");
     const cat = await syncCatalogModels(config);
-    if (cat.added > 0) console.log(`   + ${cat.added} models appended to Codex catalog (${cat.path})`);
+    if (cat.added > 0) {
+      invalidateCodexModelsCache();
+      console.log(`   + ${cat.added} models appended to Codex catalog (${cat.path})`);
+    }
   } catch (e) {
     console.error("catalog sync skipped:", e instanceof Error ? e.message : String(e));
   }
diff --git a/src/codex-catalog.ts b/src/codex-catalog.ts
@@ -2,12 +2,11 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFil
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { atomicWriteFile } from "./config";
+import { CODEX_CONFIG_PATH, CODEX_MODELS_CACHE_PATH, DEFAULT_CATALOG_PATH, readRootTomlString, resolveCodexConfigPath } from "./codex-paths";
 import { DEFAULT_MODEL_CACHE_TTL_MS, getFreshCached, getStaleCached, setCached } from "./model-cache";
 import { buildModelsRequest, resolveModelsAuthToken } from "./oauth/index";
 import type { OcxConfig, OcxProviderConfig } from "./types";
 
-const CODEX_CONFIG_PATH = join(homedir(), ".codex", "config.toml");
-const DEFAULT_CATALOG_PATH = join(homedir(), ".codex", "opencodex-catalog.json");
 const OCX_DIR = join(homedir(), ".opencodex");
 const CATALOG_BACKUP_PATH = join(OCX_DIR, "catalog-backup.json");
 
@@ -40,8 +39,8 @@ export function readCodexCatalogPath(): string {
   try {
     if (existsSync(CODEX_CONFIG_PATH)) {
       const toml = readFileSync(CODEX_CONFIG_PATH, "utf-8");
-      const m = toml.match(/^\s*model_catalog_json\s*=\s*"([^"]+)"/m);
-      if (m) return m[1];
+      const path = readRootTomlString(toml, "model_catalog_json");
+      if (path) return resolveCodexConfigPath(path);
     }
   } catch { /* ignore */ }
   return DEFAULT_CATALOG_PATH;
@@ -55,13 +54,36 @@ function readCatalog(path: string): { models?: RawEntry[]; [k: string]: unknown
   } catch { return null; }
 }
 
+function normalizeServiceTiers(entry: RawEntry): RawEntry {
+  if (entry.service_tier === "priority") entry.service_tier = "fast";
+  if (Array.isArray(entry.service_tiers)) {
+    entry.service_tiers = entry.service_tiers.map(tier => {
+      if (tier && typeof tier === "object" && "id" in tier && tier.id === "priority") {
+        return { ...tier, id: "fast" };
+      }
+      return tier;
+    });
+  }
+  return entry;
+}
+
+function loadCatalogForSync(path: string): { models?: RawEntry[]; [k: string]: unknown } | null {
+  const catalog = readCatalog(path);
+  if (catalog) return catalog;
+  return readCatalog(CODEX_MODELS_CACHE_PATH);
+}
+
+function readCurrentCatalogOrCache(): { models?: RawEntry[]; [k: string]: unknown } | null {
+  return readCatalog(readCodexCatalogPath()) ?? readCatalog(CODEX_MODELS_CACHE_PATH);
+}
+
 /**
  * A full native entry from the on-disk catalog, used as a clone template so injected
  * entries carry EVERY field Codex's strict parser requires (e.g. `base_instructions`).
  * Returns a deep copy, or null if no catalog/native entry exists.
  */
 export function loadCatalogTemplate(): RawEntry | null {
-  const cat = readCatalog(readCodexCatalogPath());
+  const cat = readCurrentCatalogOrCache();
   const native = cat?.models?.find(
     m => typeof m.slug === "string" && !m.slug.includes("/") && "base_instructions" in m,
   );
@@ -109,16 +131,16 @@ function deriveEntry(template: RawEntry | null, slug: string, desc: string, prio
       e.supported_reasoning_levels = ROUTED_REASONING_LEVELS.map(l => byEffort.get(l.effort) ?? { ...l });
       e.default_reasoning_level = "medium";
     }
-    return e;
+    return normalizeServiceTiers(e);
   }
   // Fallback when no template is available (best-effort; strict parser may need more).
-  return {
+  return normalizeServiceTiers({
     slug, display_name: slug, description: desc,
     default_reasoning_level: "medium",
     supported_reasoning_levels: ROUTED_REASONING_LEVELS.map(l => ({ ...l })),
     shell_type: "shell_command", visibility: "list", supported_in_api: true,
     priority, base_instructions: "You are a helpful coding assistant.",
-  };
+  });
 }
 
 /**
@@ -149,7 +171,7 @@ export function buildCatalogEntries(template: RawEntry | null, gptSlugs: string[
 
 /** Bare picker-visible native slugs in the live Codex catalog (drives the subagent picker UI). */
 export function listCatalogNativeSlugs(): string[] {
-  const cat = readCatalog(readCodexCatalogPath());
+  const cat = readCurrentCatalogOrCache();
   return (cat?.models ?? [])
     .filter(m => typeof m.slug === "string" && !(m.slug as string).includes("/") && m.visibility === "list")
     .map(m => m.slug as string);
@@ -244,7 +266,7 @@ export function orderForSubagents(goModels: CatalogModel[], featured?: string[])
  */
 export async function syncCatalogModels(config: OcxConfig): Promise<{ added: number; path: string }> {
   const catalogPath = readCodexCatalogPath();
-  const catalog = readCatalog(catalogPath);
+  const catalog = loadCatalogForSync(catalogPath);
   if (!catalog) return { added: 0, path: catalogPath };
 
   const template = (catalog.models ?? []).find(
@@ -272,9 +294,9 @@ export async function syncCatalogModels(config: OcxConfig): Promise<{ added: num
     .map(m => {
       const slug = m.slug as string;
       const priority = rank.has(slug) ? rank.get(slug)! : (baseline.get(slug) ?? (m.priority as number));
-      return { ...m, priority };
+      return normalizeServiceTiers({ ...m, priority });
     });
-  catalog.models = [...native, ...goEntries];
+  catalog.models = [...native, ...goEntries].map(m => normalizeServiceTiers(m));
 
   try {
     if (!existsSync(OCX_DIR)) mkdirSync(OCX_DIR, { recursive: true });
diff --git a/src/codex-inject.ts b/src/codex-inject.ts
@@ -1,14 +1,9 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { atomicWriteFile } from "./config";
 import { restoreCodexCatalog } from "./codex-catalog";
+import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH, DEFAULT_CATALOG_PATH, parseTomlString, readRootTomlString, tomlString } from "./codex-paths";
 import type { OcxConfig } from "./types";
 
-const CODEX_HOME = join(homedir(), ".codex");
-const CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
-const CODEX_PROFILE_PATH = join(CODEX_HOME, "opencodex.config.toml");
-
 const OCX_SECTION_MARKER = "# Auto-injected by opencodex";
 
 /**
@@ -31,6 +26,15 @@ function buildProviderTableBlock(port: number): string {
   return lines.join("\n") + "\n";
 }
 
+function buildProfileTableBlock(catalogPath: string): string {
+  return [
+    "",
+    "[profiles.opencodex]",
+    'model_provider = "opencodex"',
+    `model_catalog_json = ${tomlString(catalogPath)}`,
+  ].join("\n") + "\n";
+}
+
 /**
  * Strip every existing `model_provider` line that we must not duplicate: any line set to
  * "opencodex" (wherever it sits — including a previously mis-nested one under a table), plus any
@@ -70,11 +74,65 @@ function setRootModelProvider(content: string): string {
   return lines.join("\n");
 }
 
-function buildProfileFile(port: number): string {
+function readRootModelCatalogPath(content: string): string | null {
+  return readRootTomlString(content, "model_catalog_json");
+}
+
+function setRootModelCatalogPath(content: string, catalogPath: string): string {
+  if (readRootModelCatalogPath(content)) return content;
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  const key = `model_catalog_json = ${tomlString(catalogPath)}`;
+  if (firstTable === -1) {
+    return content.replace(/\n+$/, "") + "\n" + key + "\n";
+  }
+  let insertAt = firstTable;
+  while (insertAt > 0 && lines[insertAt - 1].trim() === "") insertAt--;
+  lines.splice(insertAt, 0, key);
+  return lines.join("\n");
+}
+
+function removeProfileSection(content: string): string {
+  const lines = content.split("\n");
+  const filtered: string[] = [];
+  let inProfile = false;
+  for (const line of lines) {
+    if (line.trim() === "[profiles.opencodex]") {
+      inProfile = true;
+      continue;
+    }
+    if (inProfile) {
+      if (line.startsWith("[") && line.trim() !== "[profiles.opencodex]") {
+        inProfile = false;
+        filtered.push(line);
+      }
+      continue;
+    }
+    filtered.push(line);
+  }
+  return filtered.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+function normalizeServiceTier(content: string): string {
+  return content.replace(/^(\s*service_tier\s*=\s*)["']priority["']\s*$/gm, '$1"fast"');
+}
+
+function stripDefaultCatalogPath(content: string): string {
+  return content
+    .split("\n")
+    .filter(line => {
+      const m = line.match(/^\s*model_catalog_json\s*=\s*("(?:\\.|[^"])*"|'[^']*')\s*$/);
+      return !m || parseTomlString(m[1]) !== DEFAULT_CATALOG_PATH;
+    })
+    .join("\n");
+}
+
+function buildProfileFile(port: number, catalogPath: string): string {
   return [
     "# OpenCodex proxy profile — use with: codex --profile opencodex",
     `# Routes all model requests through the opencodex proxy at localhost:${port}`,
     'model_provider = "opencodex"',
+    `model_catalog_json = ${tomlString(catalogPath)}`,
     "",
   ].join("\n");
 }
@@ -92,15 +150,21 @@ export async function injectCodexConfig(port: number, _config?: OcxConfig): Prom
   if (content.includes("[model_providers.opencodex]")) {
     content = removeOcxSection(content);
   }
+  content = removeProfileSection(content);
   content = stripExistingModelProvider(content);
+  content = normalizeServiceTier(content);
+
+  const catalogPath = readRootModelCatalogPath(content) ?? DEFAULT_CATALOG_PATH;
+  content = setRootModelCatalogPath(content, catalogPath);
 
   // 1) Root key BEFORE the first table header (must be a global, not nested under a table).
   content = setRootModelProvider(content);
   // 2) Provider table appended at EOF (position-independent).
   content = content.trimEnd() + "\n" + buildProviderTableBlock(port);
+  content = content.trimEnd() + "\n" + buildProfileTableBlock(catalogPath);
 
   writeFileSync(CODEX_CONFIG_PATH, content, "utf-8");
-  writeFileSync(CODEX_PROFILE_PATH, buildProfileFile(port), "utf-8");
+  writeFileSync(CODEX_PROFILE_PATH, buildProfileFile(port, catalogPath), "utf-8");
 
   return {
     success: true,
@@ -141,9 +205,11 @@ export function stripOpencodexConfig(content: string): string {
   if (out.includes("[model_providers.opencodex]")) {
     out = removeOcxSection(out);
   }
+  out = removeProfileSection(out);
   // Regex (not exact-string) removal so compact `model_provider="opencodex"` is stripped too —
   // must match the detection regex above, or a detected line could survive un-removed.
   out = out.split("\n").filter(l => !/^\s*model_provider\s*=\s*"opencodex"\s*$/.test(l)).join("\n");
+  out = stripDefaultCatalogPath(out);
   return out.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
 }
 
diff --git a/src/codex-paths.ts b/src/codex-paths.ts
@@ -0,0 +1,59 @@
+import { realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+
+function resolveCodexHome(): string {
+  const raw = process.env.CODEX_HOME?.trim();
+  if (raw) {
+    const path = resolve(raw);
+    let stat;
+    try {
+      stat = statSync(path);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`CODEX_HOME points to ${raw}, but that path could not be read: ${message}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`CODEX_HOME points to ${raw}, but that path is not a directory`);
+    }
+    return realpathSync.native(path);
+  }
+
+  return join(homedir(), ".codex");
+}
+
+export const CODEX_HOME = resolveCodexHome();
+export const CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
+export const CODEX_PROFILE_PATH = join(CODEX_HOME, "opencodex.config.toml");
+export const DEFAULT_CATALOG_PATH = join(CODEX_HOME, "opencodex-catalog.json");
+export const CODEX_MODELS_CACHE_PATH = join(CODEX_HOME, "models_cache.json");
+
+export function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+export function parseTomlString(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try {
+      return JSON.parse(raw) as string;
+    } catch {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw.slice(1, -1);
+}
+
+export function readRootTomlString(content: string, key: string): string | null {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  const rootLines = firstTable === -1 ? lines : lines.slice(0, firstTable);
+  for (const line of rootLines) {
+    const m = line.match(new RegExp(`^\\s*${key}\\s*=\\s*(\"(?:\\\\.|[^\"])*\"|'[^']*')`));
+    if (m) return parseTomlString(m[1]);
+  }
+  return null;
+}
+
+export function resolveCodexConfigPath(path: string): string {
+  return isAbsolute(path) ? path : join(CODEX_HOME, path);
+}
