Files

547 lines
44 KiB
JavaScript

// #1873 ride-default slice 1: Ride all adds the instance's model proxy (cliproxy) to the owner's
// organizations, skips and names the ones it must not change, and lists fixture organizations,
// which move to the owner's models only by a separate confirmed action.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash } from 'node:crypto';
import { createProxyAdmin } from '../src/admin-control.mjs';
import { initFiles, receiptFile, appendReceipt, receiptsText, ownedText } from '../src/admin.mjs';
import { execFileSync } from 'node:child_process';
import { PIN } from '../src/common.mjs';
import { cliproxyRemoved, localRide, riddenOrgs, pickModel, fixtureMove, moveFixtureOrg, readRider, ownerModelsFrom } from '../src/ride.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { orgUsesFixture } from '../../cli/src/dev-fixture.mjs';
const stopped = async () => ({ stopped: true, running: [] });
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5', label: 'Claude Opus 5.5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
const glm = row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', label: 'GLM 5.3', harnesses: ['pi'] });
const committed = changes => JSON.stringify({ state: 'committed', changes }) + '\n';
const busError = code => Object.assign(new Error('bus text that must not leak'), { code });
// A fake organization bus: `plugins` answers the providers and revision; `proxy.accounts` answers
// or throws; `plugins.set` records the write.
function bus({ providers = ['fixture'], down = false, client = true, accounts = null, set = null } = {}) {
const calls = [];
const call = async (verb, args) => {
calls.push([verb, args]);
if (down) throw busError('no-bus-host');
if (verb === 'plugins') return { business: 'x', revision: 'rev-1', plugins: { 'model-provider': providers }, available: {} };
if (verb === 'proxy.accounts') { if (accounts) throw accounts; if (!client) throw busError('not-configured'); return { accounts: [] }; }
if (verb === 'plugins.set') { if (set) throw set; providers = args.plugins['model-provider']; return { revision: 'rev-2' }; }
throw new Error(`unexpected ${verb}`);
};
return { call, calls };
}
function admin(t, { riders, ownerModels, move, unitState } = {}) {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const state = unitState ?? { installed: false, active: 'inactive', healthy: false };
const unit = { unit: 'mosaic-proxy-zz.service', status: async () => ({ unit: 'mosaic-proxy-zz.service', ...state }) };
const sha = text => createHash('sha256').update(text).digest('hex');
const pin = { ...PIN, archive: { ...PIN.archive, sha256: sha('a') }, binary: { sha256: sha('b') }, panel: { ...PIN.panel, sha256: sha('p') } };
const a = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, fetch: async () => ({}), now: () => new Date(0), pin,
...(riders ? { riders } : {}), ...(ownerModels ? { ownerModels } : {}), ...(move !== undefined ? { move } : {}) });
return { admin: a, configDir, dataRoot, pin, state };
}
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
test('a change log shows cliproxy removed only when a committed write took it off', () => {
assert.equal(cliproxyRemoved(''), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }])), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }])), true);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins', old: { 'model-provider': ['cliproxy'] }, new: { 'model-provider': ['fixture'] } }])), true);
assert.equal(cliproxyRemoved(JSON.stringify({ state: 'staged', changes: [{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }] }) + '\n'), false, 'a write that did not commit removed nothing');
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }, { path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]) ), true, 'a removal stays a removal once seen');
assert.equal(cliproxyRemoved('{not json\n'), null);
assert.equal(cliproxyRemoved(null), null);
});
test('the local rule names unreadable, removed, fixture, already and ready in that order', () => {
const removed = committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]);
assert.equal(localRide({ fixture: undefined, cliproxy: false, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: undefined, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: null }), 'unreadable');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: removed }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '' }), 'fixture');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '' }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '' }), 'ready');
// Review round: an organization that uses cliproxy now is already riding, whatever its history.
assert.equal(localRide({ fixture: false, cliproxy: true, changes: removed }), 'already', 'removed once and added back');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: null }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
// The proxy's receipts show it put cliproxy on the organization, and it lacks cliproxy now.
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: true }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: null }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: null }), 'already');
});
test('the proxy receipts name each organization ride all added, tried to add, moved or saw removed', () => {
const lines = records => records.map(r => JSON.stringify(r)).join('\n') + '\n';
const text = lines([{ op: 'ride-all', added: ['a', 'b'], skipped: [{ id: 'c', reason: 'bus-down' }], fixtures: ['d'] }, { op: 'ride-move', org: 'e', model: 'm' },
{ op: 'fetch', added: ['f'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-removed', org: 'h' }]);
assert.deepEqual([...riddenOrgs(text)].sort(), ['a', 'b', 'e', 'g', 'h']);
assert.deepEqual([...riddenOrgs('')], []);
assert.equal(riddenOrgs(null), null);
// Round 3 (P2a): a line that does not parse, or a ride record of the wrong shape, fails closed.
assert.equal(riddenOrgs(text + '{torn'), null, 'a torn line');
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: [7] }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: 'a' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-intent' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-removed', org: 3 }])), null);
assert.equal(riddenOrgs('7\n'), null, 'a line that is not a record');
// Round 3 (P2b): an intent the bus then showed was not applied is cleared, and only that intent.
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], []);
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-all', added: ['g'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier add stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-removed', org: 'g' }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier removal stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-not-added', org: 'g' }, { op: 'ride-intent', org: 'g' }]))], ['g'], 'a later intent stands');
});
test('a change log that shows cliproxy on the organization at any time, or a write to its providers it cannot read, counts as removed once cliproxy is gone', () => {
// Round 3 (P1 case b): added on the Settings page, then removed on the admin page, which writes no log entry.
const added = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
assert.equal(localRide({ fixture: false, cliproxy: false, changes: added }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: added }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: added }), 'fixture', 'a fixture organization that lists cliproxy is still listed to move');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins', old: null, new: { 'model-provider': ['cliproxy'] } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: '', old: null, new: { plugins: { 'model-provider': ['cliproxy'] } } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', oldPresent: true, newPresent: true }]) }), 'removed', 'a paths-only write to the providers');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'roles.chief.vars', oldPresent: true, newPresent: true }]) }), 'ready', 'a paths-only write elsewhere');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['openai'] }]) }), 'ready');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: JSON.stringify({ state: 'aborted', changes: [{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }] }) + '\n' }), 'ready', 'a write that did not commit');
});
test('the reviewer probe: an organization created from the cliproxy preset and saved without it on its admin page is skipped as removed', async t => {
// P1 case a. Nothing in the change log: the preset made it, the admin page took it off. The
// admin page leaves a ride-removed receipt (proxy admin rideRemoved) before it saves.
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'p', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.equal(a.rideRemoved('p').op, 'ride-removed');
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 'p', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(dataRoot).filter(x => x.op === 'ride-removed').map(x => x.org), ['p']);
assert.throws(() => a.rideRemoved('../x'), /proxy-org-invalid|invalid/);
});
test('the reviewer probe: an organization added on the Settings page and removed on its admin page is skipped as removed', async t => {
// P1 case b, with no ride-removed receipt at all: the change log's add is enough.
const b = bus({ providers: [] });
const log = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
const { admin: a } = admin(t, { riders: async () => [{ id: 's', fixture: false, cliproxy: false, changes: log, call: b.call }] });
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 's', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('each add leaves its intent receipt before plugins.set, and an add whose outcome is unknown stays recorded', async t => {
// P2b. The bus reads the receipts at the moment of the write.
let seen = null, dataRootOf = null;
const order = [];
const watching = id => { const b = bus({ providers: [] }); const call = async (verb, args) => { if (verb === 'plugins.set') { order.push(id); seen = receipts(dataRootOf()).map(r => `${r.op}:${r.org ?? ''}`); } return b.call(verb, args); }; return { ...b, call }; };
const one = watching('one'), two = watching('two');
const f = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: one.call }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: two.call }] });
dataRootOf = () => f.dataRoot;
await f.admin.rideAll();
assert.deepEqual(order, ['one', 'two']);
assert.deepEqual(seen, ['ride-intent:one', 'ride-intent:two'], 'the first add is on record before the second starts');
// Probe C: plugins.set commits, then the call times out. The bus shows cliproxy, so the intent stands.
let providers = [];
const timeout = { calls: [], call: async (verb, args) => {
if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': providers } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { providers = args.plugins['model-provider']; throw busError('timeout'); }
} };
let cp = false;
const c = admin(t, { riders: async () => [{ id: 't', fixture: false, cliproxy: cp, changes: '', call: timeout.call }] });
const first = await c.admin.rideAll();
assert.deepEqual(first.skipped, [{ id: 't', reason: 'timeout' }]);
assert.deepEqual(receipts(c.dataRoot).filter(r => r.org === 't').map(r => r.op), ['ride-intent']);
providers = []; // the owner took it off
assert.deepEqual((await c.admin.rideAll()).skipped, [{ id: 't', reason: 'removed' }]);
// A refusal the bus shows was not applied clears the intent, so the organization can ride later.
const refusedBus = bus({ providers: [], set: busError('revision-conflict') });
const d = admin(t, { riders: async () => [{ id: 'q', fixture: false, cliproxy: false, changes: '', call: refusedBus.call }] });
assert.deepEqual((await d.admin.rideAll()).skipped, [{ id: 'q', reason: 'revision-conflict' }]);
assert.deepEqual(receipts(d.dataRoot).filter(r => r.org === 'q').map(r => r.op), ['ride-intent', 'ride-not-added']);
assert.deepEqual((await d.admin.status()).ride, [{ id: 'q', state: 'ready' }]);
// A bus that does not answer the re-read leaves the intent: the add may have happened.
let gone = false;
const lost = { call: async (verb, args) => { if (gone) throw busError('no-bus-host'); if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': [] } }; if (verb === 'proxy.accounts') return { accounts: [] }; if (verb === 'plugins.set') { gone = true; throw busError('timeout'); } } };
const e = admin(t, { riders: async () => [{ id: 'l', fixture: false, cliproxy: false, changes: '', call: lost.call }] });
await e.admin.rideAll();
assert.deepEqual(receipts(e.dataRoot).filter(r => r.org === 'l').map(r => r.op), ['ride-intent']);
});
test('a removal saved while Ride all works on earlier organizations is read before the later add', async t => {
// Re-check 3, P3-1: the run's first read of the receipts showed nothing for 'late'. While the run
// reads 'first', the owner takes cliproxy off 'late' on its admin page (a ride-removed receipt).
let a = null;
const first = bus({ providers: [] }), late = bus({ providers: [] });
const firstCall = async (verb, args) => { if (verb === 'plugins') a.rideRemoved('late'); return first.call(verb, args); };
const f = admin(t, { riders: async () => [{ id: 'first', fixture: false, cliproxy: false, changes: '', call: firstCall }, { id: 'late', fixture: false, cliproxy: false, changes: '', call: late.call }] });
a = f.admin;
const r = await a.rideAll();
assert.deepEqual(r.added, ['first']); assert.deepEqual(r.skipped, [{ id: 'late', reason: 'removed' }]);
assert.equal(late.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(f.dataRoot).filter(x => x.org === 'late').map(x => x.op), ['ride-removed']);
// Receipts that turn unreadable during the run skip the later add as unreadable.
const g1 = bus({ providers: [] }), g2 = bus({ providers: [] });
let g = null;
const tear = async (verb, args) => { if (verb === 'plugins') { appendReceipt(g.dataRoot, { op: 'fetch' }); fs.appendFileSync(receiptFile(g.dataRoot), '{torn\n'); } return g1.call(verb, args); };
g = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: tear }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: g2.call }] });
const s = await g.admin.rideAll();
assert.deepEqual(s.skipped, [{ id: 'one', reason: 'unreadable' }, { id: 'two', reason: 'unreadable' }]);
assert.equal(g2.calls.some(([v]) => v === 'plugins.set'), false);
});
test('settings-p3 R1: the change log is read again before each add, and a read that fails skips the add', async t => {
// While Ride all works on 'first', the owner adds cliproxy to 'late' on its Settings page and takes it
// off again. Only its change log shows that; the receipts do not. The run's first read showed nothing.
let lateLog = '';
const first = bus({ providers: [] }), late = bus({ providers: [] });
const firstCall = async (verb, args) => { if (verb === 'plugins') lateLog = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]) + committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]); return first.call(verb, args); };
const f = admin(t, { riders: async () => [{ id: 'first', fixture: false, cliproxy: false, changes: '', call: firstCall }, { id: 'late', fixture: false, cliproxy: false, changes: lateLog, call: late.call }] });
const r = await f.admin.rideAll();
assert.deepEqual(r.added, ['first']); assert.deepEqual(r.skipped, [{ id: 'late', reason: 'removed' }]);
assert.equal(late.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(f.dataRoot).filter(x => x.org === 'late').map(x => x.op), []);
// Fail closed: a change log that can no longer be read, an organization that is no longer listed,
// or a list that can't be read again skips the add as unreadable, with no intent and no plugins.set.
for (const [name, again] of [
['log unreadable', b => [{ id: 'o', fixture: false, cliproxy: false, changes: null, call: b.call }]],
['no longer listed', () => []],
['list throws', () => { throw new Error('read failed'); }],
]) {
const b = bus({ providers: [] });
let reads = 0;
const g = admin(t, { riders: async () => (reads++ === 0 ? [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: b.call }] : again(b)) });
assert.deepEqual((await g.admin.rideAll()).skipped, [{ id: 'o', reason: 'unreadable' }], name);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false, name);
assert.deepEqual(receipts(g.dataRoot).filter(x => x.op === 'ride-intent'), [], name);
}
});
test('settings-p3 review P3-1: an organization that took cliproxy during the run reads as already using it, with no add', async t => {
const b = bus({ providers: [] });
let reads = 0;
const f = admin(t, { riders: async () => [{ id: 'o', fixture: false, cliproxy: reads++ > 0, changes: '', call: b.call }] });
const r = await f.admin.rideAll();
assert.deepEqual([r.added, r.already, r.skipped], [[], ['o'], []]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(f.dataRoot).filter(x => x.op === 'ride-intent'), []);
});
test('an intent receipt that cannot be written stops that add before plugins.set', async t => {
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'w', fixture: false, cliproxy: false, changes: '', call: b.call }] });
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.chmodSync(receiptFile(f.dataRoot), 0o400); // readable by its owner only, not writable
const r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'w', reason: 'not-recorded' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('receipts that are torn, a symlink, not the owner\'s or open to others are unreadable, and every organization without cliproxy is skipped', async t => {
// P2a and P3 (probes D and E).
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'z', fixture: false, cliproxy: false, changes: '', call: b.call }, { id: 'y', fixture: false, cliproxy: true, changes: '', call: b.call }] });
const file = receiptFile(f.dataRoot);
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.appendFileSync(file, '{"op":"ride-all","added":["z"]');
let r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'z', reason: 'unreadable' }], 'torn'); assert.deepEqual(r.already, ['y']);
fs.rmSync(file); fs.writeFileSync(join(f.dataRoot, 'state', 'empty'), '', { mode: 0o600 });
fs.symlinkSync(join(f.dataRoot, 'state', 'empty'), file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'symlink');
assert.equal(fs.lstatSync(file).isSymbolicLink(), true);
fs.rmSync(file); fs.writeFileSync(file, '', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'group-readable');
fs.rmSync(file); fs.mkdirSync(file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'not a file');
fs.rmSync(file, { recursive: true });
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual((await f.admin.rideAll()).added, ['z'], 'no receipt file is no history');
});
test('the receipts are read only when the Console\'s own user owns them', t => {
const f = admin(t);
appendReceipt(f.dataRoot, { op: 'ride-removed', org: 'p' });
assert.match(receiptsText(f.dataRoot), /"ride-removed"/);
assert.equal(receiptsText(f.dataRoot, { uid: process.getuid() + 1 }), null, 'another user\'s file');
});
test('a FIFO in place of the receipts is unreadable and never blocks the read', t => {
const f = admin(t);
fs.mkdirSync(join(f.dataRoot, 'state'), { mode: 0o700 });
execFileSync('mkfifo', ['-m', '600', receiptFile(f.dataRoot)]);
assert.equal(receiptsText(f.dataRoot), null);
});
test('the change log read takes the writer\'s rule: group readable is fine, group writable, a symlink or a missing file is not', t => {
const dir = fs.mkdtempSync(join(tmpdir(), 'rdo-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const file = join(dir, 'changes.jsonl'); fs.writeFileSync(file, 'x\n', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.equal(ownedText(file, { mask: 0o022 }), 'x\n');
fs.chmodSync(file, 0o660);
assert.throws(() => ownedText(file, { mask: 0o022 }), { code: 'proxy-file-refused' });
fs.chmodSync(file, 0o600); fs.symlinkSync(file, join(dir, 'link'));
assert.throws(() => ownedText(join(dir, 'link'), { mask: 0o022 }), { code: 'ELOOP' });
assert.throws(() => ownedText(join(dir, 'gone'), { mask: 0o022 }), { code: 'ENOENT' });
// readRider, as the Console wires it: a refused log is unreadable, a missing one is empty.
const doc = { plugins: { 'model-provider': [] } };
fs.chmodSync(file, 0o660);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(file, { mask: 0o022 }), isFixture: () => false }).changes, null);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(join(dir, 'gone'), { mask: 0o022 }), isFixture: () => false }).changes, '');
});
test('a fixture organization that uses cliproxy now, with a removal in its log, is removed, not movable', () => {
const log = committed([{ path: 'plugins.model-provider', old: ['fixture', 'cliproxy'], new: ['fixture'] }]) + committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }]);
assert.equal(localRide({ fixture: true, cliproxy: true, changes: log }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
});
test('an organization ride all once added and its owner then saved without cliproxy is skipped as removed', async t => {
// The organization's file as the Console reads it. The organization admin page saves a whole
// document and writes no change-log entry, so the log stays empty after the owner's removal.
let cliproxy = false;
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'a', fixture: false, cliproxy, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['a']);
cliproxy = true;
assert.deepEqual((await a.rideAll()).already, ['a']);
cliproxy = false; // the owner saved the organization without cliproxy on its admin page
const second = await a.rideAll();
assert.deepEqual(second.skipped, [{ id: 'a', reason: 'removed' }], JSON.stringify(second));
assert.equal(b.calls.filter(([verb]) => verb === 'plugins.set').length, 1, 'no second write');
assert.deepEqual((await a.status()).ride, [{ id: 'a', state: 'removed' }]);
// A fixture organization the proxy once moved, and its owner then put back on stand-in models, is not moved again.
const moved = { id: 'f', fixture: true, cliproxy: false, changes: '', call: bus({ down: true }).call };
const m = admin(t, { riders: async () => [moved], ownerModels: async () => ({ proxy: true, riding: true, models: [row()] }), move: async () => ({ moved: true, model: row().key }) });
appendReceipt(m.dataRoot, { op: 'ride-move', org: 'f', model: row().key });
assert.deepEqual(await m.admin.rideMove({ org: 'f' }), { org: 'f', moved: false, reason: 'removed' });
// Receipts that cannot be read name every organization without cliproxy unreadable.
fs.chmodSync(receiptFile(dataRoot), 0o200);
assert.deepEqual((await a.rideAll()).skipped, [{ id: 'a', reason: 'unreadable' }]);
});
test('the owner model is a usable catalogue row that serves every harness, claude first', () => {
assert.equal(pickModel([glm, row()]).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm]).key, 'zai-glm-5-3');
assert.equal(pickModel([glm, row()], ['claude-code']).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm], ['claude-code']), null);
assert.equal(pickModel([row({ available: false }), row({ reason: 'unverified' }), row({ module: 'fixture' })]), null, 'a model the catalogue does not offer is never picked');
assert.equal(pickModel(null), null);
});
test('ride all adds cliproxy through plugins.set and skips and names each organization it must not change', async t => {
const ready = bus({ providers: [] }), noClient = bus({ providers: [], client: false }), down = bus({ down: true }), checkFails = bus({ providers: [], accounts: busError('proxy-down') });
const refused = bus({ providers: [], set: busError('revision-conflict') }), alreadyBus = bus({ providers: ['cliproxy'] }), removedBus = bus({ providers: [] }), fixtureBus = bus({ down: true });
const unreadable = bus({ providers: [] }), raced = bus({ providers: ['cliproxy'] });
const riders = async () => [
{ id: 'ready', fixture: false, cliproxy: false, changes: '', call: ready.call },
{ id: 'removed', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: removedBus.call },
{ id: 'down', fixture: false, cliproxy: false, changes: '', call: down.call },
{ id: 'noclient', fixture: false, cliproxy: false, changes: '', call: noClient.call },
{ id: 'checkfails', fixture: false, cliproxy: false, changes: '', call: checkFails.call },
{ id: 'refused', fixture: false, cliproxy: false, changes: '', call: refused.call },
{ id: 'already', fixture: false, cliproxy: true, changes: '', call: alreadyBus.call },
{ id: 'raced', fixture: false, cliproxy: false, changes: '', call: raced.call },
{ id: 'unreadable', fixture: undefined, cliproxy: undefined, changes: '', call: unreadable.call },
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: fixtureBus.call, status: async () => ({ pid: null }) },
];
const { admin: a, dataRoot } = admin(t, { riders });
const result = await a.rideAll();
assert.deepEqual(result.added, ['ready']);
assert.deepEqual(result.already, ['already', 'raced']);
assert.deepEqual(result.skipped, [
{ id: 'removed', reason: 'removed' }, { id: 'down', reason: 'bus-down' }, { id: 'noclient', reason: 'no-proxy-client' },
{ id: 'checkfails', reason: 'proxy-check-failed' }, { id: 'refused', reason: 'revision-conflict' }, { id: 'unreadable', reason: 'unreadable' },
]);
assert.deepEqual(result.fixtures, [{ id: 'stand-in', running: false }]);
assert.deepEqual(ready.calls.find(([v]) => v === 'plugins.set'), ['plugins.set', { revision: 'rev-1', plugins: { 'model-provider': ['cliproxy'] } }]);
for (const [name, b] of Object.entries({ removedBus, down, noClient, checkFails, alreadyBus, raced, unreadable, fixtureBus }))
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false, `${name} gets no write`);
assert.equal(JSON.stringify(result).includes('must not leak'), false);
const last = receipts(dataRoot).at(-1);
assert.equal(last.op, 'ride-all'); assert.deepEqual(last.added, ['ready']); assert.deepEqual(last.fixtures, ['stand-in']);
});
test('ride all keeps the providers an organization already has', async t => {
const b = bus({ providers: ['openai'] });
const { admin: a } = admin(t, { riders: async () => [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['o']);
assert.deepEqual(b.calls.find(([v]) => v === 'plugins.set')[1].plugins, { 'model-provider': ['openai', 'cliproxy'] });
});
test('status names ride all after accounts while an organization can still ride', async t => {
let list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
const f = admin(t, { riders: async () => list, unitState: { installed: true, active: 'active', healthy: true, pid: 3 } });
const binDir = join(f.dataRoot, 'opt', 'cliproxyapi', PIN.version);
fs.mkdirSync(join(binDir, 'static'), { recursive: true });
fs.writeFileSync(join(binDir, 'cli-proxy-api'), 'b'); fs.writeFileSync(join(binDir, 'static', 'management.html'), 'p');
const files = initFiles(f.configDir, f.dataRoot);
fs.mkdirSync(join(f.configDir, 'secrets'), { mode: 0o700 }); fs.writeFileSync(files.key, 'fixture', { mode: 0o600 });
fs.mkdirSync(files.proxyDir, { mode: 0o700 });
fs.writeFileSync(files.settings, JSON.stringify({ binary: join(binDir, 'cli-proxy-api'), port: 18432 }), { mode: 0o600 });
let status = await f.admin.status();
assert.deepEqual(status.next, ['accounts', 'ride-all']);
assert.deepEqual(status.ride, [{ id: 'o', state: 'ready' }]);
list = [{ id: 'o', fixture: true, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts', 'ride-all'], 'a fixture organization can still be moved');
list = [{ id: 'o', fixture: false, cliproxy: true, changes: '', call: bus().call }];
status = await f.admin.status();
assert.deepEqual(status.next, ['accounts']);
list = [{ id: 'o', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts'], 'a removed organization is not a reason to ride');
f.state.healthy = false;
list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['unit-restart'], 'never before the proxy answers');
});
test('a fixture organization moves only when stopped, with a proxy, a riding bus and a move seam', async t => {
const owner = { proxy: true, riding: true, models: [row()] };
const moves = [];
const move = async (id, models, principal) => { moves.push({ id, models, principal }); return { moved: true, model: models[0].key }; };
let stoppedBus = bus({ down: true }), runningBus = bus();
// Round 3 (P2c): stopped is the organization admin page's test, a bus status with no process id.
const stopped = async () => ({ healthy: false, pid: null }), running = async () => ({ healthy: true, pid: 4242 });
const riders = async () => [
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
{ id: 'live', fixture: true, cliproxy: false, changes: '', call: runningBus.call, status: running },
{ id: 'busy', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => ({ healthy: false, pid: 4343 }) },
{ id: 'unproven', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => { throw busError('stale-host'); } },
{ id: 'no-status', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call },
{ id: 'real', fixture: false, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
];
let ownerNow = owner;
const f = admin(t, { riders, ownerModels: async () => ownerNow, move });
const principal = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' };
assert.deepEqual(await f.admin.rideMove({ org: 'nope', principal }), { org: 'nope', moved: false, reason: 'unknown' });
assert.deepEqual(await f.admin.rideMove({ org: 'real', principal }), { org: 'real', moved: false, reason: 'ready' });
assert.deepEqual(await f.admin.rideMove({ org: 'live', principal }), { org: 'live', moved: false, reason: 'bus-running' });
// A slow or busy bus that does not answer, or a status that cannot be read, is running.
for (const org of ['busy', 'unproven']) assert.deepEqual(await f.admin.rideMove({ org, principal }), { org, moved: false, reason: 'bus-running' }, org);
// settings-p3 R2: no status at all (the single-business Console) can never show the bus stopped, so
// "stop its bus" would not help: moving is not available there, and whether it runs is unknown.
assert.deepEqual(await f.admin.rideMove({ org: 'no-status', principal }), { org: 'no-status', moved: false, reason: 'not-available' });
const listed = await f.admin.rideAll();
assert.deepEqual(listed.fixtures, [{ id: 'stand-in', running: false }, { id: 'live', running: true }, { id: 'busy', running: true }, { id: 'unproven', running: true }, { id: 'no-status', running: null }]);
// settings-p3 review P3-3: the status summary says so before any run, without asking any bus.
assert.deepEqual((await f.admin.status()).ride.filter(r => r.state === 'fixture'), [{ id: 'stand-in', state: 'fixture' }, { id: 'live', state: 'fixture' }, { id: 'busy', state: 'fixture' }, { id: 'unproven', state: 'fixture' }, { id: 'no-status', state: 'fixture', running: null }]);
ownerNow = { ...owner, proxy: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-proxy' });
ownerNow = { ...owner, riding: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-riding-bus' });
assert.equal(moves.length, 0);
ownerNow = owner;
const done = await f.admin.rideMove({ org: 'stand-in', principal });
assert.equal(done.moved, true); assert.equal(done.model, 'claude-claude-opus-5-5');
assert.deepEqual(moves, [{ id: 'stand-in', models: [row()], principal }]);
const last = receipts(f.dataRoot).at(-1);
assert.deepEqual({ op: last.op, org: last.org, model: last.model }, { op: 'ride-move', org: 'stand-in', model: 'claude-claude-opus-5-5' });
const none = admin(t, { riders, ownerModels: async () => owner, move: null });
assert.deepEqual(await none.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'not-available' });
const throws = admin(t, { riders, ownerModels: async () => owner, move: async () => { throw Object.assign(new Error('raw text'), { code: 'revision-conflict' }); } });
assert.deepEqual(await throws.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'revision-conflict' });
});
test('the fixture move rewrites the model provider, the model entry and every role that used it', async () => {
const doc = await orgService.templateRender('alpha', { fixture: 'local' });
Object.assign(doc.roles.assistant.vars, { 'fallback.harness': 'pi', 'fallback.model': 'fixture-deterministic', 'fallback.thinking': 'off' });
doc.projects.work.agents = { helper: { definition: 'coder', vars: { harness: 'pi', model: 'fixture-deterministic', thinking: 'off' } } };
assert.deepEqual(await orgService.validateOrg(doc), { ok: true, errors: [] });
assert.equal(orgUsesFixture(doc), true);
const { doc: next, model } = fixtureMove(doc, [glm, row()]);
assert.equal(model.key, 'claude-claude-opus-5-5', 'the fixture assistant runs pi; of the models that serve pi, claude comes first');
assert.equal(orgUsesFixture(next), false);
assert.deepEqual(next.plugins['model-provider'], ['cliproxy']);
assert.deepEqual(next.launch.models, { 'claude-claude-opus-5-5': { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' } });
assert.equal(next.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars['fallback.model'], 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars.harness, 'pi', 'the harness is left as it was');
assert.equal(next.projects.work.agents.helper.vars.model, 'claude-claude-opus-5-5', 'a project\'s own agent moves too');
assert.deepEqual(await orgService.validateOrg(next), { ok: true, errors: [] });
const zai = fixtureMove(doc, [glm]);
assert.equal(zai.model.key, 'zai-glm-5-3');
assert.deepEqual(zai.doc.launch.models, { 'zai-glm-5-3': { provider: 'zai', model: 'glm-5.3', module: 'cliproxy', upstream: 'zai' } });
assert.deepEqual(await orgService.validateOrg(zai.doc), { ok: true, errors: [] });
assert.equal(doc.plugins['model-provider'][0], 'fixture', 'the input is not changed');
assert.deepEqual(fixtureMove(doc, [row({ harnesses: ['claude-code'] })]), { reason: 'no-model' }, 'a model that cannot serve the harness is not used');
assert.deepEqual(fixtureMove(doc, [row({ available: false, harnesses: ['pi'] })]), { reason: 'no-model' }, 'a model the catalogue does not offer is not used');
});
test('the fixture move writes through the organization service as the owner, and only at the revision read', async () => {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-svc-'));
try {
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const ctx = { configDir, dataRoot, instance: 'test', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } };
await orgService.createOrg(ctx, 'alpha', await orgService.templateRender('alpha', { fixture: 'local' }));
const stranger = { ...ctx, principal: { provider: 'sso', iss: 'https://idp.invalid', sub: 'someone' } };
await assert.rejects(moveFixtureOrg({ service: orgService, ctx: stranger, id: 'alpha', models: [row()] }));
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'a stranger moved nothing');
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row({ harnesses: ['claude-code'] })] }), { moved: false, reason: 'no-model' });
// A moved document the service does not accept is not written.
const refusing = { ...orgService, validateOrg: async () => ({ ok: false, errors: [{ path: '$', message: 'no' }] }) };
assert.deepEqual(await moveFixtureOrg({ service: refusing, ctx, id: 'alpha', models: [row()] }), { moved: false, reason: 'invalid' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'an invalid move wrote nothing');
// A write between the read and the update loses: the service refuses the stale revision.
const racing = { ...orgService, validateOrg: async d => { const now = await orgService.showOrg(ctx, 'alpha'); await orgService.updateOrg(ctx, 'alpha', now.doc, { ifRevision: now.revision }); return orgService.validateOrg(d); } };
await assert.rejects(moveFixtureOrg({ service: racing, ctx, id: 'alpha', models: [row()] }), { code: 'revision-conflict' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true);
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row()] }), { moved: true, model: 'claude-claude-opus-5-5' });
const after = (await orgService.showOrg(ctx, 'alpha')).doc;
assert.equal(orgUsesFixture(after), false);
assert.deepEqual(after.plugins['model-provider'], ['cliproxy']);
assert.equal(after.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.deepEqual(after.launch.models['claude-claude-opus-5-5'], { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' });
} finally { fs.rmSync(root, { recursive: true, force: true }); }
});
test('an organization is read from its file and change log; a missing log is empty and any other failure unreadable', () => {
const enoent = () => { throw Object.assign(new Error('missing'), { code: 'ENOENT' }); };
const eacces = () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); };
const doc = providers => ({ plugins: { 'model-provider': providers } });
assert.deepEqual(readRider({ id: 'a', read: () => doc(['cliproxy']), readLog: () => 'log', isFixture: () => false }), { id: 'a', fixture: false, cliproxy: true, changes: 'log' });
assert.deepEqual(readRider({ id: 'b', read: () => doc(['fixture']), readLog: enoent, isFixture: () => true }), { id: 'b', fixture: true, cliproxy: false, changes: '' });
assert.deepEqual(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false }), { id: 'c', fixture: false, cliproxy: false, changes: null });
const unread = readRider({ id: 'd', read: () => { throw new Error('bad json'); }, readLog: () => '', isFixture: () => true });
assert.deepEqual(unread, { id: 'd', fixture: undefined, cliproxy: undefined, changes: '' });
assert.equal(localRide(unread), 'unreadable');
assert.equal(localRide(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false })), 'unreadable');
// The real fixture test decides the fixture field.
assert.equal(readRider({ id: 'e', read: () => doc(['fixture']), readLog: () => '', isFixture: orgUsesFixture }).fixture, true);
});
test('the owner models come only from riding buses that answer a ready catalogue, cliproxy rows once each', async () => {
const asked = [];
const rider = (id, cliproxy, answer) => ({ id, cliproxy, call: async verb => { asked.push([id, verb]); if (answer instanceof Error) throw answer; return answer; } });
const ready = models => ({ catalogue: { status: 'ready', models } });
assert.deepEqual(await ownerModelsFrom({ proxy: false, riders: [rider('a', true, ready([row()]))] }), { proxy: false, riding: false, models: [] });
assert.deepEqual(asked, [], 'no proxy asks no bus');
const fixtureRow = row({ key: 'fixture-deterministic', module: 'fixture' });
const answer = await ownerModelsFrom({ proxy: true, riders: [
rider('a', true, ready([row(), fixtureRow])), rider('b', true, ready([row({ label: 'later copy' }), glm])), rider('c', false, ready([row({ key: 'not-riding' })])),
rider('d', true, { catalogue: { status: 'unavailable', models: [row({ key: 'fenced' })] } }), rider('e', true, busError('no-bus-host')),
] });
assert.deepEqual(answer, { proxy: true, riding: true, models: [row(), glm] });
assert.deepEqual(asked.map(([id]) => id).sort(), ['a', 'b', 'd', 'e'], 'only organizations that list cliproxy are asked');
assert.deepEqual(await ownerModelsFrom({ proxy: true, riders: [rider('d', true, { catalogue: { status: 'unavailable', models: [] } }), rider('e', true, busError('no-bus-host'))] }), { proxy: true, riding: false, models: [] });
// A hung bus does not hold the others back: they are asked together.
let release; const hung = { id: 'h', cliproxy: true, call: () => new Promise(r => { release = r; }) };
const pending = ownerModelsFrom({ proxy: true, riders: [hung, rider('a', true, ready([row()]))] });
await new Promise(r => setImmediate(r));
assert.equal(asked.filter(([id]) => id === 'a').length, 2, 'the second bus was asked while the first hung');
release(null); assert.deepEqual((await pending).models, [row()]);
// Review round: a key one bus lists as unavailable and another as usable keeps the usable row.
const stale = row({ available: false, reason: 'proxy-down', label: 'stale' });
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('s', true, ready([stale])), rider('a', true, ready([row()]))] })).models, [row()]);
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('a', true, ready([row()])), rider('s', true, ready([stale]))] })).models, [row()]);
});