llm-switcher 1.3.2 → 1.3.4

package/tests/shim.test.mjs

@@ -476,6 +476,21 @@ 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);
+// The relay key of this test install: the relay of a routed agy checks every connection with it.
+const AGY_SECRET = 'd'.repeat(64);
+fs.writeFileSync(path.join(path.dirname(AGY_CONFIG), 'gateway.secret'), AGY_SECRET);
+// Stands in for agy: sends one request with its Google token to CLOUD_CODE_URL, when it has one.
+const AGY_REQUEST = path.join(AGY_CONFIG_DIR, 'agy-request.mjs');
+fs.writeFileSync(AGY_REQUEST, `
+import http from 'node:http';
+const url = process.env.CLOUD_CODE_URL;
+if (url) await new Promise((resolve) => {
+  const req = http.request(url + '/v1internal:loadCodeAssist', { method: 'POST', agent: false, headers: { authorization: 'Bearer google-secret' } },
+    (res) => { res.resume(); res.on('end', () => { console.log('STATUS ' + res.statusCode); resolve(); }); });
+  req.on('error', (e) => { console.log('ERROR ' + e.message); resolve(); });
+  req.end('{}');
+});
+`);
 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');
@@ -491,19 +506,31 @@ function runAsync(cmd, args, opts) {
 }
 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.
+// A gateway listener: 'real' signs like this gateway (both proofs), 'forged' sends wrong proofs,
+// 'silent' never answers. `server.seen` holds the Authorization of every request that is not a probe.
 async function agyListener(kind) {
   const http = await import('node:http');
   const net = await import('node:net');
+  const crypto = await import('node:crypto');
+  const seen = [];
   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';
+      const u = new URL(req.url, 'http://x');
       res.setHeader('content-type', 'application/json');
-      res.end(JSON.stringify({ status: 'ok', proxy: 'llm-switcher', port, pid: 4242, proof }));
+      if (u.pathname !== '/health') {
+        seen.push(req.headers.authorization || '');
+        req.resume();
+        return res.end('{"answeredBy":"gateway"}');
+      }
+      const nonce = u.searchParams.get('challenge');
+      const real = kind === 'real';
+      const proof = real ? identityProof(nonce, { role: 'gateway', port, pid: 4242 }, AGY_TOKEN) : 'forged';
+      const relayProof = real ? crypto.createHmac('sha256', AGY_SECRET).update(['relay', port, 4242, nonce].join('|')).digest('hex') : 'forged';
+      res.end(JSON.stringify({ status: 'ok', proxy: 'llm-switcher', port, pid: 4242, proof, relayProof }));
     });
+  server.seen = seen;
   await new Promise(r => server.listen(0, '127.0.0.1', r));
   return server;
 }
