llm-switcher 1.2.11 → 1.3.0

package/tests/shim.test.mjs

@@ -452,3 +452,168 @@ test('the Windows shim raises the toast only while this tool is routed', (t) =>
   assert.match(off.out, /ran/);
   assert.equal(off.asked, '', 'a tool that is off raises no toast');
 });
+
+test('shim status follows the Windows lookup: an .exe earlier on PATH wins over the shim', () => {
+  const dirA = fs.mkdtempSync(path.join(STATE, 'real-'));
+  const shimDir = fs.mkdtempSync(path.join(STATE, 'shim-'));
+  fs.writeFileSync(path.join(dirA, 'agy.exe'), '');
+  fs.writeFileSync(path.join(shimDir, 'agy.cmd'), '');
+  const opts = { pathEnv: [dirA, shimDir].join(';'), shimDir, platform: 'win32', pathExt: '.COM;.EXE;.BAT;.CMD' };
+  const st = shimStatus(['agy'], opts);
+  assert.equal(st.shims[0].effective, path.join(dirA, 'agy.exe'));
+  assert.equal(st.shims[0].active, false, 'the real agy.exe runs first, so the shim is not active');
+  const fixed = shimStatus(['agy'], { ...opts, pathEnv: [shimDir, dirA].join(';') });
+  assert.equal(fixed.shims[0].active, true);
+});
+
+// ---- agy: the shim proves the gateway before it hands over CLOUD_CODE_URL -----------------------
+// agy sends its Google token in clear text to CLOUD_CODE_URL. A process that took the gateway port
+// must therefore never receive it: the shim asks for the identity proof first.
+const { identityProof } = await import(pathToFileURL(path.join(ROOT, 'state.mjs')).href);
+const AGY_TOKEN = 'a'.repeat(64);
+// Outside STATE: the other tests empty STATE file by file.
+const AGY_CONFIG_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'agyconfig-'));
+const AGY_CONFIG = path.join(AGY_CONFIG_DIR, 'config.json');
+test.after(() => fs.rmSync(AGY_CONFIG_DIR, { recursive: true, force: true }));
+fs.writeFileSync(path.join(path.dirname(AGY_CONFIG), 'admin.token'), AGY_TOKEN);
+const VERIFY = path.join(ROOT, 'verify-gateway.mjs');
+// Async on purpose: the /health listener lives in this process, and a spawnSync would block it.
+const { spawn: spawnAsync } = await import('node:child_process');
+function runAsync(cmd, args, opts) {
+  return new Promise((resolve) => {
+    const child = spawnAsync(cmd, args, opts);
+    let out = '', err = '';
+    child.stdout?.on('data', d => { out += d; });
+    child.stderr?.on('data', d => { err += d; });
+    const timer = setTimeout(() => child.kill(), 30000);
+    child.on('close', (status) => { clearTimeout(timer); resolve({ status, stdout: out, stderr: err }); });
+  });
+}
+const NOTICE = /did not prove it is this switcher/;
+
+// A /health listener: 'real' signs like this gateway, 'forged' sends a wrong proof, 'silent' never answers.
+async function agyListener(kind) {
+  const http = await import('node:http');
+  const net = await import('node:net');
+  const server = kind === 'silent'
+    ? net.createServer((sock) => sock.on('error', () => {}))
+    : http.createServer((req, res) => {
+      const port = server.address().port;
+      const nonce = new URL(req.url, 'http://x').searchParams.get('challenge');
+      const proof = kind === 'real' ? identityProof(nonce, { role: 'gateway', port, pid: 4242 }, AGY_TOKEN) : 'forged';
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ status: 'ok', proxy: 'llm-switcher', port, pid: 4242, proof }));
+    });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  return server;
+}
+
+async function runAgyWindowsShim(port) {
+  const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyshim-'));
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyfake-'));
+  fs.writeFileSync(path.join(fakeDir, 'agy.cmd'), '@echo off\r\necho CCU=[%CLOUD_CODE_URL%]\r\n');
+  for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+  fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+  fs.writeFileSync(path.join(STATE, 'env-agy.cmd'), `SET "CLOUD_CODE_URL=http://127.0.0.1:${port}"\r\n`);
+  const shim = path.join(shimDir, 'agy.cmd');
+  fs.writeFileSync(shim, renderShim('agy', 'win32'), 'utf8');
+  const started = Date.now();
+  const child = await runAsync('cmd.exe', ['/d', '/c', shim], {
+    env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)].join(path.delimiter) }
+  });
+  fs.rmSync(shimDir, { recursive: true, force: true });
+  fs.rmSync(fakeDir, { recursive: true, force: true });
+  return { out: child.stdout || '', err: child.stderr || '', ms: Date.now() - started };
+}
+
+for (const [kind, routed] of [['forged', false], ['silent', false], ['real', true]]) {
+  test(`the Windows agy shim with a ${kind} listener on the gateway port ${routed ? 'keeps' : 'drops'} CLOUD_CODE_URL`, async (t) => {
+    if (process.platform !== 'win32') return t.skip('cmd.exe only');
+    const server = await agyListener(kind);
+    t.after(() => server.close());
+    const port = server.address().port;
+    const { out, err, ms } = await runAgyWindowsShim(port);
+    if (routed) {
+      assert.match(out, new RegExp(`CCU=\\[http://127\\.0\\.0\\.1:${port}\\]`));
+      assert.doesNotMatch(err, NOTICE);
+    } else {
+      assert.match(out, /CCU=\[\]/, 'the token must not go to a port that did not prove itself');
+      assert.match(err, NOTICE);
+    }
+    assert.ok(ms < 8000, `the shim took ${ms} ms`);
+  });
+}
+
+for (const [kind, routed] of [['forged', false], ['silent', false], ['real', true]]) {
+  test(`the POSIX agy shim with a ${kind} listener on the gateway port ${routed ? 'keeps' : 'drops'} CLOUD_CODE_URL`, async (t) => {
+    if (process.platform === 'win32') return t.skip('posix only');
+    const server = await agyListener(kind);
+    t.after(() => server.close());
+    const port = server.address().port;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyposix-'));
+    fs.writeFileSync(path.join(dir, 'agy'), '#!/usr/bin/env bash\necho "CCU=[${CLOUD_CODE_URL:-}]"\n');
+    fs.chmodSync(path.join(dir, 'agy'), 0o755);
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+    fs.writeFileSync(path.join(STATE, 'env-agy.sh'), `export CLOUD_CODE_URL='http://127.0.0.1:${port}'\n`);
+    const started = Date.now();
+    const out = await runAsync(path.join(RENDER_DIR, 'agy'), [], {
+      env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [RENDER_DIR, dir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+    fs.rmSync(dir, { recursive: true, force: true });
+    if (routed) {
+      assert.match(out.stdout, new RegExp(`CCU=\\[http://127\\.0\\.0\\.1:${port}\\]`));
+      assert.doesNotMatch(out.stderr, NOTICE);
+    } else {
+      assert.match(out.stdout, /CCU=\[\]/);
+      assert.match(out.stderr, NOTICE);
+    }
+    assert.ok(Date.now() - started < 8000, `the shim took ${Date.now() - started} ms`);
+  });
+}
+
+test('verify-gateway accepts only 127.0.0.1 with a real port, whatever listens', async (t) => {
+  const server = await agyListener('real');
+  t.after(() => server.close());
+  const port = server.address().port;
+  const run = async (u) => (await runAsync(process.execPath, [VERIFY, u], { env: { ...process.env, LLM_SWITCHER_CONFIG: AGY_CONFIG } })).status;
+  assert.equal(await run(`http://127.0.0.1:${port}`), 0, 'the real gateway passes');
+  assert.notEqual(await run('http://127.0.0.1/'), 0, 'no port');
+  assert.notEqual(await run(`http://localhost:${port}`), 0, 'localhost can resolve to ::1, which the probe never checked');
+  assert.notEqual(await run(`http://other.example:${port}`), 0);
+  assert.notEqual(await run('not a url'), 0);
+});
+
+// While agy is off, a gateway address left in the shell from an earlier run is the switcher's own
+// value and goes; an address the person set for another host is theirs and stays.
+for (const [value, kept] of [['http://127.0.0.1:3456', false], ['https://cloudcode.corp.example', true]]) {
+  test(`the Windows agy shim, with agy off, ${kept ? 'keeps' : 'scrubs'} CLOUD_CODE_URL=${value}`, async (t) => {
+    if (process.platform !== 'win32') return t.skip('cmd.exe only');
+    const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyoff-'));
+    const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyofffake-'));
+    t.after(() => { fs.rmSync(shimDir, { recursive: true, force: true }); fs.rmSync(fakeDir, { recursive: true, force: true }); });
+    fs.writeFileSync(path.join(fakeDir, 'agy.cmd'), '@echo off\r\necho CCU=[%CLOUD_CODE_URL%]\r\n');
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    const shim = path.join(shimDir, 'agy.cmd');
+    fs.writeFileSync(shim, renderShim('agy', 'win32'), 'utf8');
+    const out = await runAsync('cmd.exe', ['/d', '/c', shim], {
+      env: { ...process.env, CLOUD_CODE_URL: value, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)].join(path.delimiter) }
+    });
+    assert.ok(out.stdout.includes(`CCU=[${kept ? value : ''}]`), out.stdout);
+    assert.doesNotMatch(out.stderr, NOTICE, 'no gateway check runs while agy is off');
+  });
+
+  test(`the POSIX agy shim, with agy off, ${kept ? 'keeps' : 'scrubs'} CLOUD_CODE_URL=${value}`, async (t) => {
+    if (process.platform === 'win32') return t.skip('posix only');
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agyoffposix-'));
+    t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+    fs.writeFileSync(path.join(dir, 'agy'), '#!/usr/bin/env bash\necho "CCU=[${CLOUD_CODE_URL:-}]"\n');
+    fs.chmodSync(path.join(dir, 'agy'), 0o755);
+    for (const f of fs.readdirSync(STATE)) if (fs.statSync(path.join(STATE, f)).isFile()) fs.rmSync(path.join(STATE, f), { force: true });
+    const out = await runAsync(path.join(RENDER_DIR, 'agy'), [], {
+      env: { ...process.env, CLOUD_CODE_URL: value, LLM_SWITCHER_CONFIG: AGY_CONFIG, PATH: [RENDER_DIR, dir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+    assert.ok(out.stdout.includes(`CCU=[${kept ? value : ''}]`), out.stdout);
+    assert.doesNotMatch(out.stderr, NOTICE);
+  });
+}

package/tests/state.test.mjs

@@ -30,7 +30,7 @@ const makeCfg = () => ({
 });
 
 test('legacy config without activeProfiles maps every target to activeProfile', () => {
-  assert.deepEqual(getActiveMap(makeCfg()), { claude: 'router', codex: 'router' });
+  assert.deepEqual(getActiveMap(makeCfg()), { claude: 'router', codex: 'router', agy: null });
 });
 
 test('setTargetProfile validates the target, existence (no prototype keys) and the tool', () => {
@@ -40,16 +40,16 @@ test('setTargetProfile validates the target, existence (no prototype keys) and t
   assert.match(setTargetProfile(cfg, 'anthropic', 'codexOnly'), /cannot serve/);
   assert.equal(setTargetProfile(cfg, 'responses', 'codexOnly'), null);
   // `anthropic` and `responses` are spellings of the two tools, and the map holds two keys.
-  assert.deepEqual(cfg.activeProfiles, { claude: 'router', codex: 'codexOnly' });
+  assert.deepEqual(cfg.activeProfiles, { claude: 'router', codex: 'codexOnly', agy: null });
 });
 
 test('activateProfile only assigns compatible tools; deactivateProfile leaves the other alone', () => {
   const cfg = makeCfg();
   setTargetProfile(cfg, 'claude', null);
   activateProfile(cfg, 'codexOnly');
-  assert.deepEqual(cfg.activeProfiles, { claude: null, codex: 'codexOnly' });
+  assert.deepEqual(cfg.activeProfiles, { claude: null, codex: 'codexOnly', agy: null });
   deactivateProfile(cfg, 'codexOnly');
-  assert.deepEqual(cfg.activeProfiles, { claude: null, codex: null });
+  assert.deepEqual(cfg.activeProfiles, { claude: null, codex: null, agy: null });
 });
 
 test('switching a migrated config does not make it need migration again', () => {
@@ -1315,15 +1315,15 @@ test('R1: rollBack proceeds to restore oldPort gateway even if saveConfig throws
   assert.equal(caught, false);
 });
 
-test('R5: getActiveMap returns exactly { claude, codex } and a present pointer wins over the legacy one', () => {
+test('R5: getActiveMap returns exactly { claude, codex, agy } and a present pointer wins over the legacy one', () => {
   const cfg = {
     activeProfiles: { claude: 'c-prof', codex: 'cdx-prof' },
     profiles: { 'c-prof': { tool: 'claude' }, 'cdx-prof': { tool: 'codex' } }
   };
-  assert.deepEqual(getActiveMap(cfg), { claude: 'c-prof', codex: 'cdx-prof' });
+  assert.deepEqual(getActiveMap(cfg), { claude: 'c-prof', codex: 'cdx-prof', agy: null });
   // An explicit "off" is a present pointer, not a missing one: it must not fall back to
   // activeProfile and switch the tool back on under another key.
-  assert.deepEqual(getActiveMap({ activeProfile: 'legacy', activeProfiles: { claude: null } }), { claude: null, codex: 'legacy' });
+  assert.deepEqual(getActiveMap({ activeProfile: 'legacy', activeProfiles: { claude: null } }), { claude: null, codex: 'legacy', agy: null });
 });
 
 test('R7e: saves work again after the file is fixed', (t) => {
@@ -1564,7 +1564,7 @@ test('A5: config.example.json loads and passes validation without requiring migr
   }
 
   assert.equal('activeProfile' in example, false, 'the retired top-level pointer is gone');
-  assert.deepEqual(Object.keys(example.activeProfiles).sort(), ['claude', 'codex'], 'exactly the two tools');
+  assert.deepEqual(Object.keys(example.activeProfiles).sort(), ['agy', 'claude', 'codex'], 'exactly the three tools');
   assert.deepEqual(example.blindfold, { port: 3457 }, 'the interceptor port is top-level, and it is only a port');
   for (const [key, p] of Object.entries(example.profiles)) {
     for (const retired of ['inFormat', 'blindfold', 'blindfoldPort', 'blindfoldHost', 'blindfoldPrefix']) {

package/tests/update.e2e.test.mjs

@@ -0,0 +1,197 @@
+// A real gateway, run from a copy of this checkout that tracks a local bare repository. A release
+// pushed there must reach the running gateway through POST /api/update, and through --autoupdate at
+// start. Nothing here reaches the network or the real home directory.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import http from 'node:http';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { launchBrowser, skipReason } from './cdp.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+const ID = ['-c', 'user.name=t', '-c', 'user.email=t@t', '-c', 'commit.gpgsign=false', '-c', 'core.autocrlf=false'];
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+const freePort = () => new Promise(r => {
+  const s = net.createServer().listen(0, '127.0.0.1', () => { const { port } = s.address(); s.close(() => r(port)); });
+});
+
+function copySource(dest) {
+  const files = git(ROOT, 'ls-files', '--cached', '--others', '--exclude-standard').split(/\r?\n/).filter(Boolean);
+  for (const f of files) {
+    const from = path.join(ROOT, f);
+    if (!fs.existsSync(from)) continue;
+    fs.mkdirSync(path.dirname(path.join(dest, f)), { recursive: true });
+    fs.copyFileSync(from, path.join(dest, f));
+  }
+}
+
+function bumpVersion(dir, version) {
+  const p = path.join(dir, 'package.json');
+  fs.writeFileSync(p, JSON.stringify({ ...JSON.parse(fs.readFileSync(p, 'utf8')), version }, null, 2) + '\n');
+}
+
+// The npm registry answer only drives the dashboard notice; a git checkout updates from git.
+async function registry(t, version) {
+  const srv = http.createServer((req, res) => { res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ version })); });
+  await new Promise(r => srv.listen(0, '127.0.0.1', r));
+  t.after(() => srv.close());
+  return `http://127.0.0.1:${srv.address().port}/`;
+}
+
+async function fixture(t, { registryUrl = 'http://127.0.0.1:9/' } = {}) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-update-e2e-'));
+  const upstream = path.join(base, 'upstream.git');
+  const install = path.join(base, 'install');
+  const publisher = path.join(base, 'publisher');
+  git(base, 'init', '-q', '--bare', '-b', 'main', upstream);
+  fs.mkdirSync(install);
+  copySource(install);
+  git(install, 'init', '-q', '-b', 'main');
+  git(install, 'add', '-A');
+  git(install, ...ID, 'commit', '-q', '-m', 'installed');
+  git(install, 'remote', 'add', 'origin', upstream);
+  git(install, 'push', '-q', '-u', 'origin', 'main');
+  fs.mkdirSync(publisher);
+  git(publisher, 'init', '-q', '-b', 'main');
+  git(publisher, 'remote', 'add', 'origin', upstream);
+  git(publisher, 'fetch', '-q', 'origin');
+  git(publisher, 'checkout', '-q', '-b', 'main', '--track', 'origin/main');
+
+  const data = path.join(base, 'data');
+  const home = path.join(data, 'home');
+  fs.mkdirSync(home, { recursive: true });
+  const port = await freePort();
+  const cfgPath = path.join(data, 'config.json');
+  fs.writeFileSync(cfgPath, JSON.stringify({
+    port, blindfold: { port: await freePort() }, activeProfiles: { anthropic: null, responses: null, 'openai-chat': null, vertex: null },
+    profiles: { plain: { name: 'Plain', mode: 'convert', inFormat: 'auto', baseURL: 'http://127.0.0.1:9/v1', apiKey: 'k', defaultModels: { opus: 'o' } } }
+  }, null, 2));
+  const env = {
+    ...process.env, HOME: home, USERPROFILE: home, CODEX_HOME: path.join(home, '.codex'), CLAUDE_CONFIG_DIR: path.join(home, '.claude'),
+    LLM_SWITCHER_CONFIG: cfgPath, LLM_SWITCHER_STATE_DIR: data, LLM_SWITCHER_BLINDFOLD_CERTS: path.join(data, 'certs'),
+    LLM_SWITCHER_PORT: '', PORT: '', LLM_SWITCHER_REGISTRY_URL: registryUrl
+  };
+
+  let proc = null;
+  let log = '';
+  const pid = async () => {
+    try { return (await (await fetch(`http://127.0.0.1:${port}/health?challenge=t`)).json()).pid ?? null; } catch { return null; }
+  };
+  const fx = {
+    port,
+    log: () => log,
+    pid,
+    release(version) {
+      bumpVersion(publisher, version);
+      git(publisher, 'add', '-A');
+      git(publisher, ...ID, 'commit', '-q', '-m', `v${version}`);
+      git(publisher, 'push', '-q', 'origin', 'main');
+    },
+    async start(...extra) {
+      proc = spawn(process.execPath, [path.join(install, 'proxy.mjs'), '--port', String(port), ...extra], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.stdout.on('data', d => { log += d; });
+      proc.stderr.on('data', d => { log += d; });
+      return proc;
+    },
+    async waitFor(check, what) {
+      for (let i = 0; i < 120; i++) {
+        const v = await check();
+        if (v) return v;
+        await sleep(250);
+      }
+      throw new Error(`timed out waiting for ${what}\n${log}`);
+    },
+    cli: (...args) => new Promise((resolve) => {
+      const c = spawn(process.execPath, [path.join(install, 'switch.mjs'), ...args, '--port', String(port)], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+      let out = '';
+      c.stdout.on('data', d => { out += d; });
+      c.stderr.on('data', d => { out += d; });
+      c.on('close', code => resolve({ code, out }));
+    }),
+    dashboardUrl: `http://127.0.0.1:${port}/ui`,
+    api: (p, opts = {}) => fetch(`http://127.0.0.1:${port}${p}`, {
+      ...opts,
+      headers: { 'x-llm-switcher-token': fs.readFileSync(path.join(data, 'admin.token'), 'utf8').trim(), 'Content-Type': 'application/json' }
+    })
+  };
+  t.after(async () => {
+    const live = await pid();
+    if (live) try { process.kill(live); } catch {}
+    proc?.kill();
+    await sleep(300);
+    fs.rmSync(base, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+  });
+  return fx;
+}
+
+async function readSse(res) {
+  const events = [];
+  for (const block of (await res.text()).split('\n\n')) {
+    const event = /^event: (.*)$/m.exec(block)?.[1];
+    if (event) events.push({ event, data: JSON.parse(/^data: (.*)$/m.exec(block)[1]) });
+  }
+  return events;
+}
+
+test('POST /api/update pulls the release and a new gateway takes over the port', { timeout: 90000 }, async (t) => {
+  const fx = await fixture(t);
+  const proc = await fx.start();
+  const oldPid = await fx.waitFor(fx.pid, 'the gateway');
+  assert.equal((await (await fx.api('/api/version')).json()).current, JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version);
+
+  fx.release('9.9.9');
+  const events = await readSse(await fx.api('/api/update', { method: 'POST', body: '{}' }));
+  const result = events.find(e => e.event === 'result')?.data;
+  assert.equal(result?.updated, true, JSON.stringify(events));
+  assert.equal(result.to, '9.9.9');
+
+  await fx.waitFor(async () => { const p = await fx.pid(); return p && p !== oldPid; }, 'the new gateway');
+  assert.equal((await (await fx.api('/api/version')).json()).current, '9.9.9');
+  // The first process stays as the parent: a service manager still sees the pid it started.
+  assert.equal(proc.exitCode, null);
+
+  const again = (await readSse(await fx.api('/api/update', { method: 'POST', body: '{}' }))).find(e => e.event === 'result')?.data;
+  assert.equal(again?.updated, false);
+  assert.match(again.reason, /latest/i);
+});
+
+test('--autoupdate starts the newest release', { timeout: 90000 }, async (t) => {
+  const fx = await fixture(t);
+  fx.release('9.9.10');
+  await fx.start('--autoupdate');
+  await fx.waitFor(fx.pid, 'the gateway');
+  assert.equal((await (await fx.api('/api/version')).json()).current, '9.9.10');
+  assert.match(fx.log(), /Pulled 1 commit/);
+});
+
+test('switch update asks the running gateway and waits for the new one', { timeout: 90000 }, async (t) => {
+  const fx = await fixture(t);
+  await fx.start();
+  await fx.waitFor(fx.pid, 'the gateway');
+  fx.release('9.9.11');
+  const r = await fx.cli('update');
+  assert.equal(r.code, 0, r.out);
+  assert.match(r.out, /runs v9\.9\.11/);
+  assert.equal((await (await fx.api('/api/version')).json()).current, '9.9.11');
+});
+
+test('the dashboard Update now button installs the release and reloads on the new gateway', { timeout: 90000, skip: skipReason() }, async (t) => {
+  const fx = await fixture(t, { registryUrl: await registry(t, '9.9.12') });
+  await fx.start();
+  await fx.waitFor(fx.pid, 'the gateway');
+  fx.release('9.9.12');
+  const browser = await launchBrowser();
+  t.after(() => browser.close());
+  const page = await browser.newPage();
+  await page.goto(fx.dashboardUrl);
+  await page.waitFor(`!document.getElementById('update-notice').hidden`, 'the update notice');
+  await page.click('#update-now');
+  await page.waitFor(`document.getElementById('app-version')?.textContent === 'v9.9.12'`, 'the reloaded dashboard on the new version', 30000);
+  assert.equal(await page.evaluate(`document.getElementById('update-notice').hidden`), true);
+});

package/tests/update.test.mjs

@@ -0,0 +1,145 @@
+// The update itself: a git checkout pulls fast-forward only, an npm install asks the registry.
+// Every remote here is a local bare repository or a local HTTP server.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { applyUpdate } from '../update.mjs';
+
+const git = (cwd, ...args) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+const ID = ['-c', 'user.name=t', '-c', 'user.email=t@t', '-c', 'commit.gpgsign=false'];
+
+function writeVersion(dir, version) {
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'llm-switcher', version }) + '\n');
+}
+
+function commit(dir, msg) {
+  git(dir, 'add', '-A');
+  git(dir, ...ID, 'commit', '-q', '-m', msg);
+}
+
+// upstream.git <- publisher (pushes releases), and install (the checkout being updated).
+function fixture(t) {
+  const base = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-update-'));
+  t.after(() => fs.rmSync(base, { recursive: true, force: true }));
+  const upstream = path.join(base, 'upstream.git');
+  const publisher = path.join(base, 'publisher');
+  const install = path.join(base, 'install');
+  git(base, 'init', '-q', '--bare', '-b', 'main', upstream);
+  for (const dir of [publisher, install]) {
+    fs.mkdirSync(dir);
+    git(dir, 'init', '-q', '-b', 'main');
+    git(dir, 'remote', 'add', 'origin', upstream);
+  }
+  writeVersion(publisher, '1.0.0');
+  commit(publisher, 'v1.0.0');
+  git(publisher, 'push', '-q', '-u', 'origin', 'main');
+  git(install, 'fetch', '-q', 'origin');
+  git(install, 'checkout', '-q', '-b', 'main', '--track', 'origin/main');
+  const release = (version) => {
+    writeVersion(publisher, version);
+    commit(publisher, `v${version}`);
+    git(publisher, 'push', '-q', 'origin', 'main');
+  };
+  return { install, release, head: () => git(install, 'rev-parse', 'HEAD') };
+}
+
+test('a checkout behind its upstream pulls and reports the new version', async (t) => {
+  const fx = fixture(t);
+  fx.release('1.0.1');
+  const r = await applyUpdate({ root: fx.install });
+  assert.deepEqual({ updated: r.updated, from: r.from, to: r.to }, { updated: true, from: '1.0.0', to: '1.0.1' });
+  assert.equal(JSON.parse(fs.readFileSync(path.join(fx.install, 'package.json'), 'utf8')).version, '1.0.1');
+});
+
+test('a checkout level with its upstream does nothing', async (t) => {
+  const fx = fixture(t);
+  const r = await applyUpdate({ root: fx.install });
+  assert.equal(r.updated, false);
+  assert.match(r.reason, /latest/i);
+});
+
+test('a checkout with local edits is left alone, even when upstream moved', async (t) => {
+  const fx = fixture(t);
+  fx.release('1.0.1');
+  const before = fx.head();
+  fs.appendFileSync(path.join(fx.install, 'package.json'), ' ');
+  const r = await applyUpdate({ root: fx.install });
+  assert.equal(r.updated, false);
+  assert.match(r.reason, /local changes/i);
+  assert.equal(fx.head(), before);
+});
+
+test('a checkout that is only ahead of upstream does nothing', async (t) => {
+  const fx = fixture(t);
+  fs.writeFileSync(path.join(fx.install, 'local.txt'), 'x');
+  commit(fx.install, 'local work');
+  const r = await applyUpdate({ root: fx.install });
+  assert.equal(r.updated, false);
+});
+
+test('a diverged checkout fails and is never merged', async (t) => {
+  const fx = fixture(t);
+  fs.writeFileSync(path.join(fx.install, 'local.txt'), 'x');
+  commit(fx.install, 'local work');
+  fx.release('1.0.1');
+  const before = fx.head();
+  await assert.rejects(applyUpdate({ root: fx.install }), /fast-forward|diverged/i);
+  assert.equal(fx.head(), before);
+});
+
+async function registry(t, version) {
+  const srv = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ version }));
+  });
+  await new Promise(r => srv.listen(0, '127.0.0.1', r));
+  t.after(() => srv.close());
+  return `http://127.0.0.1:${srv.address().port}/`;
+}
+
+function npmInstall(t, version) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'llmsw-npm-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  writeVersion(root, version);
+  return root;
+}
+
+test('an npm install on the latest version runs no install', async (t) => {
+  const root = npmInstall(t, '1.0.0');
+  const calls = [];
+  const r = await applyUpdate({ root, registryUrl: await registry(t, '1.0.0'), run: async (...a) => { calls.push(a); return ''; } });
+  assert.equal(r.updated, false);
+  assert.deepEqual(calls, []);
+});
+
+test('an npm install behind the registry installs that exact version globally', async (t) => {
+  const root = npmInstall(t, '1.0.0');
+  const calls = [];
+  const run = async (cmd, args) => { calls.push([cmd, ...args]); writeVersion(root, '1.0.1'); return ''; };
+  const r = await applyUpdate({ root, registryUrl: await registry(t, '1.0.1'), run });
+  assert.deepEqual({ updated: r.updated, from: r.from, to: r.to }, { updated: true, from: '1.0.0', to: '1.0.1' });
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].slice(-3), ['install', '-g', 'llm-switcher@1.0.1']);
+});
+
+// launchd and systemd --user start the gateway with a short PATH that has no Homebrew or nvm npm.
+test('npm runs with the directory of the running node first on PATH', async (t) => {
+  const root = npmInstall(t, '1.0.0');
+  let env = null;
+  const run = async (cmd, args, opts) => { env = opts.env; writeVersion(root, '1.0.1'); return ''; };
+  await applyUpdate({ root, registryUrl: await registry(t, '1.0.1'), run });
+  const keys = Object.keys(env).filter(k => k.toUpperCase() === 'PATH');
+  assert.equal(keys.length, 1, `one PATH key, got ${keys.join(', ')}`);
+  assert.equal(env[keys[0]].split(path.delimiter)[0], path.dirname(process.execPath));
+});
+
+test('an unreachable registry is not an update', async (t) => {
+  const root = npmInstall(t, '1.0.0');
+  const r = await applyUpdate({ root, registryUrl: 'http://127.0.0.1:9/' });
+  assert.equal(r.updated, false);
+  assert.match(r.reason, /registry/i);
+});