llm-switcher 1.2.7 → 1.2.9

package/tests/cdp.mjs

@@ -82,6 +82,7 @@ export class Page {
     this.dialogs = [];       // { type, message } for every alert, confirm and prompt
     this.dialogPolicy = 'accept';
     this.inflight = new Map();   // requestId -> url, so a stuck request can be named
+    this.requests = [];      // { method, url } for every request, so a double submit is countable
     this.ws.addEventListener('message', (ev) => this.#onMessage(JSON.parse(ev.data)));
   }
 
@@ -93,7 +94,10 @@ export class Page {
     });
     this.on('Runtime.exceptionThrown', (e) => this.problems.push(`exception: ${e.exceptionDetails.exception?.description || e.exceptionDetails.text}`));
     this.on('Log.entryAdded', (e) => { if (e.entry.level === 'error') this.problems.push(`log: ${e.entry.text} ${e.entry.url || ''}`.trim()); });
-    this.on('Network.requestWillBeSent', (e) => this.inflight.set(e.requestId, e.request.url));
+    this.on('Network.requestWillBeSent', (e) => {
+      this.inflight.set(e.requestId, e.request.url);
+      this.requests.push({ method: e.request.method, url: e.request.url });
+    });
     // A new document ends every request of the old one, and no event says so for some of them.
     this.on('Page.frameNavigated', (e) => { if (!e.frame.parentId) this.inflight.clear(); });
     this.on('Network.loadingFinished', (e) => this.inflight.delete(e.requestId));
@@ -132,7 +136,22 @@ export class Page {
   close() { try { this.ws.close(); } catch { /* already closed */ } }
 
   // Forget what happened so far, so a test asserts only on the action it just made.
-  clearProblems() { this.problems.length = 0; this.badResponses.length = 0; this.dialogs.length = 0; }
+  clearProblems() {
+    this.problems.length = 0;
+    this.badResponses.length = 0;
+    this.dialogs.length = 0;
+    this.requests.length = 0;
+  }
+
+  // Every request of one method whose URL holds `part`. A double submit is two entries here.
+  sent(method, part) { return this.requests.filter(r => r.method === method && r.url.includes(part)); }
+
+  // A real viewport change, the way a narrow window is, so a media query takes effect.
+  async resize(width, height) {
+    await this.send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false });
+    // A layout pass runs on the next frame, so a measurement taken at once reads the old box.
+    await this.evaluate('new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))');
+  }
 
   // Wait until no request is in flight for `quiet` ms. A click starts a request, and the page then
   // starts a second one to read the state back, so one quiet moment is not enough.

package/tests/contract-lab.test.mjs

