llm-switcher 1.2.2 → 1.2.4

package/tests/switch.test.mjs

@@ -1,31 +1,37 @@
 // CLI tests: switch.mjs runs as a child with its own config, launch files and Claude dir
 // (audit F06, BR-02, F27, F30, F46).
-import { test } from 'node:test';
+import { test, after } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, execFileSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const POSIX = process.platform !== 'win32';
 
+// Blindfold mode needs a CA. Without its own directory the CLI reads the certificates of the checkout.
+const CERTS = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-cli-certs-'));
+if (POSIX) execFileSync('bash', [path.join(ROOT, 'blindfold', 'make-certs.sh'), CERTS], { stdio: 'ignore' });
+after(() => fs.rmSync(CERTS, { recursive: true, force: true }));
+
 const freePort = () => new Promise(r => {
   const s = net.createServer().listen(0, '127.0.0.1', () => { const { port } = s.address(); s.close(() => r(port)); });
 });
 
-function workspace(t, port, profiles) {
+// A free interceptor port too: the default 3457 belongs to a switcher that may run on this machine.
+async function workspace(t, port, profiles) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-cli-'));
   const cfgPath = path.join(dir, 'config.json');
   fs.writeFileSync(cfgPath, JSON.stringify({
-    port, activeProfiles: { anthropic: null, responses: null, 'openai-chat': null, vertex: null },
+    port, blindfold: { port: await freePort() }, activeProfiles: { anthropic: null, responses: null, 'openai-chat': null, vertex: null },
     profiles: profiles || { plain: { name: 'Plain', mode: 'convert', inFormat: 'auto', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } } }
   }, null, 2), { mode: 0o600 });
   // HOME too: `switch on` installs shims under the home directory, and a test must never rewrite the real ones.
   const home = path.join(dir, 'home');
