@bitkyc08/opencodex 0.2.1 → 1.9.0

package/src/cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { execFileSync } from "node:child_process";
 import { restoreNativeCodex } from "./codex-inject";
 import { loadConfig, readPid, removePid, writePid } from "./config";
 import { serviceCommand } from "./service";
@@ -37,9 +38,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));
   }
@@ -85,32 +89,59 @@ function handleStart() {
 }
 
 function killProxy(pid: number): void {
+  if (!isProcessAlive(pid)) return;
   if (process.platform === "win32") {
+    const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
     try {
-      (require("node:child_process") as typeof import("node:child_process"))
-        .execSync(`taskkill /PID ${pid} /T /F`, { stdio: "pipe" });
-    } catch { /* process already gone */ }
+      execFileSync(taskkill, ["/PID", String(pid), "/T", "/F"], { stdio: "pipe" });
+    } catch (err) {
+      if (isProcessAlive(pid)) throw err;
+    }
   } else {
     process.kill(pid, "SIGTERM");
+    if (!waitForExit(pid, 5000)) process.kill(pid, "SIGKILL");
+  }
+  if (!waitForExit(pid, 5000)) throw new Error(`process ${pid} did not exit`);
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
 }
 
+function waitForExit(pid: number, timeoutMs: number): boolean {
+  const deadline = Date.now() + timeoutMs;
+  const marker = new Int32Array(new SharedArrayBuffer(4));
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    Atomics.wait(marker, 0, 0, 50);
+  }
+  return !isProcessAlive(pid);
+}
+
 function handleStop() {
   const pid = readPid();
+  let stopFailed = false;
   if (pid) {
     try {
       killProxy(pid);
       console.log(`✅ Proxy (PID ${pid}) stopped.`);
+      removePid();
     } catch {
-      console.log("Proxy process not found.");
+      stopFailed = true;
+      console.error(`❌ Failed to stop proxy (PID ${pid}).`);
     }
-    removePid();
   } else {
     console.log("No running proxy found.");
   }
   // Recover native Codex so plain `codex` keeps working while the proxy is down.
   const r = restoreNativeCodex();
   console.log(`↩️  ${r.message}`);
+  if (stopFailed) process.exit(1);
 }
 
 function handleStatus() {

package/src/codex-catalog.ts

@@ -1,13 +1,14 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { atomicWriteFile } from "./config";
+import { atomicWriteFile, websocketsEnabled } 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";
+import { getJawcodeModelMetadata, getJawcodeModelMetadataCaseInsensitive, listJawcodeModelMetadata, resolveJawcodeProvider } from "./generated/jawcode-model-metadata";
+import { shouldCaseFoldMetadataModelId } from "./providers/derive";
 
-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");
 
@@ -34,14 +35,15 @@ export function nativeOpenAiSlugs(): string[] {
 
 export interface CatalogModel { id: string; provider: string; owned_by?: string; }
 type RawEntry = Record<string, unknown>;
+const JAWCODE_CATALOG_AUGMENT_PROVIDERS = new Set(["opencode-go"]);
 
 /** Resolve the `model_catalog_json` path from Codex config.toml, else the default. */
 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 +57,86 @@ function readCatalog(path: string): { models?: RawEntry[]; [k: string]: unknown
   } catch { return null; }
 }
 
+function normalizeServiceTiers(entry: RawEntry): RawEntry {
+  // Codex stores the user-facing config spelling as "fast", but the catalog/request
+  // service tier id is "priority" in current codex-rs. Keep legacy catalogs working.
+  if (entry.service_tier === "fast") entry.service_tier = "priority";
+  if (Array.isArray(entry.service_tiers)) {
+    entry.service_tiers = entry.service_tiers.map(tier => {
+      if (tier && typeof tier === "object" && "id" in tier && tier.id === "fast") {
+        return { ...tier, id: "priority" };
+      }
+      return tier;
+    });
+  }
+  return entry;
+}
+
+function ensureAutoCompactTokenLimit(entry: RawEntry): RawEntry {
+  if (
+    typeof entry.context_window === "number"
+    && entry.context_window > 0
+    && typeof entry.auto_compact_token_limit !== "number"
+  ) {
+    entry.auto_compact_token_limit = Math.floor(entry.context_window * 0.9);
+  }
+  return entry;
+}
+
+export function normalizeRoutedCatalogEntry(entry: RawEntry): RawEntry {
+  delete entry.model_messages;
+  delete entry.tool_mode;
+  delete entry.multi_agent_version;
+  delete entry.use_responses_lite;
+  delete entry.supports_websockets;
+  delete entry.additional_speed_tiers;
+  delete entry.service_tier;
+  delete entry.service_tiers;
+  delete entry.default_service_tier;
+  // Routed providers use opencodex sidecars and client-executed tool discovery. The sidecar
+  // runs through native gpt-5.4-mini, so image search is available and verbalized for text-only models.
+  entry.web_search_tool_type = "text_and_image";
+  entry.supports_search_tool = true;
+  return ensureAutoCompactTokenLimit(entry);
+}
+
+function applyJawcodeCatalogMetadata(entry: RawEntry, slug: string): void {
+  const slash = slug.indexOf("/");
+  if (slash < 0) return;
+  const provider = slug.slice(0, slash);
+  const modelId = slug.slice(slash + 1);
+  const jawcodeProvider = resolveJawcodeProvider(provider);
+  if (!jawcodeProvider) return;
+  const meta = getJawcodeModelMetadata(jawcodeProvider, modelId)
+    ?? (shouldCaseFoldMetadataModelId(provider) ? getJawcodeModelMetadataCaseInsensitive(jawcodeProvider, modelId) : undefined);
+  if (!meta) return;
+  if (typeof meta.contextWindow === "number" && meta.contextWindow > 0) {
+    entry.context_window = meta.contextWindow;
+    entry.max_context_window = meta.contextWindow;
+    entry.auto_compact_token_limit = Math.floor(meta.contextWindow * 0.9);
+  }
+  if (Array.isArray(meta.input) && meta.input.length > 0) {
+    entry.input_modalities = meta.input;
+  }
+}
+
+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,
   );