@@ -260,6 +260,11 @@ function startUpstream() {
     let body = '';
     req.on('data', c => { body += c; });
     req.on('end', () => {
+      // The Bifrost lookup reads one model entry; it is not a probe request.
+      if (req.method === 'GET' && req.url.includes('/models/')) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        return res.end('{}');
+      }
       const json = body ? JSON.parse(body) : {};
       received.push({ url: req.url, headers: req.headers, body: json });
       if (JSON.stringify(json.messages || '').includes('ERR_400')) {

package/tests/dashboard.e2e.test.mjs

@@ -667,4 +667,120 @@ describe('dashboard, driven in a real browser', { skip: skipReason() }, () => {
       await expectScreenMatchesDisk('after outside edit');
     });
   });
+  // Found by a human-behaviour pass over the running dashboard on 2026-09-29: a real browser, real
+  // clicks and real keys, never a value set through the page's own JavaScript. Each test here is the
+  // reproduction of one finding from that pass.
+  describe('what a person notices when pressing the dashboard hard', () => {
+    const editButtons = () => page.evaluate(
+      `[...document.querySelectorAll('#profiles-grid .pcard button')].map(b => b.textContent.trim()).filter(t => /Edit/.test(t))`
+    );
+
+    it('gives a card back its normal Edit button after a close that saved nothing', async () => {
+      await editProfile('intact-claude');
+      await page.waitFor('document.getElementById("profile-modal-overlay").style.display === "grid"', 'the dialog');
+      await page.key('Escape');
+      await page.waitFor('document.getElementById("profile-modal-overlay").style.display === "none"', 'the dialog to close');
+      assert.deepEqual((await editButtons()).filter(t => /Editing/.test(t)), [],
+        'a dialog closed without saving left the card in the editing state');
+    });
+
+    it('moves the keyboard into the dialog when it opens', async () => {
+      await editProfile('intact-claude');
+      await page.waitFor('document.getElementById("profile-modal-overlay").style.display === "grid"', 'the dialog');
+      const inside = await page.evaluate(
+        `document.getElementById('profile-modal-overlay').contains(document.activeElement)`
+      );
+      assert.equal(inside, true, 'the focus stayed behind the overlay, so the first Tab leaves the dialog');
+    });
+
+    it('never shows the connection result of the profile opened before', async () => {
+      await editProfile('intact-claude');
+      await page.waitFor('document.getElementById("profile-modal-overlay").style.display === "grid"', 'the dialog');
+      await act(() => page.clickText('#profile-modal-overlay button', 'Test Connection'));
+      await page.waitFor(`document.getElementById('test-result').textContent.trim().length > 0`, 'a result');
+      await page.key('Escape');
+      await act(() => page.clickText('button', '+ Add Profile'));
+      assert.equal(await page.text('#test-result'), '',
+        'an untested new profile showed the connection result of the profile opened before it');
+    });
+
+    it('sends one save for one double-click on Save Profile', async () => {
+      await act(() => page.clickText('button', '+ Add Profile'));
+      await page.type('#p-key', 'dbl');
+      await page.type('#p-name', 'Double click');
+      await page.type('#p-url', 'https://dbl.example.io/v1');
+      await page.type('#p-key-val', 'sk-dbl');
+      page.clearProblems();
+      const save = '#profile-modal-overlay button[type="submit"]';
+      await page.click(save);
+      await page.click(save);
+      await page.idle();
+      assert.equal(page.sent('POST', '/api/save-profile').length, 1,
+        'a double-click sent the save twice, because the button is not disabled while it runs');
+    });
+
+    it('says so when a model search matches nothing', async () => {
+      await open('#/models');
+      await page.waitFor(`document.querySelectorAll('#catalog-claude-items .row').length > 0`, 'the catalog rows');
+      await page.type('#catalog-search', 'zzz-nothing-matches-this-zzz');
+      await page.waitFor(
+        `[...document.querySelectorAll('#catalog-claude-items .row, #catalog-codex-items .row')].every(r => r.offsetParent === null)`,
+        'every row hidden'
+      );
+      const shown = await page.evaluate(`(() => {
+        const visible = (e) => e.offsetParent !== null;
+        const message = [...document.querySelectorAll('#view-models *')]
+          .some(e => visible(e) && /no match|nothing matches|no model/i.test(e.textContent));
+        const badge = document.getElementById('badge-claude-count');
+        return { message, badge: badge && visible(badge) ? badge.textContent.trim() : '' };
+      })()`);
+      assert.equal(shown.message, true, 'an empty result looked like a broken page: no message at all');
+      assert.doesNotMatch(shown.badge, /^[1-9]/, `the header kept the unfiltered count: "${shown.badge}"`);
+    });
+
+    it('keeps the navigation reachable on a narrow window', async () => {
+      await page.resize(400, 900);
+      try {
+        const box = await page.evaluate(`(() => {
+          const aside = document.querySelector('aside'), nav = document.querySelector('aside nav');
+          const a = aside.getBoundingClientRect(), n = nav.getBoundingClientRect();
+          return { navHeight: n.height, navBottom: n.bottom, asideBottom: a.bottom, asideHeight: a.height };
+        })()`);
+        assert.ok(box.navHeight > 0, 'the navigation has no height at 400 px');
+        assert.ok(box.navBottom <= box.asideBottom + 1,
+          `the navigation is drawn outside the sidebar (nav bottom ${box.navBottom}, sidebar bottom ${box.asideBottom}, sidebar height ${box.asideHeight})`);
+        assert.equal(await page.visible('aside nav a'), true, 'no navigation link is visible at 400 px');
+      } finally {
+        await page.resize(1280, 900);
+      }
+    });
+
+    it('does not let a long profile name break the dialog header', async () => {
+      const cfg = fx.config();
+      cfg.profiles['intact-claude'].name = 'N'.repeat(300);
+      fx.writeConfig(cfg);
+      await open('#/routes');
+      await editProfile('intact-claude');
+      await page.waitFor('document.getElementById("profile-modal-overlay").style.display === "grid"', 'the dialog');
+      const t = await page.evaluate(`(() => {
+        const e = document.getElementById('form-title');
+        return { scroll: e.scrollWidth, client: e.clientWidth };
+      })()`);
+      assert.ok(t.scroll <= t.client + 1,
+        `the header text is wider than its box (${t.scroll} > ${t.client}), so it clips mid-character`);
+    });
+
+    it('opens the payload preview while auto-refresh is on', async () => {
+      const sent = await fx.messages();
+      assert.equal(sent.status, 200, sent.text);
+      await open('#/logs');
+      await page.waitFor(`document.querySelectorAll('#inspector-logs-container details').length >= 1`, 'at least one log row with a preview');
+      assert.equal(await page.evaluate(`document.getElementById('chk-auto-refresh-logs').checked`), true,
+        'this test needs the default, which is auto-refresh on');
+      // One click, the way a person clicks. A control that the poll detaches fails right here.
+      await page.click('#inspector-logs-container details summary');
+      const opened = await page.evaluate(`Boolean(document.querySelector('#inspector-logs-container details[open]'))`);
+      assert.equal(opened, true, 'the poll replaces the row, so the preview cannot be opened while it runs');
+    });
+  });
 });

