llm-switcher 1.3.1 → 1.3.3

package/tests/gateway-secret.test.mjs

@@ -0,0 +1,124 @@
+// The key of the relay proof: random, independent of admin.token, served by no route, and the only
+// key the relay accepts. Each case runs state.mjs in a child process, so it reads its own directory.
+import { test, after } 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 crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const STATE = pathToFileURL(path.join(ROOT, 'state.mjs')).href;
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'gwsecret-'));
+after(() => fs.rmSync(TMP, { recursive: true, force: true }));
+const TOKEN = 'c'.repeat(64);
+
+function dir(name) {
+  const d = path.join(TMP, name);
+  fs.mkdirSync(d, { recursive: true });
+  fs.writeFileSync(path.join(d, 'admin.token'), TOKEN);
+  return d;
+}
+// Runs `code` (an async function body that gets `s`, the state module) against directory `d`.
+function inState(d, code) {
+  const r = spawnSync(process.execPath, ['--input-type=module', '-e', `const s = await import(${JSON.stringify(STATE)}); const out = await (async () => { ${code} })(); process.stdout.write(JSON.stringify(out ?? null));`], {
+    env: { ...process.env, LLM_SWITCHER_CONFIG: path.join(d, 'config.json'), LLM_SWITCHER_STATE_DIR: d }, encoding: 'utf8'
+  });
+  if (r.status !== 0) throw new Error(r.stderr);
+  return JSON.parse(r.stdout);
+}
+const secretOf = (d) => fs.readFileSync(path.join(d, 'gateway.secret'), 'utf8');
+
+test('ensureGatewaySecret replaces a missing, empty or blank file and keeps a good one', () => {
+  const d = dir('ensure');
+  inState(d, 's.ensureGatewaySecret()');
+  const first = secretOf(d);
+  assert.match(first, /^[0-9a-f]{64}$/, 'hex only, no trailing newline');
+  inState(d, 's.ensureGatewaySecret()');
+  assert.equal(secretOf(d), first, 'an existing secret is kept');
+  for (const blank of ['', '  \n\t']) {
+    fs.writeFileSync(path.join(d, 'gateway.secret'), blank);
+    inState(d, 's.ensureGatewaySecret()');
+    assert.match(secretOf(d), /^[0-9a-f]{64}$/, `a file of ${JSON.stringify(blank)} is replaced`);
+  }
+  assert.deepEqual(fs.readdirSync(d).filter(f => f.endsWith('.tmp')), [], 'no temporary file is left');
+});
+
+test('the secret is random: never derived from admin.token or from the directory', () => {
+  const a = dir('indep-a');
+  const b = dir('indep-b');
+  inState(a, 's.ensureGatewaySecret()');
+  inState(b, 's.ensureGatewaySecret()');
+  const first = secretOf(a);
+  assert.notEqual(first, secretOf(b), 'two directories with the same admin.token');
+  assert.notEqual(first, TOKEN);
+  fs.rmSync(path.join(a, 'gateway.secret'));
+  inState(a, 's.ensureGatewaySecret()');
+  assert.notEqual(secretOf(a), first, 'the same directory and token again');
+});
+
+test('relayProof is an HMAC keyed by the raw bytes of gateway.secret', () => {
+  const d = dir('binding');
+  const raw = 'f'.repeat(64);
+  fs.writeFileSync(path.join(d, 'gateway.secret'), raw);
+  const out = inState(d, `return { secret: s.readGatewaySecret(), proof: s.relayProof('n1', { port: 3456, pid: 77 }) };`);
+  assert.equal(out.secret, raw);
+  assert.equal(out.proof, crypto.createHmac('sha256', raw).update('relay|3456|77|n1').digest('hex'));
+});
+
+test('without gateway.secret there is no proof at all, and no fallback to admin.token', () => {
+  const d = dir('nofallback');
+  const out = inState(d, `return { secret: s.readGatewaySecret(), proof: s.relayProof('n1', { port: 3456, pid: 77 }) };`);
+  assert.deepEqual(out, { secret: null, proof: '' });
+});
+
+test('ensureGatewaySecret throws when it cannot write, and leaves no temporary file', () => {
+  const d = dir('throws');
+  fs.mkdirSync(path.join(d, 'gateway.secret'));
+  assert.throws(() => inState(d, 's.ensureGatewaySecret()'));
+  assert.deepEqual(fs.readdirSync(d).filter(f => f.endsWith('.tmp')), []);
+});
+
+test('the blindfold proof keeps its exact formula', async () => {
+  const s = await import(STATE);
+  const proof = s.identityProof('n2', { role: 'blindfold', port: 3457, pid: 9, gatewayPort: 3456, activeTools: 'codex' }, TOKEN);
+  assert.equal(proof, crypto.createHmac('sha256', TOKEN).update('blindfold|3457|9|3456|codex|n2').digest('hex'));
+});
+
+test('only state.mjs touches gateway.secret: no other module of the package can read or serve it', () => {
+  const files = [...fs.readdirSync(ROOT).filter(f => f.endsWith('.mjs')).map(f => path.join(ROOT, f)),
+    ...fs.readdirSync(path.join(ROOT, 'blindfold')).filter(f => f.endsWith('.mjs')).map(f => path.join(ROOT, 'blindfold', f))];
+  assert.ok(files.length > 10, 'the scan found the package modules');
+  for (const f of files) {
+    if (path.basename(f) === 'state.mjs') continue;
+    const src = fs.readFileSync(f, 'utf8');
+    for (const name of ['gateway.secret', 'readGatewaySecret', 'gatewaySecretPath']) {
+      assert.equal(src.includes(name), false, `${path.relative(ROOT, f)} mentions ${name}`);
+    }
+  }
+  const proxy = fs.readFileSync(path.join(ROOT, 'proxy.mjs'), 'utf8');
+  assert.match(proxy, /ensureGatewaySecret\(\);/, 'the gateway makes its secret at startup and keeps no copy');
+  assert.match(proxy, /relayProof\(/);
+});
+
+test('gateway.secret stays out of git and out of the npm package', () => {
+  assert.ok(fs.readFileSync(path.join(ROOT, '.gitignore'), 'utf8').split(/\r?\n/).includes('gateway.secret'));
+});
+
+test('the .cmd command line: cmd.exe switches, quoting and the 8191 limit', async () => {
+  const { batCommandLine, CMD_LIMIT } = await import(pathToFileURL(path.join(ROOT, 'agy-relay-lib.mjs')).href);
+  const ok = batCommandLine('C:\\a\\agy.cmd', ['x']);
+  assert.deepEqual(ok.args.slice(0, 4), ['/e:ON', '/v:OFF', '/d', '/c']);
+  assert.equal(batCommandLine('C:\\a\\agy.cmd', ['50%']).args[4].includes('50%%cd:~,%'), true);
+  assert.equal(CMD_LIMIT, 8191);
+  // The /c string is `"` + `"C:\a\agy.cmd"` + ` ` + the argument + `"`: 17 code units around it.
+  const room = CMD_LIMIT - '""C:\\a\\agy.cmd" "'.length;
+  assert.equal(batCommandLine('C:\\a\\agy.cmd', ['z'.repeat(room)]).args[4].length, CMD_LIMIT);
+  assert.ok(batCommandLine('C:\\a\\agy.cmd', ['z'.repeat(room + 1)]).error);
+  // Counted in UTF-16 code units, not bytes: é is one unit and two UTF-8 bytes.
+  assert.ok(batCommandLine('C:\\a\\agy.cmd', ['é'.repeat(room - 2)]).args, 'non-ASCII is not refused early');
+  assert.ok(batCommandLine('C:\\a\\agy".cmd', []).error);
+  assert.ok(batCommandLine('C:\\a\\', []).error);
+});

package/tests/gateway.e2e.test.mjs

@@ -1149,6 +1149,8 @@ test('Direct passthrough waits for a slow client instead of buffering the whole
     req.on('error', reject);
     req.end(JSON.stringify({ model: 'claude-opus-4-6', max_tokens: 10, stream: true, messages: [{ role: 'user', content: 'DIRECT_BIG' }] }));
   });
