509 lines
38 KiB
JavaScript
509 lines
38 KiB
JavaScript
// #1873 Proxy setup routes over the real HTTP boundary: only the instance owner reaches them, a
|
|
// pasted key crosses only loopback or HTTPS, and no key reaches a response or a log line.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { request } from 'node:http';
|
|
import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { startServer } from '../src/serve.mjs';
|
|
import { createDevOwner } from '../src/dev-owner.mjs';
|
|
import { PROXY_ADMIN_PATHS, keyTransportOk, orgCatalogue } from '../src/proxy-admin.mjs';
|
|
import { consoleAccess } from '../src/access.mjs';
|
|
import { createSsoSession } from './helpers/sso-session.mjs';
|
|
import { REFUSALS } from '../../bus/src/refusals.mjs';
|
|
|
|
const SENTINEL = 'pa-http-sentinel-key-0123456789abcdef';
|
|
const ROUTES = [
|
|
['status', 'GET'], ['unit/render', 'GET'], ['fetch', 'POST', {}], ['init', 'POST', { generate: true }],
|
|
['unit/install', 'POST', {}], ['unit/start', 'POST', {}], ['unit/stop', 'POST', {}], ['unit/restart', 'POST', {}],
|
|
['fence/clear', 'POST', {}], ['init-lock/clear', 'POST', {}],
|
|
// #1873 ride-default: Ride all, and the move of one stopped fixture organization.
|
|
['ride-all', 'POST', {}], ['ride-move', 'POST', { org: 'stand-in' }],
|
|
// #1873 settings-backend A1: the model service log, the service key's made-at time, setup history.
|
|
['log', 'GET'], ['service-key', 'GET'], ['history', 'GET'],
|
|
// #1873 settings-backend A2: one program off for every organization, and access health.
|
|
['programs/off', 'POST', { name: 'alpha' }], ['access', 'GET'],
|
|
];
|
|
const A2 = ROUTES.filter(([p]) => ['programs/off', 'access'].includes(p));
|
|
const READS = ROUTES.filter(([p]) => ['log', 'service-key', 'history'].includes(p));
|
|
|
|
function fakeAdmin() {
|
|
const calls = [];
|
|
const note = name => async (...args) => { calls.push([name, ...args.filter(a => typeof a !== 'function')]); return { ok: name }; };
|
|
return {
|
|
calls,
|
|
unit: 'mosaic-proxy.service',
|
|
status: note('status'), render: note('render'), unitAction: note('unitAction'), initLockClear: note('initLockClear'), rideAll: note('rideAll'),
|
|
rideMove: async args => { calls.push(['rideMove', args]); return { org: args.org, moved: false, reason: 'bus-running' }; },
|
|
fetchStart: () => { calls.push(['fetchStart']); return { state: 'running' }; },
|
|
init: async (call, args) => { calls.push(['init', args]); await call('proxy.init', args); return { settings: { port: 18432 }, receipt: { op: 'init' } }; },
|
|
fenceClear: async call => { calls.push(['fenceClear']); return call('proxy.fence.clear', { evidence: {} }); },
|
|
log: async args => { calls.push(['log', args]); return { unit: 'mosaic-proxy.service', lines: ['ok'], redacted: 0, dropped: 0 }; },
|
|
serviceKey: () => { calls.push(['serviceKey']); return { madeAt: '2026-11-01T08:00:00.000Z', renewedAt: null, renewal: 'not-built', problem: null }; },
|
|
history: args => { calls.push(['history', args]); return { entries: [], next: null }; },
|
|
recordAccount: entry => { calls.push(['recordAccount', entry]); return true; },
|
|
programsOff: async args => { calls.push(['programsOff', args]); return { name: args.name, results: [], receipt: null }; },
|
|
access: async () => { calls.push(['access']); return { organizations: [] }; },
|
|
};
|
|
}
|
|
const send = (port, path, { method = 'GET', headers = {}, body } = {}) => new Promise((resolve, reject) => {
|
|
const req = request({ host: '127.0.0.1', port, path, method, headers }, res => {
|
|
let text = ''; res.on('data', c => { text += c; }); res.on('end', () => resolve({ status: res.statusCode, text, json: (() => { try { return JSON.parse(text); } catch { return null; } })() }));
|
|
});
|
|
req.on('error', reject); req.end(body === undefined ? undefined : typeof body === 'string' ? body : JSON.stringify(body));
|
|
});
|
|
|
|
async function devServer(t, options = {}) {
|
|
const admin = fakeAdmin(), busCalls = [], logs = [];
|
|
const s = await startServer({ port: 0, board: 'http://127.0.0.1:9', sso: createDevOwner(), send: async () => ({}), proxyAdmin: admin,
|
|
proxyCall: async (verb, args) => { busCalls.push([verb, args]); return { cleared: true }; }, log: line => logs.push(line), ...options });
|
|
t.after(() => new Promise(r => s.close(r)));
|
|
const port = s.address().port;
|
|
const hostFor = name => `${name}:${port}`;
|
|
const headers = (name = '127.0.0.1') => ({ host: hostFor(name), origin: `http://${hostFor(name)}`, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' });
|
|
return { s, port, admin, busCalls, logs, headers };
|
|
}
|
|
const hit = (f, route, extra = {}) => send(f.port, `/api/proxy/admin/${route[0]}`, { method: route[1], headers: { ...f.headers(), ...extra }, body: route[2] });
|
|
|
|
test('the route table is exactly the brief: status, render, fetch, init, four unit verbs, fence clear, lock clear, ride all, ride move, log, service key, history, programs off, access', () => {
|
|
assert.deepEqual(PROXY_ADMIN_PATHS, ROUTES.map(([p]) => `/api/proxy/admin/${p}`));
|
|
});
|
|
|
|
test('the dev local owner reaches every route; init and fence clear go to the bus; the page config offers setup', async t => {
|
|
const f = await devServer(t);
|
|
for (const route of ROUTES) {
|
|
const r = await hit(f, route);
|
|
assert.equal(r.status, route[0] === 'fetch' ? 202 : 200, route[0]);
|
|
}
|
|
assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear', 'rideAll', 'rideMove', 'log', 'serviceKey', 'history', 'programsOff', 'access']);
|
|
assert.deepEqual(f.admin.calls.find(c => c[0] === 'programsOff')[1], { name: 'alpha', user: 'Local operator' });
|
|
assert.deepEqual(f.admin.calls.filter(c => c[0] === 'unitAction').map(c => c[1]), ['install', 'start', 'stop', 'restart']);
|
|
assert.deepEqual(f.busCalls.map(c => c[0]), ['proxy.init', 'proxy.fence.clear']);
|
|
assert.deepEqual(f.busCalls[0][1], { generate: true });
|
|
const config = await send(f.port, '/api/config', { headers: { host: `127.0.0.1:${f.port}` } });
|
|
assert.equal(config.json.proxyAdmin, true);
|
|
assert.equal(config.json.proxyAdminSend, true);
|
|
for (const line of f.logs.filter(l => l.includes('/api/proxy/admin/'))) assert.match(line, /^\S+ (GET|POST) \/api\/proxy\/admin\/[a-z/-]+ \d{3} user=/);
|
|
});
|
|
|
|
test('without a proxy admin the config offers no setup and the routes answer not-configured', async t => {
|
|
const f = await devServer(t, { proxyAdmin: null });
|
|
const config = await send(f.port, '/api/config', { headers: { host: `127.0.0.1:${f.port}` } });
|
|
assert.equal(Object.hasOwn(config.json, 'proxyAdmin'), false);
|
|
assert.deepEqual((await hit(f, ROUTES[0])).json, { error: 'not-configured' });
|
|
});
|
|
|
|
test('writes refuse a foreign Origin, missing Fetch Metadata, a read-only Console and a wrong method', async t => {
|
|
const f = await devServer(t);
|
|
for (const route of ROUTES.filter(r => r[1] === 'POST')) {
|
|
assert.equal((await hit(f, route, { origin: 'http://evil.example' })).status, 403, `${route[0]} cross-origin`);
|
|
assert.equal((await hit(f, route, { 'sec-fetch-site': 'cross-site' })).status, 403, `${route[0]} cross-site`);
|
|
const noMeta = { ...f.headers() }; delete noMeta['sec-fetch-site'];
|
|
assert.equal((await send(f.port, `/api/proxy/admin/${route[0]}`, { method: 'POST', headers: noMeta, body: route[2] })).status, 403, `${route[0]} no fetch metadata`);
|
|
assert.equal((await send(f.port, `/api/proxy/admin/${route[0]}`, { method: 'GET', headers: f.headers() })).status, 405, `${route[0]} GET`);
|
|
}
|
|
assert.deepEqual(f.admin.calls, []);
|
|
const readOnly = await devServer(t, { send: null });
|
|
for (const route of ROUTES.filter(r => r[1] === 'POST')) assert.deepEqual((await hit(readOnly, route)).json, { error: 'read-only' }, route[0]);
|
|
assert.deepEqual(readOnly.admin.calls, []);
|
|
assert.equal((await hit(f, ['nope', 'GET'])).status, 404);
|
|
});
|
|
|
|
test('a pasted key: refused over plain-HTTP LAN before it is judged, accepted on loopback; mismatch and bad keys refuse', async t => {
|
|
const f = await devServer(t, { devAllowHosts: ['lan.example'] });
|
|
const lan = { ...f.headers('lan.example') }; delete lan['sec-fetch-site'];
|
|
const paste = { key: SENTINEL, confirm: SENTINEL };
|
|
const refused = await send(f.port, '/api/proxy/admin/init', { method: 'POST', headers: lan, body: paste });
|
|
assert.equal(refused.status, 403); assert.deepEqual(refused.json, { error: 'proxy-key-transport' });
|
|
const refusedMismatch = await send(f.port, '/api/proxy/admin/init', { method: 'POST', headers: lan, body: { key: SENTINEL, confirm: 'other' } });
|
|
assert.deepEqual(refusedMismatch.json, { error: 'proxy-key-transport' }, 'transport is checked before the key');
|
|
const generated = await send(f.port, '/api/proxy/admin/init', { method: 'POST', headers: lan, body: { generate: true } });
|
|
assert.equal(generated.status, 200, 'a LAN page still gets the generated key');
|
|
assert.deepEqual(f.busCalls.map(c => c[1]), [{ generate: true }]);
|
|
assert.deepEqual((await hit(f, ['init', 'POST', { key: SENTINEL, confirm: 'different' }])).json, { error: 'proxy-key-mismatch' });
|
|
assert.deepEqual((await hit(f, ['init', 'POST', { key: 'a\nb', confirm: 'a\nb' }])).json, { error: 'proxy-key-invalid' });
|
|
for (const body of [{ key: SENTINEL, confirm: SENTINEL, generate: true }, { generate: true, extra: 1 }, { generate: false }, {}])
|
|
assert.deepEqual((await hit(f, ['init', 'POST', body])).json, { error: 'invalid-request' }, JSON.stringify(body));
|
|
assert.deepEqual((await hit(f, ['init', 'POST', { generate: true, port: 8317 }])).json, { error: 'proxy-config-invalid' });
|
|
assert.deepEqual((await hit(f, ['init', 'POST', { generate: true, rotateGraceMinutes: 0 }])).json, { error: 'proxy-rotate-grace-invalid' });
|
|
assert.deepEqual((await hit(f, ['init', 'POST', { generate: true, firstOutputSeconds: 99999 }])).json, { error: 'proxy-first-output-invalid' });
|
|
const ok = await hit(f, ['init', 'POST', { ...paste, port: 18432, rotateGraceMinutes: 5, firstOutputSeconds: 60 }]);
|
|
assert.equal(ok.status, 200);
|
|
assert.deepEqual(f.busCalls.at(-1), ['proxy.init', { key: SENTINEL, port: 18432, rotateGraceMinutes: 5, firstOutputSeconds: 60 }]);
|
|
assert.equal(f.logs.join('\n').includes(SENTINEL), false, 'no key in a log line');
|
|
assert.equal(JSON.stringify(f.admin.calls.map(c => c[0])).includes(SENTINEL), false);
|
|
});
|
|
|
|
test('keyTransportOk: HTTPS anywhere, HTTP only on a loopback name from a loopback peer', () => {
|
|
assert.equal(keyTransportOk('https://console.example', '10.0.0.5'), true);
|
|
assert.equal(keyTransportOk('http://127.0.0.1:7330', '127.0.0.1'), true);
|
|
assert.equal(keyTransportOk('http://localhost:7330', '::ffff:127.0.0.1'), true);
|
|
assert.equal(keyTransportOk('http://127.0.0.1:7330', '10.0.0.5'), false, 'a forwarded peer');
|
|
assert.equal(keyTransportOk('http://lan.example:7330', '127.0.0.1'), false);
|
|
assert.equal(keyTransportOk('http://10.0.0.2:7330', '10.0.0.5'), false);
|
|
assert.equal(keyTransportOk('not a url', '127.0.0.1'), false);
|
|
});
|
|
|
|
test('a refusal from the controller or bus reaches the page as its code only', async t => {
|
|
const f = await devServer(t);
|
|
const leak = Object.assign(new Error(`${SENTINEL} /home/owner/.config/mosaic-dev/proxy.json upstream body`), { code: 'proxy-unit-failed' });
|
|
f.admin.unitAction = async () => { throw leak; };
|
|
f.admin.status = async () => { throw new Error(SENTINEL); };
|
|
const unit = await hit(f, ['unit/start', 'POST', {}]);
|
|
assert.deepEqual(unit.json, { error: 'proxy-unit-failed' });
|
|
const status = await hit(f, ROUTES[0]);
|
|
assert.deepEqual(status.json, { error: 'outcome-unknown' });
|
|
for (const text of [unit.text, status.text, f.logs.join('\n')]) { assert.equal(text.includes(SENTINEL), false); assert.equal(text.includes('/home/'), false); }
|
|
const big = await send(f.port, '/api/proxy/admin/init', { method: 'POST', headers: f.headers(), body: `{"key":"${SENTINEL}${'x'.repeat(17000)}"}` });
|
|
assert.deepEqual(big.json, { error: 'invalid-request' });
|
|
const broken = await send(f.port, '/api/proxy/admin/init', { method: 'POST', headers: f.headers(), body: `{"key":"${SENTINEL}` });
|
|
assert.deepEqual(broken.json, { error: 'invalid-request' });
|
|
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
|
});
|
|
|
|
test('an SSO root owner reaches the routes and may paste over HTTPS; a granted user gets human-required on every route', async t => {
|
|
const access = { accessVersion: 1, revision: 1,
|
|
users: [{ id: 'alice', home: 'local', subjects: [{ provider: 'writer', sub: 'alice-sub' }] }],
|
|
grants: [{ id: 'g-1', user: 'alice', business: 'demo', projects: ['*'], instances: ['*'], level: 'collaborator' }] };
|
|
const auth = await createSsoSession(t, { host: 'console.example', users: consoleAccess({ load: () => access, business: () => 'demo' }) });
|
|
const admin = fakeAdmin(), busCalls = [];
|
|
let bound = 0;
|
|
const s = await startServer({ port: 0, sso: auth.sso, send: async () => ({}), proxyAdmin: admin, proxyCall: async (verb, args) => { busCalls.push([verb, args]); return {}; },
|
|
userOptions: () => { bound++; return {}; }, log: () => {} });
|
|
t.after(() => new Promise(r => s.close(r)));
|
|
const port = s.address().port;
|
|
const owner = auth.writeHeaders(await auth.signIn(port));
|
|
assert.equal((await send(port, '/api/proxy/admin/status', { headers: owner })).status, 200);
|
|
assert.equal((await send(port, '/api/config', { headers: owner })).json.proxyAdmin, true);
|
|
const pasted = await send(port, '/api/proxy/admin/init', { method: 'POST', headers: owner, body: { key: SENTINEL, confirm: SENTINEL } });
|
|
assert.equal(pasted.status, 200, 'HTTPS origin carries a pasted key');
|
|
assert.equal(pasted.text.includes(SENTINEL), false);
|
|
const before = admin.calls.length;
|
|
const alice = auth.writeHeaders(await auth.signIn(port, { sub: 'alice-sub' }));
|
|
for (const [route, method, body] of ROUTES) {
|
|
const r = await send(port, `/api/proxy/admin/${route}`, { method, headers: alice, body });
|
|
assert.equal(r.status, 403, route);
|
|
assert.deepEqual(r.json, { error: 'human-required' }, route);
|
|
}
|
|
assert.equal(bound, 0, 'refused before a user transport is bound');
|
|
assert.equal(Object.hasOwn((await send(port, '/api/config', { headers: alice })).json, 'proxyAdmin'), false);
|
|
assert.equal(admin.calls.length, before);
|
|
});
|
|
|
|
test('the tester listener gets human-required on every route, read or write', async t => {
|
|
const { startTesterSocket } = await import('../src/tester-socket.mjs');
|
|
const { testerRequest } = await import('../../cli/src/tester-http.mjs');
|
|
const root = mkdtempSync(join(tmpdir(), 'pa-tester-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
const admin = fakeAdmin();
|
|
let calls = 0;
|
|
const s = await startTesterSocket({ dataRoot: root, proxyAdmin: admin, proxyCall: async () => { calls++; return {}; }, log: () => {} });
|
|
t.after(() => new Promise(r => s.close(r)));
|
|
for (const [route, method, body] of ROUTES) {
|
|
const r = await testerRequest({ dataRoot: root, path: `/api/proxy/admin/${route}`, method, body });
|
|
assert.equal(r.status, 403, route);
|
|
}
|
|
assert.equal(calls, 0);
|
|
assert.deepEqual(admin.calls, []);
|
|
});
|
|
|
|
test('every refusal code a setup route can answer has a refusal-table entry with a next step', () => {
|
|
for (const code of ['human-required', 'proxy-key-transport', 'proxy-key-mismatch', 'proxy-key-invalid', 'proxy-config-invalid', 'proxy-rotate-grace-invalid', 'proxy-first-output-invalid', 'proxy-admin-busy', 'proxy-restart-required', 'proxy-restart-unconfirmed', 'proxy-init-lock-held', 'proxy-init-lock-absent', 'proxy-unit-missing', 'proxy-unit-unhealthy', 'proxy-unit-failed', 'not-configured', 'outcome-unknown', 'invalid-request'])
|
|
assert.equal(typeof REFUSALS[code]?.nextStep, 'string', code);
|
|
});
|
|
|
|
test('an organization whose bus does not answer shows no model count, not a made-up 0', async () => {
|
|
assert.deepEqual(await orgCatalogue(async () => { throw new Error('down'); }), { status: 'bus-unavailable', models: null });
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'disabled' } })), { status: 'disabled', models: null });
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'enabled', models: [{ id: 'a' }, { id: 'b' }] } })), { status: 'enabled', models: 2 });
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'enabled', models: [] } })), { status: 'enabled', models: 0 });
|
|
});
|
|
|
|
// settings-p3 (re-check 3 P3-5): a ready catalogue the bus picked up after it started carries the bus's
|
|
// restart notice; Model setup gets launchRestart so it keeps that organization listed. The notice text is
|
|
// copied from packages/bus/src/runtime.mjs (not exported there); the pins below fail if the copies drift.
|
|
test('a ready catalogue with the bus restart notice is marked launchRestart, and every copy of the notice matches the bus', async () => {
|
|
const notice = 'Restart this organization to start agents on these models.';
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'ready', models: [{ id: 'a' }], notices: [notice] } })), { status: 'ready', models: 1, launchRestart: true });
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'ready', models: [{ id: 'a' }], notices: ['something else'] } })), { status: 'ready', models: 1 });
|
|
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'unavailable', models: [], notices: [notice] } })), { status: 'unavailable', models: 0 });
|
|
for (const file of ['../../bus/src/runtime.mjs', '../src/proxy-admin.mjs', '../src/public/console-restart.js'])
|
|
assert.ok(readFileSync(new URL(file, import.meta.url), 'utf8').includes(`RESTART_TO_LAUNCH = '${notice}'`), file);
|
|
});
|
|
|
|
test('ride move takes one organization id and passes the signed-in owner as the principal', async t => {
|
|
const f = await devServer(t);
|
|
for (const body of [{}, { org: '' }, { org: '../x' }, { org: 'A' }, { org: 7 }, { org: 'x', extra: 1 }])
|
|
assert.deepEqual((await hit(f, ['ride-move', 'POST', body])).json, { error: 'invalid-request' }, JSON.stringify(body));
|
|
assert.deepEqual((await hit(f, ['ride-all', 'POST', { org: 'x' }])).json, { error: 'invalid-request' }, 'ride all takes no arguments');
|
|
assert.deepEqual(f.admin.calls, []);
|
|
const r = await hit(f, ['ride-move', 'POST', { org: 'stand-in' }]);
|
|
assert.deepEqual(r.json, { org: 'stand-in', moved: false, reason: 'bus-running' });
|
|
assert.deepEqual(f.admin.calls, [['rideMove', { org: 'stand-in', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } }]]);
|
|
f.admin.rideAll = async () => { throw Object.assign(new Error(`${SENTINEL} busy`), { code: 'proxy-admin-busy' }); };
|
|
const busy = await hit(f, ['ride-all', 'POST', {}]);
|
|
assert.deepEqual(busy.json, { error: 'proxy-admin-busy' });
|
|
assert.equal(busy.text.includes(SENTINEL), false);
|
|
});
|
|
|
|
test('a signed-in member who is not the instance owner gets human-required for ride all and ride move', async t => {
|
|
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
|
|
const member = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => ({ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' }) } });
|
|
for (const route of ROUTES.filter(([p]) => p.startsWith('ride-'))) {
|
|
const inOrg = await send(member.port, `/api/orgs/x/proxy/admin/${route[0]}`, { method: route[1], headers: member.headers(), body: route[2] });
|
|
assert.equal(inOrg.status, 403, route[0]); assert.deepEqual(inOrg.json, { error: 'human-required' }, route[0]);
|
|
const plain = await hit(member, route);
|
|
assert.equal(plain.status >= 400 && plain.status < 500, true, `${route[0]} outside an organization is refused`);
|
|
}
|
|
assert.deepEqual(member.admin.calls, []);
|
|
});
|
|
|
|
// #1873 settings-backend A1: the three reads. Query keys are each read's own, once each, plain
|
|
// decimal numbers; the controller clamps the values.
|
|
test('the reads pass their query to the controller and refuse an unknown, repeated or non-number key', async t => {
|
|
const f = await devServer(t);
|
|
const get = path => send(f.port, path, { headers: f.headers() });
|
|
assert.equal((await get('/api/proxy/admin/log')).status, 200);
|
|
assert.equal((await get('/api/proxy/admin/log?lines=1000')).status, 200);
|
|
assert.equal((await get('/api/proxy/admin/history')).status, 200);
|
|
assert.equal((await get('/api/proxy/admin/history?limit=1000&before=4096')).status, 200);
|
|
assert.equal((await get('/api/proxy/admin/service-key')).status, 200);
|
|
assert.deepEqual(f.admin.calls, [['log', {}], ['log', { lines: 1000 }], ['history', { before: null }], ['history', { limit: 1000, before: 4096 }], ['serviceKey']]);
|
|
f.admin.calls.length = 0;
|
|
for (const path of ['/api/proxy/admin/log?lines=-1', '/api/proxy/admin/log?lines=1.5', '/api/proxy/admin/log?lines=', '/api/proxy/admin/log?lines=1e3', '/api/proxy/admin/log?lines=5&lines=6',
|
|
'/api/proxy/admin/log?limit=5', '/api/proxy/admin/log?unit=sshd.service', '/api/proxy/admin/log?lines=0x10', '/api/proxy/admin/log?lines=1234567890123456',
|
|
'/api/proxy/admin/history?before=abc', '/api/proxy/admin/history?lines=5', '/api/proxy/admin/history?limit=5&limit=6', '/api/proxy/admin/service-key?x=1', '/api/proxy/admin/service-key?key']) {
|
|
const r = await get(path);
|
|
assert.equal(r.status, 400, path); assert.deepEqual(r.json, { error: 'invalid-request' }, path);
|
|
}
|
|
assert.deepEqual(f.admin.calls, []);
|
|
for (const route of READS) assert.equal((await send(f.port, `/api/proxy/admin/${route[0]}`, { method: 'POST', headers: f.headers(), body: {} })).status, 405, route[0]);
|
|
});
|
|
|
|
test('a read the controller cannot answer reaches the page as its code only', async t => {
|
|
const f = await devServer(t);
|
|
f.admin.log = async () => { throw Object.assign(new Error(`${SENTINEL} journal said /home/owner/x`), { code: 'outcome-unknown' }); };
|
|
f.admin.history = () => { throw Object.assign(new Error(SENTINEL), { code: 'invalid-request' }); };
|
|
f.admin.serviceKey = () => { throw new Error(SENTINEL); };
|
|
assert.deepEqual((await hit(f, ['log', 'GET'])).json, { error: 'outcome-unknown' });
|
|
assert.equal((await hit(f, ['log', 'GET'])).status, 503);
|
|
assert.deepEqual((await hit(f, ['history', 'GET'])).json, { error: 'invalid-request' });
|
|
assert.deepEqual((await hit(f, ['service-key', 'GET'])).json, { error: 'outcome-unknown' });
|
|
f.admin.log = async () => { throw Object.assign(new Error('x'), { code: 'not-configured' }); };
|
|
assert.deepEqual((await hit(f, ['log', 'GET'])).json, { error: 'not-configured' });
|
|
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
|
});
|
|
|
|
test('a member, an organization owner and a request on a name that is not the Console\'s get refused on every read', async t => {
|
|
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
|
|
for (const session of [{ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' },
|
|
{ name: 'Olive', provider: 'local-dev', iss: 'local-dev', sub: 'olive', rootOwner: false, instanceRole: 'operator', orgRole: 'owner' }]) {
|
|
const f = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => session } });
|
|
for (const route of READS) {
|
|
const inOrg = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}?lines=5`.replace(/\?lines=5$/, ''), { headers: f.headers() });
|
|
assert.equal(inOrg.status, 403, `${session.sub} ${route[0]}`); assert.deepEqual(inOrg.json, { error: 'human-required' }, `${session.sub} ${route[0]}`);
|
|
const bad = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}?nope=1`, { headers: f.headers() });
|
|
assert.deepEqual(bad.json, { error: 'human-required' }, 'the caller is checked before the query');
|
|
const plain = await hit(f, route);
|
|
assert.equal(plain.status >= 400 && plain.status < 500, true, `${route[0]} outside an organization is refused`);
|
|
}
|
|
assert.deepEqual(f.admin.calls, []);
|
|
}
|
|
const f = await devServer(t);
|
|
for (const route of READS) {
|
|
const r = await send(f.port, `/api/proxy/admin/${route[0]}`, { headers: { host: 'console.evil.example' } });
|
|
assert.equal(r.status, 403, route[0]);
|
|
}
|
|
assert.deepEqual(f.admin.calls, []);
|
|
});
|
|
|
|
// The real controller over a scratch config and data root with keys planted in proxy.json, the
|
|
// management key file, the receipt history and the journal: none reaches an answer.
|
|
test('end to end with the real controller, no planted key reaches any read', async t => {
|
|
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
|
const { initFiles, appendReceipt } = await import('../../model-proxy/src/admin.mjs');
|
|
const root = mkdtempSync(join(tmpdir(), 'pa-a1-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
|
const files = initFiles(configDir, dataRoot);
|
|
const TAIL = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
|
const planted = ['msk-tag-qwertyu', 'mso-tag-acme-qwerty', 'mst-tag-triage-zxcvb', 'msp-tag-plmokn', `msk-k1a2-${TAIL}`, `mso-k1a2-acme-${TAIL}`, `mst-k1a2-triage-${TAIL}`, `msp-k1a2-${TAIL}`];
|
|
const { mkdirSync, writeFileSync } = await import('node:fs');
|
|
mkdirSync(join(configDir, 'secrets'), { recursive: true, mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
|
writeFileSync(files.settings, JSON.stringify({ port: 18432, note: planted[0] }), { mode: 0o600 });
|
|
writeFileSync(files.key, planted[4], { mode: 0o600 });
|
|
for (const key of planted) appendReceipt(dataRoot, { time: new Date(0).toISOString(), op: 'init', note: `key ${key}`, [key.replace(/-/g, '_')]: key });
|
|
const journalCalls = [];
|
|
const unit = {
|
|
unit: 'mosaic-proxy-zz.service',
|
|
status: async () => ({ unit: 'mosaic-proxy-zz.service', installed: true, active: 'active', healthy: true }),
|
|
log: async (lines, options) => {
|
|
const { unitLog } = await import('../../model-proxy/src/admin.mjs');
|
|
return unitLog({ run: async (command, args) => { journalCalls.push([command, ...args]); return { code: 0, stdout: [...planted.map(k => `refused ${k}`), 'auth plainwordsonly', 'served 3 requests'].join('\n') + '\n' }; }, unit: 'mosaic-proxy-zz.service', lines, secrets: options.secrets });
|
|
},
|
|
};
|
|
const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: async () => ({ stopped: true, running: [] }), env: { MOSAIC_PROXY_TOKEN: 'plainwordsonly' } });
|
|
const f = await devServer(t, { proxyAdmin: admin });
|
|
const answers = [];
|
|
for (const path of ['log', 'log?lines=1000', 'service-key', 'history', 'history?limit=2']) {
|
|
const r = await send(f.port, `/api/proxy/admin/${path}`, { headers: f.headers() });
|
|
assert.equal(r.status, 200, path);
|
|
answers.push(r.text);
|
|
}
|
|
const all = answers.join('\n') + f.logs.join('\n');
|
|
for (const bit of [...planted, ...planted.map(k => k.slice(4)), TAIL.slice(0, 10), 'plainwordsonly', root]) assert.equal(all.includes(bit), false, bit);
|
|
const log = JSON.parse(answers[0]);
|
|
assert.deepEqual(log.lines.slice(-1), ['served 3 requests']);
|
|
assert.equal(log.lines.length, planted.length + 1);
|
|
assert.equal(log.dropped, 1);
|
|
assert.deepEqual(journalCalls[1].slice(4, 6), ['-n', '200']);
|
|
const key = JSON.parse(answers[2]);
|
|
assert.deepEqual(Object.keys(key), ['madeAt', 'renewedAt', 'renewal', 'problem']);
|
|
assert.equal(key.problem, null); assert.equal(key.renewal, 'not-built');
|
|
const first = JSON.parse(answers[4]);
|
|
assert.equal(first.entries.length, 2);
|
|
const rest = await send(f.port, `/api/proxy/admin/history?limit=100&before=${first.next}`, { headers: f.headers() });
|
|
assert.equal(rest.json.entries.length, planted.length - 2);
|
|
assert.equal(rest.json.next, null);
|
|
assert.equal(rest.text.includes('qwerty'), false);
|
|
});
|
|
|
|
// Account changes made outside the setup page join its history. The bus call's answer is unchanged;
|
|
// a record that fails adds recorded: false and still answers the bus's result.
|
|
test('an account write through /api/proxy/* records a labelled entry; reads and login steps record nothing', async t => {
|
|
const f = await devServer(t);
|
|
const post = (path, body) => send(f.port, path, { method: 'POST', headers: f.headers(), body });
|
|
f.busCalls.length = 0;
|
|
const added = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
|
assert.equal(added.status, 200);
|
|
assert.deepEqual(added.json, { cleared: true }, 'the bus answer is passed through as it was');
|
|
await post('/api/proxy/login/start', { provider: 'openai' });
|
|
await send(f.port, '/api/proxy/accounts', { headers: f.headers() });
|
|
const records = f.admin.calls.filter(c => c[0] === 'recordAccount').map(c => c[1]);
|
|
assert.deepEqual(records.map(r => r.verb), ['proxy.apikey.add', 'proxy.login.start']);
|
|
assert.deepEqual(records[0], { verb: 'proxy.apikey.add', args: { provider: 'openai', key: SENTINEL }, result: { cleared: true }, user: 'Local operator', org: null });
|
|
f.admin.recordAccount = () => false;
|
|
const unrecorded = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
|
assert.deepEqual(unrecorded.json, { cleared: true, recorded: false });
|
|
f.admin.recordAccount = () => { throw new Error(SENTINEL); };
|
|
const thrown = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
|
assert.deepEqual(thrown.json, { cleared: true, recorded: false });
|
|
f.admin.recordAccount = () => null;
|
|
assert.deepEqual((await post('/api/proxy/login/cancel', { state: 's' })).json, { cleared: true }, 'not an account change: nothing added');
|
|
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
|
});
|
|
|
|
test('a refused or failed account write records nothing, and an organization route names its organization', async t => {
|
|
const f = await devServer(t, { proxyCall: async () => { throw Object.assign(new Error('x'), { code: 'provider-not-allowed' }); } });
|
|
const r = await send(f.port, '/api/proxy/apikey/add', { method: 'POST', headers: f.headers(), body: { provider: 'openai', key: SENTINEL } });
|
|
assert.equal(r.status, 400);
|
|
assert.deepEqual(f.admin.calls, []);
|
|
const organizations = { list: async () => [], resolve: async id => (id === 'acme' ? { busHealthy: true, send: async () => ({}), proxyCall: async () => ({ added: true }) } : null) };
|
|
const o = await devServer(t, { organizations });
|
|
const inOrg = await send(o.port, '/api/orgs/acme/proxy/apikey/add', { method: 'POST', headers: o.headers(), body: { provider: 'openai', key: SENTINEL } });
|
|
assert.deepEqual(inOrg.json, { added: true });
|
|
assert.deepEqual(o.admin.calls, [['recordAccount', { verb: 'proxy.apikey.add', args: { provider: 'openai', key: SENTINEL }, result: { added: true }, user: 'Local operator', org: 'acme' }]]);
|
|
});
|
|
|
|
test('a real controller records the account write without the key, and history shows it', async t => {
|
|
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
|
const root = mkdtempSync(join(tmpdir(), 'pa-a1r-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
const { mkdirSync } = await import('node:fs');
|
|
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
|
mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
|
const admin = createProxyAdmin({ dataRoot, configDir, unit: { unit: 'mosaic-proxy-zz.service', status: async () => ({ installed: false }) }, buses: async () => ({ stopped: true, running: [] }), now: () => new Date(0), env: {} });
|
|
const f = await devServer(t, { proxyAdmin: admin, proxyCall: async () => ({ added: true }) });
|
|
const r = await send(f.port, '/api/proxy/apikey/add', { method: 'POST', headers: f.headers(), body: { provider: 'openai', key: SENTINEL } });
|
|
assert.deepEqual(r.json, { added: true });
|
|
const h = await send(f.port, '/api/proxy/admin/history', { headers: f.headers() });
|
|
assert.deepEqual(h.json, { entries: [{ time: new Date(0).toISOString(), op: 'account.proxy.apikey.add', provider: 'openai', user: 'Local operator' }], next: null });
|
|
assert.equal(readFileSync(join(dataRoot, 'state', 'proxy-admin.jsonl'), 'utf8').includes(SENTINEL), false);
|
|
});
|
|
|
|
// #1873 settings-backend A2: programs off and access health.
|
|
test('A2: a member and an organization owner get human-required on programs off and access, before any controller call', async t => {
|
|
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
|
|
for (const session of [{ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' },
|
|
{ name: 'Olive', provider: 'local-dev', iss: 'local-dev', sub: 'olive', rootOwner: false, instanceRole: 'operator', orgRole: 'owner' }]) {
|
|
const f = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => session } });
|
|
for (const route of A2) {
|
|
const inOrg = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}`, { method: route[1], headers: f.headers(), body: route[2] });
|
|
assert.equal(inOrg.status, 403, `${session.sub} ${route[0]}`); assert.deepEqual(inOrg.json, { error: 'human-required' }, `${session.sub} ${route[0]}`);
|
|
const plain = await hit(f, route);
|
|
assert.equal(plain.status >= 400 && plain.status < 500, true, `${session.sub} ${route[0]} outside an organization is refused`);
|
|
}
|
|
assert.deepEqual(f.admin.calls, []);
|
|
}
|
|
});
|
|
|
|
test('A2: programs off takes one plain program name and nothing else; access takes no body', async t => {
|
|
const f = await devServer(t);
|
|
for (const body of [{}, { name: '' }, { name: 'Alpha' }, { name: '../x' }, { name: 7 }, { name: 'a'.repeat(33) }, { name: 'alpha', extra: 1 }, { name: ['alpha'] }])
|
|
assert.deepEqual((await hit(f, ['programs/off', 'POST', body])).json, { error: 'invalid-request' }, JSON.stringify(body));
|
|
assert.deepEqual(f.admin.calls, []);
|
|
assert.equal((await send(f.port, '/api/proxy/admin/access', { method: 'POST', headers: f.headers(), body: {} })).status, 405);
|
|
assert.equal((await send(f.port, '/api/proxy/admin/programs/off', { headers: f.headers() })).status, 405);
|
|
f.admin.programsOff = async () => { throw Object.assign(new Error(`${SENTINEL} busy`), { code: 'proxy-admin-busy' }); };
|
|
const busy = await hit(f, ['programs/off', 'POST', { name: 'alpha' }]);
|
|
assert.equal(busy.status, 409); assert.deepEqual(busy.json, { error: 'proxy-admin-busy' });
|
|
f.admin.access = async () => { throw new Error(SENTINEL); };
|
|
assert.deepEqual((await hit(f, ['access', 'GET'])).json, { error: 'outcome-unknown' });
|
|
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
|
});
|
|
|
|
// The real controller behind the real routes, with fake organizations whose answers carry planted keys.
|
|
test('A2 end to end: programs off writes one receipt, skips a down bus, and no answer, receipt or history holds a key; access never says ok for proxy-uncertain', async t => {
|
|
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
|
const { mkdirSync } = await import('node:fs');
|
|
const root = mkdtempSync(join(tmpdir(), 'pa-a2-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
|
mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
|
const TAIL = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
|
const planted = [`msk-k1a2-${TAIL}`, `mso-k1a2-acme-${TAIL}`, `mst-k1a2-triage-${TAIL}`, `msp-k1a2-${TAIL}`];
|
|
const REV = 'c'.repeat(64);
|
|
const sets = [];
|
|
const org = (id, { down = false, keys = [], keysError = null } = {}) => ({
|
|
id, fixture: false, cliproxy: true, changes: '',
|
|
file: () => ({ document: { roles: {}, plugins: { harness: ['alpha', 'beta'] }, note: planted[1] }, revision: REV }),
|
|
call: async (verb, args) => {
|
|
if (down) throw Object.assign(new Error(planted[0]), { code: 'outcome-unknown' });
|
|
if (verb === 'plugins') return { business: id, revision: REV, plugins: { harness: ['alpha', 'beta'] }, note: planted[0] };
|
|
if (verb === 'routes') return { business: id, revision: REV, instances: {}, note: planted[2] };
|
|
if (verb === 'plugins.set') { sets.push([id, args]); return { business: id, revision: 'd'.repeat(64) }; }
|
|
if (verb === 'proxy.keys') { if (keysError) throw Object.assign(new Error(planted[3]), { code: keysError }); return { keys }; }
|
|
throw Object.assign(new Error(planted[3]), { code: 'invalid-request' });
|
|
},
|
|
});
|
|
const orgs = [
|
|
org('acme', { keys: [{ keyId: '0123456789ab', management: 'stack-managed', agent: planted[1], issuedAt: planted[3], state: 'active' }, { keyId: 'abcdefabcdef', management: 'not stack-managed', agent: planted[0], issuedAt: null, state: null }] }),
|
|
org('bolt', { down: true }),
|
|
org('crux', { keysError: 'proxy-uncertain' }),
|
|
];
|
|
const admin = createProxyAdmin({ dataRoot, configDir, unit: { unit: 'mosaic-proxy-zz.service', status: async () => ({ installed: false }) }, buses: async () => ({ stopped: true, running: [] }), now: () => new Date(0), env: {},
|
|
riders: async () => orgs, harnesses: () => ['alpha', 'beta'], rootAgents: () => ({ state: 'absent', agents: {}, assistant: null }) });
|
|
const f = await devServer(t, { proxyAdmin: admin });
|
|
const unknown = await hit(f, ['programs/off', 'POST', { name: 'gamma' }]);
|
|
assert.equal(unknown.status, 400); assert.deepEqual(unknown.json, { error: 'invalid-request' });
|
|
const off = await hit(f, ['programs/off', 'POST', { name: 'alpha' }]);
|
|
assert.equal(off.status, 200);
|
|
assert.deepEqual(off.json.results, [{ id: 'acme', outcome: 'off' }, { id: 'bolt', outcome: 'bus-down' }, { id: 'crux', outcome: 'off' }]);
|
|
assert.deepEqual(off.json.receipt, { time: new Date(0).toISOString(), op: 'programs.off', name: 'alpha', results: off.json.results, user: 'Local operator' });
|
|
assert.deepEqual(sets.map(([id]) => id), ['acme', 'crux']);
|
|
const lines = readFileSync(join(dataRoot, 'state', 'proxy-admin.jsonl'), 'utf8').trim().split('\n');
|
|
assert.equal(lines.length, 1);
|
|
const access = await hit(f, ['access', 'GET']);
|
|
assert.equal(access.status, 200);
|
|
assert.deepEqual(access.json.organizations.map(o => [o.id, o.health, o.reason ?? null]), [['acme', 'ok', null], ['bolt', 'unreadable', 'bus-down'], ['crux', 'attention', 'proxy-uncertain']]);
|
|
assert.deepEqual(access.json.organizations[0].keys, [{ keyId: '0123456789ab', agent: null, state: 'active', issuedAt: null }]);
|
|
const status = await hit(f, ['status', 'GET']);
|
|
assert.deepEqual(status.json.programs, { installed: ['alpha', 'beta'], organizations: [{ id: 'acme', on: ['alpha', 'beta'] }, { id: 'bolt', on: null }, { id: 'crux', on: ['alpha', 'beta'] }] });
|
|
const history = await hit(f, ['history', 'GET']);
|
|
assert.deepEqual(history.json.entries, [off.json.receipt]);
|
|
const all = [unknown.text, off.text, access.text, status.text, history.text, lines.join('\n'), f.logs.join('\n')].join('\n');
|
|
assert.doesNotMatch(all, /ms[kotp]-[A-Za-z0-9_-]{4,}/);
|
|
for (const bit of [TAIL, TAIL.slice(0, 10), root]) assert.equal(all.includes(bit), false, bit);
|
|
});
|