package/tests/gateway.e2e.test.mjs

@@ -68,9 +68,23 @@ function startUpstream() {
     req.on('data', c => { body += c; });
     req.on('end', () => {
       const json = body ? JSON.parse(body) : {};
-      received.push({ url: req.url, headers: req.headers, body: json });
+      received.push({ url: req.url, headers: req.headers, body: json, raw: body });
       const lastUser = JSON.stringify(json.messages?.at(-1) ?? json.contents?.at(-1) ?? '');
 
+      // A stand-in intact: claude/* is a Claude Code account, the rest is not.
+      if (req.method === 'GET' && req.url.startsWith('/intact/v1/models/')) {
+        const id = decodeURIComponent(req.url.slice('/intact/v1/models/'.length));
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ id, owned_by: id.split('/')[0], ...(id.startsWith('claude/') ? { bifrost_ua: 'claude-cli/' } : {}) }));
+      }
+      if (req.url.startsWith('/intact/v1/messages')) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ id: 'msg_n', type: 'message', role: 'assistant', model: json.model, content: [{ type: 'text', text: 'bifrost ok' }], stop_reason: 'end_turn', usage: { input_tokens: 3, output_tokens: 2 } }));
+      }
+      if (req.url.startsWith('/intact/v1/chat/completions')) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ id: 'c1', object: 'chat.completion', model: json.model, choices: [{ index: 0, message: { role: 'assistant', content: 'converted ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 1, completion_tokens: 1 } }));
+      }
       if (req.url.startsWith('/chat/v1/chat/completions')) {
         if (lastUser.includes('RATE_LIMIT')) {
           res.writeHead(429, { 'Content-Type': 'application/json', 'retry-after': '7' });
@@ -202,6 +216,7 @@ before(async () => {
       pub: { name: 'Mock Public', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-pub', publicModels: ['gpt-5.6-sol', 'gpt-5.2'], defaultModels: { main: 'ag/mock-flash' }, model1M: { main: true } },
       roles: { name: 'Mock Public Roles', mode: 'convert', inFormat: 'responses', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-roles', publicModels: ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'], defaultModels: { main: 'ag/mock-flash', review: 'ag/mock-review', subagent: 'ag/mock-low' } },
       native: { name: 'Mock Strict OpenAI', mode: 'convert', inFormat: 'auto', outFormat: 'openai-chat', thinkingMode: 'native', baseURL: `${base}/chat/v1`, apiKey: 'sk-secret-native', defaultModels: models },
+      intactcc: { name: 'Mock intact', mode: 'convert', tool: 'claude', outFormat: 'openai-chat', thinkingMode: 'off', baseURL: `${base}/intact/v1`, apiKey: 'sk-intact-user', defaultModels: { opus: 'claude/claude-opus-5', sonnet: 'gem/flash', haiku: 'claude/claude-haiku-4-5', fable: 'gem/flash' } },
       ant: { name: 'Mock Anthropic', mode: 'direct', inFormat: 'auto', outFormat: 'anthropic', baseURL: `${base}/ant`, apiKey: 'sk-secret-ant', defaultModels: models }
     }
   };
@@ -470,7 +485,7 @@ test('save-profile rejects a model name that could act as a command', async () =
   assert.equal(ok.status, 200);
 });
 
-test('Codex WS transport: upstream 429 becomes response.failed with rate_limit_exceeded', async () => {  const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
+test('Codex WS transport: upstream 429 becomes response.failed with rate_limit_exceeded', { skip: typeof WebSocket === 'undefined' && 'global WebSocket needs Node 22+' }, async () => {  const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
   await new Promise((resolve, reject) => {
     const t = setTimeout(() => reject(new Error('ws open timeout')), 5000);
     ws.addEventListener('open', () => { clearTimeout(t); resolve(); }, { once: true });
@@ -577,6 +592,40 @@ test('Direct Anthropic passthrough strips hop-by-hop headers and blocks client c
   assert.equal(up.body.model, 'up-opus');
 });
 
+test('Bifrost: Claude Code to a Claude Code account on intact changes only the key', async () => {
+  // Orphaned tool_result and a thinking block: the healer and thinkingMode=off would both change these.
+  const body = { model: 'claude-opus-4-6', max_tokens: 10, thinking: { type: 'adaptive' }, metadata: { user_id: 'u1' },
+    messages: [{ role: 'user', content: [{ type: 'tool_result', tool_use_id: 'gone', content: 'x' }] }] };
+  const res = await post('/v1/messages?beta=true', body, {
+    'x-llm-profile': 'intactcc', 'user-agent': 'claude-cli/2.1.300 (external, cli)', 'x-api-key': 'client-own-key',
+    authorization: 'Bearer client-oauth', 'anthropic-beta': 'oauth-2025-04-20,new-beta', 'anthropic-dangerous-direct-browser-access': 'true', 'x-app': 'cli'
+  });
+  assert.equal(res.status, 200);
+  assert.equal((await res.json()).content[0].text, 'bifrost ok');
+  const up = received.at(-1);
+  assert.equal(up.url, '/intact/v1/messages?beta=true');
+  assert.equal(up.headers['x-api-key'], 'sk-intact-user');
+  assert.equal(up.headers.authorization, undefined);
+  assert.equal(up.headers['user-agent'], 'claude-cli/2.1.300 (external, cli)');
+  assert.equal(up.headers['anthropic-beta'], 'oauth-2025-04-20,new-beta');
+  assert.equal(up.headers['anthropic-dangerous-direct-browser-access'], 'true');
+  assert.equal(up.headers['x-app'], 'cli');
+  assert.equal(up.raw, JSON.stringify({ ...body, model: 'claude/claude-opus-5' }));
+});
+
+test('Bifrost stays off for a model that is not a Claude Code account', async () => {
+  const res = await post('/v1/messages', { model: 'claude-sonnet-5', max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
+    { 'x-llm-profile': 'intactcc', 'user-agent': 'claude-cli/2.1.300 (external, cli)' });
+  assert.equal(res.status, 200);
+  assert.equal(received.at(-1).url, '/intact/v1/chat/completions');
+});
+
+test('Bifrost stays off for a client that is not Claude Code', async () => {
+  await post('/v1/messages', { model: 'claude-opus-4-6', max_tokens: 10, messages: [{ role: 'user', content: 'hi' }] },
+    { 'x-llm-profile': 'intactcc', 'user-agent': 'some-sdk/1.0' });
+  assert.equal(received.at(-1).url, '/intact/v1/chat/completions');
+});
+
 test('Healer: orphaned tool_result and missing tool_result produce a valid chat history', async () => {
   await post('/v1/messages', {
     model: 'claude-opus-4-6', max_tokens: 50, messages: [

package/tests/hook-status.test.mjs

@@ -0,0 +1,119 @@
+// The launch hook: what a coding tool shows the person about the switcher at the start of a session.
+//
+// The shim toast fires only when the shim runs, and it needs the shim directory first on PATH. A
+// hook runs inside the tool itself, so it reports even when the launcher is the person's own script.
+// Both tools read one JSON object from stdout and show `systemMessage` to the person.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HOOK = path.join(ROOT, 'hook-status.mjs');
+const { identityProof } = await import(pathToFileURL(path.join(ROOT, 'state.mjs')).href);
+
+function tmpState(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-hook-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  // The proof is an HMAC over the admin token, so the fake gateway needs the same file.
+  fs.writeFileSync(path.join(dir, 'admin.token'), 'tok-for-the-hook-test', { mode: 0o600 });
+  return dir;
+}
+
+function writeConfig(dir, port) {
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({
+    port,
+    activeProfiles: { claude: 'cl', codex: null },
+    profiles: {
+      cl: {
+        name: 'Intact Claude', baseURL: 'https://intact.example.io/v1', apiKey: 'sk-secret',
+        defaultModels: { opus: 'gemini-3.8-flash' }, model1M: { opus: true }
+      }
+    }
+  }), { mode: 0o600 });
+}
+
+// A gateway of this build: it answers /health with a proof over the challenge.
+function fakeGateway(t, port) {
+  const srv = http.createServer((req, res) => {
+    const nonce = new URL(req.url, 'http://127.0.0.1').searchParams.get('challenge') || '';
+    const body = { proxy: 'llm-switcher', port, pid: process.pid };
+    body.proof = identityProof(nonce, { role: 'gateway', port, pid: body.pid }, 'tok-for-the-hook-test');
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(body));
+  });
+  return new Promise((resolve) => srv.listen(port, '127.0.0.1', () => {
+    t.after(() => new Promise(r => srv.close(r)));
+    resolve(srv);
+  }));
+}
+
+function freePort() {
+  return new Promise((resolve) => {
+    const s = http.createServer();
+    s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => resolve(p)); });
+  });
+}
+
+function runHook(dir, tool) {
+  const out = execFileSync(process.execPath, [HOOK, tool], {
+    encoding: 'utf8', timeout: 20000,
+    env: {
+      ...process.env,
+      LLM_SWITCHER_STATE_DIR: dir,
+      LLM_SWITCHER_CONFIG: path.join(dir, 'config.json'),
+      LLM_SWITCHER_PORT: ''
+    }
+  });
+  return { raw: out, json: JSON.parse(out.trim() || '{}') };
+}
+
+test('a tool that is not routed gets no message at all', async (t) => {
+  const dir = tmpState(t);
+  writeConfig(dir, await freePort());
+  // codex has no profile, so its route file is empty. This is the state after `switch off codex`.
+  fs.writeFileSync(path.join(dir, 'active.flag'), 'active');
+  fs.writeFileSync(path.join(dir, 'route-codex.txt'), '');
+  const r = runHook(dir, 'codex');
+  assert.equal(r.json.systemMessage, undefined, 'a tool on its official endpoint says nothing');
+});
+
+test('a routed tool with a live gateway reports where its traffic goes', async (t) => {
+  const dir = tmpState(t);
+  const port = await freePort();
+  writeConfig(dir, port);
+  await fakeGateway(t, port);
+  fs.writeFileSync(path.join(dir, 'active.flag'), 'active');
+  fs.writeFileSync(path.join(dir, 'route-claude.txt'), 'claude -> cl | intact.example.io | gemini-3.8-flash | 1M\n');
+  const r = runHook(dir, 'claude');
+  assert.match(r.json.systemMessage, /LLM Switcher/, 'the message names the switcher');
+  assert.match(r.json.systemMessage, /intact\.example\.io/, 'and the host the traffic goes to');
+  assert.match(r.json.systemMessage, /gemini-3\.8-flash/, 'and the model');
+  assert.doesNotMatch(r.json.systemMessage, /sk-secret/, 'and never the API key');
+});
+
+test('a routed tool with a dead gateway is warned that it cannot reach the provider', async (t) => {
+  const dir = tmpState(t);
+  const port = await freePort();   // nothing listens on it
+  writeConfig(dir, port);
+  fs.writeFileSync(path.join(dir, 'active.flag'), 'active');
+  fs.writeFileSync(path.join(dir, 'route-claude.txt'), 'claude -> cl | intact.example.io | gemini-3.8-flash | 1M\n');
+  const r = runHook(dir, 'claude');
+  assert.match(r.json.systemMessage, /does not answer|not running/i, 'the message says the gateway is down');
+  assert.match(r.json.systemMessage, new RegExp(String(port)), 'and names the port');
+  assert.match(r.json.systemMessage, /switch on/, 'and names the command that fixes it');
+});
+
+test('a broken state never fails the session: exit 0 and parseable output', async (t) => {
+  const dir = tmpState(t);
+  fs.writeFileSync(path.join(dir, 'config.json'), '{ this is not json', { mode: 0o600 });
+  fs.writeFileSync(path.join(dir, 'active.flag'), 'active');
+  const r = runHook(dir, 'claude');
+  assert.equal(typeof r.json, 'object', 'the tool still gets one JSON object');
+  const bad = runHook(dir, 'not-a-tool');
+  assert.equal(bad.json.systemMessage, undefined, 'an unknown tool name says nothing');
+});

package/tests/plugin.test.mjs

@@ -0,0 +1,132 @@
+// Installing the launch hook into the two coding tools, without editing any configuration of theirs.
+//
+// Claude Code loads any folder under a skills directory that holds `.claude-plugin/plugin.json` as
+// a plugin, on the next session, with no marketplace and no install step. Codex loads
+// `$CODEX_HOME/hooks.json` by itself. So both tools get the hook from a file of their own, and
+// `settings.json` and `config.toml` are never touched.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { renderClaudePlugin, renderClaudeHooks, renderCodexHooks, installPlugin, uninstallPlugin, pluginStatus } =
+  await import(pathToFileURL(path.join(ROOT, 'plugin.mjs')).href);
+
+function dirs(t) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-plug-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const claudeSkillsDir = path.join(home, '.claude', 'skills');
+  const codexHome = path.join(home, '.codex');
+  fs.mkdirSync(claudeSkillsDir, { recursive: true });
+  fs.mkdirSync(codexHome, { recursive: true });
+  return { home, claudeSkillsDir, codexHome, opts: { claudeSkillsDir, codexHome } };
+}
+
+const readJson = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
+
+test('the Claude plugin manifest and hooks name the hook script and the tool claude', () => {
+  const manifest = JSON.parse(renderClaudePlugin());
+  assert.equal(typeof manifest.name, 'string');
+  assert.ok(manifest.name.length > 0, 'a plugin needs a name, it becomes the skills-dir id');
+  assert.ok(manifest.version, 'and a version');
+  const hooks = JSON.parse(renderClaudeHooks());
+  const entry = hooks.hooks.SessionStart[0].hooks[0];
+  assert.equal(entry.type, 'command');
+  assert.match(JSON.stringify(entry), /hook-status\.mjs/);
+  assert.match(JSON.stringify(entry), /"claude"/, 'the claude plugin asks about claude');
+  assert.doesNotMatch(JSON.stringify(entry), /codex/);
+});
+
+test('the Codex hooks file asks about codex and matches a fresh start or a resume', () => {
+  const hooks = JSON.parse(renderCodexHooks());
+  const group = hooks.hooks.SessionStart[0];
+  assert.match(group.matcher, /startup/, 'the first open of a session');
+  assert.match(group.matcher, /resume/, 'and a resumed session, which is the bypass this exists for');
+  const entry = group.hooks[0];
+  assert.equal(entry.type, 'command');
+  assert.match(entry.command, /hook-status\.mjs/);
+  assert.match(entry.command, /codex/);
+});
+
+test('install writes a plugin for Claude Code and a hooks file for Codex, and repeats cleanly', (t) => {
+  const { claudeSkillsDir, codexHome, opts } = dirs(t);
+  const first = installPlugin(opts);
+  assert.deepEqual(first.failed, [], 'nothing failed');
+  assert.deepEqual(first.installed.sort(), ['claude', 'codex']);
+
+  const manifest = path.join(claudeSkillsDir, 'llm-switcher-status', '.claude-plugin', 'plugin.json');
+  assert.ok(fs.existsSync(manifest), 'the manifest is what makes the folder a plugin');
+  assert.ok(fs.existsSync(path.join(claudeSkillsDir, 'llm-switcher-status', 'hooks', 'hooks.json')));
+  assert.ok(fs.existsSync(path.join(codexHome, 'hooks.json')));
+
+  // The whole point: neither tool's own configuration file is created or changed.
+  assert.equal(fs.existsSync(path.join(codexHome, 'config.toml')), false, 'config.toml is never written');
+
+  const second = installPlugin(opts);
+  assert.deepEqual(second.failed, [], 'a second install is a no-op that still succeeds');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(codexHome, 'hooks.json'), 'utf8')).hooks.SessionStart.length, 1,
+    'and it does not add a second copy of our entry');
+});
+
+test('install keeps a Codex hook that belongs to someone else', (t) => {
+  const { codexHome, opts } = dirs(t);
+  fs.writeFileSync(path.join(codexHome, 'hooks.json'), JSON.stringify({
+    description: 'the rule gate of this machine',
+    hooks: {
+      PreToolUse: [{ matcher: '^Bash$', hooks: [{ type: 'command', command: 'node rule-gate.js' }] }],
+      SessionStart: [{ matcher: 'startup', hooks: [{ type: 'command', command: 'node someone-else.js' }] }]
+    }
+  }, null, 2));
+
+  installPlugin(opts);
+  const after = readJson(path.join(codexHome, 'hooks.json'));
+  assert.equal(after.hooks.PreToolUse.length, 1, 'another event is untouched');
+  assert.match(JSON.stringify(after.hooks.PreToolUse), /rule-gate/);
+  const commands = after.hooks.SessionStart.flatMap(g => g.hooks.map(h => h.command));
+  assert.ok(commands.some(c => /someone-else\.js/.test(c)), 'the other SessionStart hook survives');
+  assert.ok(commands.some(c => /hook-status\.mjs/.test(c)), 'and ours is added beside it');
+
+  const removed = uninstallPlugin(opts);
+  assert.deepEqual(removed.failed, []);
+  const end = readJson(path.join(codexHome, 'hooks.json'));
+  const endCommands = JSON.stringify(end);
+  assert.match(endCommands, /someone-else\.js/, 'uninstall leaves the other hook in place');
+  assert.match(endCommands, /rule-gate/);
+  assert.doesNotMatch(endCommands, /hook-status\.mjs/, 'and takes only ours away');
+});
+
+test('install refuses a Codex hooks file it cannot parse, and changes nothing', (t) => {
+  const { codexHome, opts } = dirs(t);
+  const f = path.join(codexHome, 'hooks.json');
+  fs.writeFileSync(f, '{ not json at all');
+  const r = installPlugin(opts);
+  assert.equal(fs.readFileSync(f, 'utf8'), '{ not json at all', 'a file that may hold real hooks is never overwritten');
+  assert.ok(r.failed.some(x => x.tool === 'codex'), 'and the refusal is reported');
+  assert.ok(r.installed.includes('claude'), 'while the other tool still gets its plugin');
+});
+
+test('install leaves a folder that is not our plugin alone', (t) => {
+  const { claudeSkillsDir, opts } = dirs(t);
+  const dir = path.join(claudeSkillsDir, 'llm-switcher-status');
+  fs.mkdirSync(path.join(dir, '.claude-plugin'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: 'someone-elses-work' }));
+  const r = installPlugin(opts);
+  assert.match(fs.readFileSync(path.join(dir, '.claude-plugin', 'plugin.json'), 'utf8'), /someone-elses-work/);
+  assert.ok(r.failed.some(x => x.tool === 'claude'));
+});
+
+test('status reports each tool, and says plainly when nothing is installed', (t) => {
+  const { opts } = dirs(t);
+  const before = pluginStatus(opts);
+  assert.equal(before.claude.installed, false);
+  assert.equal(before.codex.installed, false);
+  installPlugin(opts);
+  const after = pluginStatus(opts);
+  assert.equal(after.claude.installed, true);
+  assert.equal(after.codex.installed, true);
+  assert.match(after.claude.path, /llm-switcher-status/);
+  assert.match(after.codex.path, /hooks\.json$/);
+});

package/tests/real-user-sim.test.mjs

@@ -324,7 +324,7 @@ test('Real User Sim 3: Gemini / Vertex healing of empty & complex tool schemas',
   await post('/api/switch', { tool: 'claude', profile: 'chat' });
 });
 
-test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch -> continue)', async () => {
+test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch -> continue)', { skip: typeof WebSocket === 'undefined' && 'global WebSocket needs Node 22+' }, async () => {
   const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
   const messages = [];
 
@@ -387,7 +387,7 @@ test('Real User Sim 4: Codex WebSocket turns (warmup -> prompt -> apply_patch ->
   ws.close();
 });
 