@@ -511,7 +538,7 @@ async function agyListener(kind) {
 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');
+  fs.writeFileSync(path.join(fakeDir, 'agy.cmd'), `@echo off\r\necho CCU=[%CLOUD_CODE_URL%]\r\nnode "${AGY_REQUEST}"\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`);
@@ -534,11 +561,17 @@ for (const [kind, routed] of [['forged', false], ['silent', false], ['real', tru
     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}\\]`));
+      // agy gets the port of its own relay, which proves the gateway on every connection.
+      const relayPort = Number((out.match(/CCU=\[http:\/\/127\.0\.0\.1:(\d+)\]/) || [])[1]);
+      assert.ok(relayPort > 0 && relayPort !== port, `agy must get the relay port, not ${port}: ${out}`);
+      // The request really crossed the relay and reached this gateway, token included.
+      assert.match(out, /STATUS 200/, out);
+      assert.deepEqual(server.seen, ['Bearer google-secret']);
       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.deepEqual(server.seen ?? [], [], 'the listener never received the token');
     }
     assert.ok(ms < 8000, `the shim took ${ms} ms`);
   });
@@ -551,7 +584,7 @@ for (const [kind, routed] of [['forged', false], ['silent', false], ['real', tru
     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.writeFileSync(path.join(dir, 'agy'), `#!/usr/bin/env bash\necho "CCU=[\${CLOUD_CODE_URL:-}]"\nnode "${AGY_REQUEST}"\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');
@@ -562,11 +595,15 @@ for (const [kind, routed] of [['forged', false], ['silent', false], ['real', tru
     });
     fs.rmSync(dir, { recursive: true, force: true });
     if (routed) {
-      assert.match(out.stdout, new RegExp(`CCU=\\[http://127\\.0\\.0\\.1:${port}\\]`));
+      const relayPort = Number((out.stdout.match(/CCU=\[http:\/\/127\.0\.0\.1:(\d+)\]/) || [])[1]);
+      assert.ok(relayPort > 0 && relayPort !== port, `agy must get the relay port, not ${port}: ${out.stdout}`);
+      assert.match(out.stdout, /STATUS 200/, out.stdout);
+      assert.deepEqual(server.seen, ['Bearer google-secret']);
       assert.doesNotMatch(out.stderr, NOTICE);
     } else {
       assert.match(out.stdout, /CCU=\[\]/);
       assert.match(out.stderr, NOTICE);
+      assert.deepEqual(server.seen ?? [], [], 'the listener never received the token');
     }
     assert.ok(Date.now() - started < 8000, `the shim took ${Date.now() - started} ms`);
   });

package/tests/switch.test.mjs

@@ -621,3 +621,43 @@ test('R7e: saves work again after the file is fixed', async (t) => {
   assert.equal(fixed.status, 0, fixed.stdout + fixed.stderr);
   assert.ok(readCfg(ws).profiles.plain, 'the file writes again');
 });
+
+// A second instance (LLM_SWITCHER_PORT) must never stop the service of the first one: the unit
+// runs the gateway of another port. This test once stopped the real gateway of the machine.
+test('switch off stops the installed service only when that service owns the port', { skip: process.platform !== 'linux' && 'a systemd fake' }, async (t) => {
+  const ws = await workspace(t, await freePort());
+  const unitDir = path.join(ws.home, '.config', 'systemd', 'user');
+  fs.mkdirSync(unitDir, { recursive: true });
+  fs.writeFileSync(path.join(unitDir, 'llm-switcher.service'), '[Service]\nExecStart=/usr/bin/node /opt/llm-switcher/proxy.mjs --port 3456\n');
+  // A systemctl that only records what it was told.
+  const bin = path.join(ws.dir, 'fakebin');
+  fs.mkdirSync(bin);
+  const calls = path.join(ws.dir, 'systemctl.log');
+  fs.writeFileSync(path.join(bin, 'systemctl'), `#!/bin/sh\necho "$@" >> "${calls}"\nexit 0\n`, { mode: 0o755 });
+  const env = { PATH: `${bin}${path.delimiter}${process.env.PATH}` };
+  assert.equal((await run(ws, ['on', 'plain'], { env })).status, 0);
+  assert.equal((await run(ws, ['off'], { env })).status, 0);
+  const log = fs.existsSync(calls) ? fs.readFileSync(calls, 'utf8') : '';
+  assert.doesNotMatch(log, /\b(stop|restart)\b/, `systemctl was told to stop the instance on port 3456:\n${log}`);
+});
+
+// The same rule for `switch port`: the unit of another instance keeps its port and is not restarted.
+test('switch port leaves the installed service of another port unchanged', { skip: process.platform !== 'linux' && 'a systemd fake' }, async (t) => {
+  const ws = await workspace(t, await freePort());
+  const unitDir = path.join(ws.home, '.config', 'systemd', 'user');
+  fs.mkdirSync(unitDir, { recursive: true });
+  const unit = path.join(unitDir, 'llm-switcher.service');
+  const original = '[Service]\nExecStart=/usr/bin/node /opt/llm-switcher/proxy.mjs --port 3456\n';
+  fs.writeFileSync(unit, original);
+  const bin = path.join(ws.dir, 'fakebin');
+  fs.mkdirSync(bin);
+  const calls = path.join(ws.dir, 'systemctl.log');
+  fs.writeFileSync(path.join(bin, 'systemctl'), `#!/bin/sh\necho "$@" >> "${calls}"\nexit 0\n`, { mode: 0o755 });
+  const env = { PATH: `${bin}${path.delimiter}${process.env.PATH}` };
+  assert.equal((await run(ws, ['on', 'plain'], { env })).status, 0);
+  const r = await run(ws, ['port', String(await freePort())], { env });
+  assert.equal(r.status, 0, r.out);
+  assert.equal(fs.readFileSync(unit, 'utf8'), original, 'the unit of port 3456 was rewritten');
+  const log = fs.existsSync(calls) ? fs.readFileSync(calls, 'utf8') : '';
+  assert.doesNotMatch(log, /\b(stop|restart|start|enable)\b/, `systemctl was told to act on the other instance:\n${log}`);
+});

package/tests/update.e2e.test.mjs

@@ -115,6 +115,8 @@ async function fixture(t, { registryUrl = 'http://127.0.0.1:9/' } = {}) {
       c.on('close', code => resolve({ code, out }));
     }),
     dashboardUrl: `http://127.0.0.1:${port}/ui`,
