llm-switcher 1.2.6 → 1.2.8

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', () => {

package/tests/shim.test.mjs

@@ -282,6 +282,22 @@ test('the POSIX shims source launch files only when this account owns them', ()
 
 // ISS-CC-LS-002: on zsh a later line in .zshrc or .zprofile can prepend npm-global or Homebrew
 // ahead of the shim. The hint names both files and says the line must come last.
+test('pathOrderHint gives a fish user the fish file and fish syntax', () => {
+  // `export PATH=...` is not fish syntax. A fish user who pasted the old hint got an error, and
+  // the hint named ~/.profile, which fish does not read.
+  const shell = process.env.SHELL;
+  process.env.SHELL = '/usr/bin/fish';
+  try {
+    assert.deepEqual(suggestedRcFiles('linux'), [path.join(os.homedir(), '.config', 'fish', 'config.fish')]);
+    const text = pathOrderHint('linux').join(' ');
+    assert.ok(text.includes('config.fish'), text);
+    assert.ok(text.includes('fish_add_path'), text);
+    assert.ok(!text.includes('export PATH='), text);
+  } finally {
+    if (shell === undefined) delete process.env.SHELL; else process.env.SHELL = shell;
+  }
+});
+
 test('pathOrderHint tells a zsh user to put the export last in .zshrc and .zprofile', () => {
   const shell = process.env.SHELL;
   process.env.SHELL = '/bin/zsh';
@@ -340,3 +356,99 @@ test('A8: the Windows shim scrubs a loopback base URL and resolves every subrout
   assert.match(child.stdout || '', /HTTPS=\[http:\/\/127\.0\.0\.1:3457\]/,
     'R2: the proxy comes from the env file of this tool');
 });
+
+// ---- The route notice: the launcher tells the person the switcher took the traffic -------------
+
+// A person opens `claude`, the switcher routes it to another provider, and nothing on screen says
+// so. The shim therefore raises a notice at launch. It is guarded by TOOL_ACTIVE, so a tool whose
+// profile is off stays silent: the guard is the same one that decides whether to source the env.
+test('the route notice is guarded by TOOL_ACTIVE and names only this tool route file', () => {
+  for (const platform of ['win32', 'linux']) {
+    const claude = renderShim('claude', platform);
+    const codex = renderShim('codex', platform);
+    assert.match(claude, /route-claude\.txt/, `${platform}: the claude shim reads its own route file`);
+    assert.doesNotMatch(claude, /route-codex/, `${platform}: and never the other tool file`);
+    assert.match(codex, /route-codex\.txt/);
+    assert.doesNotMatch(codex, /route-claude/);
+    // Everything that raises the notice sits after the TOOL_ACTIVE decision, never before it.
+    const guard = platform === 'win32' ? claude.indexOf('set "TOOL_ACTIVE=1"') : claude.indexOf('TOOL_ACTIVE=1');
+    assert.ok(guard > 0, `${platform}: the guard exists`);
+    assert.ok(claude.indexOf('route-claude.txt') > guard, `${platform}: the notice comes after the guard`);
+  }
+});
+
+test('the POSIX shim prints the route line for an active tool and nothing for one that is off', (t) => {
+  if (process.platform === 'win32') return t.skip('posix only');
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimfake-'));
+  t.after(() => fs.rmSync(fakeDir, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(fakeDir, 'claude'), '#!/bin/sh\necho ran\n');
+  fs.chmodSync(path.join(fakeDir, 'claude'), 0o755);
+
+  const run = ({ active, route }) => {
+    for (const f of fs.readdirSync(STATE)) fs.rmSync(path.join(STATE, f), { force: true });
+    if (active) {
+      fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+      fs.writeFileSync(path.join(STATE, 'env-claude.sh'), "export HTTPS_PROXY='http://127.0.0.1:3457'\n");
+    }
+    fs.writeFileSync(path.join(STATE, 'route-claude.txt'), route);
+    return spawnSync(path.join(RENDER_DIR, 'claude'), [], {
+      encoding: 'utf8', timeout: 15000,
+      env: { ...process.env, PATH: [RENDER_DIR, fakeDir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+  };
+
+  const on = run({ active: true, route: 'claude -> cl | intact.example.io | gemini | 1M\n' });
+  assert.match(on.stderr, /intact\.example\.io/, 'an active tool shows where its traffic goes');
+  assert.match(on.stdout, /ran/, 'and the real binary still runs');
+
+  const off = run({ active: false, route: 'claude -> cl | intact.example.io | gemini | 1M\n' });
+  assert.doesNotMatch(off.stderr, /intact\.example\.io/, 'a tool that is off says nothing, even with a stale route file');
+  assert.match(off.stdout, /ran/);
+});
+
+// The Windows notice is a detached toast, so the only way to prove it fires is to put a fake
+// `powershell` on PATH and read what the shim asked it to do.
+test('the Windows shim raises the toast only while this tool is routed', (t) => {
+  if (process.platform !== 'win32') return t.skip('cmd.exe only');
+  const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimwintoast-'));
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimfaketoast-'));
+  t.after(() => {
+    fs.rmSync(shimDir, { recursive: true, force: true });
+    fs.rmSync(fakeDir, { recursive: true, force: true });
+  });
+  const log = path.join(fakeDir, 'toast.log');
+  fs.writeFileSync(path.join(fakeDir, 'claude.cmd'), '@echo off\r\necho ran\r\n');
+  fs.writeFileSync(path.join(fakeDir, 'powershell.cmd'), `@echo off\r\necho %*>>"${log}"\r\n`);
+  const shim = path.join(shimDir, 'shim.cmd');
+  fs.writeFileSync(shim, renderShim('claude', 'win32'), 'utf8');
+
+  const run = ({ active }) => {
+    for (const f of fs.readdirSync(STATE)) fs.rmSync(path.join(STATE, f), { force: true });
+    fs.rmSync(log, { force: true });
+    if (active) {
+      fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+      fs.writeFileSync(path.join(STATE, 'env-claude.cmd'), 'SET "HTTPS_PROXY=http://127.0.0.1:3457"\r\n');
+    }
+    fs.writeFileSync(path.join(STATE, 'route-claude.txt'), 'claude -> cl | intact.example.io | gemini | 1M\r\n');
+    const child = spawnSync('cmd.exe', ['/d', '/c', shim, '--version'], {
+      encoding: 'utf8', timeout: 30000,
+      env: {
+        ...process.env,
+        PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)]
+          .join(path.delimiter)
+      }
+    });
+    // `start /b` detaches, so the fake may still be writing when the shim has already exited.
+    for (let i = 0; i < 60 && !fs.existsSync(log); i++) execFileSync(process.execPath, ['-e', 'setTimeout(()=>{},50)']);
+    return { out: child.stdout || '', asked: fs.existsSync(log) ? fs.readFileSync(log, 'utf8') : '' };
+  };
+
+  const on = run({ active: true });
+  assert.match(on.out, /ran/, 'the real binary still runs');
+  assert.match(on.asked, /route-claude\.txt/, 'the toast is asked for, with this tool route file');
+  assert.match(on.asked, /notify-route\.ps1/, 'through the notifier that ships with the switcher');
+
+  const off = run({ active: false });
+  assert.match(off.out, /ran/);
+  assert.equal(off.asked, '', 'a tool that is off raises no toast');
+});

package/tests/state.test.mjs

@@ -7,7 +7,7 @@ import {
   modelSlotsForProfile, modelForSlot, primaryModel, codexPublicModel,
   certCoversHost, blindfoldPreflight, ROOT_DIR, openLog, probeGateway, isSafeModelName,
   getMigrationCollision, getMigrationError, getConfigLoadError, saveConfig, loadConfig,
-  migrateConfigInMemory, saveConfigAtomicCAS, TOOLS, validateProfileInput, needsMigration
+  migrateConfigInMemory, saveConfigAtomicCAS, TOOLS, validateProfileInput, needsMigration, hasPlaceholder
 } from '../state.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -52,6 +52,76 @@ test('activateProfile only assigns compatible tools; deactivateProfile leaves th
   assert.deepEqual(cfg.activeProfiles, { claude: null, codex: null });
 });
 
+test('switching a migrated config does not make it need migration again', () => {
+  // A legacy pointer written on every switch re-ran the migration on the next load and left one
+  // more config.json.bak-* (with the API keys) in the data folder each time.
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: null, codex: null },
+    profiles: {
+      router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } },
+      codexOnly: { tool: 'codex', apiKey: 'sk-2', baseURL: 'https://c/v1', defaultModels: { main: 'gpt-main' } }
+    }
+  };
+  assert.equal(needsMigration(cfg), false, 'fixture is already migrated');
+  assert.equal(activateProfile(cfg, 'router'), null);
+  assert.equal(setTargetProfile(cfg, 'codex', 'codexOnly'), null);
+  assert.equal(Object.hasOwn(cfg, 'activeProfile'), false);
+  assert.equal(needsMigration(cfg), false);
+});
+
+test('hasPlaceholder spots the example config values', () => {
+  assert.equal(hasPlaceholder({ baseURL: 'https://YOUR-ROUTER-HOST/v1', apiKey: 'sk-real' }), true);
+  assert.equal(hasPlaceholder({ baseURL: 'https://r/v1', apiKey: 'REPLACE-ME' }), true);
+  assert.equal(hasPlaceholder({ apiKey: 'sk-real' }), true, 'no baseURL');
+  assert.equal(hasPlaceholder({ baseURL: 'https://r/v1', apiKey: 'sk-real' }), false);
+  assert.equal(hasPlaceholder({ baseURL: 'http://127.0.0.1:11434/v1' }), false, 'a keyless local backend is fine');
+});
+
+test('the interceptor port follows LLM_SWITCHER_BLINDFOLD_PORT and never lands on the gateway port', () => {
+  // The gateway reads --port and LLM_SWITCHER_PORT through resolvePort. The interceptor read only
+  // config.json, so a second instance collided and HTTPS_PROXY named a port nothing listened on.
+  const saved = process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+  delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: 'router', codex: null },
+    profiles: { router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } } }
+  };
+  try {
+    assert.equal(computeLaunchState(cfg, 4000).blindfold.port, 3457, 'the default');
+    assert.equal(computeLaunchState({ ...cfg, blindfold: { port: 4444 } }, 4000).blindfold.port, 4444, 'the file');
+    process.env.LLM_SWITCHER_BLINDFOLD_PORT = '5555';
+    assert.equal(computeLaunchState({ ...cfg, blindfold: { port: 4444 } }, 4000).blindfold.port, 5555, 'the environment wins');
+    delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+    // A gateway moved onto 3457 by --port or by the environment must push the interceptor off it.
+    const st = computeLaunchState(cfg, 3457);
+    assert.notEqual(st.blindfold.port, 3457, 'the interceptor moved off the gateway port');
+    const proxy = st.envClaude.find(([k]) => k === 'HTTPS_PROXY');
+    assert.equal(proxy[1], `http://127.0.0.1:${st.blindfold.port}`, 'HTTPS_PROXY names the real port');
+  } finally {
+    if (saved === undefined) delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+    else process.env.LLM_SWITCHER_BLINDFOLD_PORT = saved;
+  }
+});
+
+test('deleteProfile does not make a migrated config need migration again', () => {
+  // Reachable from the dashboard Delete Profile button via POST /api/delete-profile, which
+  // persists. A legacy pointer written here revives the backup leak the switch path just lost.
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: null, codex: 'codexOnly' },
+    profiles: {
+      router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } },
+      codexOnly: { tool: 'codex', apiKey: 'sk-2', baseURL: 'https://c/v1', defaultModels: { main: 'gpt-main' } }
+    }
+  };
+  assert.equal(needsMigration(cfg), false, 'fixture is already migrated');
+  assert.equal(deleteProfile(cfg, 'codexOnly'), null);
+  assert.equal(Object.hasOwn(cfg, 'activeProfile'), false);
+  assert.equal(needsMigration(cfg), false);
+});
+
 test('deleteProfile unassigns targets that pointed at it', () => {
   const cfg = makeCfg();
   activateProfile(cfg, 'codexOnly');
@@ -602,15 +672,21 @@ test('isSafeModelName refuses names that TOML reads as something other than a st
 test('launch-file writers take turns through a lock, and a dead holder does not block them', async (t) => {
   const { dir, env } = tmpDirs(t);
   const lock = path.join(dir, '.launch.lock');
+  const startedFile = path.join(dir, 'writer.started');
   // A live holder: this test process. The child must wait until the lock is gone.
   fs.writeFileSync(lock, String(process.pid));
-  setTimeout(() => fs.rmSync(lock, { force: true }), 400);
-  const started = Date.now();
-  const r = await new Promise((resolve, reject) => {
+  const done = new Promise((resolve, reject) => {
     execFileCb(process.execPath, ['--input-type=module', '-e',
-      `const s = await import(${JSON.stringify(pathToFileURL(path.join(ROOT_DIR, 'state.mjs')).href)}); const t0 = Date.now(); s.applyLaunchState(s.loadConfig(), 4000); console.log(Date.now() - t0);`],
+      `const s = await import(${JSON.stringify(pathToFileURL(path.join(ROOT_DIR, 'state.mjs')).href)}); (await import('node:fs')).writeFileSync(${JSON.stringify(startedFile)}, ''); const t0 = Date.now(); s.applyLaunchState(s.loadConfig(), 4000); console.log(Date.now() - t0);`],
     { env: { ...process.env, LLM_SWITCHER_PORT: '', ...env }, encoding: 'utf8' }, (err, out) => (err ? reject(err) : resolve(Number(out.trim()))));
   });
+  // The 400 ms count from the writer's start, the same way the next test does it. A spawn plus an
+  // import measured 163 to 541 ms on Node 18, so a fixed timer left under 100 ms of wait and the
+  // assertion below failed on a loaded machine.
+  for (let i = 0; i < 1000 && !fs.existsSync(startedFile); i++) await new Promise(r => setTimeout(r, 10));
+  const started = Date.now();
+  setTimeout(() => fs.rmSync(lock, { force: true }), 400);
+  const r = await done;
   // Without the lock the write takes a few ms; with it the child waits for the release at 400 ms.
   assert.ok(r >= 100, `the writer waited ${r} ms for the live holder`);
   assert.ok(Date.now() - started >= 380);
@@ -1496,3 +1572,52 @@ test('A5: config.example.json loads and passes validation without requiring migr
     }
   }
 });
+
+// ---- Route lines: what the launcher shows when it routes a tool -------------------------------
+
+// A person opens `claude` and cannot see that the switcher took over the traffic. The launcher
+// therefore reads one line per tool, written beside that tool's env file. The line exists exactly
+// when that tool is routed, so a tool whose profile is off stays silent with no extra condition.
+test('each routed tool gets a route line; a tool that is off gets an empty one', (t) => {
+  const { dir, env } = tmpDirs(t);
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({
+    port: 4000,
+    activeProfiles: { claude: 'cl', codex: 'cx' },
+    profiles: {
+      cl: {
+        name: 'Intact Claude', baseURL: 'https://intact.example.io/v1', apiKey: 'sk-secret-claude',
+        defaultModels: { opus: 'gemini-3.8-flash' }, model1M: { opus: true }
+      },
+      cx: {
+        inFormat: 'responses', baseURL: 'https://other.example.io/v1', apiKey: 'sk-secret-codex',
+        defaultModels: { main: 'gpt-5.6-sol' }
+      }
+    }
+  }), { mode: 0o600 });
+
+  const r = runState(env, `
+    const read = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return null; } };
+    s.applyLaunchState(s.loadConfig(), 4000);
+    const on = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    s.emptyToolEnvFiles('claude');
+    const oneOff = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    s.applyLaunchState(s.loadConfig(), 4000);
+    s.clearLaunchState(4000);
+    const allOff = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    return { on, oneOff, allOff };
+  `);
+
+  assert.match(r.on.claude, /\bcl\b/, 'the line names the profile that serves claude');
+  assert.match(r.on.claude, /intact\.example\.io/, 'and the host the traffic goes to');
+  assert.match(r.on.claude, /gemini-3\.8-flash/, 'and the model it maps to');
+  assert.match(r.on.claude, /1M/, 'and the 1M window, because that changes what the session costs');
+  assert.match(r.on.codex, /\bcx\b/);
+  assert.match(r.on.codex, /other\.example\.io/);
+  assert.doesNotMatch(r.on.codex, /intact\.example\.io/, 'one tool never shows the other tool route');
+  assert.doesNotMatch(`${r.on.claude}${r.on.codex}`, /sk-secret/, 'a route line never carries the API key');
+
+  assert.equal(r.oneOff.claude.trim(), '', 'the tool switched off has no route line');
+  assert.notEqual(r.oneOff.codex.trim(), '', 'the other tool keeps its own');
+  assert.equal(r.allOff.claude.trim(), '', 'switch off leaves no route line for either tool');
+  assert.equal(r.allOff.codex.trim(), '');
+});

package/tests/ui.test.mjs

@@ -41,7 +41,7 @@ test('Enter in a profile field does not submit the form', () => {
 
 test('the overlay closes the dialog only for a press that started on the overlay', () => {
   assert.match(html, /id="profile-modal-overlay"[^>]*onmousedown="overlayPressed = event\.target === this"/);
-  assert.match(html, /id="profile-modal-overlay"[^>]*onclick="if \(overlayPressed && event\.target === this\) closeProfileModal\(\)"/);
+  assert.match(html, /id="profile-modal-overlay"[^>]*onclick="if \(overlayPressed && event\.target === this\) requestCloseProfileModal\(\)"/);
 });
 
 test('Escape inside a dialog field is left to the field', () => {