llm-switcher 1.1.0

package/tests/switch.test.mjs

@@ -0,0 +1,156 @@
+// 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 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 { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const POSIX = process.platform !== 'win32';
+
+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) {
+  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 },
+    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: '' } };
+  t.after(async () => {
+    await run(ws, ['off']).catch(() => {});
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+  return ws;
+}
+
+// onLine lets a test act at a precise moment of the run, for example while the CLI waits.
+function run(ws, args, { onLine, env = {} } = {}) {
+  return new Promise(resolve => {
+    const child = spawn(process.execPath, [path.join(ROOT, 'switch.mjs'), ...args], { env: { ...ws.env, ...env } });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', d => {
+      stdout += d;
+      if (onLine) for (const line of String(d).split('\n')) onLine(line);
+    });
+    child.stderr.on('data', d => { stderr += d; });
+    const timer = setTimeout(() => child.kill('SIGKILL'), 30000);
+    child.on('close', code => { clearTimeout(timer); resolve({ status: code, stdout, stderr }); });
+  });
+}
+
+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(), {
+    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']);
+  assert.equal(r.status, 0, r.stderr);
+  assert.ok(!/[\u0000-\u0008\u000b-\u001f\u007f]/.test(r.stdout), JSON.stringify(r.stdout));
+  assert.match(r.stdout, /Evil/);
+});
+
+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 r = await run(ws, ['-p', String(other), 'status']);
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /=== LLM Switcher Status ===/);
+  assert.match(r.stdout, new RegExp(`/ui`));
+  assert.ok(r.stdout.includes(`:${other}/ui`), r.stdout);
+  assert.equal(readCfg(ws).port, port, 'config.json keeps its port');
+});
+
+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());
+  let edited = false;
+  const r = await run(ws, ['on', 'plain'], {
+    onLine: (line) => {
+      if (edited || !line.startsWith('Starting proxy service')) return;
+      edited = true;
+      const cfg = readCfg(ws);
+      cfg.profiles.plain.name = 'Renamed while waiting';
+      fs.writeFileSync(`${ws.cfgPath}.x`, JSON.stringify(cfg));
+      fs.renameSync(`${ws.cfgPath}.x`, ws.cfgPath);
+    }
+  });
+  assert.equal(r.status, 0, r.stderr + r.stdout);
+  assert.ok(edited, 'the CLI started a gateway');
+  const cfg = readCfg(ws);
+  assert.equal(cfg.profiles.plain.name, 'Renamed while waiting');
+  assert.equal(cfg.activeProfiles.anthropic, 'plain');
+});
+
+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);
+  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)));
+  t.after(() => squatter.close());
+  const r = await run(ws, ['port', String(held)]);
+  assert.notEqual(r.status, 0);
+  assert.match(r.stderr, /held by another process/);
+  assert.equal(readCfg(ws).port, port);
+  const status = await run(ws, ['status']);
+  assert.match(status.stdout, new RegExp(`RUNNING \\(port ${port}\\)`));
+});
+
+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);
+  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());
+  t.after(() => squatter.close());
+  const r = await run(ws, ['port', String(next)], {
+    onLine: (line) => { if (line.startsWith('Stopping gateway')) squatter.listen(next, '127.0.0.1'); }
+  });
+  assert.notEqual(r.status, 0, r.stdout);
+  assert.match(r.stderr, new RegExp(`back on port ${port}`));
+  assert.equal(readCfg(ws).port, port);
+  assert.match((await run(ws, ['status'])).stdout, new RegExp(`RUNNING \\(port ${port}\\)`));
+});
+
+// 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 r = await run(ws, ['on', 'plain']);
+  assert.equal(r.status, 0, r.stderr);
+  assert.match(r.stdout, /\[Shim\] Not installed automatically/);
+  assert.equal(fs.existsSync(path.join(ws.home, '.llm-switcher', 'bin', 'claude')), false);
+});
+
+// Only the named script starts late: the CLI itself runs at normal speed.
+const slowStart = (script, ms) => ({ NODE_OPTIONS: `--import=data:text/javascript,${encodeURIComponent(`if ((process.argv[1] || '').endsWith('${script}')) { const end = Date.now() + ${ms}; while (Date.now() < end) {} }`)}` });
+
+// A gateway that comes up after the 5 s wait must not stay on the new port after the rollback
+// (follow-up RACER-5).
+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);
+  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);
+  await new Promise(res => setTimeout(res, 8000));
+  const probe = await new Promise(res => {
+    const s = net.connect(next, '127.0.0.1', () => { s.destroy(); res('listening'); });
+    s.on('error', () => res('free'));
+  });
+  assert.equal(probe, 'free', 'nothing listens on the abandoned port');
+});