+    // How `switch ui` opens it: the token comes in the fragment, never in the page.
+    tokenUrl: () => `http://127.0.0.1:${port}/ui#token=${fs.readFileSync(path.join(data, 'admin.token'), 'utf8').trim()}`,
     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' }
@@ -189,14 +191,16 @@ test('the dashboard Update now button installs the release and reloads on the ne
   const browser = await launchBrowser();
   t.after(() => browser.close());
   const page = await browser.newPage();
-  await page.goto(fx.dashboardUrl);
+  await page.goto(fx.tokenUrl());
   await page.waitFor(`!document.getElementById('update-notice').hidden`, 'the update notice');
   await page.click('#update-now');
   try {
-    await page.waitFor(`document.getElementById('app-version')?.textContent === 'v9.9.12'`, 'the reloaded dashboard on the new version', 30000);
+    // Longer than the 30 s the page polls for the new gateway, so a failure shows the page's own verdict.
+    await page.waitFor(`document.getElementById('app-version')?.textContent === 'v9.9.12'`, 'the reloaded dashboard on the new version', 40000);
   } catch (err) {
     // A CI runner cannot be watched: put what the gateway and the page saw into the failure.
-    err.message += `\ngateway log:\n${fx.log()}\npage problems: ${JSON.stringify(page.problems)}`;
+    const stage = await page.evaluate(`document.getElementById('update-status')?.textContent || ''`).catch(() => '(page gone)');
+    err.message += `\nupdate status on the page: ${stage}\ngateway log:\n${fx.log()}\npage problems: ${JSON.stringify(page.problems)}`;
     throw err;
   }
   assert.equal(await page.evaluate(`document.getElementById('update-notice').hidden`), true);

package/ui.html

@@ -1247,10 +1247,12 @@
   <script>
     // State & Globals
     const ADMIN_TOKEN_KEY = 'llm-switcher-admin-token';
-    const servedToken = document.querySelector('meta[name="llm-switcher-token"]')?.content;
+    // The token comes only in the #token of the private launcher that `switch ui` opens, and stays in
+    // this tab. The page itself never carries it: any process on the machine can load /ui.
+    const NO_TOKEN_HINT = 'This tab has no access token. Open the dashboard with `switch ui`.';
     const hashTokenMatch = location.hash.match(/(?:^#|&)token=([0-9a-f]+)/);
-    if (servedToken || hashTokenMatch) {
-      sessionStorage.setItem(ADMIN_TOKEN_KEY, servedToken || hashTokenMatch[1]);
+    if (hashTokenMatch) {
+      sessionStorage.setItem(ADMIN_TOKEN_KEY, hashTokenMatch[1]);
     }
     if (hashTokenMatch) {
       history.replaceState(null, '', location.pathname + location.search + '#/routes');
@@ -1278,13 +1280,13 @@
 
     // API Helper
     async function api(path, opts = {}) {
-      const token = sessionStorage.getItem(ADMIN_TOKEN_KEY) || document.querySelector('meta[name="llm-switcher-token"]')?.content || '';
+      const token = sessionStorage.getItem(ADMIN_TOKEN_KEY) || '';
       const headers = {
         ...opts.headers,
         'x-llm-switcher-token': token
       };
       const res = await fetch(path, { ...opts, headers });
-      if (res.status === 401) showToast('Unauthorized: check admin.token in server directory', true);
+      if (res.status === 401) showToast(NO_TOKEN_HINT, true);
       if (res.status === 409) setTimeout(loadStatus, 0);
       return res;
     }
@@ -2792,6 +2794,7 @@
     }
 
     document.addEventListener('DOMContentLoaded', () => {
+      if (!sessionStorage.getItem(ADMIN_TOKEN_KEY)) showToast(NO_TOKEN_HINT, true);
       // Setup initial theme buttons state
       const currentTheme = document.documentElement.dataset.theme || 'dark';
       document.getElementById('btn-theme-dark')?.setAttribute('aria-pressed', currentTheme === 'dark');