-test('Real User Sim 5: High-concurrency dual-tool execution (Claude streaming + Codex WS simultaneously)', async () => {
+test('Real User Sim 5: High-concurrency dual-tool execution (Claude streaming + Codex WS simultaneously)', { skip: typeof WebSocket === 'undefined' && 'global WebSocket needs Node 22+' }, async () => {
   const ws = new WebSocket(`ws://127.0.0.1:${proxyPort}/v1/responses`);
   await new Promise(r => { ws.onopen = r; });
   const wsMessages = [];

package/tests/service.test.mjs

@@ -16,6 +16,8 @@ const HAS_XMLLINT = (() => { try { execFileSync('xmllint', ['--version'], { stdi
 test('serviceEnv passes only the variables that change where the gateway reads and writes', () => {
   const env = serviceEnv({ CLAUDE_CONFIG_DIR: '/c', LLM_SWITCHER_CONFIG: '/cfg.json', LLM_SWITCHER_BLINDFOLD_CERTS: '', HOME: '/h', PATH: '/bin' });
   assert.deepEqual(env, [['CLAUDE_CONFIG_DIR', '/c'], ['LLM_SWITCHER_CONFIG', '/cfg.json']]);
+  // The data folder override must reach the service too, or it reads another config.json.
+  assert.deepEqual(serviceEnv({ LLM_SWITCHER_HOME: '/data' }), [['LLM_SWITCHER_HOME', '/data']]);
 });
 
 test('systemd unit quotes the command and carries the environment', () => {