llm-switcher 1.2.2 → 1.2.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog — LLM Switcher
 
+## Release 1.2.3
+
+- **Update notice:** The dashboard sidebar shows the running version. When npm has a newer release, a notice shows the update command with a copy button. The new command `switch version` prints the same information. The switcher asks the npm registry at most once in 12 hours. Without an answer, no notice shows.
+- **Codex daemon follows the route:** The interactive Codex TUI talks to a shared `codex app-server` daemon, and that daemon keeps the environment that it started with. As a result, the TUI bypassed the gateway after a switch. Now each change of the Codex route restarts the running daemon with the new variables. When no daemon runs, nothing starts.
+- **API keys stay with their host:** A catalog refresh sent the key of the active profile to the official Anthropic and OpenAI model lists. Now a key goes only to the host of its own profile.
+- **Real model catalog:** The catalog reads the model list that Codex and Claude Code keep on disk for the signed-in account. A failed refresh no longer marks the tool version as done, so the next request tries again.
+- **Dashboard saves:** Every write action reported a failure after it succeeded, because the page read `ok` and the server sends `success`. Enter in a field no longer saves a half-edited profile. A text selection that ends outside the dialog no longer closes it.
+- **Model slots:** Each slot is a searchable list of the provider models. The list loads when you open the Model Slots tab and sends the saved key. A profile without `outFormat` keeps it empty after a save.
+- **Other fixes:** `make-certs.sh` works when the path contains a dot. `switch doctor` warns again about a Codex profile without `publicModels`. Three dashboard controls have an accessible name.
+- **Tests:** The tests use the 1.2 configuration schema, never read the certificates of the checkout, and never reach the real Codex daemon, npm registry, or `claude` binary.
+
 ## Release 1.2.2
 
 - **Structured output reaches every upstream:** A request that asks for JSON that matches a schema now keeps that schema. Before this release, the gateway did not read `output_config.format` (Claude Code) or `text.format` (Codex), so the provider got a free-text request. The schema now goes to the provider as `response_format` (OpenAI Chat), `output_config.format` (Anthropic), or `responseMimeType` with `responseSchema` (Gemini and Vertex). A request for JSON without a schema reaches Anthropic as plain text, because Anthropic has no JSON mode without a schema.

package/README.md

