diff --git a/packages/model-proxy/src/admin-control.mjs b/packages/model-proxy/src/admin-control.mjs index 59d51fd9b..afaf317a0 100644 --- a/packages/model-proxy/src/admin-control.mjs +++ b/packages/model-proxy/src/admin-control.mjs @@ -7,7 +7,8 @@ import { homedir } from 'node:os'; import { fetchPinned } from './fetch.mjs'; import { PIN } from './common.mjs'; import { localRide, riddenOrgs } from './ride.mjs'; -import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS } from './admin.mjs'; +import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS, LOG_LINES, receiptHistory, serviceKeyState } from './admin.mjs'; +import { secretValues } from './redact.mjs'; export const proxyCode = (error, fallback) => (/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : fallback); const failure = code => Object.assign(new Error(code), { code }); @@ -254,6 +255,38 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir if (typeof org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) throw failure('proxy-org-invalid'); return receipt({ op: 'ride-removed', org }); }, + // #1873 settings-backend A1: three reads for the instance owner's setup page. + // The proxy unit's last journal lines, redacted. A unit that is not installed is not-configured; + // a unit state that cannot be read is outcome-unknown, as is a journal that cannot be read. + async log({ lines = LOG_LINES.default } = {}) { + if (typeof control.log !== 'function') throw failure('not-configured'); + const state = await unitStatus(); + if (state.error) throw failure('outcome-unknown'); + if (!state.installed) throw failure('not-configured'); + return control.log(lines, { secrets: secretValues(env) }); + }, + // When the service key was made, from proxy.json's mtime; never the key or any part of it. + serviceKey() { return serviceKeyState(configDir); }, + // The setup history, a page at a time (receiptHistory). + history({ limit, before = null } = {}) { return receiptHistory(dataRoot, { limit, before, secrets: secretValues(env) }); }, + // An account change made through /api/proxy/* or an organization's /api/orgs//proxy/*, + // recorded after its bus call answered. Labels only: the provider id, a 12-hex account id, a + // priority or a model count, the organization whose route carried it, and the signed-in name. + // Never a key, a login state, a callback URL, a model list or a body. Answers null when the verb + // is not an account change, true when recorded and false when the append failed. + recordAccount({ verb, args = {}, result = null, user = null, org = null } = {}) { + const label = value => (typeof value === 'string' && /^[a-z0-9][a-z0-9._-]{0,31}$/.test(value) ? value : null); + const account = value => (typeof value === 'string' && /^[a-f0-9]{12}$/.test(value) ? value : null); + let record; + if (verb === 'proxy.apikey.add') record = { op: 'account.proxy.apikey.add', provider: label(args.provider) }; + else if (verb === 'proxy.login.status' && result?.status === 'ok') record = { op: 'account.proxy.login.complete' }; + else if (verb === 'proxy.priority.set') record = { op: 'account.proxy.priority.set', accountId: account(args.accountId), priority: Number.isSafeInteger(args.priority) ? args.priority : null }; + else if (verb === 'proxy.group.models.set') record = { op: 'account.proxy.group.models.set', accountId: account(args.accountId), models: Array.isArray(args.models) ? args.models.length : null }; + else return null; + if (typeof org === 'string' && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) record.org = org; + if (typeof user === 'string' && user) record.user = user.slice(0, 64); + try { receipt(record); return true; } catch { return false; } + }, async initLockClear() { return exclusive('init-lock-clear', async () => ({ receipt: clearInitLock({ configDir, dataRoot, buses: await buses(), now }) })); }, diff --git a/packages/model-proxy/src/admin.mjs b/packages/model-proxy/src/admin.mjs index af79e0dec..f93d55a20 100644 --- a/packages/model-proxy/src/admin.mjs +++ b/packages/model-proxy/src/admin.mjs @@ -9,6 +9,7 @@ import { execFile } from 'node:child_process'; import { fileURLToPath } from 'node:url'; import { PIN, refuse } from './common.mjs'; import { installPaths, loadProxy, verifyInstall } from './settings.mjs'; +import { holdsSecret, redactLine, redactValue } from './redact.mjs'; const REPO = fileURLToPath(new URL('../../../', import.meta.url)).replace(/\/$/, ''); export const INSTANCE_NAME = /^[a-z][a-z0-9]{1,15}$/; @@ -142,6 +143,123 @@ export function recentReceipts(dataRoot, limit = 10) { } finally { fs.closeSync(fd); } } +// #1873 settings-backend A1 (item 9): the setup history, one page at a time, newest page first and +// oldest first within a page. `before` is a byte offset the previous page answered as `next`: the +// start of a line. The file is read the way ownedText reads (no symlink, no FIFO, owned by the +// Console's user, no group or other bits) and backward from `before` in 64 KB chunks. A partial +// last line (a write in progress) waits for a later read; a line that does not parse, or is longer +// than 64 KB, is skipped. Each entry is redacted (redact.mjs) before it is answered, so a receipt +// that ever held key text shows none. A missing file is an empty history; any other failure to +// read refuses outcome-unknown. `uid` is a test seam. +export const HISTORY_LIMIT = Object.freeze({ min: 1, max: 100, default: 25 }); +const HISTORY_CHUNK = 65536, HISTORY_LINE_MAX = 65536, HISTORY_SCAN_MAX = 2000; +export function receiptHistory(dataRoot, { limit = HISTORY_LIMIT.default, before = null, uid = process.getuid(), secrets = [] } = {}) { + if (!Number.isSafeInteger(limit)) refuse('invalid-request'); + const n = Math.min(HISTORY_LIMIT.max, Math.max(HISTORY_LIMIT.min, limit)); + if (before !== null && !(Number.isSafeInteger(before) && before >= 0)) refuse('invalid-request'); + let fd; + try { fd = fs.openSync(receiptFile(dataRoot), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK); } + catch (error) { + if (error.code !== 'ENOENT') refuse('outcome-unknown'); + if (before !== null && before !== 0) refuse('invalid-request'); + return { entries: [], next: null }; + } + try { + let stat; + try { stat = fs.fstatSync(fd); } catch { refuse('outcome-unknown'); } + if (!stat.isFile() || stat.uid !== uid || (stat.mode & 0o077)) refuse('outcome-unknown'); + const size = stat.size; + if (before !== null && before > size) refuse('invalid-request'); + // A window over the file: `buf` holds bytes [start, start + buf.length). + let start = 0, buf = Buffer.alloc(0); + const readAt = (offset, length) => { + const out = Buffer.alloc(length); + let got; + try { got = fs.readSync(fd, out, 0, length, offset); } catch { refuse('outcome-unknown'); } + if (got !== length) refuse('outcome-unknown'); + return out; + }; + // The offset of the last newline in [0, from), or -1. + const lastNewline = from => { + let pos = from; + while (pos > 0) { + if (!(pos > start && pos <= start + buf.length)) { start = Math.max(0, pos - HISTORY_CHUNK); buf = readAt(start, pos - start); } + const i = buf.lastIndexOf(0x0a, pos - start - 1); + if (i >= 0) return start + i; + pos = start; + } + return -1; + }; + const bytes = (from, to) => (from >= start && to <= start + buf.length ? buf.subarray(from - start, to - start) : readAt(from, to - from)); + // `cursor` is always 0 or the offset just after a newline: the end of the next line to read. + let cursor; + if (before === null) cursor = lastNewline(size) + 1; + else if (before > 0 && bytes(before - 1, before)[0] !== 0x0a) refuse('invalid-request'); + else cursor = before; + const entries = []; + for (let scanned = 0; cursor > 0 && entries.length < n && scanned < HISTORY_SCAN_MAX; scanned++) { + const lineStart = lastNewline(cursor - 1) + 1, lineEnd = cursor - 1; + if (lineEnd - lineStart <= HISTORY_LINE_MAX) { + let value = null; + try { value = JSON.parse(bytes(lineStart, lineEnd).toString('utf8')); } catch { /* torn line */ } + if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.op === 'string') entries.push(redactValue(value, secrets)); + } + cursor = lineStart; + } + entries.reverse(); + return { entries, next: cursor > 0 ? cursor : null }; + } finally { fs.closeSync(fd); } +} + +// #1873 settings-backend A1 (item 7): when the service key was made. proxy.json is created in the +// same init step as the management key, with exclusive create, and is never rewritten, so its +// mtime is the key's creation time. Only proxy.json is lstat'ed: the key file is never opened or +// stat'ed, and nothing is read. A missing proxy.json is `missing`; a symlink, a non-file, one owned +// by another user or one that cannot be examined is `unreadable`, with no date. There is no +// renewal yet (proxy-scope: no rotation in the MVP), so renewedAt is null and renewal 'not-built'. +export function serviceKeyState(configDir, { uid = process.getuid() } = {}) { + const out = { madeAt: null, renewedAt: null, renewal: 'not-built', problem: null }; + let stat; + try { stat = fs.lstatSync(path.join(configDir, 'proxy.json')); } + catch (error) { out.problem = error.code === 'ENOENT' ? 'missing' : 'unreadable'; return out; } + if (!stat.isFile() || stat.uid !== uid || !Number.isFinite(stat.mtimeMs) || stat.mtimeMs <= 0) { out.problem = 'unreadable'; return out; } + out.madeAt = new Date(stat.mtimeMs).toISOString(); + return out; +} + +// #1873 settings-backend A1 (item 3): the proxy unit's last journal lines, made safe to show. The +// unit name is unitName()'s, never the caller's; `lines` is clamped to 1..200. journalctl runs +// through `run` (defaultRun: its timeout and 1 MB cap). A missing journalctl, a nonzero exit or a +// timeout refuses outcome-unknown, with no lines and no other source tried. Each line is redacted +// (redact.mjs) and cut to 300 characters; a line that cannot be shown is dropped, never shown raw. +// A secret from `secrets` found across the shown lines, though in no one line, drops every line. +export const LOG_LINES = Object.freeze({ min: 1, max: 200, default: 50 }); +export async function unitLog({ run = defaultRun, unit, lines = LOG_LINES.default, env, secrets = [] } = {}) { + if (typeof unit !== 'string' || !/^mosaic-proxy(-[a-z][a-z0-9]{1,15})?\.service$/.test(unit)) refuse('proxy-unit-usage'); + if (!Number.isSafeInteger(lines)) refuse('invalid-request'); + const n = Math.min(LOG_LINES.max, Math.max(LOG_LINES.min, lines)); + let result; + try { result = await run('journalctl', ['--user', '-u', unit, '-n', String(n), '-o', 'cat', '--no-pager', '-q'], { env, timeout: 15000 }); } + catch { refuse('outcome-unknown'); } + if (!result || result.code !== 0 || typeof result.stdout !== 'string') refuse('outcome-unknown'); + const raw = result.stdout.split('\n'); + if (raw.at(-1) === '') raw.pop(); + const kept = raw.slice(-n); + const out = []; + let redacted = 0, dropped = 0; + try { + for (const line of kept) { + const safe = redactLine(line, secrets); + if (safe.text === null) { if (line.trim()) dropped++; continue; } + if (safe.redacted) redacted++; + out.push(safe.text); + } + // The lines that will be shown, read together: a secret split across them drops them all. + if (holdsSecret(out.join(''), secrets)) { dropped += out.length; out.length = 0; } + } catch { refuse('outcome-unknown'); } + return { unit, lines: out, redacted, dropped }; +} + export function unitName(instance) { if (instance !== null && instance !== undefined && instance !== 'dev' && !INSTANCE_NAME.test(instance)) refuse('proxy-unit-usage'); return instance && instance !== 'dev' ? `mosaic-proxy-${instance}.service` : 'mosaic-proxy.service'; @@ -215,6 +333,8 @@ export function createUnitControl({ instance = null, port = () => null, unitDir return { unit, status, + // settings-backend A1: the unit's last journal lines, redacted (unitLog). + log(lines, { secrets = [] } = {}) { return unitLog({ run, unit, lines, env, secrets }); }, async render() { return (await service('render')).stdout; }, async install() { await service('install'); return status(); }, async start() { diff --git a/packages/model-proxy/src/redact.mjs b/packages/model-proxy/src/redact.mjs new file mode 100644 index 000000000..7a064ea22 --- /dev/null +++ b/packages/model-proxy/src/redact.mjs @@ -0,0 +1,88 @@ +// #1873 settings-backend A1: redaction for the model service's log lines and the setup history, +// read by the instance owner on the setup page. +// +// It is the redaction chat-fail landed for a failed turn's cause (packages/harness/src/failure-notice.mjs, +// its REDACT list), with Mosaic's own key prefixes added to the key-prefix line: mso- (an organization's +// model key), mst- (the Triage key) and msp-, beside msk- (the owner's). failure-notice.mjs does not +// export its list, and packages/harness/ belongs to another lane now, so the list is copied here. +// tests/redact.test.mjs fails when a copied line no longer matches failure-notice.mjs. +// +// A text is decoded (%XX, HTML references, NFKC) and cleaned (ANSI, controls, whitespace) with +// failure-notice's own exported helpers before it is redacted. A text that holds one of the +// Console's environment secrets (secretValues), even split by spaces or controls, is withheld +// whole. A text that redacts to nothing but [redacted] says nothing and is dropped. +import { cleanText, decodeText } from '../../harness/src/failure-notice.mjs'; + +export { secretValues } from '../../harness/src/failure-notice.mjs'; + +export const LINE_MAX = 300; +export const REDACTED = '[redacted]'; + +// Copied from failure-notice.mjs. Only the key-prefix line differs: it adds mso, mst and msp. +const KEY_WORD = "(?:\\w*[_-])?(?:api[_-]?key|key|token|secret|password|passwd|authorization|cookie|session)"; +const REDACT = [ + /(? clean.replace(/[\p{M}\p{Z}\s]/gu, ''); + +function cap(text, n = LINE_MAX) { + const chars = Array.from(text); + return chars.length <= n ? text : chars.slice(0, n - 3).join('') + '...'; +} + +// One text made safe to show. Answers { text, redacted } where text is null when nothing can be +// shown: an empty text, one holding a secret (withheld: true), or one that redacts to only +// [redacted]. Redaction runs over the whole text before the cap, so the cut never parts a key word +// from its value. `secrets` is secretValues(env). +export function redactLine(line, secrets = []) { + const clean = cleanText(decodeText(String(line))); + if (!clean) return { text: null, redacted: false }; + if (secrets.length) { + const flat = compact(clean); + if (secrets.some(value => flat.includes(value))) return { text: null, redacted: true, withheld: true }; + } + let shown = clean; + for (const re of REDACT) shown = shown.replace(re, REDACTED); + shown = shown.replace(/(?:\[redacted\]\s*){2,}/g, `${REDACTED} `).trim(); + if (!shown || shown === REDACTED) return { text: null, redacted: true }; + return { text: cap(shown), redacted: shown !== clean }; +} + +// True when the whole text, joined with no spaces, holds a secret: one split across lines is seen. +export function holdsSecret(text, secrets = []) { + if (!secrets.length) return false; + const flat = compact(cleanText(decodeText(String(text)))); + return secrets.some(value => flat.includes(value)); +} + +// A stored value made safe to show: strings are redacted, and a string that cannot be shown +// becomes [redacted]. Keys that redaction would change are dropped with their value. Depth and +// size are bounded; anything past the bound becomes null. +export function redactValue(value, secrets = [], depth = 0) { + if (value === null || typeof value === 'number' || typeof value === 'boolean') return value; + if (typeof value === 'string') return value === '' ? '' : redactLine(value, secrets).text ?? REDACTED; + if (depth >= 4 || typeof value !== 'object') return null; + if (Array.isArray(value)) return value.slice(0, 64).map(item => redactValue(item, secrets, depth + 1)); + const out = {}; + for (const [key, item] of Object.entries(value).slice(0, 64)) { + if (!/^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(key) || redactLine(key, secrets).text !== key) continue; + out[key] = redactValue(item, secrets, depth + 1); + } + return out; +} diff --git a/packages/model-proxy/tests/admin-control.test.mjs b/packages/model-proxy/tests/admin-control.test.mjs index de425ae3a..0decef9bc 100644 --- a/packages/model-proxy/tests/admin-control.test.mjs +++ b/packages/model-proxy/tests/admin-control.test.mjs @@ -227,3 +227,83 @@ test('status carries the last receipts from proxy-admin.jsonl, so the page shows assert.equal(receipts.length, 10); assert.ok(receipts.every(r => r.op === 'unit.stop')); }); + +// #1873 settings-backend A1: the controller's three reads and the account-change record. +function a1Fixture(t, { unitState = { installed: true, active: 'active', healthy: true }, log = undefined, statusError = false, env = {} } = {}) { + const root = fs.mkdtempSync(join(tmpdir(), 'pc-')); + 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 calls = []; + const unit = { + unit: 'mosaic-proxy-zz.service', + status: async () => { if (statusError) throw Object.assign(new Error('systemctl gone'), { code: 'proxy-unit-failed' }); return { unit: 'mosaic-proxy-zz.service', ...unitState }; }, + ...(log === undefined ? { log: async (lines, options) => { calls.push({ lines, options }); return { unit: 'mosaic-proxy-zz.service', lines: ['ok'], redacted: 0, dropped: 0 }; } } : log === null ? {} : { log }), + }; + const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, now: () => new Date(0), env }); + return { admin, calls, configDir, dataRoot }; +} + +test('log reads the unit journal with the env secrets; a missing unit or log reader is not-configured, an unreadable state outcome-unknown', async t => { + const { admin, calls } = a1Fixture(t, { env: { MOSAIC_PROXY_KEY: 'plainwordsonly', PATH: '/usr/bin' } }); + assert.deepEqual(await admin.log(), { unit: 'mosaic-proxy-zz.service', lines: ['ok'], redacted: 0, dropped: 0 }); + assert.deepEqual(calls, [{ lines: 50, options: { secrets: ['plainwordsonly'] } }]); + await admin.log({ lines: 7 }); + assert.equal(calls[1].lines, 7); + await assert.rejects(a1Fixture(t, { unitState: { installed: false, active: 'inactive', healthy: false } }).admin.log(), code('not-configured')); + await assert.rejects(a1Fixture(t, { log: null }).admin.log(), code('not-configured')); + await assert.rejects(a1Fixture(t, { statusError: true }).admin.log(), code('outcome-unknown')); + const failing = a1Fixture(t, { log: async () => { throw Object.assign(new Error('journal'), { code: 'outcome-unknown' }); } }); + await assert.rejects(failing.admin.log(), code('outcome-unknown')); +}); + +test('serviceKey and history read the configured directories', async t => { + const { admin, configDir, dataRoot } = a1Fixture(t); + assert.equal(admin.serviceKey().problem, 'missing'); + fs.writeFileSync(join(configDir, 'proxy.json'), '{}', { mode: 0o600 }); + assert.equal(admin.serviceKey().problem, null); + assert.match(admin.serviceKey().madeAt, /^\d{4}-\d\d-\d\dT/); + assert.deepEqual(admin.history(), { entries: [], next: null }); + admin.recordAccount({ verb: 'proxy.login.status', result: { status: 'ok' } }); + assert.deepEqual(admin.history({ limit: 5 }), { entries: [{ time: new Date(0).toISOString(), op: 'account.proxy.login.complete' }], next: null }); + assert.equal(receipts(dataRoot).length, 1); +}); + +test('history withholds an env secret a receipt holds', async t => { + const { admin, dataRoot } = a1Fixture(t, { env: { PROXY_TOKEN: 'plainwordsonly' } }); + fs.mkdirSync(join(dataRoot, 'state'), { recursive: true, mode: 0o700 }); + fs.writeFileSync(receiptFile(dataRoot), JSON.stringify({ op: 'x', note: 'plain words only' }) + '\n', { mode: 0o600 }); + assert.deepEqual(admin.history().entries, [{ op: 'x', note: '[redacted]' }]); +}); + +test('recordAccount records account changes by label only, never a key, login state, callback or model name', async t => { + const { admin, dataRoot } = a1Fixture(t); + const KEY = 'sk-proj-Ab3dE5fG7hJ9kL1mN3pQ5rS7tU9vW1xY'; + assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: 'openai', key: KEY }, result: { added: true }, user: 'jason', org: 'acme' }), true); + assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: KEY, key: KEY } }), true); + assert.equal(admin.recordAccount({ verb: 'proxy.login.status', args: { state: 'state-secret-123' }, result: { status: 'ok' } }), true); + assert.equal(admin.recordAccount({ verb: 'proxy.login.status', args: { state: 'state-secret-123' }, result: { status: 'wait' } }), null); + assert.equal(admin.recordAccount({ verb: 'proxy.priority.set', args: { accountId: '0123456789ab', priority: 2 } }), true); + assert.equal(admin.recordAccount({ verb: 'proxy.group.models.set', args: { accountId: 'not-hex', models: ['secret-model-name', 'b'] }, org: '../x' }), true); + for (const verb of ['proxy.login.start', 'proxy.login.submit', 'proxy.login.cancel', 'plugins.set', 'proxy.accounts', undefined]) { + assert.equal(admin.recordAccount({ verb, args: { redirect_url: 'https://cb.example/?code=abc', provider: 'x' } }), null, String(verb)); + } + const all = receipts(dataRoot); + const at = new Date(0).toISOString(); + assert.deepEqual(all, [ + { time: at, op: 'account.proxy.apikey.add', provider: 'openai', org: 'acme', user: 'jason' }, + { time: at, op: 'account.proxy.apikey.add', provider: null }, + { time: at, op: 'account.proxy.login.complete' }, + { time: at, op: 'account.proxy.priority.set', accountId: '0123456789ab', priority: 2 }, + { time: at, op: 'account.proxy.group.models.set', accountId: null, models: 2 }, + ]); + const text = fs.readFileSync(receiptFile(dataRoot), 'utf8'); + for (const bit of ['Ab3dE5', 'state-secret', 'secret-model', 'cb.example', 'code=abc']) assert.equal(text.includes(bit), false, bit); +}); + +test('recordAccount answers false, and throws nothing, when the history cannot be written', async t => { + const { admin, dataRoot } = a1Fixture(t); + fs.mkdirSync(join(dataRoot, 'state'), { mode: 0o700 }); + fs.mkdirSync(receiptFile(dataRoot)); + assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: 'openai', key: 'k' } }), false); +}); diff --git a/packages/model-proxy/tests/admin.test.mjs b/packages/model-proxy/tests/admin.test.mjs index d3ac2bc5b..87ccf3594 100644 --- a/packages/model-proxy/tests/admin.test.mjs +++ b/packages/model-proxy/tests/admin.test.mjs @@ -6,12 +6,15 @@ import fs from 'node:fs'; import { join } from 'node:path'; import { tmpdir } from 'node:os'; import { createHash } from 'node:crypto'; +import { execFileSync } from 'node:child_process'; import { PIN } from '../src/common.mjs'; import { installPaths } from '../src/settings.mjs'; import { processTree, pidListensOn, processStartMs, verifyRestart, initLockStatus, clearInitLock, initFiles, initState, fenceState, createUnitControl, releaseState, receiptFile, unitName, + unitLog, serviceKeyState, receiptHistory, appendReceipt, LOG_LINES, HISTORY_LIMIT, } from '../src/admin.mjs'; +import { secretValues } from '../src/redact.mjs'; const code = name => error => error.code === name; const scratch = t => { const dir = fs.mkdtempSync(join(tmpdir(), 'pa-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true })); return dir; }; @@ -193,3 +196,186 @@ test('unit actions map proxy-service refusals by code and refuse a missing unit' assert.equal(started.healthy, true); assert.deepEqual(verbs, ['start']); assert.throws(() => createUnitControl({ unitDir: 'relative' }), code('proxy-unit-path')); }); + +// #1873 settings-backend A1: the reads behind the setup page's log, service key and history. +// Planted keys, one of each Mosaic prefix and short enough that only the prefix rule finds them, +// plus long ones of the real shapes. +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 ENV_SECRET = 'plainwordsonly'; +const leaks = text => [...PLANTED, ...PLANTED.map(k => k.slice(4)), TAIL.slice(0, 10), ENV_SECRET].filter(bit => text.includes(bit)); + +function journal(stdout, { code: exit = 0, calls = [] } = {}) { + return async (command, args, options) => { calls.push({ command, args, options }); if (stdout instanceof Error) throw stdout; return { code: exit, stdout, stderr: 'raw stderr msk-tag-qwertyu' }; }; +} + +test('unitLog asks journalctl for the named unit only, clamps the line count, and shows no planted key', async () => { + const calls = []; + const lines = ['proxy listening on 127.0.0.1:18432', ...PLANTED.map(k => `upstream refused ${k} for model x`), `auth with ${ENV_SECRET} ok`, 'msk-tag-qwertyu', '', 'last line']; + const result = await unitLog({ run: journal(lines.join('\n') + '\n', { calls }), unit: 'mosaic-proxy-zz.service', lines: 10000, env: { X: '1' }, secrets: secretValues({ PROXY_KEY: ENV_SECRET }) }); + assert.deepEqual(calls[0].args, ['--user', '-u', 'mosaic-proxy-zz.service', '-n', String(LOG_LINES.max), '-o', 'cat', '--no-pager', '-q']); + assert.equal(calls[0].command, 'journalctl'); + assert.deepEqual(calls[0].options.env, { X: '1' }); + assert.equal(result.unit, 'mosaic-proxy-zz.service'); + assert.equal(result.lines[0], 'proxy listening on 127.0.0.1:18432', 'a line with nothing secret shows as it is'); + assert.equal(result.lines.at(-1), 'last line'); + assert.equal(result.lines.filter(l => l === 'upstream refused [redacted] for model x').length, PLANTED.length); + assert.equal(result.redacted, PLANTED.length, 'shown lines with a redaction; dropped lines count in dropped'); + assert.equal(result.dropped, 2, 'the env-secret line and the key-only line are dropped, the blank one is not counted'); + assert.deepEqual(leaks(JSON.stringify(result)), []); + // At least one line, and a line count that is not an integer is refused. + await unitLog({ run: journal('x\n', { calls }), unit: 'mosaic-proxy.service', lines: 0 }); + assert.equal(calls.at(-1).args[4], '1'); + await assert.rejects(unitLog({ run: journal('x\n'), unit: 'mosaic-proxy.service', lines: 2.5 }), code('invalid-request')); + await assert.rejects(unitLog({ run: journal('x\n'), unit: 'mosaic-proxy.service', lines: '5' }), code('invalid-request')); +}); + +test('unitLog keeps only the last lines asked for and never takes a unit name it was not given by unitName', async () => { + const many = Array.from({ length: 30 }, (_, i) => `line ${i}`).join('\n'); + assert.deepEqual((await unitLog({ run: journal(many), unit: 'mosaic-proxy.service', lines: 3 })).lines, ['line 27', 'line 28', 'line 29']); + for (const unit of ['sshd.service', 'mosaic-proxy.service; rm', '../mosaic-proxy.service', 'mosaic-proxy-A.service', undefined]) { + await assert.rejects(unitLog({ run: journal('x'), unit, lines: 5 }), code('proxy-unit-usage'), String(unit)); + } +}); + +test('a journal that cannot be read refuses outcome-unknown with no lines and no other source', async () => { + for (const run of [journal(Object.assign(new Error('spawn journalctl ENOENT'), { code: 'ENOENT' })), journal('partial msk-tag-qwertyu', { code: 1 }), async () => ({ code: 0, stdout: null }), async () => null]) { + await assert.rejects(unitLog({ run, unit: 'mosaic-proxy.service', lines: 5 }), error => error.code === 'outcome-unknown' && !leaks(String(error.message) + JSON.stringify(error)).length); + } +}); + +test('a secret split across journal lines drops every line', async () => { + const result = await unitLog({ run: journal('ok one\nplain\nwordsonly\nok two\n'), unit: 'mosaic-proxy.service', lines: 10, secrets: [ENV_SECRET] }); + assert.deepEqual(result.lines, []); + assert.equal(result.dropped, 4); +}); + +test('createUnitControl.log runs unitLog for its own unit', async () => { + const calls = []; + const control = createUnitControl({ instance: 'zz', port: () => 1, run: journal('hello msk-tag-qwertyu\n', { calls }), probe: async () => true, waitMs: 0, pollMs: 0 }); + assert.deepEqual(await control.log(5), { unit: 'mosaic-proxy-zz.service', lines: ['hello [redacted]'], redacted: 1, dropped: 0 }); + assert.equal(calls[0].args[2], 'mosaic-proxy-zz.service'); +}); + +test('serviceKeyState answers proxy.json\'s mtime and never opens or stats the key file', t => { + const dir = scratch(t); + assert.deepEqual(serviceKeyState(dir), { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'missing' }); + const files = initFiles(dir, join(dir, 'data')); + fs.writeFileSync(files.settings, '{}', { mode: 0o600 }); + fs.mkdirSync(join(files.key, '..'), { recursive: true, mode: 0o700 }); + fs.writeFileSync(files.key, 'msk-k1a2-' + TAIL, { mode: 0o600 }); + fs.utimesSync(join(dir, 'proxy.json'), new Date(Date.UTC(2026, 10, 1, 8)), new Date(Date.UTC(2026, 10, 1, 8))); + const spies = ['openSync', 'readFileSync', 'statSync', 'lstatSync', 'accessSync', 'existsSync', 'realpathSync', 'readdirSync'].map(name => t.mock.method(fs, name)); + const state = serviceKeyState(dir); + const seen = spies.flatMap(spy => spy.mock.calls.map(call => String(call.arguments[0]))); + spies.forEach(spy => spy.mock.restore()); + assert.deepEqual(state, { madeAt: '2026-11-01T08:00:00.000Z', renewedAt: null, renewal: 'not-built', problem: null }); + assert.deepEqual(seen, [join(dir, 'proxy.json')]); + assert.deepEqual(leaks(JSON.stringify(state)), []); +}); + +test('serviceKeyState gives no date for a proxy.json that is a symlink, a directory or another user\'s', t => { + const dir = scratch(t), other = scratch(t); + fs.writeFileSync(join(other, 'real.json'), '{}'); + fs.symlinkSync(join(other, 'real.json'), join(dir, 'proxy.json')); + assert.deepEqual(serviceKeyState(dir), { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'unreadable' }); + fs.rmSync(join(dir, 'proxy.json')); fs.mkdirSync(join(dir, 'proxy.json')); + assert.equal(serviceKeyState(dir).problem, 'unreadable'); + fs.rmSync(join(dir, 'proxy.json'), { recursive: true }); fs.writeFileSync(join(dir, 'proxy.json'), '{}'); + assert.equal(serviceKeyState(dir, { uid: process.getuid() + 1 }).problem, 'unreadable'); + assert.equal(serviceKeyState(dir).problem, null); +}); + +// A receipt file with `count` entries; some lines padded so the file crosses several 64 KB chunks. +function history(t, count, { pad = 0 } = {}) { + const dataRoot = scratch(t); + for (let i = 0; i < count; i++) appendReceipt(dataRoot, { time: new Date(i * 1000).toISOString(), op: 'fetch', n: i, ...(pad ? { note: 'word '.repeat(pad) } : {}) }); + return dataRoot; +} +const pages = (dataRoot, limit, extra = {}) => { + const seen = []; let before = null, guard = 0; + do { + const page = receiptHistory(dataRoot, { limit, before, ...extra }); + seen.push(page.entries.map(e => e.n)); + before = page.next; + } while (before !== null && ++guard < 1000); + return seen; +}; + +test('receiptHistory pages newest first, oldest first within a page, each entry exactly once across chunks', t => { + const dataRoot = history(t, 300, { pad: 150 }); + assert.ok(fs.statSync(receiptFile(dataRoot)).size > 3 * 65536, 'the file spans several chunks'); + const seen = pages(dataRoot, 7); + assert.deepEqual(seen[0], [293, 294, 295, 296, 297, 298, 299]); + assert.deepEqual(seen.flat().sort((a, b) => a - b), Array.from({ length: 300 }, (_, i) => i)); + assert.equal(new Set(seen.flat()).size, 300); + assert.deepEqual(seen.reverse().flat(), Array.from({ length: 300 }, (_, i) => i), 'pages read back to front are the whole history in order'); + const first = receiptHistory(dataRoot); + assert.equal(first.entries.length, HISTORY_LIMIT.default); + assert.equal(receiptHistory(dataRoot, { limit: 1000 }).entries.length, HISTORY_LIMIT.max, 'limit is clamped'); + assert.equal(receiptHistory(dataRoot, { limit: 0 }).entries.length, 1); + assert.deepEqual(Object.keys(first.entries[0]).sort(), ['n', 'note', 'op', 'time']); +}); + +test('receiptHistory skips a torn line and a partial last line, and a write after a page does not repeat or lose entries', t => { + const dataRoot = history(t, 5); + const file = receiptFile(dataRoot); + const text = fs.readFileSync(file, 'utf8').split('\n'); + text.splice(2, 0, '{"op":"torn', '[1,2]', '{"no":"op"}', 'x'.repeat(70000)); + // The last line is a whole object whose newline is not written yet: it waits for the newline. + fs.writeFileSync(file, text.join('\n') + '{"op":"partial","n":99}'); + const first = receiptHistory(dataRoot, { limit: 2 }); + assert.deepEqual(first.entries.map(e => e.n), [3, 4]); + assert.deepEqual(receiptHistory(dataRoot, { limit: 1 }).entries.map(e => e.n), [4], 'not shown before its newline'); + fs.appendFileSync(file, '\n'); appendReceipt(dataRoot, { op: 'fetch', n: 100 }); + const rest = receiptHistory(dataRoot, { limit: 10, before: first.next }); + assert.deepEqual(rest.entries.map(e => e.n), [0, 1, 2]); + assert.equal(rest.next, null); + assert.deepEqual(receiptHistory(dataRoot, { limit: 3 }).entries.map(e => e.n), [4, 99, 100], 'the finished line shows on the next newest read'); +}); + +test('receiptHistory refuses a cursor that is not a line start, past the end, negative or not an integer', t => { + const dataRoot = history(t, 3); + const size = fs.statSync(receiptFile(dataRoot)).size; + for (const before of [1, size + 1, -1, 1.5, '10', Number.MAX_SAFE_INTEGER + 2]) { + assert.throws(() => receiptHistory(dataRoot, { before }), code('invalid-request'), String(before)); + } + assert.throws(() => receiptHistory(dataRoot, { limit: 'all' }), code('invalid-request')); + assert.deepEqual(receiptHistory(dataRoot, { before: 0 }), { entries: [], next: null }); + assert.equal(receiptHistory(dataRoot, { before: size }).entries.length, 3); +}); + +test('receiptHistory: a missing file is an empty history; a symlink, FIFO, directory, group-readable or foreign file refuses', t => { + const dataRoot = scratch(t); + assert.deepEqual(receiptHistory(dataRoot), { entries: [], next: null }); + assert.throws(() => receiptHistory(dataRoot, { before: 5 }), code('invalid-request')); + appendReceipt(dataRoot, { op: 'fetch' }); + const file = receiptFile(dataRoot); + fs.chmodSync(file, 0o640); + assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown')); + fs.chmodSync(file, 0o600); + assert.throws(() => receiptHistory(dataRoot, { uid: process.getuid() + 1 }), code('outcome-unknown')); + assert.equal(receiptHistory(dataRoot).entries.length, 1); + const elsewhere = join(scratch(t), 'x.jsonl'); fs.writeFileSync(elsewhere, '{"op":"planted"}\n', { mode: 0o600 }); + fs.rmSync(file); fs.symlinkSync(elsewhere, file); + assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown')); + fs.rmSync(file); fs.mkdirSync(file); + assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown')); + fs.rmSync(file, { recursive: true }); + execFileSync('mkfifo', ['-m', '600', file]); + assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown'), 'a FIFO is refused without blocking'); +}); + +test('receiptHistory shows no planted key from any receipt field, nested value or key name', t => { + const dataRoot = scratch(t); + for (const key of PLANTED) appendReceipt(dataRoot, { time: new Date(0).toISOString(), op: 'init', note: `made ${key}`, nested: { list: [key, { deeper: key }] }, [key.replace(/-/g, '_')]: 1 }); + appendReceipt(dataRoot, { op: 'init', env: ENV_SECRET, [`x${ENV_SECRET}`]: 1 }); + appendReceipt(dataRoot, { op: PLANTED[1] }); + const all = receiptHistory(dataRoot, { limit: 100, secrets: secretValues({ PROXY_TOKEN: ENV_SECRET }) }); + assert.equal(all.entries.length, PLANTED.length + 2); + assert.deepEqual(leaks(JSON.stringify(all)), []); + assert.deepEqual(all.entries[0], { time: new Date(0).toISOString(), op: 'init', note: 'made [redacted]', nested: { list: ['[redacted]', { deeper: '[redacted]' }] } }); + assert.deepEqual(all.entries.at(-2), { op: 'init', env: '[redacted]' }); + assert.deepEqual(all.entries.at(-1), { op: '[redacted]' }); +}); diff --git a/packages/model-proxy/tests/redact.test.mjs b/packages/model-proxy/tests/redact.test.mjs new file mode 100644 index 000000000..010d77b2b --- /dev/null +++ b/packages/model-proxy/tests/redact.test.mjs @@ -0,0 +1,108 @@ +// #1873 settings-backend A1: the redaction the setup page's log and history reads use. It is +// chat-fail's list (packages/harness/src/failure-notice.mjs) with Mosaic's key prefixes added. +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import { fileURLToPath } from 'node:url'; +import { redactLine, redactValue, holdsSecret, secretValues, REDACTED, LINE_MAX } from '../src/redact.mjs'; + +// Short keys of each Mosaic prefix, letters only, so no long-run or mixed-run rule catches them: +// only the key-prefix line does. +const SHORT = { msk: 'msk-tag-qwertyu', mso: 'mso-tag-acme-qwerty', mst: 'mst-tag-triage-zxcvb', msp: 'msp-tag-plmokn' }; + +for (const [prefix, key] of Object.entries(SHORT)) { + test(`a short ${prefix}- key is redacted from a line, and the rest of the line stays`, () => { + const safe = redactLine(`proxy said ${key} was refused`); + assert.equal(safe.text, `proxy said ${REDACTED} was refused`); + assert.equal(safe.redacted, true); + assert.equal(safe.text.includes(key), false); + // Upper case, and joined by _ instead of -, too. + assert.equal(redactLine(`proxy said ${key.toUpperCase()} x`).text, `proxy said ${REDACTED} x`); + assert.equal(redactLine(`proxy said ${key.replace('-', '_')} x`).text, `proxy said ${REDACTED} x`); + }); +} + +test('the real key shapes of each prefix are redacted', () => { + const tail = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE'; + for (const key of [`msk-k1a2-${tail}`, `mso-k1a2-acme-${tail}`, `mst-k1a2-triage-${tail}`, `msp-k1a2-${tail}`, `sk-ant-${tail}`]) { + const safe = redactLine(`key ${key} rejected by upstream`); + assert.equal(safe.text.includes(key.slice(0, 12)), false, key.slice(0, 4)); + assert.equal(safe.text.includes(tail.slice(0, 8)), false, key.slice(0, 4)); + } +}); + +test('bearer and basic tokens, key=value pairs, links, emails and paths never show', () => { + const line = 'POST https://u:p@api.example/v1?key=abc Authorization: Bearer abcdefgh api_key=hunter2 token "quoted value" ' + + 'by jane@example.com from /home/jane/.config/mosaic-dev/proxy.json and ~/.mosaic/x C:\\Users\\j \\\\host\\share Basic dXNlcjpwYXNz eyJhbGciOi.x.y'; + const safe = redactLine(line); + for (const bit of ['u:p@', 'api.example', 'abcdefgh', 'hunter2', 'quoted value', 'jane@', '/home/jane', '.config', '.mosaic', 'Users', 'share', 'dXNlcjpwYXNz', 'eyJhbGci']) { + assert.equal(safe.text.includes(bit), false, bit); + } + assert.match(safe.text, /^POST /); +}); + +test('a line holding an environment secret is withheld whole, even split by spaces, controls or encoding', () => { + const secrets = secretValues({ MOSAIC_PROXY_KEY: 'plainwordsonly', HOME: '/home/x', SHORT_TOKEN: 'abc' }); + assert.deepEqual(secrets, ['plainwordsonly'], 'only secret-named values of 8 or more characters'); + for (const line of ['started with plainwordsonly', 'started with plain words only', 'started p\u0000lainwords\u200bonly', 'started %70lainwordsonly', 'started plainwordsonly']) { + assert.deepEqual(redactLine(line, secrets), { text: null, redacted: true, withheld: true }, JSON.stringify(line)); + } + assert.equal(holdsSecret('plain\nwords\nonly', secrets), true, 'split across lines'); + assert.equal(holdsSecret('nothing here', secrets), false); + assert.equal(holdsSecret('plainwordsonly', []), false); +}); + +test('a line that is empty, blank or only redactions is dropped; a long one is cut to the line cap', () => { + assert.deepEqual(redactLine(''), { text: null, redacted: false }); + assert.deepEqual(redactLine(' \u0000\t '), { text: null, redacted: false }); + assert.deepEqual(redactLine(`${SHORT.mso} ${SHORT.mst}`), { text: null, redacted: true }); + assert.equal(redactLine(`a ${SHORT.mso} ${SHORT.mst} b`).text, `a ${REDACTED} b`, 'repeated redactions collapse'); + const long = redactLine('word '.repeat(200)); + assert.equal(Array.from(long.text).length, LINE_MAX); + assert.match(long.text, /\.\.\.$/); + assert.equal(redactLine('\u001b[31mred\u001b[0m text').text, 'red text', 'ANSI goes'); +}); + +test('a stored value is redacted all through: strings, nested strings, and keys that read as secrets', () => { + const value = { op: 'account.proxy.apikey.add', time: '2026-11-19T12:34:56.789Z', provider: 'openai', note: `got ${SHORT.mso}`, deep: { list: [SHORT.msk, 3, true, null] }, [SHORT.mst.replace(/-/g, '_')]: 'x', 'bad key': 1 }; + const out = redactValue(value); + assert.deepEqual(out, { op: 'account.proxy.apikey.add', time: '2026-11-19T12:34:56.789Z', provider: 'openai', note: `got ${REDACTED}`, deep: { list: [REDACTED, 3, true, null] } }); + assert.equal(JSON.stringify(out).includes('qwerty'), false); + // Depth and size are bounded. + assert.deepEqual(redactValue({ a: { b: { c: { d: { e: 1 } } } } }), { a: { b: { c: { d: null } } } }); + assert.equal(redactValue(Array.from({ length: 100 }, (_, i) => i)).length, 64); + assert.equal(redactValue('plainwordsonly', ['plainwordsonly']), REDACTED); + assert.equal(redactValue(undefined), null); +}); + +// chat-fail's shape: redaction runs over a whole line before the cut, so a long run with no spaces +// must stay linear. +test('a 128000-character run with no spaces is redacted in well under a second', () => { + const N = 128000; + const secrets = secretValues({ API_KEY: 'plainwordsonly' }); + for (const run of ['a'.repeat(N), 'a.'.repeat(N / 2), 'a-'.repeat(N / 2), 'a/'.repeat(N / 2), 'a:'.repeat(N / 2), 'a"'.repeat(N / 2), 'mso-'.repeat(N / 4), 'a@'.repeat(N / 2)]) { + const started = performance.now(); + const safe = redactLine(`${run} then the unit stopped`, secrets); + const took = performance.now() - started; + assert.ok(took < 1000, `${run.slice(0, 4)}... took ${Math.round(took)} ms`); + assert.ok(safe.text === null || Array.from(safe.text).length <= LINE_MAX); + } + // A run that reads as a key is redacted whole, so the words after it show. + assert.equal(redactLine(`${'a'.repeat(N)} then the unit stopped`).text, `${REDACTED} then the unit stopped`); +}); + +// The list is a copy of failure-notice.mjs's. Every line must still match it, except the key-prefix +// line, which is the original with mso, mst and msp added after msk. +test('the redaction list matches failure-notice.mjs line for line, with only the prefixes added', () => { + const source = file => fs.readFileSync(fileURLToPath(new URL(file, import.meta.url)), 'utf8'); + const block = text => { + const body = /const REDACT = \[\n([\s\S]*?)\n\];/.exec(text)[1]; + return body.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('//')).map(line => line.replace(/,\s*\/\/ .*$/, ',').replace(/,$/, '')); + }; + const keyWord = text => /const KEY_WORD = (.*);/.exec(text)[1]; + const theirs = source('../../harness/src/failure-notice.mjs'), ours = source('../src/redact.mjs'); + assert.equal(keyWord(ours), keyWord(theirs)); + const expected = block(theirs).map(line => line.replace('(?:sk|msk|rk|', '(?:sk|msk|mso|mst|msp|rk|')); + assert.equal(expected.filter((line, i) => line !== block(theirs)[i]).length, 1, 'the original has one key-prefix line'); + assert.deepEqual(block(ours), expected); +}); diff --git a/packages/webui/src/proxy-admin.mjs b/packages/webui/src/proxy-admin.mjs index bdf6c88b0..65673be13 100644 --- a/packages/webui/src/proxy-admin.mjs +++ b/packages/webui/src/proxy-admin.mjs @@ -36,7 +36,24 @@ const ROUTES = Object.freeze({ // #1873 ride-default: Ride all, and the confirmed move of one stopped fixture organization. '/api/proxy/admin/ride-all': ['POST', []], '/api/proxy/admin/ride-move': ['POST', ['org']], + // #1873 settings-backend A1: reads for Model setup. The list names each read's query keys. + '/api/proxy/admin/log': ['GET', ['lines']], + '/api/proxy/admin/service-key': ['GET', []], + '/api/proxy/admin/history': ['GET', ['limit', 'before']], }); +// The A1 reads take a query; every other route ignores one, as before. +const QUERY_ROUTES = new Set(['/api/proxy/admin/log', '/api/proxy/admin/service-key', '/api/proxy/admin/history']); +// Each query key at most once, only the route's own keys, each a plain decimal number. +function readQuery(req, allowed) { + let params; + try { params = new URL(req.url, 'http://localhost').searchParams; } catch { return null; } + const out = {}; + for (const [key, value] of params) { + if (!allowed.includes(key) || Object.hasOwn(out, key) || !/^[0-9]{1,15}$/.test(value)) return null; + out[key] = Number(value); + } + return out; +} export const PROXY_ADMIN_PATHS = Object.freeze(Object.keys(ROUTES)); const INIT_KEYS = ['generate', 'key', 'confirm', 'port', 'rotateGraceMinutes', 'firstOutputSeconds']; const json = (res, status, value) => { @@ -71,6 +88,8 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste if (req.headersDistinct.origin?.length !== 1 || req.headers.origin !== origin) return done(403, { error: 'cross-origin request refused' }); if (req.headersDistinct['sec-fetch-site']?.length !== 1 || req.headers['sec-fetch-site'] !== 'same-origin') return done(403, { error: 'cross-site request refused' }); } + let query = {}; + if (QUERY_ROUTES.has(path)) { query = readQuery(req, route[1]); if (!query) return refuse('invalid-request'); } if (!admin) return refuse('not-configured'); let args = {}; if (req.method === 'POST') { @@ -118,6 +137,9 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste case '/api/proxy/admin/ride-move': if (typeof args.org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(args.org)) return refuse('invalid-request'); return done(200, await admin.rideMove({ org: args.org, principal })); + case '/api/proxy/admin/log': return done(200, await admin.log(Object.hasOwn(query, 'lines') ? { lines: query.lines } : {})); + case '/api/proxy/admin/service-key': return done(200, await admin.serviceKey()); + case '/api/proxy/admin/history': return done(200, await admin.history({ ...(Object.hasOwn(query, 'limit') ? { limit: query.limit } : {}), before: query.before ?? null })); } } catch (error) { const code = ['human-required', 'not-configured', 'invalid-request'].includes(error?.code) ? error.code : proxyCode(error, 'outcome-unknown'); diff --git a/packages/webui/src/proxy-http.mjs b/packages/webui/src/proxy-http.mjs index 2c2a563ab..79d83cf37 100644 --- a/packages/webui/src/proxy-http.mjs +++ b/packages/webui/src/proxy-http.mjs @@ -18,7 +18,10 @@ const codes = ['not-configured', 'human-required', 'provider-not-allowed', 'logi const json = (res, status, value) => { res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(value)); }; -export async function proxyHTTP(req, res, { path, call, named, tester, granted, send, origin, user, log }) { +// `record` is the proxy setup controller's recordAccount (settings-backend A1), or null where this +// Console has no proxy setup: after a write's bus call answers, an account change is added to the +// setup history. A record that fails leaves the bus answer as it is and adds recorded: false. +export async function proxyHTTP(req, res, { path, call, named, tester, granted, send, origin, user, log, record = null }) { const route = routes[path]; const done = (status, value) => { // No request body, query, login state, authorization URL or exception text. @@ -48,11 +51,18 @@ export async function proxyHTTP(req, res, { path, call, named, tester, granted, } catch { return done(400, { error: 'invalid-request' }); } } if (path === '/api/proxy/plugins/set' && (!args.plugins || typeof args.plugins !== 'object' || Array.isArray(args.plugins) || Object.keys(args.plugins).length !== 1 || !['harness', 'model-provider'].includes(Object.keys(args.plugins)[0]) || !Array.isArray(Object.values(args.plugins)[0]) || !Object.values(args.plugins)[0].every(name => typeof name === 'string'))) return done(400, { error: 'invalid-request' }); - try { return done(200, await call(route[1], args)); } + let value; + try { value = await call(route[1], args); } catch (error) { const code = codes.includes(error.code) || (path === '/api/proxy/plugins/set' && typeof error.code === 'string' && /^[a-z-]{1,64}$/.test(error.code)) ? error.code : 'outcome-unknown'; // proxy-pickup (#1873): a bus with no proxy client names the cause in one plain line. const reason = code === 'not-configured' && typeof error.reason === 'string' ? { reason: error.reason.slice(0, 300) } : {}; return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code, ...reason }); } + if (req.method === 'POST' && typeof record === 'function') { + let recorded; + try { recorded = record({ verb: route[1], args, result: value, user: user ?? null }); } catch { recorded = false; } + if (recorded === false && value && typeof value === 'object' && !Array.isArray(value)) value = { ...value, recorded: false }; + } + return done(200, value); } diff --git a/packages/webui/src/serve.mjs b/packages/webui/src/serve.mjs index 201fedeea..5f043b645 100644 --- a/packages/webui/src/serve.mjs +++ b/packages/webui/src/serve.mjs @@ -1051,7 +1051,8 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, principal: currentSession ? { provider: currentSession.provider, iss: currentSession.iss, sub: currentSession.sub } : null, log }); if (path.startsWith('/api/proxy/')) return proxyHTTP(req, res, { path, call: proxyCall, named, tester, granted, - send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log }); + send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log, + record: proxyAdmin && typeof proxyAdmin.recordAccount === 'function' ? entry => proxyAdmin.recordAccount({ ...entry, org: orgId }) : null }); } // #1873 triage-host: the Triage session's two routes answer only the instance owner's own session on // the public name, with no organization selected. Anyone else falls through to the answer an diff --git a/packages/webui/tests/proxy-admin-http.test.mjs b/packages/webui/tests/proxy-admin-http.test.mjs index deb59d533..67525065a 100644 --- a/packages/webui/tests/proxy-admin-http.test.mjs +++ b/packages/webui/tests/proxy-admin-http.test.mjs @@ -20,7 +20,10 @@ const ROUTES = [ ['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'], ]; +const READS = ROUTES.filter(([p]) => ['log', 'service-key', 'history'].includes(p)); function fakeAdmin() { const calls = []; @@ -33,6 +36,10 @@ function fakeAdmin() { 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; }, }; } const send = (port, path, { method = 'GET', headers = {}, body } = {}) => new Promise((resolve, reject) => { @@ -54,7 +61,7 @@ async function devServer(t, options = {}) { } 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', () => { +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', () => { assert.deepEqual(PROXY_ADMIN_PATHS, ROUTES.map(([p]) => `/api/proxy/admin/${p}`)); }); @@ -64,7 +71,7 @@ test('the dev local owner reaches every route; init and fence clear go to the bu 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']); + assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear', 'rideAll', 'rideMove', 'log', 'serviceKey', 'history']); 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 }); @@ -245,3 +252,166 @@ test('a signed-in member who is not the instance owner gets human-required for r } 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); +});