-  const ws = { dir, cfgPath, home, env: { ...process.env, HOME: home, USERPROFILE: home, LLM_SWITCHER_CONFIG: cfgPath, LLM_SWITCHER_STATE_DIR: dir, CLAUDE_CONFIG_DIR: path.join(dir, 'claude'), LLM_SWITCHER_PORT: '', PORT: '' } };
+  const ws = { dir, cfgPath, home, env: { ...process.env, HOME: home, USERPROFILE: home, LLM_SWITCHER_CONFIG: cfgPath, LLM_SWITCHER_STATE_DIR: dir, LLM_SWITCHER_BLINDFOLD_CERTS: CERTS, CLAUDE_CONFIG_DIR: path.join(dir, 'claude'), LLM_SWITCHER_PORT: '', PORT: '' } };
   t.after(async () => {
     await run(ws, ['off']).catch(() => {});
     fs.rmSync(dir, { recursive: true, force: true });
@@ -52,7 +58,7 @@ function run(ws, args, { onLine, env = {} } = {}) {
 const readCfg = (ws) => JSON.parse(fs.readFileSync(ws.cfgPath, 'utf8'));
 
 test('profile names are printed without terminal control sequences', { skip: !POSIX && 'posix' }, async (t) => {
-  const ws = workspace(t, await freePort(), {
+  const ws = await workspace(t, await freePort(), {
     evil: { name: 'Evil\u001b[2J\u001b]0;pwned\u0007', mode: 'convert', inFormat: 'auto', baseURL: 'http://127.0.0.1:9/v1\u001b[31m', apiKey: 'k', defaultModels: { opus: 'o' } }
   });
   const r = await run(ws, ['status']);
@@ -64,7 +70,7 @@ test('profile names are printed without terminal control sequences', { skip: !PO
 test('-p is the global port option at any position, never the port command', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
   const other = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   const r = await run(ws, ['-p', String(other), 'status']);
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, /=== LLM Switcher Status ===/);
@@ -74,7 +80,7 @@ test('-p is the global port option at any position, never the port command', { s
 });
 
 test('switch on keeps a change that another writer saved while it waited for the gateway', { skip: !POSIX && 'posix' }, async (t) => {
-  const ws = workspace(t, await freePort());
+  const ws = await workspace(t, await freePort());
   let edited = false;
   const r = await run(ws, ['on', 'plain'], {
     onLine: (line) => {
@@ -95,7 +101,7 @@ test('switch on keeps a change that another writer saved while it waited for the
 
 test('switch port refuses a port that another process holds and leaves the gateway where it was', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   assert.equal((await run(ws, ['on', 'plain'])).status, 0);
   const squatter = net.createServer(s => s.end('HTTP/1.1 200 OK\r\n\r\nnot the switcher'));
   const held = await new Promise(r => squatter.listen(0, '127.0.0.1', () => r(squatter.address().port)));
@@ -111,7 +117,7 @@ test('switch port refuses a port that another process holds and leaves the gatew
 test('switch port puts config.json and the gateway back when the new gateway does not come up', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
   const next = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   assert.equal((await run(ws, ['on', 'plain'])).status, 0);
   // The new port is free at the check and taken right after the old gateway stops.
   const squatter = net.createServer(s => s.destroy());
@@ -128,7 +134,7 @@ test('switch port puts config.json and the gateway back when the new gateway doe
 // A shim bakes in the state dir. A temp state dir, deleted later, would make every shim source a path that
 // another account can re-create (audit follow-up attacker-1).
 test('switch on installs no shims when the launch files live outside the checkout', { skip: !POSIX && 'posix' }, async (t) => {
-  const ws = workspace(t, await freePort());
+  const ws = await workspace(t, await freePort());
   const r = await run(ws, ['on', 'plain']);
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, /\[Shim\] Not installed automatically/);
@@ -143,7 +149,7 @@ const slowStart = (script, ms) => ({ NODE_OPTIONS: `--import=data:text/javascrip
 test('switch port stops the new gateway it started when it rolls back', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
   const next = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   assert.equal((await run(ws, ['on', 'plain'])).status, 0);
   const r = await run(ws, ['port', String(next)], { env: slowStart('proxy.mjs', 7000) });
   assert.notEqual(r.status, 0, r.stdout);
@@ -158,8 +164,8 @@ test('switch port stops the new gateway it started when it rolls back', { skip:
 // Without publicModels the gateway has no official name to give Codex: no model catalog, no OpenAI-Model
 // header, and Codex prints false "metadata not found" and "high-risk cyber activity" warnings.
 test('switch codex and switch doctor warn when the Codex profile has no publicModels', { skip: !POSIX && 'posix' }, async (t) => {
-  const base = { mode: 'convert', inFormat: 'auto', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } };
-  const ws = workspace(t, await freePort(), { bare: { name: 'Bare', ...base }, named: { name: 'Named', ...base, publicModels: ['gpt-5.6-sol'] } });
+  const base = { mode: 'convert', tool: 'codex', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } };
+  const ws = await workspace(t, await freePort(), { bare: { name: 'Bare', ...base }, named: { name: 'Named', ...base, publicModels: ['gpt-5.6-sol'] } });
   const on = await run(ws, ['codex', 'bare']);
   assert.equal(on.status, 0, on.stderr);
   assert.match(on.stdout + on.stderr, /\[WARN\].*"bare".*publicModels/);
@@ -189,7 +195,7 @@ const failCASInject = {
 
 test('with migrationError set, running "switch <p>" asserts exit 1, stderr containing "Migration error", and no gateway answering on the port afterwards', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port, { plain: { inFormat: 'anthropic' } });
+  const ws = await workspace(t, port, { plain: { inFormat: 'anthropic' } });
   const r = await run(ws, ['plain'], { env: failCASInject });
   assert.equal(r.status, 1, r.stdout + r.stderr);
   assert.match(r.stderr, /Migration error/);
@@ -218,7 +224,7 @@ test('A5: save-profile refuses inFormat and legacy blindfold fields with 400', a
 
 test('R7: gateway process startup and reconcile refuse while getMigrationCollision is non-null', { skip: !POSIX && 'posix' }, async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   // Write a colliding config into workspace
   const collidingCfg = {
     port,
@@ -314,7 +320,7 @@ test('calling /api/switch, /api/toggle, /api/save-profile, /api/delete-profile w
 // probe from this workspace can never reach the interceptor of another install on the machine.
 async function collisionWs(t, extra = {}) {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   const bfPort = await freePort();
   fs.writeFileSync(ws.cfgPath, JSON.stringify({
     port,
@@ -451,7 +457,7 @@ test('R7: during collision, switch doctor exits 0', async (t) => {
 // accepts the request and then has nowhere to send it.
 test('A6: switch codex <claude-profile> exits non-zero and changes nothing', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port, {
+  const ws = await workspace(t, port, {
     claudeOnly: { name: 'C', mode: 'convert', tool: 'claude', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'x' } },
     codexOnly: { name: 'K', mode: 'convert', tool: 'codex', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { main: 'y' } }
   });
@@ -492,7 +498,7 @@ const failCASThenClean = {
 
 test('with migrationError set, running "switch off <tool>" uses CAS setting activeProfiles.<tool>=null, empties env-<tool>.sh, syncs interceptor, and exits 0', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   fs.writeFileSync(ws.cfgPath, JSON.stringify({
     port,
     activeProfile: 'plain',
@@ -515,7 +521,7 @@ test('with migrationError set, running "switch off <tool>" uses CAS setting acti
 
 test('R1: bare switch off under migrationError writes both pointers null through the CAS writer; after 3 forced CAS failures it exits 1 and the gateway still answers', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   fs.writeFileSync(ws.cfgPath, JSON.stringify({
     port,
     activeProfile: 'plain',
@@ -540,7 +546,7 @@ test('R1: bare switch off under migrationError writes both pointers null through
 
 test('R7e: CLI mutating command exits non-zero with error on stderr when saveConfig refuses under getMigrationError', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port, { plain: { inFormat: 'anthropic' } });
+  const ws = await workspace(t, port, { plain: { inFormat: 'anthropic' } });
   const r = await run(ws, ['on', 'plain'], { env: failCASInject });
   assert.equal(r.status, 1, r.stdout + r.stderr);
   assert.match(r.stderr, /Migration error/);
@@ -554,7 +560,7 @@ test('R7e: CLI mutating command exits non-zero with error on stderr when saveCon
 test('R1: port-change path exits 1 before stopProxy is called under migrationError', async (t) => {
   const port = await freePort();
   const other = await freePort();
-  const ws = workspace(t, port, { plain: { inFormat: 'anthropic' } });
+  const ws = await workspace(t, port, { plain: { inFormat: 'anthropic' } });
   await startGateway(t, ws.dir, ws.cfgPath, port, failCASInject);
 
   const r = await run(ws, ['port', String(other)], { env: failCASInject });
@@ -571,7 +577,7 @@ test('R1: port-change path exits 1 before stopProxy is called under migrationErr
 // parsing while it waited for the gateway.
 test('R7e: parse guard blocks writes and exits non-zero when lastLoadError is set', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port);
+  const ws = await workspace(t, port);
   fs.writeFileSync(ws.cfgPath, JSON.stringify({
     port,
     blindfold: { port: await freePort() },
@@ -599,7 +605,7 @@ test('R7e: parse guard blocks writes and exits non-zero when lastLoadError is se
 
 test('R7e: saves work again after the file is fixed', async (t) => {
   const port = await freePort();
-  const ws = workspace(t, port, { plain: { inFormat: 'anthropic' } });
+  const ws = await workspace(t, port, { plain: { inFormat: 'anthropic' } });
   fs.writeFileSync(ws.cfgPath, '{"port": ');
   const broken = await run(ws, ['plain']);
   assert.notEqual(broken.status, 0, broken.stdout);

package/tests/ui.test.mjs

@@ -0,0 +1,110 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const html = fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'ui.html'), 'utf8');
+
+function functionBody(name) {
+  const start = html.indexOf(`function ${name}(`);
+  assert.ok(start >= 0, `${name} not found in ui.html`);
+  return html.slice(start, html.indexOf('\n    }\n', start));
+}
+
+// The UI holds a redacted config, so a saved key reaches the server as MASKED_KEY.
+// The server resolves it only from the profile named in `key`.
+test('Browse Models sends the profile key, so a masked API key resolves to the stored one', () => {
+  assert.match(functionBody('fetchModelList'), /key:\s*formLoadedKey/);
+});
+
+// Every admin write endpoint answers { success: true } (proxy.mjs). A check on `ok` reads undefined
+// and reports a failure after the write already reached disk.
+test('the UI reads `success` from every admin write endpoint', () => {
+  const writes = ['/api/switch', '/api/toggle', '/api/save-profile', '/api/delete-profile', '/api/catalog/refresh', '/api/logs/clear'];
+  for (const endpoint of writes) {
+    let at = html.indexOf(`api('${endpoint}'`);
+    assert.ok(at >= 0, `${endpoint} is not called`);
+    for (; at >= 0; at = html.indexOf(`api('${endpoint}'`, at + 1)) {
+      const check = html.slice(at, html.indexOf('\n', html.indexOf('if (data.', at)));
+      assert.match(check, /if \(data\.success\)/, `${endpoint} is checked with the wrong field`);
+    }
+  }
+});
+
+test('Enter in a profile field does not submit the form', () => {
+  assert.match(html, /id="profile-form"[^>]*onkeydown="blockImplicitSubmit\(event\)"/);
+  const guard = functionBody('blockImplicitSubmit');
+  assert.match(guard, /e\.key === 'Enter'/);
+  assert.match(guard, /preventDefault\(\)/);
+});
+
+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\(\)"/);
+});
+
+test('Escape inside a dialog field is left to the field', () => {
+  const start = html.indexOf("window.addEventListener('keydown'");
+  const handler = html.slice(start, html.indexOf('});', start));
+  assert.match(handler, /closest(\?\.)?\('input, select, textarea'\)/);
+});
+
+// X1: one searchable combobox per slot replaces the shared datalist and the chip box.
+test('each model slot is its own combobox with its own listbox', () => {
+  const slotInput = html.match(/<input type="text" id="p-\$\{s\.id\}"[^>]*>/)?.[0] || '';
+  assert.match(slotInput, /role="combobox"/);
+  assert.match(slotInput, /aria-controls="p-\$\{s\.id\}-list"/);
+  assert.match(slotInput, /aria-autocomplete="list"/);
+  assert.doesNotMatch(slotInput, /list="model-options"/, 'no shared datalist');
+  assert.match(html, /<ul class="combo-list" id="p-\$\{s\.id\}-list" role="listbox"/);
+  for (const gone of ['id="model-browser"', '<datalist id="model-options"', 'function selectModel(', 'function renderModelBrowser(', 'id="btn-fetch-models"']) {
+    assert.ok(!html.includes(gone), `${gone} is still in ui.html`);
+  }
+});
+
+test('opening the Model Slots tab loads the provider models once per source', () => {
+  assert.match(functionBody('switchTab'), /if \(tabId === 'tab-models'\) ensureModelsLoaded\(\)/);
+  const ensure = functionBody('ensureModelsLoaded');
+  assert.match(ensure, /modelsSourceKey\(\)/);
+  assert.match(ensure, /fetchModelList\(\)/);
+  assert.match(html, /id="models-status"[^>]*aria-live="polite"/);
+});
+
+test('the combobox keeps the keyboard inside the field', () => {
+  const keys = functionBody('onComboKeydown');
+  for (const k of ['ArrowDown', 'ArrowUp', 'Enter', 'Escape']) assert.match(keys, new RegExp(`'${k}'`));
+  assert.match(keys, /stopPropagation\(\)/, 'Escape and Enter do not reach the dialog');
+  // An option is chosen on mousedown, before the field loses the focus.
+  assert.match(functionBody('renderComboOptions'), /onmousedown/);
+  // scrollIntoView also scrolls the dialog body and pushes the other slots out of view.
+  assert.doesNotMatch(functionBody('setComboActive'), /scrollIntoView/);
+  assert.match(functionBody('placeCombo'), /maxHeight/, 'the list fits the room it opens into');
+});
+
+// A profile without outFormat routes by the model. Loading it as 'openai-chat' made every save write
+// that value, which changed the routing of a profile the user did not touch.
+test('a profile without outFormat keeps auto routing through a save', () => {
+  assert.match(html, /<select id="p-outformat">\s*<option value="">/);
+  assert.match(html, /getElementById\('p-outformat'\)\.value = p\.outFormat \|\| '';/);
+});
+
+// The 1M box is locked only when the model's window is known and under 1M. An unknown window
+// only warns: many gateways list no limits at all.
+test('contextVerdict locks only a window known to be under 1M', () => {
+  const verdict = new Function(functionBody('contextVerdict') + '\n    }\n    return contextVerdict;')();
+  assert.equal(verdict(undefined).kind, 'unknown');
+  assert.equal(verdict({ output: 32000 }).kind, 'unknown');
+  assert.equal(verdict({ context: 200000 }).kind, 'small');
+  assert.equal(verdict({ context: 200000 }).window, 200000);
+  assert.equal(verdict({ input: 1000000 }).kind, 'ok');
+  assert.equal(verdict({ context: 1048576 }).kind, 'ok');
+});
+
+test('each 1M box names its slot and points at its note', () => {
+  const slots = functionBody('renderModelSlots');
+  assert.match(slots, /aria-label="1M context for \$\{escapeHtml\(s\.name\)\}"/);
+  assert.match(slots, /aria-describedby="p-\$\{s\.id\}-1m-note"/);
+  assert.match(slots, /class="slot-1m-note" id="p-\$\{s\.id\}-1m-note" role="status"/);
+  assert.doesNotMatch(html, /\.slot-1m-note:empty \{ display: none/);
+});

package/tests/version.test.mjs

@@ -0,0 +1,78 @@
+// The running version and the update notice. The registry is a local server, never npm.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import http from 'node:http';
+import { CURRENT_VERSION, isNewer, checkForUpdate } from '../version.mjs';
+
+const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+async function registry(handler) {
+  let hits = 0;
+  const server = http.createServer((req, res) => { hits++; handler(req, res); });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  return { url: `http://127.0.0.1:${server.address().port}/llm-switcher/latest`, hits: () => hits, close: () => server.close() };
+}
+const tmpState = () => fs.mkdtempSync(path.join(os.tmpdir(), 'lsw-version-'));
+
+test('the current version is the one in package.json', () => {
+  assert.equal(CURRENT_VERSION, pkg.version);
+});
+
+test('isNewer compares numerically, and a prerelease is not an update', () => {
+  assert.equal(isNewer('1.2.10', '1.2.9'), true);
+  assert.equal(isNewer('2.0.0', '1.9.9'), true);
+  assert.equal(isNewer('1.2.2', '1.2.2'), false);
+  assert.equal(isNewer('1.2.1', '1.2.2'), false);
+  assert.equal(isNewer('1.3.0-beta.1', '1.2.2'), false);
+  assert.equal(isNewer('garbage', '1.2.2'), false);
+  assert.equal(isNewer(null, '1.2.2'), false);
+});
+
+test('a newer registry version is reported with the update command, and cached', async () => {
+  const reg = await registry((req, res) => res.end(JSON.stringify({ version: '99.0.0' })));
+  const stateDir = tmpState();
+  try {
+    const r = await checkForUpdate({ stateDir, url: reg.url });
+    assert.equal(r.current, CURRENT_VERSION);
+    assert.equal(r.latest, '99.0.0');
+    assert.equal(r.updateAvailable, true);
+    assert.match(r.updateCommand, /^(npm install -g llm-switcher@latest|git -C ".+" pull)$/);
+    await checkForUpdate({ stateDir, url: reg.url });
+    assert.equal(reg.hits(), 1, 'the second check reads the cache');
+  } finally {
+    reg.close();
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});
+
+test('the same version is no update; a stale cache asks the registry again', async () => {
+  const reg = await registry((req, res) => res.end(JSON.stringify({ version: CURRENT_VERSION })));
+  const stateDir = tmpState();
+  try {
+    fs.writeFileSync(path.join(stateDir, 'version-check.json'), JSON.stringify({ checkedAt: 0, latest: '99.0.0' }));
+    const r = await checkForUpdate({ stateDir, url: reg.url });
+    assert.equal(reg.hits(), 1);
+    assert.equal(r.updateAvailable, false);
+    assert.equal(r.latest, CURRENT_VERSION);
+  } finally {
+    reg.close();
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});
+
+test('an unreachable or broken registry gives no notice and never throws', async () => {
+  const reg = await registry((req, res) => { res.statusCode = 500; res.end('down'); });
+  const stateDir = tmpState();
+  try {
+    const r = await checkForUpdate({ stateDir, url: reg.url });
+    assert.deepEqual([r.current, r.latest, r.updateAvailable], [CURRENT_VERSION, null, false]);
+    const closed = await checkForUpdate({ stateDir: tmpState(), url: 'http://127.0.0.1:9/x' });
+    assert.equal(closed.updateAvailable, false);
+  } finally {
+    reg.close();
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});