@@ -401,6 +401,7 @@ Add the server to your MCP configuration (for example `opencode.jsonc`, `claude_
 ```bash
 switch ui                      # Open the Web UI dashboard in your browser
 switch status                  # Display status for all active CLI targets
+switch version                 # Show the version and tell you when npm has a newer one
 switch doctor                  # Audit environment, settings & routing
 switch on [profile]            # Start the gateway and activate a profile
 switch <profile>               # Activate a profile for both tools

package/blindfold/make-certs.sh

@@ -103,8 +103,10 @@ openssl req -x509 -new -key "$WORK/ca.key" -sha256 -days "$CA_DAYS" \
 
 openssl ecparam -name prime256v1 -genkey -noout -out "$WORK/leaf.key"
 openssl req -new -key "$WORK/leaf.key" -config "$WORK/leaf.cnf" -out "$WORK/leaf.csr"
+# An explicit -CAserial: LibreSSL derives the default name by cutting the CA path at its first dot,
+# so a home directory such as /Users/first.last sent the serial file to /Users/first.srl.
 openssl x509 -req -in "$WORK/leaf.csr" \
-  -CA "$WORK/ca.pem" -CAkey "$WORK/ca.key" -CAcreateserial \
+  -CA "$WORK/ca.pem" -CAkey "$WORK/ca.key" -CAcreateserial -CAserial "$WORK/ca.srl" \
   -days "$LEAF_DAYS" -sha256 -extfile "$WORK/leaf.ext" \
   -out "$WORK/leaf.pem"
 

package/catalog.mjs

@@ -7,6 +7,7 @@
 // ============================================================
 
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 export const OFFICIAL_MODEL_URLS = {
@@ -69,6 +70,70 @@ export function loadCatalogCache(stateDir) {
   };
 }
 
+function defaultSources() {
+  return {
+    codexHome: process.env.CODEX_HOME || path.join(os.homedir(), '.codex'),
+    claudeDir: process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
+  };
+}
+
+/**
+ * Reads the model list that the tool itself keeps on disk for the signed-in account, so no key and
+ * no network call is needed. Codex writes models_cache.json; Claude Code writes cache/model-catalog.
+ * Returns null when the tool has no list.
+ */
+export function readLocalToolModels(tool, sources = defaultSources()) {
+  try {
+    if (tool === 'codex') {
+      const d = JSON.parse(fs.readFileSync(path.join(sources.codexHome, 'models_cache.json'), 'utf8'));
+      const models = (Array.isArray(d?.models) ? d.models : [])
+        .filter(m => m && typeof m.slug === 'string' && m.slug)
+        .map(m => ({ id: m.slug, role: classifyCodexRole(m.slug), ...(Number.isInteger(m.context_window) ? { contextWindow: m.context_window } : {}) }));
+      return models.length ? { models, version: String(d.client_version || '') } : null;
+    }
+    if (tool === 'claude') {
+      // One file per account or surface; the newest fetch wins.
+      const dir = path.join(sources.claudeDir, 'cache', 'model-catalog');
+      let newest = null;
+      for (const f of fs.readdirSync(dir)) {
+        if (!f.endsWith('.json')) continue;
+        try {
+          const d = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+          const list = d?.catalog?.config?.models;
+          if (Array.isArray(list) && list.length && (!newest || (d.fetchedAt || 0) > newest.fetchedAt)) newest = { fetchedAt: d.fetchedAt || 0, list };
+        } catch {}
+      }
+      const models = (newest?.list || [])
+        .filter(m => m && typeof m.id === 'string' && m.id)
+        .map(m => ({ id: m.id, display_name: m.name || m.id, tier: classifyClaudeTier(m.id) }));
+      return models.length ? { models, version: '' } : null;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Copies the tools' own lists into the catalog when they changed. A tool can update and rewrite its
+ * list without any request through the gateway, so readers of the catalog call this first.
+ */
+export function syncLocalCatalog(stateDir, sources = defaultSources()) {
+  const cache = loadCatalogCache(stateDir);
+  let changed = false;
+  for (const tool of ['claude', 'codex']) {
+    const local = readLocalToolModels(tool, sources);
+    if (!local) continue;
+    const ids = (cache[tool]?.models || []).map(m => m.id).join('\n');
+    if (ids === local.models.map(m => m.id).join('\n') && cache[tool]?.source === 'local') continue;
+    cache[tool] = { ...cache[tool], models: local.models, source: 'local' };
+    changed = true;
+  }
+  if (changed) {
+    cache.updatedAt = Date.now();
+    saveCatalogCache(stateDir, cache);
+  }
+  return cache;
+}
+
 /** Atomically writes the model catalog cache to disk */
 export function saveCatalogCache(stateDir, catalog) {
   const p = catalogCachePath(stateDir);
@@ -141,19 +206,33 @@ export async function fetchToolModels(tool, { url, apiKey, timeout = 3000 } = {}
   }
 }
 
+// A profile key is a credential for that profile's baseURL. Send it to the official model list only
+// when the profile itself points at the official host, never to a third party.
+function officialKey(profile, tool) {
+  try {
+    if (profile?.apiKey && new URL(profile.baseURL).host === new URL(OFFICIAL_MODEL_URLS[tool]).host) return profile.apiKey;
+  } catch {}
+  return undefined;
+}
+
 /**
  * Refreshes the local catalog cache with models from both official endpoints
  * and saves to the state directory.
  */
-export async function refreshCatalog(stateDir, { claudeKey, codexKey } = {}) {
+export async function refreshCatalog(stateDir, { claudeProfile, codexProfile, sources = defaultSources() } = {}) {
   const cache = loadCatalogCache(stateDir);
+  const local = { claude: readLocalToolModels('claude', sources), codex: readLocalToolModels('codex', sources) };
 
+  // A local list is the list of the account itself; the built-in names are guesses and are not added.
   const [claudeRes, codexRes] = await Promise.all([
-    fetchToolModels('claude', { apiKey: claudeKey }),
-    fetchToolModels('codex', { apiKey: codexKey })
+    local.claude || fetchToolModels('claude', { apiKey: officialKey(claudeProfile, 'claude') }),
+    local.codex || fetchToolModels('codex', { apiKey: officialKey(codexProfile, 'codex') })
   ]);
+  for (const tool of ['claude', 'codex']) {
+    if (local[tool]) cache[tool] = { ...cache[tool], models: local[tool].models, source: 'local' };
+  }
 
-  if (claudeRes.ok && claudeRes.models.length > 0) {
+  if (!local.claude && claudeRes.ok && claudeRes.models.length > 0) {
     const existing = new Set(claudeRes.models.map(m => m.id));
     // Keep any baseline models that might be absent from the API
     for (const [tier, ids] of Object.entries(BASELINE_MODELS.claude)) {
@@ -161,17 +240,17 @@ export async function refreshCatalog(stateDir, { claudeKey, codexKey } = {}) {
         if (!existing.has(id)) claudeRes.models.push({ id, tier });
       }
     }
-    cache.claude = { models: claudeRes.models };
+    cache.claude = { ...cache.claude, models: claudeRes.models, source: 'official' };
   }
 
-  if (codexRes.ok && codexRes.models.length > 0) {
+  if (!local.codex && codexRes.ok && codexRes.models.length > 0) {
     const existing = new Set(codexRes.models.map(m => m.id));
     for (const [role, ids] of Object.entries(BASELINE_MODELS.codex)) {
       for (const id of ids) {
         if (!existing.has(id)) codexRes.models.push({ id, role });
       }
     }
-    cache.codex = { models: codexRes.models };
+    cache.codex = { ...cache.codex, models: codexRes.models, source: 'official' };
   }
 
   cache.updatedAt = Date.now();
@@ -199,48 +278,59 @@ const refreshingTools = new Set();
 
 /**
  * Version-triggered auto-poll:
- * When a request arrives with a new tool version not yet seen in cache,
- * immediately records the new version and kicks off an asynchronous background refresh.
- * Subsequent requests with the same version do zero network calls.
+ * When a request arrives with a tool version that has no refreshed catalog yet, the catalog is
+ * refreshed from the tool's own list on disk, or else from the official list in the background.
+ * The version is recorded only after a refresh succeeds, so a failed refresh is tried again.
  */
-export function checkVersionAndRefresh(tool, headers, stateDir, apiKey) {
+const RETRY_AFTER_MS = 10 * 60 * 1000;
+const failedAttempts = new Map();
+
+export function checkVersionAndRefresh(tool, headers, stateDir, apiKey, sources = defaultSources()) {
   const version = detectToolVersion(headers, tool);
   if (!version) return;
 
   const cache = loadCatalogCache(stateDir);
-  const toolEntry = cache[tool] || {};
-  const lastVersion = toolEntry.lastSeenVersion || '';
+  if (version === (cache[tool]?.lastSeenVersion || '')) return;
 
-  if (version !== lastVersion) {
-    toolEntry.lastSeenVersion = version;
-    cache[tool] = toolEntry;
+  const local = readLocalToolModels(tool, sources);
+  if (local) {
+    cache[tool] = { ...cache[tool], lastSeenVersion: version, models: local.models, source: 'local' };
+    cache.updatedAt = Date.now();
     saveCatalogCache(stateDir, cache);
+    console.log(`[llm-switcher:catalog] Detected ${tool} ${version} -> model catalog read from the tool (${local.models.length} models)`);
+    return;
+  }
+
+  // Without a local list every request would call the network again; wait between failed attempts.
+  const failed = failedAttempts.get(tool);
+  if (failed && failed.version === version && Date.now() - failed.at < RETRY_AFTER_MS) return;
+  if (refreshingTools.has(tool)) return;
 
-    if (!refreshingTools.has(tool)) {
-      refreshingTools.add(tool);
-      fetchToolModels(tool, { apiKey })
-        .then(res => {
-          if (res.ok && res.models.length > 0) {
-            const fresh = loadCatalogCache(stateDir);
-            const existing = new Set(res.models.map(m => m.id));
-            const baseline = BASELINE_MODELS[tool] || {};
-            for (const [, ids] of Object.entries(baseline)) {
-              for (const id of ids) {
-                if (!existing.has(id)) {
-                  res.models.push({ id, ...(tool === 'claude' ? { tier: classifyClaudeTier(id) } : { role: classifyCodexRole(id) }) });
-                }
-              }
-            }
-            fresh[tool] = { lastSeenVersion: version, models: res.models };
-            fresh.updatedAt = Date.now();
-            saveCatalogCache(stateDir, fresh);
-            console.log(`[llm-switcher:catalog] Detected ${tool} version update to ${version} -> refreshed model catalog (${res.models.length} models)`);
+  refreshingTools.add(tool);
+  fetchToolModels(tool, { apiKey })
+    .then(res => {
+      if (!res.ok || res.models.length === 0) {
+        failedAttempts.set(tool, { version, at: Date.now() });
+        console.log(`[llm-switcher:catalog] ${tool} ${version}: no local model list, official list failed (${res.error || 'empty'})`);
+        return;
+      }
+      const fresh = loadCatalogCache(stateDir);
+      const existing = new Set(res.models.map(m => m.id));
+      const baseline = BASELINE_MODELS[tool] || {};
+      for (const [, ids] of Object.entries(baseline)) {
+        for (const id of ids) {
+          if (!existing.has(id)) {
+            res.models.push({ id, ...(tool === 'claude' ? { tier: classifyClaudeTier(id) } : { role: classifyCodexRole(id) }) });
           }
-        })
-        .catch(() => {})
-        .finally(() => {
-          refreshingTools.delete(tool);
-        });
-    }
-  }
+        }
+      }
+      fresh[tool] = { ...fresh[tool], lastSeenVersion: version, models: res.models, source: 'official' };
+      fresh.updatedAt = Date.now();
+      saveCatalogCache(stateDir, fresh);
+      console.log(`[llm-switcher:catalog] Detected ${tool} version update to ${version} -> refreshed model catalog (${res.models.length} models)`);
+    })
+    .catch(() => {})
+    .finally(() => {
+      refreshingTools.delete(tool);
+    });
 }

package/mcp.mjs

@@ -143,11 +143,11 @@ async function handleToolCall(name, args) {
   const port = getMcpPort();
 
   if (name === 'switcher_models') {
-    const { loadCatalogCache, refreshCatalog } = await import('./catalog.mjs');
+    const { syncLocalCatalog, refreshCatalog } = await import('./catalog.mjs');
     if (args?.refresh) {
       await refreshCatalog(STATE_DIR);
     }
-    const cache = loadCatalogCache(STATE_DIR);
+    const cache = syncLocalCatalog(STATE_DIR);
     const t = args?.tool?.toLowerCase();
     const res = {};
     if (!t || t === 'claude') res.claude = cache.claude;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code, Codex, OpenAI and Gemini clients",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -23,7 +23,8 @@ import {
   codexModelEntry, smallestWindows, publicModelWindows, model1MForSlot,
   contractLabSettings, STATE_DIR
 } from './state.mjs';
-import { classifyCodexRole, classifyClaudeTier, loadCatalogCache, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
+import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
+import { checkForUpdate } from './version.mjs';
 import { createContractLab, createHalfTap, tapClientWrites, capText, capJson, toolVersionFromUA, finishHalf, PROBE_HEADER, TRACE_ID_RE } from './contract.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -1287,9 +1288,13 @@ async function routeApi(req, res, method, pathname) {
     return sendJson(res, 200, { logs: requestLogs.slice().reverse() });
   }
 
+  if (method === 'GET' && pathname === '/api/version') {
+    return sendJson(res, 200, await checkForUpdate({ stateDir: STATE_DIR }));
+  }
+
   // GET /api/catalog (Dynamic Model Discovery)
   if (method === 'GET' && pathname === '/api/catalog') {
-    return sendJson(res, 200, loadCatalogCache(STATE_DIR));
+    return sendJson(res, 200, syncLocalCatalog(STATE_DIR));
   }
 
   if (method !== 'POST') {
@@ -1310,10 +1315,7 @@ async function routeApi(req, res, method, pathname) {
     const cfg = requireConfig(res) || {};
     const claudeProfile = active.claude ? cfg.profiles?.[active.claude] : null;
     const codexProfile = active.codex ? cfg.profiles?.[active.codex] : null;
-    const updated = await refreshCatalog(STATE_DIR, {
-      claudeKey: claudeProfile?.apiKey,
-      codexKey: codexProfile?.apiKey
-    });
+    const updated = await refreshCatalog(STATE_DIR, { claudeProfile, codexProfile });
     return sendJson(res, 200, { success: true, catalog: updated });
   }
 

package/scripts/run-tests.mjs

@@ -15,5 +15,7 @@ const files = [];
   }
 })(path.join(root, 'tests'));
 
-const r = spawnSync(process.execPath, ['--test', ...process.argv.slice(2), ...files], { cwd: root, stdio: 'inherit' });
+// A version check must never reach the real npm registry.
+const env = { ...process.env, LLM_SWITCHER_REGISTRY_URL: 'http://127.0.0.1:9/' };
+const r = spawnSync(process.execPath, ['--test', ...process.argv.slice(2), ...files], { cwd: root, stdio: 'inherit', env });
 process.exit(r.status ?? 1);

package/state.mjs

@@ -1441,26 +1441,78 @@ function writeToolFiles(pairs, shPath, cmdPath) {
 // launcher files are never opened (A13: emptied, never deleted).
 export function emptyToolEnvFiles(tool) {
   const codex = tool === 'codex';
-  withLaunchLock(() => {
+  const codexRouteChanged = withLaunchLock(() => {
+    const before = codex ? readOrEmpty(paths.envCodexSh) : '';
     writeAtomic(codex ? paths.envCodexCmd : paths.envClaudeCmd, '');
     writeAtomic(codex ? paths.envCodexSh : paths.envClaudeSh, '');
+    return before !== '';
   });
+  return { codexRouteChanged, codexDaemon: codexRouteChanged ? restartCodexDaemon([]) : undefined };
 }
 
 // Write the per-tool env files from activeProfiles. settings.json is never touched here: it
 // belongs to the coding tool (R1), and model-catalog.json is no longer written (R9).
 export function applyLaunchState(cfg, port, opts = {}) {
-  return withLaunchLock(() => writeLaunchState(cfg, port, opts));
+  const st = withLaunchLock(() => writeLaunchState(cfg, port, opts));
+  if (st.codexRouteChanged) st.codexDaemon = restartCodexDaemon(st.envCodex);
+  return st;
+}
+
+const LOOPBACK_URL = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?\/?$/i;
+
+/**
+ * The interactive Codex TUI talks to a shared `codex app-server` daemon, and the daemon keeps the
+ * environment it started with. A new route reaches it only through a restart. Only the launch files
+ * that the installed codex shim reads can route that daemon, so any other state dir (tests) is a no-op.
+ */
+export function restartCodexDaemon(pairs, {
+  home = os.homedir(),
+  codexHome = process.env.CODEX_HOME || path.join(home, '.codex'),
+  stateDir = STATE_DIR,
+  baseEnv = process.env,
+  ca = paths.blindfoldCA,
+  spawnFn = spawn
+} = {}) {
+  let shim = '';
+  try { shim = fs.readFileSync(path.join(home, '.llm-switcher', 'bin', 'codex'), 'utf8'); } catch {}
+  if (!shim.includes(`SWITCHER_DIR="${stateDir}"`)) return { restarted: false, reason: 'the codex shim does not read this state dir' };
+  const bin = path.join(codexHome, 'packages', 'app-server-daemon', 'current', 'bin', 'codex');
+  // The socket is a link to the running daemon; it no longer resolves once the daemon stopped.
+  if (!fs.existsSync(bin) || !fs.existsSync(path.join(codexHome, 'app-server-control', 'app-server-control.sock'))) {
+    return { restarted: false, reason: 'no Codex daemon runs' };
+  }
+
+  // Remove only the values this switcher writes (R8); a proxy or CA the user set stays.
+  const env = { ...baseEnv };
+  for (const k of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy']) if (LOOPBACK_URL.test(env[k] || '')) delete env[k];
+  for (const k of ['NO_PROXY', 'no_proxy']) if (env[k] === '127.0.0.1,localhost') delete env[k];
+  if (env.CODEX_CA_CERTIFICATE === ca) delete env.CODEX_CA_CERTIFICATE;
+  for (const [k, v] of pairs) env[k] = v;
+
+  try {
+    const child = spawnFn(bin, ['app-server', 'daemon', 'restart'], { env, stdio: 'ignore', detached: true });
+    child.on?.('error', () => {});
+    child.unref?.();
+    return { restarted: true };
+  } catch (err) {
+    return { restarted: false, reason: err.message };
+  }
+}
+
+function readOrEmpty(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch { return ''; }
 }
 
 function writeLaunchState(cfg, port) {
   const st = computeLaunchState(cfg, port);
+  const codexBefore = readOrEmpty(paths.envCodexSh);
 
   // Env files first, the flag last: a flag that says "active" while a file is missing or stale
   // makes the launcher route with the wrong variables. A failed write leaves the flag as it was.
   try {
     writeToolFiles(st.envClaude, paths.envClaudeSh, paths.envClaudeCmd);
     writeToolFiles(st.envCodex, paths.envCodexSh, paths.envCodexCmd);
+    st.codexRouteChanged = readOrEmpty(paths.envCodexSh) !== codexBefore;
     // Recorded on switch on so a shell opened while the gateway ran can still recognize its own
     // stale loopback URL later, after the port changed (R8).
     if (st.active) writeAtomic(paths.gatewayPort, `${port}\n`);
@@ -1476,7 +1528,8 @@ function writeLaunchState(cfg, port) {
 }
 
 export function clearLaunchState(port) {
-  withLaunchLock(() => {
+  const codexRouteChanged = withLaunchLock(() => {
+    const codexBefore = readOrEmpty(paths.envCodexSh);
     writeOrRemove(paths.activeFlag, null);
     // Stubs rather than deletions, and the tool files emptied rather than removed (R8, A13):
     // `switch off claude` must leave an empty claude file behind, and bare `switch off` must
@@ -1486,9 +1539,10 @@ export function clearLaunchState(port) {
     for (const f of [paths.envClaudeCmd, paths.envClaudeSh, paths.envCodexCmd, paths.envCodexSh]) {
       writeAtomic(f, '');
     }
+    return codexBefore !== '';
   });
   // settings.json belongs to the coding tool: the switcher neither reads nor writes it (R1).
-  return { changed: false, removed: [] };
+  return { changed: false, removed: [], codexRouteChanged, codexDaemon: codexRouteChanged ? restartCodexDaemon([]) : undefined };
 }
 
 export function readLaunchFlags() {

package/switch.mjs

@@ -26,6 +26,12 @@ const proxyScript = path.join(ROOT_DIR, 'proxy.mjs');
 const proxyLogPath = paths.proxyLog;
 const userProfile = os.homedir();
 
+// The version needs no config.json: it must also answer before the first setup.
+if (['version', '--version', '-v'].includes(String(process.argv[2] || '').toLowerCase())) {
+  await showVersion();
+  process.exit(0);
+}
+
 const config = loadConfig();
 if (!config) {
   const err = getConfigLoadError();
@@ -415,6 +421,7 @@ async function turnOn(profileName, cliTarget) {
   const savedBytes = fs.readFileSync(configPath);
   const st = applyLaunchState(planned, port);
   reportSettings(st.settings);
+  reportCodexDaemon(st);
   const bf = await requestBlindfoldSync(port);
   if (!bf.ok) {
     console.error(`[Error] ${bf.error}`);
@@ -520,7 +527,7 @@ async function turnOff(targetArg) {
       // The order is fixed by R7b: the CAS write, then this tool's env files, then the active-tools
       // update. If the CAS write cannot land, the env file and the interceptor stay untouched.
       const saved = casOff([target]);
-      emptyToolEnvFiles(target);
+      reportCodexDaemon(emptyToolEnvFiles(target));
       const bf = await syncOrStopBlindfold(port, config);
       if (!bf.ok) {
         console.error(`[Error] ${target} is switched back, but the interceptor is not in line: ${bf.error}`);
@@ -534,6 +541,7 @@ async function turnOff(targetArg) {
     saveConfig(config);
     const st = applyLaunchState(config, port);
     reportSettings(st.settings);
+    reportCodexDaemon(st);
     const bf = await syncOrStopBlindfold(port, config);
     if (!bf.ok) {
       console.error(`[Error] ${target} is switched back, but the blindfold interceptor is not in line: ${bf.error}`);
@@ -581,6 +589,12 @@ function auditActiveClis() {
 function reportSettings(result) {
   if (result?.removed?.length) console.log(`[settings.json] Removed switcher-written values: ${result.removed.join(', ')}`);
   if (result?.error) console.warn(`[settings.json] Not cleaned: ${result.error}`);
+  reportCodexDaemon(result);
+}
+
+// The interactive Codex TUI keeps using its shared daemon, so a new route needs that daemon restarted.
+function reportCodexDaemon(st) {
+  if (st?.codexDaemon?.restarted) console.log('[Codex] Restarted the codex app-server daemon: open Codex sessions reconnect with the new route.');
 }
 
 async function showStatus() {
@@ -848,7 +862,7 @@ async function runDoctor() {
     const p = config.profiles[key];
     if (!p) warn(`[WARN] Target ${t} points to missing profile "${show(key)}".`);
     else if (!p.baseURL || /YOUR-|REPLACE-ME/i.test(`${p.baseURL} ${p.apiKey}`)) warn(`[WARN] Profile "${show(key)}" (${t}) still has placeholder baseURL/apiKey.`);
-    if (p && t === 'responses') {
+    if (p && t === 'codex') {
       const codexWarning = codexPublicModelsWarning(show(key), p);
       if (codexWarning) warn(`[WARN] ${codexWarning}`);
     }
@@ -1036,13 +1050,22 @@ async function runContractCheck() {
   }
 }
 
+async function showVersion() {
+  const { checkForUpdate } = await import('./version.mjs');
+  const v = await checkForUpdate({ stateDir: STATE_DIR });
+  console.log(`llm-switcher ${v.current}`);
+  if (v.updateAvailable) console.log(`A new version is available: ${v.latest}. Update with: ${v.updateCommand}`);
+  else if (!v.latest) console.log('Could not check the npm registry for a newer version.');
+  else console.log('This is the latest version.');
+}
+
 async function showModels(target) {
-  const { loadCatalogCache, refreshCatalog } = await import('./catalog.mjs');
+  const { syncLocalCatalog, refreshCatalog } = await import('./catalog.mjs');
   if (optionValue('--refresh') || process.argv.includes('--refresh')) {
     console.log('Refreshing models catalog from official endpoints...');
     await refreshCatalog(STATE_DIR);
   }
-  const cache = loadCatalogCache(STATE_DIR);
+  const cache = syncLocalCatalog(STATE_DIR);
   console.log('=== LLM Switcher Discovered Models Catalog ===\n');
   const t = target ? target.toLowerCase() : '';
   if (!t || t === 'claude') {
@@ -1105,6 +1128,7 @@ if (cmd === 'off' || cmd === 'stop') {
   console.log('Usage:');
   console.log('  switch ui                      # Open Web UI dashboard');
   console.log('  switch status                  # Show multi-CLI active status');
+  console.log('  switch version                 # Show the version and check for a newer one');
   console.log('  switch doctor                  # Audit environment, settings & routing');
   console.log('  switch on [profile]            # Start gateway & activate profile for all compatible targets');
   console.log('  switch <profile>               # Activate profile for all compatible targets');

package/tests/blindfold-e2e.test.mjs

@@ -150,7 +150,7 @@ async function startInterceptor({ port, gatewayPort, config, upstreamPort }) {
   child.stdout.on('data', (d) => output.push(String(d)));
   child.stderr.on('data', (d) => output.push(String(d)));
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };
@@ -181,7 +181,7 @@ async function startGateway(t, port, cfgPath) {
   child.stdout.on('data', (d) => { log += d; });
   child.stderr.on('data', (d) => { log += d; });
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };

package/tests/blindfold-task5.test.mjs

@@ -113,7 +113,7 @@ async function startInterceptor({ port, gatewayPort, config, activeTools = 'clau
   child.stderr.on('data', (d) => output.push(String(d)));
 
   const stop = async () => {
-    if (child.exitCode !== null) return;
+    if (child.exitCode !== null || child.signalCode !== null) return;
     child.kill();
     await once(child, 'exit').catch(() => {});
   };

package/tests/blindfold.task3.test.mjs

@@ -126,7 +126,7 @@ async function startInterceptor({ port, gatewayPort, config, activeTools = 'clau
   child.stderr.on('data', (d) => output.push(String(d)));
 
   const stop = async () => {
-    if (child.exitCode !== null) return;   // already gone: waiting for 'exit' would never resolve
+    if (child.exitCode !== null || child.signalCode !== null) return;   // already gone: waiting for 'exit' would never resolve
     child.kill();
     await once(child, 'exit').catch(() => {});
   };
@@ -650,7 +650,7 @@ test('R3b: an interceptor from 1.1.11 proves the old way and is replaced, not tr
   `;
   const legacy = spawn(process.execPath, ['--input-type=module', '-e', legacySrc], { stdio: ['ignore', 'pipe', 'pipe'] });
   t.after(async () => {
-    if (legacy.exitCode !== null) return;
+    if (legacy.exitCode !== null || legacy.signalCode !== null) return;
     legacy.kill();
     await once(legacy, 'exit').catch(() => {});
   });

package/tests/blindfold.wire.test.mjs

@@ -53,7 +53,9 @@ async function startInterceptor() {
   const port = await freePort();
   const child = spawn(process.execPath, [path.join(ROOT, 'blindfold', 'blindfold.mjs'),
     '--port', String(port), '--gateway-port', String(gatewayPort), '--certs', certDir,
-    '--capture', captureDir, '--token-file', path.join(dir, 'admin.token')], { stdio: ['ignore', 'pipe', 'pipe'] });
+    '--capture', captureDir, '--token-file', path.join(dir, 'admin.token'),
+    // Since R3 only the paths of an active tool reach the gateway; everything else passes through.
+    '--active-tools', 'codex'], { stdio: ['ignore', 'pipe', 'pipe'] });
   let out = '';
   child.stdout.on('data', d => { out += d; });
   child.stderr.on('data', d => { out += d; });