+  // The end callback of the mock can run after the client's 'end' under load: 0 means not recorded yet.
+  assert.ok(await until(() => bigState.finishedAt, 2000), 'the upstream never finished');
   assert.ok(bigState.finishedAt >= resumedAt, `upstream finished ${resumedAt - bigState.finishedAt} ms before the client read anything`);
 });
 

package/tests/make-certs.test.mjs

@@ -20,3 +20,17 @@ test('make-certs.sh builds the certificates under a path that contains a dot', {
   for (const f of ['ca.pem', 'ca.key', 'leaf.pem', 'leaf.key']) assert.ok(fs.existsSync(path.join(out, f)), `${f} is missing`);
   assert.deepEqual(fs.readdirSync(dir), ['first.last'], 'no serial file outside the output directory');
 });
+
+// A Windows path has no forward slash. The script took `C:\...\certs` for the host of the old
+// two-argument form, ignored it, and rebuilt the default certificates of the checkout instead.
+test('make-certs.sh writes to a Windows path given as its only argument', { skip: process.platform !== 'win32' && 'a Windows path' }, (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'llmswcerts-win-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const out = path.join(dir, 'certs');
+  // Where the script falls back to: a decoy, so a failing run never touches the real certificates.
+  const decoy = path.join(dir, 'decoy');
+  execFileSync('bash', [path.join(ROOT, 'blindfold', 'make-certs.sh'), out], { stdio: 'pipe', env: { ...process.env, LLM_SWITCHER_BLINDFOLD_CERTS: decoy } });
+  assert.match(out, /^[A-Za-z]:\\/, 'the argument is a native Windows path');
+  for (const f of ['ca.pem', 'ca.key', 'leaf.pem', 'leaf.key']) assert.ok(fs.existsSync(path.join(out, f)), `${f} is missing in ${out}`);
+  assert.equal(fs.existsSync(decoy), false, 'nothing is written to the default directory');
+});