@@ -108,17 +183,22 @@ 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";
+      normalizeRoutedCatalogEntry(e);
+      applyJawcodeCatalogMetadata(e, slug);
     }
-    return e;
+    return ensureAutoCompactTokenLimit(normalizeServiceTiers(e));
   }
   // Fallback when no template is available (best-effort; strict parser may need more).
-  return {
+  const entry: RawEntry = {
     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.",
+    ...(slug.includes("/") ? { web_search_tool_type: "text_and_image", supports_search_tool: true } : {}),
   };
+  applyJawcodeCatalogMetadata(entry, slug);
+  return ensureAutoCompactTokenLimit(normalizeServiceTiers(entry));
 }
 
 /**
@@ -126,7 +206,7 @@ function deriveEntry(template: RawEntry | null, slug: string, desc: string, prio
  * catalog sync and the proxy `/v1/models?client_version` branch.
  * Native gpt slugs stay bare; routed models are namespaced `<provider>/<model>`.
  */
-export function buildCatalogEntries(template: RawEntry | null, gptSlugs: string[], goModels: CatalogModel[], featured?: string[]): RawEntry[] {
+export function buildCatalogEntries(template: RawEntry | null, gptSlugs: string[], goModels: CatalogModel[], featured?: string[], wsEnabled = false): RawEntry[] {
   // Codex's models-manager sorts by `priority` ASC and advertises the first 5 picker-visible
   // models to spawn_agent (sort_by_key(priority) + MAX_MODEL_OVERRIDES_IN_SPAWN_AGENT=5). Catalog
   // ARRAY order is discarded — so "featuring" a model = giving it the LOWEST priority (0..N-1) so
@@ -144,12 +224,19 @@ export function buildCatalogEntries(template: RawEntry | null, gptSlugs: string[
     if (rank.has(slug)) e.priority = rank.get(slug)!;
     out.push(e);
   }
+  // Central capability override (phase 120.4): the advertised flag must match the implemented WS
+  // endpoint. Overrides both the routed strip (normalizeRoutedCatalogEntry) and any native template
+  // leak (deriveEntry clones the template as-is for native slugs).
+  for (const entry of out) {
+    if (wsEnabled) entry.supports_websockets = true;
+    else delete entry.supports_websockets;
+  }
   return out;
 }
 
 /** 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);
@@ -211,11 +298,28 @@ export async function gatherRoutedModels(config: OcxConfig): Promise<CatalogMode
   const lists = await Promise.all(
     Object.entries(config.providers).map(([name, prov]) => fetchProviderModels(name, prov, ttlMs)),
   );
-  const all = lists.flat();
+  const all = augmentRoutedModelsWithJawcodeMetadata(lists.flat(), Object.keys(config.providers));
   all.sort((a, b) => (a.provider === b.provider ? a.id.localeCompare(b.id) : a.provider.localeCompare(b.provider)));
   return all;
 }
 
+export function augmentRoutedModelsWithJawcodeMetadata(models: CatalogModel[], providerNames: string[]): CatalogModel[] {
+  const out = [...models];
+  const seen = new Set(out.map(m => `${m.provider}/${m.id}`));
+  for (const provider of providerNames) {
+    if (!JAWCODE_CATALOG_AUGMENT_PROVIDERS.has(provider)) continue;
+    const jawcodeProvider = resolveJawcodeProvider(provider);
+    if (!jawcodeProvider) continue;
+    for (const meta of listJawcodeModelMetadata(jawcodeProvider)) {
+      const key = `${provider}/${meta.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ provider, id: meta.id, owned_by: provider });
+    }
+  }
+  return out;
+}
+
 /**
  * Reorder routed models so the configured subagent picks come FIRST (in the chosen order).
  * Codex's spawn_agent advertises only the first 5 routed catalog entries, so putting the chosen
@@ -244,7 +348,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(
@@ -261,7 +365,7 @@ export async function syncCatalogModels(config: OcxConfig): Promise<{ added: num
   const featured = config.subagentModels ?? [];
   const rank = new Map(featured.map((slug, i) => [slug, i] as const));
   const orderedGoModels = orderForSubagents(enabledGo, featured); // stable tie-break among equal priorities
-  const goEntries = buildCatalogEntries(template ? JSON.parse(JSON.stringify(template)) : null, [], orderedGoModels, featured);
+  const goEntries = buildCatalogEntries(template ? JSON.parse(JSON.stringify(template)) : null, [], orderedGoModels, featured, websocketsEnabled(config));
   // Keep genuine native entries (gpt-*, codex-*) with their real per-model fields, but drop bare
   // duplicates of routed models (replaced by namespaced entries) + any prior "/" entries. Re-derive
   // each native's priority from the pristine baseline so featuring a native is reversible.
@@ -272,9 +376,18 @@ 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];
+  // Central WS capability override on the FINAL on-disk catalog (the file Codex reads). Applies to
+  // native AND routed so the advertised flag matches the implemented endpoint (phase 120.4) and a
+  // native template can never leak supports_websockets while the flag is off.
+  const wsEnabled = websocketsEnabled(config);
+  catalog.models = [...native, ...goEntries].map(m => {
+    const e = ensureAutoCompactTokenLimit(normalizeServiceTiers(m));
+    if (wsEnabled) e.supports_websockets = true;
+    else delete e.supports_websockets;
+    return e;
+  });
 
   try {
     if (!existsSync(OCX_DIR)) mkdirSync(OCX_DIR, { recursive: true });
@@ -306,13 +419,12 @@ export function restoreCodexCatalog(): { removed: number; kept: number; path: st
 }
 
 /**
- * Delete Codex's models cache (~/.codex/models_cache.json) so the next turn re-fetches /v1/models.
+ * Delete Codex's models cache ($CODEX_HOME/models_cache.json) so the next turn re-fetches /v1/models.
  * Codex caches the model list for 5 min (DEFAULT_MODEL_CACHE_TTL); invalidating makes catalog edits
  * (enable/disable, subagent reorder) apply on the next turn instead of waiting for the TTL.
  */
 export function invalidateCodexModelsCache(): void {
   try {
-    const p = join(homedir(), ".codex", "models_cache.json");
-    if (existsSync(p)) unlinkSync(p);
+    if (existsSync(CODEX_MODELS_CACHE_PATH)) unlinkSync(CODEX_MODELS_CACHE_PATH);
   } catch { /* best-effort */ }
 }

package/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 { atomicWriteFile, websocketsEnabled } 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";
 
 /**
@@ -19,7 +14,7 @@ const OCX_SECTION_MARKER = "# Auto-injected by opencodex";
  * whatever `[table]` happened to be open last (e.g. `[plugins."chrome@openai-bundled"]`), so Codex
  * never saw a global model_provider and silently fell back to the `openai` (ChatGPT) provider.
  */
-function buildProviderTableBlock(port: number): string {
+export function buildProviderTableBlock(port: number, supportsWebsockets = false): string {
   const lines = [
     "",
     OCX_SECTION_MARKER,
@@ -27,7 +22,9 @@ function buildProviderTableBlock(port: number): string {
     'name = "OpenCodex Proxy"',
     `base_url = "http://localhost:${port}/v1"`,
     'wire_api = "responses"',
+    "requires_openai_auth = true",
   ];
+  if (supportsWebsockets) lines.push("supports_websockets = true");
   return lines.join("\n") + "\n";
 }
 
@@ -53,6 +50,17 @@ function stripExistingModelProvider(content: string): string {
   return out.join("\n");
 }
 
+function stripRootContextWindowOverrides(content: string): string {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  return lines
+    .filter((line, i) => {
+      const isRoot = firstTable === -1 || i < firstTable;
+      return !isRoot || !/^\s*model_(?:context_window|auto_compact_token_limit)\s*=/.test(line);
+    })
+    .join("\n");
+}
+
 /**
  * Insert `model_provider = "opencodex"` at the document ROOT — immediately before the first table
  * header (TOML root keys must precede all tables). If there are no tables, append it to the root body.
@@ -70,16 +78,95 @@ 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 ensureFastModeFeature(content: string): string {
+  const lines = content.split("\n");
+  const featuresStart = lines.findIndex(line => line.trim() === "[features]");
+  if (featuresStart === -1) {
+    return content.trimEnd() + "\n\n[features]\nfast_mode = true\n";
+  }
+
+  const nextTable = lines.findIndex((line, index) => index > featuresStart && /^\s*\[/.test(line));
+  const featuresEnd = nextTable === -1 ? lines.length : nextTable;
+  for (let i = featuresStart + 1; i < featuresEnd; i++) {
+    if (/^\s*fast_mode\s*=/.test(lines[i])) {
+      lines[i] = lines[i].replace(/^(\s*)fast_mode\s*=.*$/, "$1fast_mode = true");
+      return lines.join("\n");
+    }
+  }
+
+  let insertAt = featuresEnd;
+  while (insertAt > featuresStart + 1 && lines[insertAt - 1].trim() === "") insertAt--;
+  lines.splice(insertAt, 0, "fast_mode = true");
+  return lines.join("\n");
+}
+
+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)}`,
+    "",
+    "[features]",
+    "fast_mode = true",
     "",
   ].join("\n");
 }
 
-export async function injectCodexConfig(port: number, _config?: OcxConfig): Promise<{ success: boolean; message: string }> {
+export async function injectCodexConfig(port: number, config?: OcxConfig): Promise<{ success: boolean; message: string }> {
   if (!existsSync(CODEX_CONFIG_PATH)) {
     return { success: false, message: `Codex config not found at ${CODEX_CONFIG_PATH}. Is Codex installed?` };
   }
@@ -92,15 +179,22 @@ 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 = stripRootContextWindowOverrides(content);
+  content = normalizeServiceTier(content);
+  content = ensureFastModeFeature(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" + buildProviderTableBlock(port, websocketsEnabled(config ?? {}));
 
   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 +235,12 @@ 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 = stripRootContextWindowOverrides(out);
+  out = stripDefaultCatalogPath(out);
   return out.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
 }
 
@@ -159,6 +256,8 @@ export function removeCodexConfig(): { success: boolean; message: string } {
   const had = hasOpencodexRouting(content);
   if (had) {
     atomicWriteFile(CODEX_CONFIG_PATH, stripOpencodexConfig(content));
+  } else if (stripRootContextWindowOverrides(content) !== content) {
+    atomicWriteFile(CODEX_CONFIG_PATH, stripOpencodexConfig(content));
   }
   if (existsSync(CODEX_PROFILE_PATH)) unlinkSync(CODEX_PROFILE_PATH);
   return {

package/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);
+}

package/src/config.ts

@@ -57,6 +57,10 @@ export function saveConfig(config: OcxConfig): void {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 
+export function websocketsEnabled(config: Pick<OcxConfig, "websockets">): boolean {
+  return config.websockets === true;
+}
+
 export function getDefaultConfig(): OcxConfig {
   // Fresh-install default: works out of the box with Codex's ChatGPT OAuth (no API key).
   // gpt-* requests forward the caller's incoming OAuth headers to the ChatGPT backend.
@@ -72,6 +76,7 @@ export function getDefaultConfig(): OcxConfig {
     },
     defaultProvider: "openai",
     subagentModels: [...DEFAULT_SUBAGENT_MODELS],
+    websockets: false,
   };
 }
 

package/src/debug.ts

@@ -0,0 +1,10 @@
+// Opt-in frame-drop visibility. The streaming path is intentionally quiet (no unconditional
+// console output), so this no-ops unless OCX_DEBUG_FRAMES=1. Lets a malformed/chunk-split
+// upstream frame be detected instead of silently truncating content.
+const DEBUG_FRAMES = process.env.OCX_DEBUG_FRAMES === "1";
+
+export function debugDroppedFrame(adapter: string, payload: string): void {
+  if (!DEBUG_FRAMES) return;
+  const preview = payload.length > 200 ? `${payload.slice(0, 200)}…` : payload;
+  console.error(`[ocx:frame-drop] ${adapter}: ${preview}`);
+}