// #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); });