llm-switcher 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-switcher",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "Zero-dependency multi-protocol edge gateway & provider switcher for Claude Code and Codex, with OpenAI-compatible, Anthropic and Vertex upstreams",
   "keywords": [
     "llm",

package/proxy.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import zlib from 'node:zlib';
 import crypto from 'node:crypto';
 import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { createFrameReader } from './blindfold/wsframe.mjs';
 import {
@@ -21,10 +22,11 @@ import {
   modelForSlot, primaryModel, codexPublicModel, isSafeModelName, parsePort, CODEX_MODEL_SLOTS,
   ensureAdminToken, identityProof, reconcileBlindfold, checkBlindfoldTarget,
   codexModelEntry, smallestWindows, publicModelWindows, model1MForSlot,
-  contractLabSettings, STATE_DIR
+  contractLabSettings, STATE_DIR, stopRecordedBlindfold
 } from './state.mjs';
 import { classifyCodexRole, classifyClaudeTier, syncLocalCatalog, refreshCatalog, checkVersionAndRefresh } from './catalog.mjs';
 import { checkForUpdate } from './version.mjs';
+import { applyUpdate } from './update.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));
@@ -46,6 +48,7 @@ if (missingNoProxy.length > 0) {
 // Fixed port for the process lifetime: changing "port" in config.json at runtime has no effect
 // env.cmd / flags would point at a port the server is not listening on.
 const PORT = resolvePort();
+let updateInProgress = false;
 
 // In-memory Request / Response Inspector Ring Buffer (up to 40 most recent requests)
 const requestLogs = [];
@@ -1123,6 +1126,14 @@ async function testUpstream(body, cfg) {
   const apiKey = resolveApiKey(cfg, body.key, body.apiKey, baseURL);
   const model = body.model || 'default';
   const profile = { baseURL, apiKey, mode: body.mode, outFormat: body.outFormat || undefined };
+  // A Bifrost model answers only its own client: a plain test request would draw a fake 429.
+  // The model lookup itself proves the key and the model, so it is the test.
+  const lookupStart = Date.now();
+  const bifrostUA = await bifrostUAFor(profile, model);
+  if (bifrostUA) {
+    return { status: 200, json: { ok: true, latency: Date.now() - lookupStart, outFormat: 'bifrost',
+      sample: `Bifrost: the key works and ${model} is served. Only the real client (${bifrostUA}) can call it, so no test message was sent.` } };
+  }
   const outFormat = resolveOutFormat(profile, model);
   const { url, headers } = upstreamEndpoint(profile, outFormat, model, false, null);
   const ir = { model, system: '', messages: [{ role: 'user', content: 'ping' }], tools: [], toolChoice: null, params: { maxTokens: 16, temperature: null, topP: null, topK: null, stop: [] }, thinking: { type: 'disabled' }, stream: false };
@@ -1408,6 +1419,28 @@ async function routeApi(req, res, method, pathname) {
     return sendJson(res, 200, { success: true, catalog: updated });
   }
 
+  // POST /api/update: progress as SSE; after a successful update the gateway hands over to the new code.
+  if (pathname === '/api/update') {
+    if (updateInProgress) return sendJson(res, 409, { error: 'An update is already in progress' });
+    updateInProgress = true;
+    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no' });
+    let result = null;
+    try {
+      result = await applyUpdate({ logger: (text) => sendSSE(res, 'log', { text }) });
+      sendSSE(res, 'result', result);
+    } catch (err) {
+      sendSSE(res, 'error', { message: err.message });
+    }
+    res.end();
+    if (result?.updated) {
+      console.log(`[llm-switcher:update] v${result.from} -> v${result.to}. Handing over to the new code.`);
+      handOver();
+    } else {
+      updateInProgress = false;
+    }
+    return;
+  }
+
   // POST /api/logs/clear
   if (pathname === '/api/logs/clear') {
     requestLogs.length = 0;
@@ -1961,7 +1994,36 @@ if (getMigrationCollision()) {
   console.error(`[llm-switcher:ERROR] Configuration migration collision: ${JSON.stringify(getMigrationCollision().clashingKeys)}. Fix config.json; it is not being rewritten.`);
 }
 
-server.listen(PORT, '127.0.0.1', () => {
+// The new code starts as a child that binds the port as soon as this listener closes. This process
+// finishes its open streams and then waits as the parent, so a service manager keeps the pid it
+// started, and `switch off` still stops the gateway by the pid that listens.
+async function handOver() {
+  server.close();
+  server.closeIdleConnections?.();
+  // The new gateway starts its own interceptor, so new interceptor code runs too.
+  await stopRecordedBlindfold().catch(() => {});
+  const args = process.argv.slice(2).filter(a => a !== '--autoupdate');
+  const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...args], { stdio: 'inherit', windowsHide: true });
+  child.on('exit', (code) => process.exit(code ?? 1));
+  for (const sig of ['SIGINT', 'SIGTERM']) process.on(sig, () => { child.kill(sig); process.exit(0); });
+}
+
+// --autoupdate is on the service command line: each logon starts the newest release.
+let handedOver = false;
+if (process.argv.includes('--autoupdate')) {
+  try {
+    const r = await applyUpdate({ logger: (msg) => console.log(`[llm-switcher:autoupdate] ${msg}`) });
+    console.log(`[llm-switcher:autoupdate] ${r.reason}`);
+    if (r.updated) {
+      handedOver = true;
+      await handOver();
+    }
+  } catch (err) {
+    console.warn(`[llm-switcher:autoupdate] ${err.message} Starting the installed version.`);
+  }
+}
+
+if (!handedOver) server.listen(PORT, '127.0.0.1', () => {
   // A service start or a restart on a new port finds env-codex.* already pointing at the interceptor.
   const cfg = loadConfig();
   if (getMigrationCollision()) {

package/service.mjs

@@ -14,13 +14,14 @@ export function serviceEnv(env = process.env) {
 const xmlEscape = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 const systemdQuote = (s) => `"${String(s).replace(/(["\\])/g, '\\$1')}"`;
 
-export function systemdUnit({ nodeBin, script, port, env = [] }) {
+export function systemdUnit({ nodeBin, script, port, env = [], autoupdate = false }) {
+  const args = autoupdate ? `${systemdQuote(script)} --port ${port} --autoupdate` : `${systemdQuote(script)} --port ${port}`;
   return `[Unit]
 Description=LLM Switcher Local Gateway
 After=network.target
 
 [Service]
-ExecStart=${systemdQuote(nodeBin)} ${systemdQuote(script)} --port ${port}
+ExecStart=${systemdQuote(nodeBin)} ${args}
 ${env.map(([k, v]) => `Environment=${systemdQuote(`${k}=${v}`)}\n`).join('')}Restart=always
 
 [Install]
@@ -28,7 +29,7 @@ WantedBy=default.target
 `;
 }
 
-export function launchdPlist({ nodeBin, script, port, logPath, env = [] }) {
+export function launchdPlist({ nodeBin, script, port, logPath, env = [], autoupdate = false }) {
   const envBlock = env.length
     ? `  <key>EnvironmentVariables</key>
   <dict>
@@ -48,7 +49,7 @@ ${env.map(([k, v]) => `    <key>${xmlEscape(k)}</key>\n    <string>${xmlEscape(v
     <string>${xmlEscape(script)}</string>
     <string>--port</string>
     <string>${port}</string>
-  </array>
+${autoupdate ? '    <string>--autoupdate</string>\n' : ''}  </array>
 ${envBlock}  <key>StandardOutPath</key>
   <string>${xmlEscape(logPath)}</string>
   <key>StandardErrorPath</key>
@@ -65,7 +66,8 @@ ${envBlock}  <key>StandardOutPath</key>
 // Task Scheduler reads the command and its arguments from two elements, so no path goes through
 // the quoting rules of a /TR command line. A task made with /TR also stops after 72 hours by
 // default; PT0S removes that limit.
-export function scheduledTaskXml({ nodeBin, script, port, userId }) {
+export function scheduledTaskXml({ nodeBin, script, port, userId, autoupdate = false }) {
+  const args = autoupdate ? `"${script}" --port ${port} --autoupdate` : `"${script}" --port ${port}`;
   return `<?xml version="1.0" encoding="UTF-16"?>
 <Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
   <RegistrationInfo>
@@ -94,7 +96,7 @@ export function scheduledTaskXml({ nodeBin, script, port, userId }) {
   <Actions Context="Author">
     <Exec>
       <Command>${xmlEscape(nodeBin)}</Command>
-      <Arguments>${xmlEscape(`"${script}" --port ${port}`)}</Arguments>
+      <Arguments>${xmlEscape(args)}</Arguments>
     </Exec>
   </Actions>
 </Task>
@@ -115,6 +117,10 @@ export function portFromServiceText(text) {
   return Number.isInteger(n) && n > 0 && n <= 65535 ? n : null;
 }
 
+export function autoupdateFromServiceText(text) {
+  return /--autoupdate\b/.test(String(text));
+}
+
 /** Writes a service definition. Returns the backup path when it replaced different content. */
 export function writeServiceFile(file, content) {
   fs.mkdirSync(path.dirname(file), { recursive: true });

package/skills/llm-switcher/SKILL.md

@@ -1,93 +1,93 @@
----
-name: llm-switcher
-description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
----
-
-# LLM Switcher Edge Gateway Skill
-
-This skill governs how AI coding agents (Claude Code, Codex, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
-
-## 1. The Core Directive
-
-> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
-> 
-> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
->
-> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
-
-```
-[Client CLI / Agent]
-         │
-         ▼
-[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
-         │
-         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
-[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
-         │
-         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
-[Internet / intact (Recommended) / 9Router / Upstream LLM]
-```
-
-## 2. Why This is Mandatory
-
-Direct outbound calls from token compressors will break the developer environment for several reasons:
-
-1. **Schema Breakage & The Healer Engine:**
-   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
-   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
-   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
-2. **Thinking / Reasoning Protection:**
-   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
-   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
-3. **Official Context Windows & Dynamic Model Discovery:**
-   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
-4. **Server Gateway Synergy (intact / 9Router):**
-   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
-
-## 3. Configuring Token Compression Tools
-
-When setting up or assisting the user with token compression tools, apply these exact configurations:
-
-### A. Headroom (Prompt Compression Proxy)
-When configuring Headroom's upstream endpoint:
-- In Headroom config (`headroom.yaml` or environment variables):
-  ```bash
-  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
-  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
-  ```
-- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
-
-### B. RTK (Rust Token Killer / Repomix)
-- In RTK configuration or execution flags:
-  ```bash
-  # Ensure RTK's target upstream proxy is LLM Switcher
-  export UPSTREAM_URL="http://127.0.0.1:3456"
-  ```
-
-### C. Ponytail / Custom Proxies
-- Always set the proxy's upstream host to:
-  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
-
-### D. Sub-Agents & Spawned Terminal Commands
-When an agent spawns sub-processes that call LLM CLIs:
-- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
-  more, so sourcing one changes nothing — and a stale variable an older version once wrote
-  would still point the tool at a port where nothing listens.
-- Run `switch claude <profile>` or `switch codex <profile>` instead. The shims in
-  `~/.llm-switcher/bin` inject the proxy variables into the tool process itself and clear
-  anything stale first.
-- `claude` and `codex` on `PATH` already are those shims: invoke them normally, and never
-  wrap them in another script.
-
-## 4. Operational Rules for AI Agents
-
-1. **NEVER edit `~/.claude/settings.json` directly.**
-   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
-2. **Check Gateway Health Before Complex Operations:**
-   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
-   - LLM Switcher is active on port `3456`.
-   - The active profile matches the intended CLI target (Claude Code, Codex, or OpenAI).
-3. **Verify Routing When Errors Occur:**
-   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
-   - Run `switch doctor` to audit port collisions and environment variables.
-   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.
+---
+name: llm-switcher
+description: Mandatory guidance for AI coding agents and token compression tools (Headroom, RTK, Ponytail, Repomix). Enforces routing all LLM traffic through the local LLM Switcher edge gateway (http://127.0.0.1:3456) instead of directly calling provider endpoints.
+---
+
+# LLM Switcher Edge Gateway Skill
+
+This skill governs how AI coding agents (Claude Code, Codex, Cursor, Windsurf, Opencode) and prompt optimization/compression tools (Headroom, RTK, Ponytail, Repomix) must interact with LLM providers on this workstation.
+
+## 1. The Core Directive
+
+> **ALL OUTBOUND LLM REQUESTS MUST ROUTE THROUGH LLM SWITCHER (`http://127.0.0.1:3456`).**
+> 
+> Never configure any tool, script, sub-agent, or token compression proxy to call external provider endpoints directly (such as `https://api.anthropic.com`, `https://api.openai.com`, or `https://generativelanguage.googleapis.com`).
+>
+> If a token compression tool (Headroom, RTK, Ponytail) is used, it MUST be positioned as an **inner processing layer**, and its **upstream destination MUST be configured to point to LLM Switcher** at `http://127.0.0.1:3456`.
+
+```
+[Client CLI / Agent]
+         │
+         ▼
+[Token Compressor: RTK / Headroom / Ponytail]  <-- Inner Layer
+         │
+         ▼ (MANDATORY: Upstream MUST point to http://127.0.0.1:3456)
+[LLM Switcher Edge Gateway (:3456)]            <-- Outermost Gatekeeper
+         │
+         ▼ (Heals schemas, maps 1M context, extracts thinking, converts protocol)
+[Internet / intact (Recommended) / 9Router / Upstream LLM]
+```
+
+## 2. Why This is Mandatory
+
+Direct outbound calls from token compressors will break the developer environment for several reasons:
+
+1. **Schema Breakage & The Healer Engine:**
+   Token optimizers frequently prune conversation history to save tokens. In doing so, they often delete an `assistant` turn containing a `tool_use`, while leaving the subsequent `user` turn containing a `tool_result`.
+   - Anthropic and OpenAI APIs strictly reject this with `HTTP 400 (orphaned tool_use_id)`.
+   - **LLM Switcher** intercepts these malformed requests and runs its **Healer Engine**, automatically converting orphaned results into safe context text blocks and merging consecutive same-role turns so upstream providers accept the payload cleanly.
+2. **Thinking / Reasoning Protection:**
+   Many token compressors naively strip `thinking` parameters or reasoning budgets to reduce token count.
+   - When routed through LLM Switcher, the gateway detects reasoning models (such as `ag/claude-opus-4-6-thinking` or `ag/gemini-3.8-flash`) and **automatically restores thinking parameters**, ensuring the model retains its full reasoning capabilities.
+3. **Official Context Windows & Dynamic Model Discovery:**
+   Context windows follow the model you select without mutating permanent settings. The gateway auto-discovers official models from Anthropic and OpenAI, refreshing mappings on tool version upgrades (`switch models`).
+4. **Server Gateway Synergy (intact / 9Router):**
+   LLM Switcher pairs directly with server-side gateways like **intact** (strongly recommended for credential proxying, account pooling, and contract lab self-healing) or 9Router, handling retries and quotas far better than any local tool.
+
+## 3. Configuring Token Compression Tools
+
+When setting up or assisting the user with token compression tools, apply these exact configurations:
+
+### A. Headroom (Prompt Compression Proxy)
+When configuring Headroom's upstream endpoint:
+- In Headroom config (`headroom.yaml` or environment variables):
+  ```bash
+  ANTHROPIC_BASE_URL="http://127.0.0.1:3456"
+  OPENAI_BASE_URL="http://127.0.0.1:3456/v1"
+  ```
+- Point your CLI to Headroom's listening port (e.g. `http://127.0.0.1:8787`). Headroom compresses the prompt and forwards it to LLM Switcher on port `3456`.
+
+### B. RTK (Rust Token Killer / Repomix)
+- In RTK configuration or execution flags:
+  ```bash
+  # Ensure RTK's target upstream proxy is LLM Switcher
+  export UPSTREAM_URL="http://127.0.0.1:3456"
+  ```
+
+### C. Ponytail / Custom Proxies
+- Always set the proxy's upstream host to:
+  `http://127.0.0.1:3456` (or `http://127.0.0.1:3456/v1` for OpenAI-compatible tools).
+
+### D. Sub-Agents & Spawned Terminal Commands
+When an agent spawns sub-processes that call LLM CLIs:
+- **Never advise sourcing `env.sh` or `env.cmd`.** Those files carry no proxy variables any
+  more, so sourcing one changes nothing — and a stale variable an older version once wrote
+  would still point the tool at a port where nothing listens.
+- Run `switch claude <profile>` or `switch codex <profile>` instead. The shims in
+  `~/.llm-switcher/bin` inject the proxy variables into the tool process itself and clear
+  anything stale first.
+- `claude` and `codex` on `PATH` already are those shims: invoke them normally, and never
+  wrap them in another script.
+
+## 4. Operational Rules for AI Agents
+
+1. **NEVER edit `~/.claude/settings.json` directly.**
+   LLM Switcher uses zero-mutation launcher flags (`active.flag`). Writing custom base URLs or auth tokens into `settings.json` triggers warning banners in Claude Code and risks breaking the user's official subscription. Use `switch` CLI commands instead.
+2. **Check Gateway Health Before Complex Operations:**
+   Run `switch status` or call the `switcher_audit` MCP tool to confirm:
+   - LLM Switcher is active on port `3456`.
+   - The active profile matches the intended CLI target (Claude Code, Codex, or OpenAI).
+3. **Verify Routing When Errors Occur:**
+   If a tool fails with `HTTP 400`, `HTTP 502`, or connection errors:
+   - Run `switch doctor` to audit port collisions and environment variables.
+   - Inspect recent request logs via `http://127.0.0.1:3456/ui` (Tab 4: Live Inspector) to see if an intermediary tool mangled the payload.

package/switch.cmd

@@ -1,2 +1,2 @@
-@echo off
-node "%~dp0switch.mjs" %*
+@echo off
+node "%~dp0switch.mjs" %*

package/switch.mjs

@@ -20,7 +20,7 @@ import {
   suggestedRcFiles, auditRunningProcesses
 } from './shim.mjs';
 import {
-  serviceEnv, systemdUnit, launchdPlist, scheduledTaskXml, decodeConsoleText, portFromServiceText, writeServiceFile
+  serviceEnv, systemdUnit, launchdPlist, scheduledTaskXml, decodeConsoleText, portFromServiceText, autoupdateFromServiceText, writeServiceFile
 } from './service.mjs';
 
 const proxyScript = path.join(ROOT_DIR, 'proxy.mjs');
@@ -272,6 +272,9 @@ async function changePort(newPortStr) {
   const target = await probeGateway(p);
   if (isHeld(target)) refuseForeignPort(p, 'this switcher', target);
   const svc = installedService();
+  // The unit is rewritten below. It keeps the choice that `service install --no-autoupdate` made.
+  const svcText = svc ? serviceText(svc) : null;
+  const autoupdate = svcText === null || autoupdateFromServiceText(svcText);
   const wasRunning = await checkProxyRunning(oldPort);
   // Stop the old gateway even when a service is installed: it may be a copy started outside the unit.
   if (wasRunning) {
@@ -301,7 +304,7 @@ async function changePort(newPortStr) {
     } catch (err) {
       console.error(`[Error] Failed to restore config.json during rollback: ${err.message}`);
     }
-    if (svc) installService(oldPort);
+    if (svc) installService(oldPort, { autoupdate });
     else if (wasRunning) startProxyBackground(oldPort);
     let up = !svc && !wasRunning;
     for (let i = 0; i < 20 && !up; i++) { await sleep(250); up = await checkProxyRunning(oldPort); }
@@ -311,7 +314,7 @@ async function changePort(newPortStr) {
   if (svc) {
     // The unit fixes the port on its command line, so it is rewritten and restarted, not fought.
     console.log(`Reinstalling the ${svc} service on port ${p}...`);
-    if (!installService(p)) await rollBack(`The ${svc} service could not be installed for port ${p}.`);
+    if (!installService(p, { autoupdate })) await rollBack(`The ${svc} service could not be installed for port ${p}.`);
     let up = false;
     for (let i = 0; i < 20 && !up; i++) { await sleep(250); up = await checkProxyRunning(p); }
     if (!up) await rollBack(`The ${svc} service did not come up on port ${p}. See ${proxyLogPath}.`);
@@ -669,16 +672,22 @@ function serviceStart(kind) {
   } catch {}
 }
 
-/** The port on the service's command line, or null when it cannot be read. */
-function servicePort(kind) {
+/** The installed service definition, or null when it cannot be read. */
+function serviceText(kind) {
   try {
-    if (kind === 'systemd') return portFromServiceText(fs.readFileSync(SYSTEMD_UNIT, 'utf8'));
-    if (kind === 'launchd') return portFromServiceText(fs.readFileSync(LAUNCHD_PLIST, 'utf8'));
-    if (kind === 'schtasks') return portFromServiceText(decodeConsoleText(execFileSync('schtasks', ['/Query', '/TN', 'LLMSwitcher', '/XML'])));
+    if (kind === 'systemd') return fs.readFileSync(SYSTEMD_UNIT, 'utf8');
+    if (kind === 'launchd') return fs.readFileSync(LAUNCHD_PLIST, 'utf8');
+    if (kind === 'schtasks') return decodeConsoleText(execFileSync('schtasks', ['/Query', '/TN', 'LLMSwitcher', '/XML']));
   } catch {}
   return null;
 }
 
+/** The port on the service's command line, or null when it cannot be read. */
+function servicePort(kind) {
+  const text = serviceText(kind);
+  return text === null ? null : portFromServiceText(text);
+}
+
 function reportBackup(backup) {
   if (backup) console.log(`[Service] The previous definition differed and is kept as ${backup}.`);
 }
@@ -693,7 +702,7 @@ function serviceStop(kind) {
 }
 
 // Writes the service for `port` and (re)starts it, so a running unit picks up the new command line.
-function installService(port) {
+function installService(port, { autoupdate = true } = {}) {
   const nodeBin = process.execPath;
   const env = serviceEnv();
   if (process.platform === 'win32') {
@@ -702,12 +711,12 @@ function installService(port) {
       const userId = process.env.USERDOMAIN && process.env.USERNAME ? `${process.env.USERDOMAIN}\\${process.env.USERNAME}` : os.userInfo().username;
       const xmlPath = path.join(dir, 'task.xml');
       // Task Scheduler reads the XML as UTF-16, the encoding it declares.
-      fs.writeFileSync(xmlPath, Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(scheduledTaskXml({ nodeBin, script: proxyScript, port, userId }), 'utf16le')]));
+      fs.writeFileSync(xmlPath, Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(scheduledTaskXml({ nodeBin, script: proxyScript, port, userId, autoupdate }), 'utf16le')]));
       execFileSync('schtasks', ['/Create', '/TN', 'LLMSwitcher', '/XML', xmlPath, '/F'], { stdio: 'inherit' });
       try { execFileSync('schtasks', ['/End', '/TN', 'LLMSwitcher'], { stdio: 'ignore' }); } catch {}
       execFileSync('schtasks', ['/Run', '/TN', 'LLMSwitcher'], { stdio: 'ignore' });
       if (env.length) console.log(`[WARN] The scheduled task does not receive ${env.map(([k]) => k).join(', ')}. Set them as User environment variables.`);
-      console.log('[SUCCESS] Installed and started Windows Scheduled Task "LLMSwitcher" (auto-starts on logon).');
+      console.log(`[SUCCESS] Installed and started Windows Scheduled Task "LLMSwitcher" (${autoupdate ? 'auto-updates on logon and starts' : 'auto-starts on logon'}).`);
       return true;
     } catch (err) {
       console.error('[Error] Failed to register the scheduled task:', err.message);
@@ -718,7 +727,7 @@ function installService(port) {
   }
   if (process.platform === 'darwin') {
     try {
-      reportBackup(writeServiceFile(LAUNCHD_PLIST, launchdPlist({ nodeBin, script: proxyScript, port, logPath: proxyLogPath, env })));
+      reportBackup(writeServiceFile(LAUNCHD_PLIST, launchdPlist({ nodeBin, script: proxyScript, port, logPath: proxyLogPath, env, autoupdate })));
       try { execFileSync('launchctl', ['unload', LAUNCHD_PLIST], { stdio: 'ignore' }); } catch {}
       execFileSync('launchctl', ['load', LAUNCHD_PLIST], { stdio: 'inherit' });
       console.log('[SUCCESS] Installed and started macOS launchd service.');
@@ -729,7 +738,7 @@ function installService(port) {
     }
   }
   try {
-    reportBackup(writeServiceFile(SYSTEMD_UNIT, systemdUnit({ nodeBin, script: proxyScript, port, env })));
+    reportBackup(writeServiceFile(SYSTEMD_UNIT, systemdUnit({ nodeBin, script: proxyScript, port, env, autoupdate })));
     systemctlUser(['daemon-reload'], { stdio: 'inherit' });
     systemctlUser(['enable', 'llm-switcher'], { stdio: 'inherit' });
     systemctlUser(['restart', 'llm-switcher'], { stdio: 'inherit' });
@@ -745,7 +754,8 @@ async function manageService(action) {
   const port = getTargetPort();
 
   if (action === 'install') {
-    if (!installService(port)) process.exit(1);
+    const autoupdate = !process.argv.includes('--no-autoupdate');
+    if (!installService(port, { autoupdate })) process.exit(1);
     return;
   }
 
@@ -1106,6 +1116,78 @@ async function showVersion() {
   else console.log('This is the latest version.');
 }
 
+async function gatewayPid(port) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/health?challenge=update`, { signal: AbortSignal.timeout(2000) });
+    return (await r.json()).pid ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// A running gateway updates itself and hands over to the new code, so the CLI and the dashboard
+// share one update path. With no gateway up, the files are updated here and the next start runs them.
+async function runUpdate() {
+  const port = getTargetPort();
+  if (!(await checkProxyRunning(port))) {
+    const { applyUpdate } = await import('./update.mjs');
+    try {
+      const r = await applyUpdate({ logger: (text) => console.log(`  ${text}`) });
+      console.log(r.updated ? `[SUCCESS] Updated v${r.from} -> v${r.to}.` : r.reason);
+    } catch (err) {
+      console.error(`[Error] ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+  const oldPid = await gatewayPid(port);
+  const res = await fetch(`http://127.0.0.1:${port}/api/update`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-llm-switcher-token': readAdminToken() || '' },
+    body: '{}'
+  });
+  if (!res.ok) {
+    console.error(`[Error] ${(await res.json().catch(() => ({}))).error || `HTTP ${res.status}`}`);
+    process.exit(1);
+  }
+  let result = null;
+  let failed = null;
+  let buf = '';
+  const decoder = new TextDecoder();
+  for await (const chunk of res.body) {
+    buf += decoder.decode(chunk, { stream: true });
+    let i;
+    while ((i = buf.indexOf('\n\n')) !== -1) {
+      const block = buf.slice(0, i);
+      buf = buf.slice(i + 2);
+      const event = /^event: (.*)$/m.exec(block)?.[1];
+      const data = JSON.parse(/^data: (.*)$/m.exec(block)?.[1] || 'null');
+      if (event === 'log') console.log(`  ${show(data.text)}`);
+      else if (event === 'result') result = data;
+      else if (event === 'error') failed = data.message;
+    }
+  }
+  if (failed || !result) {
+    console.error(`[Error] ${show(failed || 'The gateway closed the update stream without a result.')}`);
+    process.exit(1);
+  }
+  if (!result.updated) {
+    console.log(show(result.reason));
+    return;
+  }
+  console.log(`Updated v${show(result.from)} -> v${show(result.to)}. Waiting for the new gateway...`);
+  for (let i = 0; i < 60; i++) {
+    await sleep(250);
+    const pid = await gatewayPid(port);
+    if (pid && pid !== oldPid && (await checkProxyRunning(port))) {
+      console.log(`[SUCCESS] The gateway on port ${port} runs v${show(result.to)}.`);
+      return;
+    }
+  }
+  console.error(`[Error] The new gateway did not answer on port ${port}. See ${proxyLogPath}.`);
+  process.exit(1);
+}
+
 async function showModels(target) {
   const { syncLocalCatalog, refreshCatalog } = await import('./catalog.mjs');
   if (optionValue('--refresh') || process.argv.includes('--refresh')) {
@@ -1169,6 +1251,8 @@ if (cmd === 'off' || cmd === 'stop') {
   await showModels(subArg);
 } else if (cmd === 'status' || cmd === 'st') {
   await showStatus();
+} else if (cmd === 'update' || cmd === 'upgrade') {
+  await runUpdate();
 } else if (cmd === 'on' || cmd === 'start') {
   await turnOn(subArg);
 } else if (cmd && findProfileKey(config, rawCmd)) {
@@ -1179,12 +1263,13 @@ if (cmd === 'off' || cmd === 'stop') {
   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 update                  # Install the newest release and restart the gateway');
   console.log('  switch on [profile]            # Start gateway & activate profile for all compatible targets');
   console.log('  switch <profile>               # Activate profile for all compatible targets');
   console.log('  switch claude <profile>        # Set active profile for Claude Code');
   console.log('  switch codex <profile>         # Set active profile for Codex');
   console.log('  switch port <number>           # Change gateway port');
-  console.log('  switch service install         # Install OS background autostart service');
+  console.log('  switch service install         # Install OS background autostart service (auto-updates on logon)');
   console.log('  switch service uninstall       # Uninstall background autostart service');
   console.log('  switch shim install            # Auto-inject env into resumed sessions (claude --resume)');
   console.log('  switch shim status             # Check shims + detect sessions bypassing the gateway');

package/tests/gateway.e2e.test.mjs

@@ -1251,6 +1251,17 @@ test('Codex WS: conversation.item.create is echoed and response.cancel stops the
   ws.socket.destroy();
 });
 
+test('Test connection on a Bifrost model checks the model and the key, and sends no fake request', async () => {
+  const before = received.length;
+  const r = await post('/api/test-upstream', { baseURL: `http://127.0.0.1:${upstreamPort}/intact/v1`, apiKey: 'k', model: 'claude/claude-opus-5', mode: 'convert' });
+  const j = await r.json();
+  assert.equal(j.ok, true);
+  assert.equal(j.outFormat, 'bifrost');
+  assert.match(j.sample, /claude-cli\//);
+  const sent = received.slice(before).map(x => x.url);
+  assert.ok(!sent.some(u => u.includes('/messages') || u.includes('/chat/completions')), `sent ${sent}`);
+});
+
 test('Admin test-upstream reports latency and a sample from the upstream', async () => {
   const r = await post('/api/test-upstream', { baseURL: `http://127.0.0.1:${upstreamPort}/chat/v1`, apiKey: 'k', model: 'm', mode: 'convert' });
   assert.equal(r.status, 200);