package/tests/wsframe.test.mjs

@@ -0,0 +1,154 @@
+// Tests for blindfold/wsframe.mjs — the frame reader that a capture uses.
+//
+// Why it exists (2026-09-20): a Codex completion does not travel over HTTP. The
+// blindfold log shows `upgrade passthrough /backend-api/codex/responses`, so the
+// request that matters is a WebSocket and a capture of HTTP alone records the
+// handshake and nothing else.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import zlib from 'node:zlib';
+import { createFrameReader, negotiatesDeflate, OPCODE } from '../blindfold/wsframe.mjs';
+
+// Build a frame the way a client does: masked, because RFC 6455 requires every
+// client frame to be masked and an unmasking bug is invisible without a test.
+function frame(opcode, payload, { fin = true, mask = false, rsv1 = false } = {}) {
+  const body = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+  const head = [(fin ? 0x80 : 0) | (rsv1 ? 0x40 : 0) | opcode];
+  let lengthBytes = [];
+  if (body.length < 126) {
+    lengthBytes = [];
+    head.push((mask ? 0x80 : 0) | body.length);
+  } else if (body.length < 65536) {
+    head.push((mask ? 0x80 : 0) | 126);
+    const b = Buffer.alloc(2); b.writeUInt16BE(body.length); lengthBytes = [...b];
+  } else {
+    head.push((mask ? 0x80 : 0) | 127);
+    const b = Buffer.alloc(8); b.writeBigUInt64BE(BigInt(body.length)); lengthBytes = [...b];
+  }
+  const key = mask ? Buffer.from([0x01, 0x02, 0x03, 0x04]) : Buffer.alloc(0);
+  const masked = Buffer.from(body);
+  if (mask) for (let i = 0; i < masked.length; i++) masked[i] ^= key[i & 3];
+  return Buffer.concat([Buffer.from(head), Buffer.from(lengthBytes), key, masked]);
+}
+
+test('a masked client frame is unmasked', () => {
+  const read = createFrameReader();
+  const out = read(frame(OPCODE.text, '{"type":"response.create"}', { mask: true }));
+  assert.equal(out.length, 1);
+  assert.equal(out[0].type, 'text');
+  assert.equal(out[0].payload.toString(), '{"type":"response.create"}');
+});
+
+test('an unmasked server frame is read as it is', () => {
+  const read = createFrameReader();
+  const out = read(frame(OPCODE.text, 'hello'));
+  assert.equal(out[0].payload.toString(), 'hello');
+});
+
+// A TCP chunk boundary has nothing to do with a frame boundary. Both directions
+// of this split must work, or a capture loses whole messages at random.
+test('one frame split across chunks is reassembled', () => {
+  const read = createFrameReader();
+  const f = frame(OPCODE.text, 'split me please', { mask: true });
+  assert.deepEqual(read(f.subarray(0, 3)), []);
+  assert.deepEqual(read(f.subarray(3, 7)), []);
+  const out = read(f.subarray(7));
+  assert.equal(out[0].payload.toString(), 'split me please');
+});
+
+test('several frames in one chunk are all returned', () => {
+  const read = createFrameReader();
+  const out = read(Buffer.concat([
+    frame(OPCODE.text, 'one', { mask: true }),
+    frame(OPCODE.text, 'two', { mask: true }),
+    frame(OPCODE.text, 'three', { mask: true })
+  ]));
+  assert.deepEqual(out.map((m) => m.payload.toString()), ['one', 'two', 'three']);
+});
+
+test('a fragmented message is joined, and only the final frame is emitted', () => {
+  const read = createFrameReader();
+  const first = read(frame(OPCODE.text, 'part one ', { fin: false, mask: true }));
+  assert.deepEqual(first, [], 'a non-final frame must not be emitted on its own');
+  const out = read(frame(OPCODE.continuation, 'part two', { mask: true }));
+  assert.equal(out.length, 1);
+  assert.equal(out[0].payload.toString(), 'part one part two');
+});
+
+// 126 and 127 select a 2-byte and an 8-byte length. Getting either offset wrong
+// shifts every later frame, so the whole stream decodes as noise.
+test('the extended length forms are read', () => {
+  const read = createFrameReader();
+  const medium = 'x'.repeat(300);
+  assert.equal(read(frame(OPCODE.text, medium, { mask: true }))[0].payload.toString(), medium);
+  const large = 'y'.repeat(70000);
+  assert.equal(read(frame(OPCODE.text, large, { mask: true }))[0].payload.toString(), large);
+});
+
+test('a control frame is reported and does not break a fragmented message', () => {
+  const read = createFrameReader();
+  read(frame(OPCODE.text, 'start ', { fin: false, mask: true }));
+  const ping = read(frame(OPCODE.ping, '', { mask: true }));
+  assert.equal(ping[0].type, 'ping');
+  assert.equal(ping[0].control, true);
+  const out = read(frame(OPCODE.continuation, 'end', { mask: true }));
+  assert.equal(out[0].payload.toString(), 'start end', 'the ping must not join the message');
+});
+
+test('a permessage-deflate payload is inflated when the handshake negotiated it', () => {
+  const text = '{"type":"response.output_text.delta","delta":"PONG"}';
+  // A permessage-deflate sender ends the message with Z_SYNC_FLUSH, which leaves
+  // the empty block 00 00 ff ff, and then strips those four bytes. Z_FINISH, the
+  // default of deflateRawSync, does not produce that tail at all.
+  const deflated = zlib.deflateRawSync(Buffer.from(text), { finishFlush: zlib.constants.Z_SYNC_FLUSH });
+  assert.deepEqual([...deflated.subarray(deflated.length - 4)], [0x00, 0x00, 0xff, 0xff]);
+  const body = deflated.subarray(0, deflated.length - 4);
+  const read = createFrameReader({ inflate: true });
+  const out = read(frame(OPCODE.text, body, { mask: true, rsv1: true }));
+  assert.equal(out[0].compressed, true);
+  assert.equal(out[0].payload.toString(), text);
+});
+
+// Measured on a real Codex stream (2026-09-20): inflating each message on its own
+// decoded the first and lost the next 20 with "invalid distance too far back".
+// permessage-deflate keeps the compression window between messages by default.
+test('a second compressed message decodes, because the inflate context is kept', async () => {
+  // One sender stream, flushed per message: that is what context takeover means.
+  const sender = zlib.createDeflateRaw({ windowBits: 15 });
+  const chunks = [];
+  sender.on('data', (c) => chunks.push(c));
+  const deflate = (text) => new Promise((resolve) => {
+    const before = Buffer.concat(chunks).length;
+    sender.write(Buffer.from(text));
+    sender.flush(zlib.constants.Z_SYNC_FLUSH, () => {
+      const all = Buffer.concat(chunks);
+      resolve(all.subarray(before, all.length - 4));
+    });
+  });
+  const first = '{"type":"codex.rate_limits","rate_limits":{"used_percent":2}}';
+  const second = '{"type":"codex.rate_limits","rate_limits":{"used_percent":3}}';
+  const payloads = [await deflate(first), await deflate(second)];
+
+  const read = createFrameReader({ inflate: true });
+  const a = read(frame(OPCODE.text, payloads[0], { rsv1: true }));
+  const b = read(frame(OPCODE.text, payloads[1], { rsv1: true }));
+  assert.equal(a[0].payload.toString(), first);
+  assert.equal(b[0].payload.toString(), second, 'the second message must decode as well');
+  assert.equal(b[0].note, undefined, 'no decode failure is expected');
+});
+
+test('a payload that cannot be inflated keeps a reason instead of noise', () => {
+  const read = createFrameReader({ inflate: true });
+  const out = read(frame(OPCODE.text, Buffer.from([0xff, 0xfe, 0xfd]), { mask: true, rsv1: true }));
+  assert.equal(out[0].compressed, true);
+  assert.match(out[0].note, /cannot inflate permessage-deflate payload/);
+});
+
+test('deflate is only used when the handshake asked for it', () => {
+  assert.equal(negotiatesDeflate('permessage-deflate; client_max_window_bits'), true);
+  assert.equal(negotiatesDeflate('PERMESSAGE-DEFLATE'), true);
+  assert.equal(negotiatesDeflate('x-webkit-deflate-frame'), false);
+  assert.equal(negotiatesDeflate(undefined), false);
+  assert.equal(negotiatesDeflate(''), false);
+});