package/tests/shim.test.mjs

@@ -534,7 +534,9 @@ 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}`);
       assert.doesNotMatch(err, NOTICE);
     } else {
       assert.match(out, /CCU=\[\]/, 'the token must not go to a port that did not prove itself');
@@ -562,7 +564,8 @@ 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.doesNotMatch(out.stderr, NOTICE);
     } else {
       assert.match(out.stdout, /CCU=\[\]/);

package/tests/switch.test.mjs

@@ -621,3 +621,22 @@ 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}`);
+});

package/tests/update.e2e.test.mjs

@@ -192,6 +192,13 @@ test('the dashboard Update now button installs the release and reloads on the ne
   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);
+  try {
+    await page.waitFor(`document.getElementById('app-version')?.textContent === 'v9.9.12'`, 'the reloaded dashboard on the new version', 30000);
+  } catch (err) {
+    // A CI runner cannot be watched: put what the gateway and the page saw into the failure.
+    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/tests/ws-client.mjs

@@ -0,0 +1,46 @@
+// A raw WebSocket client for the gateway tests. It sends the handshake headers Codex sends (a
+// User-Agent, a profile header), which the WebSocket of Node cannot set.
+import net from 'node:net';
+import crypto from 'node:crypto';
+import { createFrameReader } from '../blindfold/wsframe.mjs';
+
+// One masked client frame, as RFC 6455 requires from a client.
+export function clientFrame(opcode, payload) {
+  const data = Buffer.from(payload);
+  const len = data.length;
+  const head = len < 126 ? Buffer.from([0x80 | opcode, 0x80 | len])
+    : len < 65536 ? Buffer.from([0x80 | opcode, 0x80 | 126, len >> 8, len & 0xff])
+      : Buffer.concat([Buffer.from([0x80 | opcode, 0x80 | 127]), (() => { const b = Buffer.alloc(8); b.writeBigUInt64BE(BigInt(len)); return b; })()]);
+  const mask = crypto.randomBytes(4);
+  return Buffer.concat([head, mask, Buffer.from(data.map((b, i) => b ^ mask[i & 3]))]);
+}
+
+// Opens /v1/responses on the gateway. `messages` collects every JSON text frame the gateway sends.
+export function openResponsesWs(port, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(port, '127.0.0.1');
+    const extra = Object.entries(headers).map(([k, v]) => `${k}: ${v}\r\n`).join('');
+    socket.write(`GET /v1/responses HTTP/1.1\r\nHost: 127.0.0.1:${port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: ${crypto.randomBytes(16).toString('base64')}\r\n${extra}\r\n`);
+    let head = Buffer.alloc(0);
+    const read = createFrameReader();
+    const messages = [];
+    const onData = (chunk) => {
+      head = Buffer.concat([head, chunk]);
+      const end = head.indexOf('\r\n\r\n');
+      if (end < 0) return;
+      socket.off('data', onData);
+      const collect = (c) => { for (const f of read(c)) if (f.type === 'text') messages.push(JSON.parse(f.payload.toString())); };
+      socket.on('data', collect);
+      const rest = head.subarray(end + 4);
+      if (rest.length) collect(rest);
+      resolve({
+        reply: head.subarray(0, end).toString(),
+        messages,
+        send: (obj) => socket.write(clientFrame(1, JSON.stringify(obj))),
+        close: () => socket.destroy()
+      });
+    };
+    socket.on('data', onData);
+    socket.on('error', reject);
+  });
+}