Compare commits

...
Author SHA1 Message Date
jason.woltje de39750ebb fix(webui): settings-s5b recheck: after an empty history page, folding the list keeps Show older, since the line still names it (N1); a test holds that a successful Read again moves focus to Show older (N2); tests red on 3b17326b7 (#1873, lane settings-s5b) 2026-11-19 23:30:29 -06:00
jason.woltje 3b17326b74 fix(webui): settings-s5b review: Show older shows whenever there is an older page and nothing read is folded away, and what it reads stays open; Show all only when entries are folded (P2-1); an older page not further back than the one asked for is outcome unknown (P3-1); when the pressed history button goes, focus lands on Read again, Show older, Show fewer, then the heading (P3-2); a service that is not installed has no lines, said plainly, not as a failed read (P3-3); an unknown history action reads Other setup action, even one named like an object property (P3-4); a hidden user reads "someone whose name Mosaic hid" (P3-5); a test holds a stale history answer (P3-6); the service key is the last row of the state list and fails in the same banner style with Read again (P3-7); the setup-stops test now refuses a real unit start; tests red on d03ae494e (#1873, lane settings-s5b) 2026-11-19 23:17:08 -06:00
jason.woltje d03ae494e8 fix(webui): settings-s5b: in Technical details the service key and the history sit right after Release and Service, as models-advanced shows them, with the service's last lines after the history; history entries are not numbered (#1873, lane settings-s5b) 2026-11-19 22:59:03 -06:00
jason.woltje e1b56d9ea7 feat(webui): settings-s5b: Model setup's Technical details shows when the service key was made (GET /api/proxy/admin/service-key, never the key, with renewal not built yet), the setup history a page at a time (GET /api/proxy/admin/history, withheld rows plain, an empty page with a next page still offers Show older) and the service's last lines (GET /api/proxy/admin/log, as the answer gives them); a failed step 1 opens the lines; each read waits until its box opens, a failed read says so with Read again, and none of it is read or shown for a non-owner; the raw receipts list is gone; leaving the Models page for any page drops its focus request; tests red on e6f6f5445 (#1873, lane settings-s5b) 2026-11-19 22:53:50 -06:00
jason.woltje e6f6f5445b fix(webui): settings-s5 recheck: coming back to an organization's Models page reads the model service again, so the not set up line goes once the owner has set it up (N1); a switch left while it writes no longer moves focus to its outcome line on the next visit, and a render that paints no outcome line drops the focus request (N2); tests red on da123f6dd (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje 55f9652f6a fix(webui): settings-s5 review P2-1: while an organization needs a restart its Models page leaves out Stop using your models, as the org-models-restart mockup does, since buttons here have no disabled look; the shots add the model service not set up state (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje 9e434c0e9c fix(webui): settings-s5 review: on an organization's Models page Stop using your models waits while the organization needs a restart (P2-1); the header says the models come from your accounts only when the plugins read says the organization uses them, and from its own organization file when not (P2-2); a choice not in force says when the model service isn't set up or isn't answering, with a link to Model setup, from the owner's status read (P2-3); after a switch focus moves to the outcome line (P2-4); Use your models shows Saving while its write is out (P3-1); a failed read before the write says "Not changed. Nothing was written." with Read again (P3-2); a Console with no organizations says "this business" mid-sentence (P3-3); the choice sits in the form column at 1440 (P3-4); tests red on e4bb2be14 (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje e732ae7450 test(webui): settings-s5: shots of Acme Studio's models (not using your models, after Use your models, needs a restart), the account reasons, step 3 can't start, Technical details and Messages at 390 and 1440, light and dark, measured for sideways scroll and focus rings; "No accounts yet." on Model setup reads as one line instead of squeezing into the name column, with a test red without the shell.css rule (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje 66255c9bf2 feat(webui): settings-s5: an organization's Models page offers its one choice, "Where <Org> gets its models": Use your models (the cliproxy model-provider module, written through plugins.set after a fresh read, refused when the page is stale or a route draft is open) or Use its own model service, dashed, disabled and badged Coming later; the page says from the plugins read which one is in force and what a switch changes, Stop using your models is the way back, a refusal keeps the read's choice, a failed read offers Read again, and while the organization needs a restart its banner's Restart is the one primary and the choice waits; the sidebar marks read the status again after a switch; tests for slice 5 and the slice 4 items, red on 524132b42 except the no-Details control case (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje cecc901854 fix(webui): settings-s5: a failed turn in Messages whose body carries its own "\nDetails: " part shows its cause and "Details:" once, split on the first "\nDetails: " as chat.js does; #/settings/members and #/orgs/<id>/settings/members land on that organization's Agents page at #/settings/agents?org=<id> (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje 81ca8399a2 fix(webui): settings-s5: Model setup names each organization by its display name in the Move confirm, its result, the not-moved line and the skipped lines, and a stand-in organization's line says "your models" in step 3's words; before the first account step 3 names an organization the sidebar marks "can't start", with a Can't start badge, and stays closed; Technical details and Advanced show the timeouts init chose (firstOutputSeconds, rotateGraceMinutes, "the default" when proxy.json leaves them unset) from the status read; MosaicModelDots gains read() so another page can ask the marks to read the status again (#1873, lane settings-s5) 2026-11-19 21:48:50 -06:00
jason.woltje 37c3854849 fix(model-proxy): settings-backend A1 review P3-1 and P3-3: a short Mosaic key glued to a word (xmso-..., _msk-...) is redacted by one added line after the copied key-prefix line, which the pin test now expects; a history entry whose redacted values, or keys and values, read together still hold an environment secret split across them is answered as { withheld: true }; comments name the split-key journal limit (P3-2) and the unmarked non-object answer (P3-9) (#1873, lane settings-backend-a1) 2026-11-19 21:09:58 -06:00
jason.woltje db2dc96aa2 feat(model-proxy): settings-backend A1: three instance-owner reads under /api/proxy/admin/ for Model setup: the model service's last log lines with keys and secrets removed (log), the service key's made-at time from proxy.json's mtime with no renewal yet (service-key), and setup history a page at a time (history); account writes through /api/proxy/* and an organization's proxy routes now join that history by label only; redaction is chat-fail's list with the mso-, mst- and msp- prefixes added, pinned to failure-notice.mjs (#1873, lane settings-backend-a1) 2026-11-19 21:09:58 -06:00
jason.woltje f666590d54 fix(proxy-scope): slice 4 review round 1: a save runs ensure only when it creates the route, so after Turn Triage off only Repair access brings a key back; the key walk stops at a bus whose outcome is unknown and the whole walk has one 30 s deadline; the status reads the same riding list the walk asks; a repeated sweep refusal is logged when it appears or changes and then once an hour; Off asks first and each key action has its own plain line; the host send-path test asserts the stop before it waits (#1873, lane proxy-scope-s4) 2026-11-19 20:41:55 -06:00
jason.woltje 2f20346719 feat(proxy-scope): slice 4: the bus issues, rotates and retires the Triage key through proxy.triage.key (op ensure or revoke), for the instance owner's path-bound proof only; a riding bus sweeps a due rotation or retirement under the instance proxy lock, re-reads the file, never issues the first key and does the work once across buses; the Console asks one riding organization's bus on the first save, Repair access and Off, shows triage-no-riding-bus and rotation overdue, and stops a session at its key's retireAt with triage-key-rotated; answers, events and receipts carry key ids only (#1873, lane proxy-scope-s4) 2026-11-19 20:41:55 -06:00
37 changed files with 3582 additions and 125 deletions

No files matched your search

+24 -1
View File
@@ -708,6 +708,7 @@ export class Broker {
#credentialVerbs;
#proxyInit;
#proxyFenceClear;
#proxyTriageKey;
#proxyPage;
#project;
#library;
@@ -772,7 +773,7 @@ export class Broker {
#processing;
#taskTracker;
// credentialStatus is the runtime's metadata-only Credentials.status(); the broker never gets use().
constructor({ store, businesses, pluginService = null, secretCheck = () => {}, credentialStatus = () => [], organization = null, hires = null, autonomy = null, project = null, library = null, usage = null, limits = null, harnessOn = null, credentialVerbs = null, proxyInit = null, proxyFenceClear = null, proxyPage = null, hostGrant = null, hostKeys = null, processing = null, testerOn = null, grantScope = null, roleFile = null, giteaGrant = null, copyGrant = null, copyLaunch = null, copyRevoker = null, giteaKeys = null, access = null, accessStamp = null, compactions = null, requestLifecycle = null, requirementsHost = null, workspaceRead = null, taskTracker = null }) {
constructor({ store, businesses, pluginService = null, secretCheck = () => {}, credentialStatus = () => [], organization = null, hires = null, autonomy = null, project = null, library = null, usage = null, limits = null, harnessOn = null, credentialVerbs = null, proxyInit = null, proxyFenceClear = null, proxyTriageKey = null, proxyPage = null, hostGrant = null, hostKeys = null, processing = null, testerOn = null, grantScope = null, roleFile = null, giteaGrant = null, copyGrant = null, copyLaunch = null, copyRevoker = null, giteaKeys = null, access = null, accessStamp = null, compactions = null, requestLifecycle = null, requirementsHost = null, workspaceRead = null, taskTracker = null }) {
if (!object(businesses) || !Object.keys(businesses).length) fail('invalid-business');
// Row 194 b15 (sage-2501): the function-argument checks come before anything reads the store.
if (harnessOn !== null && typeof harnessOn !== 'function') throw new TypeError('harnessOn must be a function');
@@ -802,6 +803,7 @@ export class Broker {
this.#credentialVerbs = credentialVerbs;
this.#proxyInit = proxyInit;
this.#proxyFenceClear = proxyFenceClear;
this.#proxyTriageKey = proxyTriageKey;
this.#proxyPage = proxyPage;
this.#hostGrant = hostGrant;
this.#hostKeys = hostKeys;
@@ -6220,6 +6222,27 @@ export class Broker {
return result;
}).catch(error => { throw this.#refused(s, new BusError(/^proxy-[a-z-]+$/.test(error.code ?? '') ? error.code : 'proxy-down'), { verb: request.verb }); });
}
// proxy-scope slice 4 (Jason 2026-11-19): ensure or revoke the instance's Triage key through the
// proxy this bus rides. Owner only, before every other gate, like proxy.fence.clear. The
// answer, the event and the refusal carry key ids and codes only, never a key.
if (request.verb === 'proxy.triage.key') {
this.#human(s);
if (!this.#proxyTriageKey) fail('not-configured');
const args = request.args ?? {};
keys(args, ['op'], ['op']);
if (args.op !== 'ensure' && args.op !== 'revoke') fail('invalid-request');
const ID = /^[0-9a-f]{12}$/;
const idList = v => Array.isArray(v) && v.every(id => typeof id === 'string' && ID.test(id));
return Promise.resolve().then(() => this.#proxyTriageKey(args.op)).then(result => {
const ACTIONS = args.op === 'ensure' ? ['issued', 'held', 'replaced'] : ['revoked', 'none'];
if (!object(result) || !ACTIONS.includes(result.action) || !idList(result.addedKeyIds) || !idList(result.removedKeyIds)
|| (args.op === 'ensure' && !(typeof result.keyId === 'string' && ID.test(result.keyId)))) fail('proxy-client-response');
const answer = { op: args.op, action: result.action, addedKeyIds: [...result.addedKeyIds], removedKeyIds: [...result.removedKeyIds],
...(args.op === 'ensure' ? { keyId: result.keyId, rotateBy: /^\d{4}-\d{2}-\d{2}$/.test(result.rotateBy ?? '') ? result.rotateBy : null } : {}) };
this.#store.transaction(() => this.#event(s, 'action.allowed', { call: 'proxy.triage.key', ...answer }, null));
return answer;
}).catch(error => { throw this.#refused(s, error instanceof BusError ? error : new BusError('storage-unavailable', 'triage-key-failed'), { verb: request.verb }); });
}
// FED R3 (design 3.5, 3.7 trigger 1): a user reaches the collaborator list only, and each
// request reads the access file again, so a removed or expired grant refuses the next one.
let grants = null;
+4
View File
@@ -87,6 +87,10 @@ group("proxy-key-mismatch", "R1: a pasted management key is confirmed before ini
group("proxy-lock-busy proxy-lock-invalid", "R4: one proxy key write at a time", "Wait for the running proxy write to finish and retry. An invalid lock file needs the owner to inspect the proxy state directory.");
group("proxy-not-configured proxy-unit-usage proxy-unit-exists proxy-unit-dropin proxy-unit-copy proxy-unit-path proxy-unit-missing proxy-unit-unhealthy proxy-unit-failed", "R1/R4: proxy user unit is explicit creation", "Initialize the proxy first, then install the unit from the Proxy page or with mosaic proxy unit install. An existing unit or drop-in is never replaced; remove it by hand. An unhealthy unit: read its journal by unit name and restart it.");
group("proxy-client-invalid proxy-client-refused proxy-client-response", "R1: proxy management answers", "Check the proxy unit is running and its port answers on the Proxy page, then retry. Upstream bodies are never shown.");
// proxy-scope slice 4 (Jason 2026-11-19): the Triage key lives with a bus that rides the owner's
// proxy, and a Triage session on a key past its retireAt ends before the key leaves the proxy.
group("triage-no-riding-bus", "R1/R4: the Triage key is issued and rotated by a bus that rides the owner's proxy", "Triage needs one organization that uses the owner's models. Start an organization that rides the owner's model proxy, then repair Triage access from Settings, Triage.");
group("triage-key-rotated", "R1/R6: a session ends when its Triage key's grace ends", "The Triage key was rotated and the old key's grace has ended. Send the next message; Triage starts again on the current key.");
group(
"block-recipient block-reply-required block-sender message-recipient-refused message-sender-refused tester-reply-required tester-thread-human user-reply-required user-thread-human",
"Role messaging: permitted sender, recipient and reply context",
+84 -3
View File
@@ -34,6 +34,7 @@ import { createModelCatalogue } from './model-catalogue.mjs';
import { sha256 } from '../../model-proxy/src/common.mjs';
import { initializeProxy, loadProxy } from '../../model-proxy/src/settings.mjs';
import { createProxyLock } from './proxy-lock.mjs';
import { ensureKey, readKey as readTriageKey, revokeKeys, sweepDue, sweepKeys } from './triage-key.mjs';
import { verifyRestart } from '../../model-proxy/src/admin.mjs';
import { ModelKeys, modelOrganization, stopModelRuns, MODEL_STOP_TIMEOUT_MS } from './model-keys.mjs';
import { instanceSettings } from '../../organization/src/instance-settings.mjs';
@@ -622,6 +623,10 @@ export async function startBroker({
// P1 validated sidecar from the trusted host; never a socket request setting.
proxy = null,
org = null, instanceDataRoot = null, instanceConfigDir = null,
// proxy-scope slice 4: the Triage key sweep on a riding org bus. intervalMs (default 30 s) and
// marginMs (default 30 s past a retiring key's retireAt, so the Console stops a session on it
// first) are in-process seams, as are now and hook (triage-key.mjs's clock and stage hook).
triageKeys = {},
// Host-only preparation/admission capabilities. The host builds its own from the organization writer and `trackers`
// (request-host.mjs); anything given here replaces the host's, and a capability nothing supplies leaves a setup wait.
requestServices = {},
@@ -657,6 +662,8 @@ export async function startBroker({
throw new BusError('invalid-host-request');
let modelProxyClient = null, proxyPage = null, proxyUsage = null, usageTimer = null, proxyLock = null, proxyPort = null;
let modelKeys = null, modelTimer = null, modelSweep = null, modelCatalogues = null;
// proxy-scope slice 4: the settings of the proxy this bus rides (boot, picked up or initialized).
let proxySettings = null, triageTimer = null, triageSweepRun = null;
const modelRuns = new Map();
let store, credentials, server, adapter, processing, syncTimer = null, syncPass = null, accessTimer = null, requestTimer = null, copyLaunch = null, copyRevoker = null, copyTimer = null;
// #1873 CB4: a revoke's stop waits for the broker; a start that fails before it exists stops nothing.
@@ -707,7 +714,7 @@ export async function startBroker({
proxyLock = createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${proxy.port}` });
}
modelProxyClient = await loadManagementClient({ configDir: org ? instanceConfigDir : organization.dir, proxy, receipt: proxyReceipt });
proxyPort = proxy.port;
proxyPort = proxy.port; proxySettings = proxy;
}
// Row 234 (#1740, r6 X4 third bullet): each host grant record gives its agent a store reference to
@@ -845,7 +852,7 @@ export async function startBroker({
// is no client: static text and a refusal code, never a path or a key.
let lateProxy = false, proxyCause = null, proxySync = Promise.resolve();
const dropLateProxy = cause => {
if (lateProxy) { modelProxyClient = null; proxyPage = null; proxyPort = null; proxyLock = null; lateProxy = false; modelCatalogues?.invalidate?.(); }
if (lateProxy) { modelProxyClient = null; proxyPage = null; proxyPort = null; proxyLock = null; proxySettings = null; lateProxy = false; modelCatalogues?.invalidate?.(); }
proxyCause = cause;
};
// The host refuses fixture-proxy-configured at boot when a dev fixture is recorded for the
@@ -879,11 +886,65 @@ export async function startBroker({
catch { return dropLateProxy('The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.'); }
}
proxyCause = null;
proxySettings = found;
// Same port, key and lock still load: keep the client and its page, which holds login states.
if (modelProxyClient) return;
modelProxyClient = client; proxyPort = found.port; proxyLock = lock; lateProxy = true;
configureProxyPage(); modelCatalogues?.invalidate?.();
}
// proxy-scope slice 4: what triage-key.mjs needs from a riding org bus. A key error becomes a bus
// refusal the table already holds: proxy codes it knows pass through, the rest name the key
// store's code in the reason only. Neither carries a key, a path or upstream text.
// The verb checks the proxy first, as proxy.fence.clear does; the sweep uses what this bus holds
// and never picks a proxy up on its own timer.
const triageOptions = async ({ sync = true } = {}) => {
if (sync) await syncProxy();
if (org === null || !organization || !proxyLock || !modelProxyClient || !proxySettings || typeof instanceConfigDir !== 'string' || typeof instanceDataRoot !== 'string')
throw new BusError('triage-no-riding-bus');
return { configDir: instanceConfigDir, system: { dataRoot: instanceDataRoot, proxy: proxySettings }, client: modelProxyClient, lock: proxyLock,
...(triageKeys.now ? { now: triageKeys.now } : {}), ...(triageKeys.hook ? { hook: triageKeys.hook } : {}) };
};
const TRIAGE_PASS = new Set(['proxy-lock-busy', 'proxy-lock-invalid', 'proxy-lock-uncertain', 'proxy-client-invalid', 'proxy-client-refused', 'proxy-client-response', 'proxy-management-key-invalid']);
const TRIAGE_MAP = { 'triage-key-no-proxy': 'triage-no-riding-bus', 'triage-key-raced': 'proxy-lock-busy', 'triage-key-unconfirmed': 'proxy-lock-uncertain',
'proxy-uncertain': 'proxy-lock-uncertain', 'proxy-client-down': 'proxy-client-response', 'proxy-client-redirect': 'proxy-client-response', 'triage-key-proxy-open': 'proxy-not-configured' };
const triageRefusal = error => {
if (error instanceof BusError) return error;
const code = typeof error?.code === 'string' ? error.code : '';
if (TRIAGE_PASS.has(code)) return new BusError(code);
if (Object.hasOwn(TRIAGE_MAP, code)) return new BusError(TRIAGE_MAP[code], code);
return new BusError('storage-unavailable', /^triage-key-[a-z-]+$/.test(code) ? code : 'triage-key-failed');
};
// The sweep: a cheap read of the file first, so the proxy is asked only when something is due;
// sweepKeys decides again under the lock. It never issues: no file, nothing.
const triageMarginMs = Number.isSafeInteger(triageKeys.marginMs) && triageKeys.marginMs >= 0 ? triageKeys.marginMs : 30_000;
// A refusal that repeats on every tick is logged when it first appears or changes, and then once
// an hour while it stays the same; any other outcome clears it.
let triageLastRefusal = null;
const sweepRefused = (now, entry) => {
const sig = `${entry.code}|${entry.reason ?? ''}`;
if (triageLastRefusal?.sig === sig && now - triageLastRefusal.at < 3_600_000) return;
triageLastRefusal = { sig, at: now };
proxyReceipt({ action: 'triage.key.sweep-refused', ...entry });
};
const sweepTriage = async () => {
let opts;
try { opts = await triageOptions({ sync: false }); } catch { return { action: 'none' }; }
const now = (opts.now ?? Date.now)();
let record;
try { record = readTriageKey(opts.configDir); } catch { sweepRefused(now, { code: 'triage-key-unreadable' }); return { action: 'none' }; }
if (!sweepDue(record, now, triageMarginMs)) { triageLastRefusal = null; return { action: 'none' }; }
try {
const result = await sweepKeys(opts, { marginMs: triageMarginMs });
triageLastRefusal = null;
if (result.action !== 'none') proxyReceipt({ action: `triage.key.${result.action}`, keyId: result.keyId ?? null, addedKeyIds: result.addedKeyIds, removedKeyIds: result.removedKeyIds });
return result;
} catch (error) {
const refusal = triageRefusal(error);
sweepRefused(now, { code: refusal.code, ...(typeof refusal.reason === 'string' ? { reason: refusal.reason } : {}) });
return { action: 'refused', code: refusal.code };
}
};
const triageSweepOnce = () => (triageSweepRun ??= sweepTriage().finally(() => { triageSweepRun = null; }));
// One check at a time; an unexpected failure drops a late client, never keeps it.
const syncProxy = () => (proxySync = proxySync.then(pickProxy).catch(() => dropLateProxy('The model proxy could not be checked (proxy-down). Try again shortly.')));
// Unavailable with no client: the catalogue names the cause instead of a bare unavailable.
@@ -1419,7 +1480,7 @@ export async function startBroker({
const lock = org && !proxyLock ? createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${settings.port}` }) : proxyLock;
// proxy-pickup: a client this bus did not boot with is checked again like a picked-up one.
if (!proxy) { lateProxy = true; proxyCause = null; }
modelProxyClient = client; proxyPort = settings.port; proxyLock = lock;
modelProxyClient = client; proxyPort = settings.port; proxyLock = lock; proxySettings = settings;
configureProxyPage(); modelCatalogues?.invalidate?.();
return settings;
} : null,
@@ -1430,6 +1491,15 @@ export async function startBroker({
if (!proxyLock || !modelProxyClient) throw new BusError('not-configured', proxyCause ?? undefined);
return proxyLock.clear({ restarted: true, read: () => modelProxyClient.getKeys(), verify: previous => verifyRestart(evidence, { fence: previous, port: proxyPort }) });
} : null,
// proxy-scope slice 4 (Jason 2026-11-19): ensure or revoke the instance's Triage key through the
// proxy this org bus rides, under the bus's own client and instance proxy lock. The answer is
// ids only. A no-org bus, or an org bus with no proxy client and lock, refuses
// triage-no-riding-bus.
proxyTriageKey: async (op) => {
const opts = await triageOptions();
try { return op === 'ensure' ? await ensureKey(opts) : await revokeKeys(opts); }
catch (error) { throw triageRefusal(error); }
},
credentialVerbs: organization
? credentialVerbs({ credentials, writer: organizationWriter({ dir: organization.dir, rolesDir: organization.rolesDir, dataRoot:instanceRoot ?? dataRoot }),
organizations: () => Object.keys(businesses), boot: copies?.definitions ? { org: copies.org, definitions: copies.definitions } : null })
@@ -1737,6 +1807,12 @@ export async function startBroker({
}, access.intervalMs ?? ACCESS_SWEEP_MS);
accessTimer.unref();
}
// proxy-scope slice 4: only an org bus sweeps the Triage key; each tick checks it still rides.
if (org !== null && organization) {
triageTimer = setInterval(() => { triageSweepOnce(); },
Number.isSafeInteger(triageKeys.intervalMs) && triageKeys.intervalMs > 0 ? triageKeys.intervalMs : 30_000);
triageTimer.unref();
}
if (modelKeys) {
modelTimer = setInterval(() => {
if (modelSweep) return;
@@ -1905,6 +1981,8 @@ export async function startBroker({
definitionScan,
launches: bound,
readers: readCaps,
// proxy-scope slice 4: one Triage key sweep now, as the timer runs it (tests).
triageKeySweep: () => triageSweepOnce(),
async close() {
clearInterval(copyTimer);
brokerUp(null);
@@ -1913,6 +1991,8 @@ export async function startBroker({
await proxyUsage.close();
clearInterval(modelTimer);
await modelSweep;
clearInterval(triageTimer);
await triageSweepRun;
clearInterval(accessTimer);
await stopSync();
await server.close();
@@ -1930,6 +2010,7 @@ export async function startBroker({
clearInterval(usageTimer);
await proxyUsage?.close();
clearInterval(modelTimer);
clearInterval(triageTimer);
clearInterval(accessTimer);
await server?.close();
await adapter?.close?.();
+2
View File
@@ -155,6 +155,8 @@ export async function serve({ broker, path, authenticateHuman = null, authentica
// Row 236 (#1742): the grants verbs may call Gitea several times, 15 s each at most.
GRANTS_VERBS.includes(r.verb) ||
r.verb === 'proxy.init' ||
// proxy-scope slice 4: the Triage key verb waits on the proxy lock and the proxy.
r.verb === 'proxy.triage.key' ||
(r.verb === 'decision.raise' && (Object.hasOwn(r.args ?? {}, 'spec_path') || Object.hasOwn(r.args ?? {}, 'spec_commit') ||
Object.hasOwn(r.args ?? {}, 'grant')))) {
const own = transient;
File renamed without changes.
@@ -1,5 +1,9 @@
// #1873 triage-key: Triage's own model proxy client key, issued from the owner's terminal
// (design report reports/triage-route-design.md slice 3, Jason's ruling 2026-11-18).
// (design report reports/triage-route-design.md slice 3, Jason's ruling 2026-11-18), and since
// proxy-scope slice 4 (Jason's ruling 2026-11-19) by the bus too: the verb proxy.triage.key
// (ensure, revoke) and a riding org bus's sweep call this module with the bus's own management
// client and instance proxy lock. It moved here from packages/cli/src so the bus can import it; the
// terminal verbs (packages/cli/src/triage.mjs) call it unchanged.
//
// <configDir>/secrets/triage/model (directory 0700, file 0600, the running user's)
// { version, key, keyId, issuedAt, rotateBy, retiring: [{ key, keyId, issuedAt, retireAt }] }
@@ -16,9 +20,11 @@
// uncertain fence, which every proxy writer on the instance refuses until a human clears it
// (`mosaic proxy fence clear --proxy-restarted`).
//
// Nothing runs on a timer. rotate records when the old key's grace ends; the key stays in the proxy
// until a later retire, rotate or issue removes it, and status says when that is due. The same goes
// for rotateBy: status marks it due; only rotate replaces the key.
// rotate records when the old key's grace ends; the key stays in the proxy until a later retire,
// rotate, issue or sweep removes it, and status says when that is due. A riding org bus runs
// sweepKeys on a timer: under the lock it reads the file again and rotates when rotateBy is due, or
// retires keys whose grace (plus a margin, so the Console stops a session on the key first) has
// passed. The sweep only replaces a key that exists; it never issues the first one.
//
// Nothing here prints, logs or records a key. Receipts and output carry key ids only (the first 12
// hex of sha256(key), the id the bus uses). Messages name files and options, never values.
@@ -27,7 +33,7 @@ import { closeSync, constants, fchmodSync, fsyncSync, lstatSync, openSync, readd
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { isDeepStrictEqual } from "node:util";
import { createProxyLock } from "../../bus/src/proxy-lock.mjs";
import { createProxyLock } from "./proxy-lock.mjs";
import { loadManagementClient } from "../../model-proxy/src/client.mjs";
// #1873 triage-wiring: the key file's reader lives in triage-key-file.mjs (node built-ins only), so
@@ -136,20 +142,24 @@ const proxyFailure = (code) => {
};
// opts.uid, opts.now and opts.hook(stage) are test seams; a stage hook may throw or kill the process.
function context({ configDir, system, uid, fileUid, now, hook }) {
// opts.client and opts.lock: the bus passes its own management client and instance proxy lock, so a
// bus change runs under the lock object its model key sweep uses and reads no key file of its own.
function context({ configDir, system, uid, fileUid, now, hook, client, lock }) {
if (!system?.proxy || !Number.isInteger(system.proxy.port)) throw new TriageKeyError("triage-key-no-proxy", "the instance has no model proxy set up (proxy.json)");
return {
configDir, dataRoot: system.dataRoot, proxy: system.proxy, stateDir: join(system.dataRoot, "proxy"),
uid: uid ?? process.getuid(), fileUid, now: now ?? Date.now, hook: hook ?? (() => {}),
uid: uid ?? process.getuid(), fileUid, now: now ?? Date.now, hook: hook ?? (() => {}), client, lock,
};
}
function lockFor(c) {
if (c.lock) return c.lock;
try { return createProxyLock({ stateDir: c.stateDir, identity: `${c.configDir}:${c.proxy.port}` }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-lock-invalid"); }
}
async function clientFor(c) {
if (c.client) return c.client;
try { return await loadManagementClient({ configDir: c.configDir, proxy: c.proxy }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-management-key-invalid"); }
}
@@ -162,9 +172,10 @@ function checkSentinel(c, keys) {
}
// Under the instance proxy lock: read the list, check the sentinel, run `plan`, write the result.
// `plan(keys, record)` returns { after, record, removed, added, done }; `record` null leaves the
// file alone. The proxy changes first, then the file, then one receipt line.
async function change(c, op, plan) {
// `plan(keys, record)` returns { after, record, remove, op, done }; `record` null leaves the file
// alone, `remove` true unlinks it (revoke), `op` names the change when the plan picks it (sweep).
// The proxy changes first, then the file, then one receipt line.
async function change(c, opName, plan) {
const lock = lockFor(c);
const client = await clientFor(c);
try {
@@ -173,6 +184,8 @@ async function change(c, op, plan) {
checkSentinel(c, before);
const current = readKey(c.configDir, { uid: c.uid, fileUid: c.fileUid });
const result = plan(before, current);
const op = result.op ?? opName;
const remove = result.remove === true && current !== null;
if (result.record) prepareDirs(c.configDir, c.uid);
removeTemps(c.configDir);
receiptsReady(c.stateDir, c.uid);
@@ -195,8 +208,8 @@ async function change(c, op, plan) {
}
c.hook("write");
let unsynced = false;
if (result.record) {
try { writeKey(c.configDir, result.record, c.uid, c.hook); }
if (result.record || remove) {
try { if (remove) unlinkKey(c.configDir, c.hook); else writeKey(c.configDir, result.record, c.uid, c.hook); }
catch (e) {
if (e instanceof NotSynced) unsynced = true;
else throw new TriageKeyError("triage-key-unwritten", `the proxy list changed but ${keyPaths(c.configDir).file} was not written (${e.message}); fix the file's directory, then run mosaic triage key ${op} again, which clears what this run left`);
@@ -204,7 +217,7 @@ async function change(c, op, plan) {
}
c.hook("receipt");
// A run that changed neither the proxy nor the file leaves no receipt.
if (added.length || removed.length || result.record) receipt(c.stateDir, c.uid, { op: `triage.key.${op}`, time: new Date(c.now()).toISOString(), addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) });
if (added.length || removed.length || result.record || remove) receipt(c.stateDir, c.uid, { op: `triage.key.${op}`, time: new Date(c.now()).toISOString(), addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) });
// The file is in place and the receipt written; only its durability is in doubt.
if (unsynced) throw new TriageKeyError("triage-key-unsynced", `${keyPaths(c.configDir).file} was written but its directory could not be synced, so it may not survive a power loss; run mosaic triage key status`);
return { ...result.done, addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) };
@@ -215,6 +228,18 @@ async function change(c, op, plan) {
}
}
// Revoke's file step: unlink, then sync the directory, with writeKey's stages and failures.
function unlinkKey(configDir, hook = () => {}) {
const { dir, file } = keyPaths(configDir);
try { hook("rename"); unlinkSync(file); }
catch (e) { if (e?.code !== "ENOENT") throw unreadable("the key file cannot be removed"); }
try {
hook("sync");
const dfd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY);
try { fsyncSync(dfd); } finally { closeSync(dfd); }
} catch { throw new NotSynced(); }
}
const newKey = (configDir) => keyPrefix(configDir) + randomBytes(32).toString("base64url");
// Keys in the Triage namespace that the file does not hold: left by a crash between the PUT and the
@@ -235,39 +260,117 @@ export async function issueKey(opts) {
});
}
// Retiring keys whose grace has passed, or that the proxy no longer holds.
const dueOf = (record, keys, nowMs) => record.retiring.filter((r) => Date.parse(r.retireAt) <= nowMs || !keys.includes(r.key));
// Retiring keys whose grace (plus marginMs, 0 for the terminal verbs) has passed, or that the proxy
// no longer holds.
const dueOf = (record, keys, nowMs, marginMs = 0) => record.retiring.filter((r) => Date.parse(r.retireAt) + marginMs <= nowMs || !keys.includes(r.key));
const rotateDueAt = (record) => Date.parse(`${record.rotateBy}T00:00:00Z`);
// The rotate plan, shared by the terminal verb and the sweep.
function rotatePlan(c, before, current, nowMs, marginMs = 0) {
const orphans = orphansOf(c.configDir, before, current);
const due = dueOf(current, before, nowMs, marginMs);
const keep = before.includes(current.key);
const retiring = [...current.retiring.filter((r) => !due.includes(r)),
...(keep ? [{ key: current.key, keyId: current.keyId, issuedAt: current.issuedAt, retireAt: retireAtFor(nowMs, c.proxy) }] : [])];
if (retiring.length > MAX_RETIRING) throw new TriageKeyError("triage-key-failed", "too many keys are retiring; run mosaic triage key retire once their grace has passed");
const key = newKey(c.configDir);
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring };
const drop = [...orphans, ...due.map((r) => r.key)];
return {
after: [...before.filter((k) => !drop.includes(k)), key], record,
done: { keyId: record.keyId, rotateBy: record.rotateBy, old: keep ? { keyId: current.keyId, retireAt: retiring.at(-1).retireAt } : { keyId: current.keyId, lost: true } },
};
}
export async function rotateKey(opts) {
const c = context(opts);
return change(c, "rotate", (before, current) => {
if (!current) throw new TriageKeyError("triage-key-not-issued", "no Triage key is issued; use mosaic triage key issue");
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = dueOf(current, before, nowMs);
const keep = before.includes(current.key);
const retiring = [...current.retiring.filter((r) => !due.includes(r)),
...(keep ? [{ key: current.key, keyId: current.keyId, issuedAt: current.issuedAt, retireAt: retireAtFor(nowMs, c.proxy) }] : [])];
if (retiring.length > MAX_RETIRING) throw new TriageKeyError("triage-key-failed", "too many keys are retiring; run mosaic triage key retire once their grace has passed");
const key = newKey(c.configDir);
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring };
const drop = [...orphans, ...due.map((r) => r.key)];
return {
after: [...before.filter((k) => !drop.includes(k)), key], record,
done: { keyId: record.keyId, rotateBy: record.rotateBy, old: keep ? { keyId: current.keyId, retireAt: retiring.at(-1).retireAt } : { keyId: current.keyId, lost: true } },
};
return rotatePlan(c, before, current, c.now());
});
}
function retirePlan(c, before, current, nowMs, marginMs = 0) {
const orphans = orphansOf(c.configDir, before, current);
const due = current ? dueOf(current, before, nowMs, marginMs) : [];
const record = current && due.length ? { ...current, retiring: current.retiring.filter((r) => !due.includes(r)) } : null;
const drop = [...orphans, ...due.map((r) => r.key)];
return { after: before.filter((k) => !drop.includes(k)), record, done: { droppedKeyIds: due.map((r) => r.keyId) } };
}
export async function retireKeys(opts) {
const c = context(opts);
return change(c, "retire", (before, current) => {
return change(c, "retire", (before, current) => retirePlan(c, before, current, c.now()));
}
// proxy-scope slice 4: the bus verb proxy.triage.key op ensure. Leaves a held key alone, issues one
// when none exists, replaces one the proxy lost. Never prints the key; the answer is ids only.
// issued no file: a new key (keys in the namespace the file does not hold are removed)
// held the proxy holds the file's key: only orphans and retiring keys the proxy lost go
// replaced the proxy does not hold the file's key: a new key, the old one marked lost
export async function ensureKey(opts) {
const c = context(opts);
return change(c, "ensure", (before, current) => {
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = current ? dueOf(current, before, nowMs) : [];
const record = current && due.length ? { ...current, retiring: current.retiring.filter((r) => !due.includes(r)) } : null;
const drop = [...orphans, ...due.map((r) => r.key)];
return { after: before.filter((k) => !drop.includes(k)), record, done: { droppedKeyIds: due.map((r) => r.keyId) } };
const fresh = (retiring) => {
const key = newKey(c.configDir);
return { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring };
};
if (!current) {
const record = fresh([]);
return { after: [...before.filter((k) => !orphans.includes(k)), record.key], record, done: { action: "issued", keyId: record.keyId, rotateBy: record.rotateBy } };
}
const lost = current.retiring.filter((r) => !before.includes(r.key));
const retiring = current.retiring.filter((r) => !lost.includes(r));
if (before.includes(current.key)) {
return {
after: before.filter((k) => !orphans.includes(k)), record: lost.length ? { ...current, retiring } : null,
done: { action: "held", keyId: current.keyId, rotateBy: current.rotateBy },
};
}
const record = fresh(retiring);
return {
after: [...before.filter((k) => !orphans.includes(k)), record.key], record,
done: { action: "replaced", keyId: record.keyId, rotateBy: record.rotateBy, old: { keyId: current.keyId, lost: true } },
};
});
}
// proxy-scope slice 4: op revoke, when the owner turns Triage off. Every name in this instance's
// Triage namespace leaves the proxy list, then the key file goes. No file and no names: nothing.
export async function revokeKeys(opts) {
const c = context(opts);
return change(c, "revoke", (before, current) => {
const mine = before.filter(inNamespace(c.configDir));
return { after: before.filter((k) => !mine.includes(k)), record: null, remove: true, done: { action: mine.length || current ? "revoked" : "none" } };
});
}
// What a sweep would do from the file alone: "rotate" when rotateBy has come, "retire" when a
// retiring key's grace plus marginMs has passed, else null. A cheap check without the lock or the
// proxy; sweepKeys decides again under the lock.
export function sweepDue(record, nowMs, marginMs = 0) {
if (!record) return null;
if (rotateDueAt(record) <= nowMs) return "rotate";
return record.retiring.some((r) => Date.parse(r.retireAt) + marginMs <= nowMs) ? "retire" : null;
}
// The bus sweep. Under the instance proxy lock it reads the file again and acts only if the action
// is still due, so two buses that wake together change the proxy once. No file: nothing, ever.
export async function sweepKeys(opts, { marginMs = 0 } = {}) {
const c = context(opts);
return change(c, "sweep", (before, current) => {
const nowMs = c.now();
const due = sweepDue(current, nowMs, marginMs);
if (due === "rotate") {
const plan = rotatePlan(c, before, current, nowMs, marginMs);
return { ...plan, op: "rotate", done: { action: "rotated", ...plan.done } };
}
if (due === "retire") {
const plan = retirePlan(c, before, current, nowMs, marginMs);
return { ...plan, op: "retire", done: { action: "retired", ...plan.done } };
}
return { after: before, record: null, done: { action: "none" } };
});
}
+305
View File
@@ -0,0 +1,305 @@
// proxy-scope slice 4 (#1873): the Triage key in the bus. Real organization buses on one instance,
// a stand-in proxy management server on loopback and a temporary config directory; nothing here
// reads a real config, proxy or secret. Each test scans every answer, event, receipt line and
// stderr line for every Triage key the stand-in ever held.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { createHash, randomBytes } from 'node:crypto';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { keyPaths, readKey } from '../src/triage-key.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
const NOW = Date.parse('2026-11-18T12:00:00.000Z');
const MIN = 60_000, HOUR = 60 * MIN, DAY = 24 * HOUR;
const MANAGE = 'fx1873-s4-manage';
const KEY_PATH = '/v8/management/config/access/api-keys';
const sha = s => createHash('sha256').update(s).digest('hex');
const tag = dir => sha(dir).slice(0, 12);
const id = key => sha(key).slice(0, 12);
const b64 = () => randomBytes(32).toString('base64url');
const code = name => e => e.code === name;
// Every Triage key the stand-in ever held, and every text a bus produced, across the file.
const SEEN = new Set();
const TEXTS = [];
function leaks(text) {
for (const key of SEEN) {
const secret = key.slice(-43);
if (text.includes(key) || text.includes(secret)) return key.slice(0, 8);
for (let i = 0; i + 8 <= secret.length; i++) if (text.includes(secret.slice(i, i + 8))) return key.slice(0, 8);
}
return null;
}
// Every stderr line while the test runs: the bus's model-proxy receipt lines go there.
function captureStderr(t) {
const write = process.stderr.write, lines = [];
process.stderr.write = (chunk, ...rest) => { lines.push(String(chunk)); return write.call(process.stderr, chunk, ...rest); };
t.after(() => { process.stderr.write = write; TEXTS.push(lines.join('')); });
return lines;
}
async function instance(t) {
const root = fs.realpathSync(fs.mkdtempSync(join(tmpdir(), 'tkb-')));
const configDir = join(root, 'config');
fs.mkdirSync(join(configDir, 'secrets'), { recursive: true, mode: 0o700 });
fs.chmodSync(configDir, 0o700); fs.chmodSync(join(configDir, 'secrets'), 0o700);
fs.writeFileSync(join(configDir, 'secrets', 'proxy-management.key'), MANAGE, { mode: 0o600 });
fs.mkdirSync(join(root, 'proxy'), { mode: 0o700 });
const sentinel = `msk-${tag(configDir)}-sentinel-${b64()}`, orgKey = `mso-${tag(configDir)}-other-key-${b64()}`;
// triagePuts counts the writes that changed a Triage name; the organization buses' own key
// reconcile writes the list too, and those do not count.
const state = { keys: [sentinel, 'foreign-client-key', orgKey], puts: [], triagePuts: 0 };
const triageNames = list => JSON.stringify(list.filter(k => k.startsWith('mst-')).sort());
const server = http.createServer(async (req, res) => {
if (req.url !== KEY_PATH) {
const key = req.headers.authorization?.slice(7);
res.writeHead(state.keys.includes(key) ? 200 : 401); res.end('{}'); return;
}
if (req.headers.authorization !== `Bearer ${MANAGE}`) { res.writeHead(401); res.end('{}'); return; }
if (req.method === 'GET') { res.end(JSON.stringify(state.keys)); return; }
const chunks = []; for await (const c of req) chunks.push(c);
const next = JSON.parse(Buffer.concat(chunks));
for (const k of next) if (/^mst-.*-[A-Za-z0-9_-]{43}$/.test(k)) SEEN.add(k);
state.puts.push(next);
if (triageNames(next) !== triageNames(state.keys)) state.triagePuts++;
state.keys = next;
res.end('{"status":"ok"}');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
const port = server.address().port;
const closers = [];
t.after(async () => {
for (const close of closers.reverse()) await close().catch(() => {});
server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
const receipts = join(root, 'proxy', 'mosaic-keys.receipts.jsonl');
if (fs.existsSync(receipts)) TEXTS.push(fs.readFileSync(receipts, 'utf8'));
fs.rmSync(root, { recursive: true, force: true });
});
const rolesDir = rolesCopy(root), system = systemFor(root);
const f = {
root, configDir, port, state, closers, rolesDir, system, sentinel, orgKey, clock: { now: NOW },
prefix: `mst-${tag(configDir)}-triage-`,
file: keyPaths(configDir).file,
record: () => readKey(configDir),
triageKeys: () => f.state.keys.filter(k => k.startsWith(f.prefix)),
receipts: () => {
const p = join(root, 'proxy', 'mosaic-keys.receipts.jsonl');
return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse) : [];
},
// A real organization bus on this instance. `proxy: false` starts it with no proxy settings, as
// a bus on an instance with no proxy.json does.
async bus(orgId, { proxy = true, triageKeys = {} } = {}) {
const doc = businessDoc(root, orgId);
doc.plugins = { ...doc.plugins, harness: ['pi'] };
writeJson(join(configDir, 'businesses', `${orgId}.json`), doc);
const business = loadBusiness(orgId, { dir: configDir, rolesDir }), resolved = {};
for (const name of Object.keys(business.roles)) resolved[name] = resolveInstance({ system, business, instance: name });
const dataRoot = join(root, `${orgId}-bus`);
fs.mkdirSync(dataRoot, { mode: 0o700 }); new Registry(dataRoot);
const bus = await startBroker({ dataRoot, businesses: { [orgId]: busOrganization(business, resolved) },
organization: { dir: configDir, rolesDir, system }, ...(proxy ? { proxy: { port, binary: '/fixture-unused' } } : {}),
org: { id: orgId }, instanceDataRoot: root, instanceConfigDir: configDir,
triageKeys: { intervalMs: 3_600_000, now: () => f.clock.now, ...triageKeys } });
closers.push(() => bus.close());
const cap = bus.broker.bindHuman({ business: orgId, human: business.human ?? doc.human, via: 'cli', outsideAgent: true });
const ask = async (verb, args) => {
try { const answer = await bus.broker.request(cap, { verb, args }); TEXTS.push(JSON.stringify(answer)); return answer; }
catch (error) { TEXTS.push(JSON.stringify({ code: error.code, reason: error.reason, message: error.message, nextStep: error.nextStep })); throw error; }
};
const sweep = async () => { const r = await bus.triageKeySweep(); TEXTS.push(JSON.stringify(r)); return r; };
return { bus, ask, sweep, dataRoot };
},
};
return f;
}
// Every byte under a bus's data root (its store, with events and refusals, and its logs), as text.
function eventsText(b, called = true) {
const out = [];
const walk = dir => {
for (const name of fs.readdirSync(dir)) {
const p = join(dir, name), st = fs.lstatSync(p);
if (st.isDirectory()) walk(p);
else if (st.isFile()) out.push(fs.readFileSync(p).toString('latin1'));
}
};
walk(b.dataRoot);
if (called) assert.ok(out.join('').includes('proxy.triage.key'), 'the store holds the verb\'s events');
return out.join('\n');
}
test('ensure issues one key, a second ensure keeps it, and both answers carry ids only', async t => {
captureStderr(t);
const f = await instance(t);
const a = await f.bus('alpha');
const first = await a.ask('proxy.triage.key', { op: 'ensure' });
assert.equal(first.action, 'issued');
assert.equal(f.triageKeys().length, 1);
const record = f.record();
assert.equal(first.keyId, record.keyId);
assert.equal(first.keyId, id(f.triageKeys()[0]));
assert.deepEqual(first.addedKeyIds, [record.keyId]);
assert.equal(fs.statSync(f.file).mode & 0o777, 0o600);
const second = await a.ask('proxy.triage.key', { op: 'ensure' });
assert.deepEqual(second, { op: 'ensure', action: 'held', addedKeyIds: [], removedKeyIds: [], keyId: record.keyId, rotateBy: record.rotateBy });
assert.equal(f.triageKeys().length, 1, 'ensure twice gives one key');
assert.equal(f.record().key, record.key);
// Through a second riding bus on the same instance: still the one key.
const b = await f.bus('beta');
assert.equal((await b.ask('proxy.triage.key', { op: 'ensure' })).action, 'held');
assert.equal(f.triageKeys().length, 1);
assert.equal(f.state.triagePuts, 1, 'only the first ensure wrote the proxy list');
// The receipt names the change by op and ids.
const receipts = f.receipts().filter(r => r.op?.startsWith('triage.'));
assert.deepEqual(receipts.map(r => [r.op, r.addedKeyIds, r.removedKeyIds]), [['triage.key.ensure', [record.keyId], []]]);
for (const text of [eventsText(a), eventsText(b)]) assert.equal(leaks(text), null);
});
test('ensure replaces a key the proxy lost, and revoke removes every Triage name and the file', async t => {
captureStderr(t);
const f = await instance(t);
const a = await f.bus('alpha');
const issued = await a.ask('proxy.triage.key', { op: 'ensure' });
// The proxy loses the key (removed by hand): ensure issues a new one and names the old as lost.
f.state.keys = f.state.keys.filter(k => !k.startsWith(f.prefix));
const replaced = await a.ask('proxy.triage.key', { op: 'ensure' });
assert.equal(replaced.action, 'replaced');
assert.notEqual(replaced.keyId, issued.keyId);
assert.equal(f.triageKeys().length, 1);
// An orphan in the namespace (a crash left it) goes with revoke too.
const orphan = `${f.prefix}${b64()}`; SEEN.add(orphan);
f.state.keys.push(orphan);
const revoked = await a.ask('proxy.triage.key', { op: 'revoke' });
assert.equal(revoked.action, 'revoked');
assert.deepEqual(revoked.removedKeyIds.sort(), [replaced.keyId, id(orphan)].sort());
assert.equal(f.triageKeys().length, 0);
assert.equal(fs.existsSync(f.file), false);
assert.equal(f.record(), null);
// Revoke again: nothing to do, nothing written.
const puts = f.state.triagePuts;
assert.deepEqual(await a.ask('proxy.triage.key', { op: 'revoke' }), { op: 'revoke', action: 'none', addedKeyIds: [], removedKeyIds: [] });
assert.equal(f.state.triagePuts, puts);
// Namespace guard: the sentinel, the organization key and the foreign key are still there.
for (const k of [f.sentinel, f.orgKey, 'foreign-client-key']) assert.ok(f.state.keys.includes(k), k.slice(0, 4));
assert.equal(leaks(eventsText(a)), null);
});
test('a bus that does not ride the owner\'s proxy refuses triage-no-riding-bus, and its sweep does nothing', async t => {
captureStderr(t);
const f = await instance(t);
const loose = await f.bus('loose', { proxy: false });
await assert.rejects(loose.ask('proxy.triage.key', { op: 'ensure' }), e => e.code === 'triage-no-riding-bus'
&& /^Triage needs one organization that uses the owner's models\./.test(e.nextStep));
await assert.rejects(loose.ask('proxy.triage.key', { op: 'revoke' }), code('triage-no-riding-bus'));
assert.equal(f.state.triagePuts, 0);
// With a key issued through a riding bus and its rotation due, the loose bus still does nothing.
const a = await f.bus('alpha');
await a.ask('proxy.triage.key', { op: 'ensure' });
f.clock.now += 31 * DAY;
assert.deepEqual(await loose.sweep(), { action: 'none' });
assert.equal(f.state.triagePuts, 1);
});
test('the sweep rotates when rotateBy comes, once across two buses that wake together, and again a rotation later', async t => {
captureStderr(t);
const f = await instance(t);
const a = await f.bus('alpha'), b = await f.bus('beta');
const issued = await a.ask('proxy.triage.key', { op: 'ensure' });
// Not due yet: neither bus touches the proxy.
assert.deepEqual([await a.sweep(), await b.sweep()], [{ action: 'none' }, { action: 'none' }]);
assert.equal(f.state.triagePuts, 1);
f.clock.now = Date.parse(`${issued.rotateBy}T00:00:00Z`);
const both = await Promise.all([a.sweep(), b.sweep()]);
assert.deepEqual(both.map(r => r.action).sort(), ['none', 'rotated']);
assert.equal(f.state.triagePuts, 2, 'two buses rotated once');
const rotated = both.find(r => r.action === 'rotated');
const record = f.record();
assert.equal(rotated.keyId, record.keyId);
assert.deepEqual(record.retiring.map(r => r.keyId), [issued.keyId]);
assert.equal(f.triageKeys().length, 2, 'the old key stays live through its grace');
// Inside the grace both buses leave it; at retireAt plus the margin one of them retires it.
const retireAt = Date.parse(record.retiring[0].retireAt);
f.clock.now = retireAt + 10_000;
assert.deepEqual((await Promise.all([a.sweep(), b.sweep()])).map(r => r.action), ['none', 'none']);
f.clock.now = retireAt + 30_000;
const retired = await Promise.all([a.sweep(), b.sweep()]);
assert.deepEqual(retired.map(r => r.action).sort(), ['none', 'retired']);
assert.equal(f.state.triagePuts, 3);
assert.deepEqual(f.triageKeys().map(id), [record.keyId]);
assert.deepEqual(f.record().retiring, []);
// A second rotation 30 days on: again once.
f.clock.now = Date.parse(`${record.rotateBy}T00:00:00Z`) + HOUR;
const again = await Promise.all([b.sweep(), a.sweep()]);
assert.deepEqual(again.map(r => r.action).sort(), ['none', 'rotated']);
assert.equal(f.state.triagePuts, 4);
assert.equal(f.triageKeys().length, 2);
// Namespace guard across every sweep.
for (const k of [f.sentinel, f.orgKey, 'foreign-client-key']) assert.ok(f.state.keys.includes(k), k.slice(0, 4));
const ops = f.receipts().filter(r => r.op?.startsWith('triage.')).map(r => r.op);
assert.deepEqual(ops, ['triage.key.ensure', 'triage.key.rotate', 'triage.key.retire', 'triage.key.rotate']);
for (const bus of [a, b]) assert.equal(leaks(eventsText(bus, bus === a)), null);
});
test('the sweep never issues the first key, and a sweep refusal is a receipt line with a code only', async t => {
const lines = captureStderr(t);
const f = await instance(t);
const a = await f.bus('alpha');
f.clock.now += 400 * DAY;
assert.deepEqual(await a.sweep(), { action: 'none' });
assert.equal(f.state.triagePuts, 0);
assert.equal(f.record(), null);
// A due rotation on a proxy with no sentinel (it may be another proxy): refused, nothing written.
await a.ask('proxy.triage.key', { op: 'ensure' });
f.state.keys = f.state.keys.filter(k => k !== f.sentinel);
f.clock.now += 31 * DAY;
const r = await a.sweep();
assert.deepEqual(r, { action: 'refused', code: 'proxy-not-configured' });
assert.equal(f.state.triagePuts, 1);
const refusal = lines.join('').split('\n').filter(l => l.includes('triage.key.sweep-refused'));
assert.equal(refusal.length, 1);
assert.deepEqual(JSON.parse(refusal[0].replace(/^model-proxy: /, '')), { action: 'triage.key.sweep-refused', code: 'proxy-not-configured', reason: 'triage-key-proxy-open' });
// The same refusal on the next ticks is not logged again within the hour; after it, once more.
const refusals = () => lines.join('').split('\n').filter(l => l.includes('triage.key.sweep-refused')).length;
for (let i = 0; i < 3; i++) { f.clock.now += 30_000; assert.equal((await a.sweep()).code, 'proxy-not-configured'); }
assert.equal(refusals(), 1);
f.clock.now += HOUR;
await a.sweep();
assert.equal(refusals(), 2);
});
test('a revoke stopped between the proxy write and the file is finished by the next revoke; ensure after a stopped revoke replaces the key', async t => {
captureStderr(t);
const f = await instance(t);
let stage = null;
const a = await f.bus('alpha', { triageKeys: { hook: s => { if (s === stage) throw new Error(`stop at ${s}`); } } });
await a.ask('proxy.triage.key', { op: 'ensure' });
stage = 'write';
await assert.rejects(a.ask('proxy.triage.key', { op: 'revoke' }), e => e.code === 'storage-unavailable' && !/stop at/.test(e.message));
assert.equal(f.triageKeys().length, 0, 'the proxy write happened');
assert.ok(f.record(), 'the file stayed');
stage = null;
// ensure now sees a file whose key the proxy lacks: a new key, the old named lost.
const replaced = await a.ask('proxy.triage.key', { op: 'ensure' });
assert.equal(replaced.action, 'replaced');
stage = 'rename';
await assert.rejects(a.ask('proxy.triage.key', { op: 'revoke' }), code('storage-unavailable'));
stage = null;
assert.equal((await a.ask('proxy.triage.key', { op: 'revoke' })).action, 'revoked');
assert.equal(f.record(), null);
assert.equal(f.triageKeys().length, 0);
});
test('no answer, event, receipt line or stderr line in this file holds any Triage key the stand-in saw', () => {
assert.ok(SEEN.size >= 8, `only ${SEEN.size} keys were seen`);
assert.ok(TEXTS.length >= 30, `only ${TEXTS.length} texts`);
for (const text of TEXTS) assert.equal(leaks(text), null);
});
+125
View File
@@ -0,0 +1,125 @@
// proxy-scope slice 4 (#1873): the bus verb proxy.triage.key at the broker. Only the instance
// owner's path-bound proof (a human cap from the cli transport, outside any agent) reaches the
// runtime's hook; an agent, a tester, a Console proof, a grant holder and an organization owner get
// human-required, a reader read-only. The answer and the event carry key ids only, and a hook
// failure that is not a bus refusal becomes storage-unavailable with no text of its own.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { Broker, BusError } from '../src/broker.mjs';
import { Store } from '../src/store.mjs';
import { REFUSALS } from '../src/refusals.mjs';
const role = { authority: { withinRole: ['message.send'], crossRole: [] } };
const code = name => error => error.code === name;
const SUBJECT = { provider: 'fixture', iss: 'https://sso.invalid', sub: 'owner-1' };
// A Triage key as triage-key.mjs makes them, so a leak check has a real-looking value to look for.
const KEY = `mst-0123456789ab-triage-${'Q'.repeat(20)}xY_-${'z'.repeat(19)}`;
function fixture(t, { proxyTriageKey = null } = {}) {
const store = new Store(fs.mkdtempSync(join(tmpdir(), 'tkv-bus-')));
t.after(() => store.close());
const b = new Broker({ store, proxyTriageKey, businesses: { demo: { id: 'demo', human: 'owner', arbiters: { technical: 'chief', delivery: 'chief' }, vars: { 'bus.tester': true }, roles: { chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } }, coder: role } } } });
return {
store, b,
human: b.bindHuman({ business: 'demo', human: 'owner', via: 'cli', outsideAgent: true }),
tester: b.bindTester({ business: 'demo' }), reader: b.bindReader({ business: 'demo' }),
agent: b.bindLaunch({ business: 'demo', role: 'coder', run: 'tkv-run', harness: 'pi' }),
// The owner's Console proof, a granted account that holds org.hire, and an organization owner
// who is not the instance owner: none is the path-bound cli proof.
console: b.bindConsole({ business: 'demo', human: 'owner', subject: SUBJECT }),
grant: b.bindHireConsole({ business: 'demo', actor: 'grantee', subject: { ...SUBJECT, sub: 'grantee-1' }, rights: ['org.hire', 'decide'] }),
orgOwner: b.bindHireConsole({ business: 'demo', actor: 'orgowner', subject: { ...SUBJECT, sub: 'orgowner-1' }, rights: ['org.hire'], owner: true }),
};
}
const events = store => JSON.stringify(store.all('SELECT body FROM events'));
const bodies = store => store.all('SELECT body FROM events').map(r => JSON.parse(r.body));
test('proxy.triage.key refuses an agent, a tester, a Console proof, a grant holder and an organization owner with human-required, and a reader with read-only', async t => {
let calls = 0;
const f = fixture(t, { proxyTriageKey: async () => { calls++; return { action: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-19', addedKeyIds: ['0123456789ab'], removedKeyIds: [] }; } });
for (const op of ['ensure', 'revoke']) {
for (const [name, cap] of [['agent', f.agent], ['tester', f.tester], ['console', f.console], ['grant', f.grant], ['orgOwner', f.orgOwner]])
assert.throws(() => f.b.request(cap, { verb: 'proxy.triage.key', args: { op } }), code('human-required'), `${name} ${op}`);
assert.throws(() => f.b.request(f.reader, { verb: 'proxy.triage.key', args: { op } }), code('read-only'));
}
assert.equal(calls, 0);
// The same verb runs for the owner's cli proof.
const answer = await f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'ensure' } });
assert.equal(answer.action, 'issued');
assert.equal(calls, 1);
});
test('proxy.triage.key takes op ensure or revoke and nothing else, and a bus with no hook is not-configured', async t => {
let calls = 0;
const f = fixture(t, { proxyTriageKey: async () => { calls++; return { action: 'none', addedKeyIds: [], removedKeyIds: [] }; } });
for (const args of [{}, { op: 'rotate' }, { op: 'issue' }, { op: 'ensure', key: KEY }, { op: 'revoke', force: true }, { op: ['ensure'] }])
assert.throws(() => f.b.request(f.human, { verb: 'proxy.triage.key', args }), code('invalid-request'), JSON.stringify(args));
assert.throws(() => f.b.request(f.human, { verb: 'proxy.triage.key' }), code('invalid-request'));
assert.equal(calls, 0);
assert.equal(events(f.store).includes(KEY), false);
assert.equal(events(f.store).includes(KEY.slice(-43)), false);
const g = fixture(t);
assert.throws(() => g.b.request(g.human, { verb: 'proxy.triage.key', args: { op: 'ensure' } }), code('not-configured'));
});
test('the answer and the event of each op carry ids only, even when the hook returns more', async t => {
const seen = [];
const f = fixture(t, { proxyTriageKey: async op => {
seen.push(op);
// A hook that returns the key beside the ids: the broker copies the named fields only.
return op === 'ensure'
? { action: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-19', addedKeyIds: ['0123456789ab'], removedKeyIds: ['ba9876543210'], key: KEY, old: { key: KEY } }
: { action: 'revoked', addedKeyIds: [], removedKeyIds: ['0123456789ab'], key: KEY };
} });
const ensure = await f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'ensure' } });
assert.deepEqual(ensure, { op: 'ensure', action: 'issued', addedKeyIds: ['0123456789ab'], removedKeyIds: ['ba9876543210'], keyId: '0123456789ab', rotateBy: '2026-12-19' });
const revoke = await f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'revoke' } });
assert.deepEqual(revoke, { op: 'revoke', action: 'revoked', addedKeyIds: [], removedKeyIds: ['0123456789ab'] });
assert.deepEqual(seen, ['ensure', 'revoke']);
assert.deepEqual(bodies(f.store).filter(b => b.call === 'proxy.triage.key'), [{ call: 'proxy.triage.key', ...ensure }, { call: 'proxy.triage.key', ...revoke }]);
for (const text of [JSON.stringify(ensure), JSON.stringify(revoke), events(f.store)]) {
assert.equal(text.includes(KEY), false);
assert.equal(text.includes(KEY.slice(-43)), false);
}
});
test('an answer the broker cannot vouch for refuses proxy-client-response and records no allowed event', async t => {
const answers = [
null, { action: 'issued' },
{ action: 'deleted', keyId: '0123456789ab', addedKeyIds: [], removedKeyIds: [] },
{ action: 'issued', keyId: KEY, addedKeyIds: [], removedKeyIds: [] },
{ action: 'issued', keyId: '0123456789ab', addedKeyIds: [KEY], removedKeyIds: [] },
{ action: 'held', keyId: '0123456789ab', addedKeyIds: [], removedKeyIds: 'none' },
];
let next = 0;
const f = fixture(t, { proxyTriageKey: async () => answers[next++] });
for (const answer of answers)
await assert.rejects(f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'ensure' } }), code('proxy-client-response'), JSON.stringify(answer));
await assert.rejects(Promise.resolve().then(() => fixture(t, { proxyTriageKey: async () => ({ action: 'issued', addedKeyIds: [], removedKeyIds: [] }) }))
.then(g => g.b.request(g.human, { verb: 'proxy.triage.key', args: { op: 'revoke' } })), code('proxy-client-response'));
assert.equal(bodies(f.store).some(b => b.call === 'proxy.triage.key'), false);
assert.equal(events(f.store).includes(KEY.slice(-43)), false);
});
test('a bus refusal from the hook passes through with its guidance; any other failure is storage-unavailable and names nothing from the error', async t => {
const f = fixture(t, { proxyTriageKey: async op => { throw op === 'ensure' ? new BusError('triage-no-riding-bus') : Object.assign(new Error(`boom ${KEY} /home/x`), { code: 'EACCES' }); } });
await assert.rejects(f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'ensure' } }), e => e.code === 'triage-no-riding-bus'
&& /Triage needs one organization that uses the owner's models/.test(e.nextStep ?? REFUSALS['triage-no-riding-bus'].nextStep));
await assert.rejects(f.b.request(f.human, { verb: 'proxy.triage.key', args: { op: 'revoke' } }), e => e.code === 'storage-unavailable'
&& !JSON.stringify({ ...e, message: e.message }).includes(KEY.slice(-43)) && !String(e.message).includes('/home/x'));
assert.equal(events(f.store).includes(KEY.slice(-43)), false);
});
test('the two slice 4 codes have refusal-table entries with a next step and no absolute path', () => {
for (const c of ['triage-no-riding-bus', 'triage-key-rotated']) {
const entry = REFUSALS[c];
assert.ok(entry, c);
assert.equal(typeof entry.nextStep, 'string', c);
assert.ok(entry.nextStep.length > 20, c);
assert.equal(/\/(home|mnt|srv|tmp)\//.test(entry.nextStep), false, c);
}
assert.match(REFUSALS['triage-no-riding-bus'].nextStep, /^Triage needs one organization that uses the owner's models\./);
});
+2 -2
View File
@@ -16,7 +16,7 @@
//
// mosaic triage key issue | rotate | retire | status
//
// Triage's own model proxy client key (packages/cli/src/triage-key.mjs). Human verbs as well,
// Triage's own model proxy client key (packages/bus/src/triage-key.mjs, shared with the bus). Human verbs as well,
// refused in an agent run before anything is read. No output names a key, only its id.
import { lstatSync } from "node:fs";
import { join } from "node:path";
@@ -24,7 +24,7 @@ import { fileURLToPath } from "node:url";
import { readRoute, RouteStoreError, writeRoute } from "../../webui/src/triage-route-store.mjs";
import { loadSystem } from "./config.mjs";
import { configDir } from "../../organization/src/organization-config.mjs";
import { issueKey, keyPaths, keyStatus, retireKeys, rotateKey, TriageKeyError } from "./triage-key.mjs";
import { issueKey, keyPaths, keyStatus, retireKeys, rotateKey, TriageKeyError } from "../../bus/src/triage-key.mjs";
import { CliError } from "./errors.mjs";
import { refuseInsideAgent } from "./transport.mjs";
+1 -1
View File
@@ -12,7 +12,7 @@ import { join } from "node:path";
import { createHash, randomBytes } from "node:crypto";
import { run } from "../src/cli.mjs";
import { AGENT_MARKERS } from "../src/transport.mjs";
import { DEFAULT_ROTATE_GRACE_MINUTES, keyPaths, retireAtFor, rotateByFor } from "../src/triage-key.mjs";
import { DEFAULT_ROTATE_GRACE_MINUTES, keyPaths, retireAtFor, rotateByFor } from "../../bus/src/triage-key.mjs";
import { ModelKeys } from "../../bus/src/model-keys.mjs";
import { ManagementClient } from "../../model-proxy/src/client.mjs";
import { startBroker } from "../../bus/src/runtime.mjs";
+34 -1
View File
@@ -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/<id>/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 }) }));
},
+132
View File
@@ -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,135 @@ 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. An entry whose redacted values read together, or whose keys
// and values read together, still hold an environment secret split across them is answered as
// { withheld: true }; pieces kept apart by another whole field are not seen (known limit). 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;
// A redacted entry's values joined in order, with each object key before its value when `keys`.
const entryText = (value, keys) => (value !== null && typeof value === 'object'
? Object.entries(value).map(([key, item]) => (keys && !Array.isArray(value) ? key : '') + entryText(item, keys)).join('')
: String(value));
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') {
const safe = redactValue(value, secrets);
const split = holdsSecret(entryText(safe, false), secrets) || holdsSecret(entryText(safe, true), secrets);
entries.push(split ? { withheld: true } : safe);
}
}
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.
// Only environment secrets are checked this way. A key pattern broken across two journal
// lines, each part too short for the long-run rules, is a known limit shared with chat-fail.
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 +345,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() {
+92
View File
@@ -0,0 +1,92 @@
// #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). One line is added after it:
// those four Mosaic prefixes with no word boundary, so a key glued to a word (xmso-...) is caught
// too. Over-redaction there is the safe side. 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. The key-prefix line adds mso, mst and msp, and the line after
// it is Mosaic's own; every other line is failure-notice's.
const KEY_WORD = "(?:\\w*[_-])?(?:api[_-]?key|key|token|secret|password|passwd|authorization|cookie|session)";
const REDACT = [
/(?<![a-z0-9+.-])[a-z0-9+.-]+:\/\/\S*/gi, // any link, its userinfo and query included, from the run's start
/\bwww\.\S+/gi,
/(?<!\S)(?=\S*\S@\S)\S+/g, // email addresses and user@host: the whole run holding the @
/(?:^|(?<=[\s("'=:]))(?:~|\.{1,2})?\/\S+/g, // absolute and home paths
/\b[A-Za-z]:\\\S*/g, // Windows paths
/\\\\\S+/g, // UNC paths
/\b(?:bearer|basic)\s+\S+/gi,
new RegExp(`\\b${KEY_WORD}["']?\\s*[:=]\\s*(?:"[^"]*"?|'[^']*'?|[^\\s,;}]+)`, "gi"),
new RegExp(`\\b${KEY_WORD}["']?\\s+(?:"[^"]*"?|'[^']*'?|(?=[^\\s"',;}]*\\d)[^\\s"',;}]+|[^\\s"',;}]{8,})`, "gi"),
/\b(?:sk|msk|mso|mst|msp|rk|pk|ghp|gho|ghs|glpat|xox[a-z])[-_]\S+/gi,
/ms[kotp][-_]\S+/gi, // Mosaic's prefixes glued to a word: added here, not in failure-notice.mjs
/\beyJ\S+/g, // JWT
/[A-Za-z0-9_\-+/=.]{32,}/g,
/(?<![A-Za-z0-9_\-+/=.])(?=[A-Za-z0-9_\-+/=.]*\d)(?=[A-Za-z0-9_\-+/=.]*[A-Za-z])[A-Za-z0-9_\-+/=.]{16,}/g,
];
// The text with every space, mark and separator gone, after cleanText, for the secret check.
// cleanText has already removed ANSI, format, surrogate and private-use characters and turned
// controls into spaces, so this removes the same set failure-notice's compactText does.
const compact = clean => 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;
}
@@ -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);
});
+198
View File
@@ -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,198 @@ 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 withholds an entry whose fields hold an environment secret split across them', t => {
const dataRoot = scratch(t);
appendReceipt(dataRoot, { op: 'fetch', n: 1 });
appendReceipt(dataRoot, { op: 'x', a: 'plainword', b: 'sonly' });
appendReceipt(dataRoot, { op: 'x', plainw: 'ordsonly' });
appendReceipt(dataRoot, { op: 'x', list: ['plainwo', 'rdsonly'] });
appendReceipt(dataRoot, { op: 'fetch', n: 2 });
const all = receiptHistory(dataRoot, { limit: 10, secrets: secretValues({ PROXY_TOKEN: ENV_SECRET }) });
assert.deepEqual(all.entries, [{ op: 'fetch', n: 1 }, { withheld: true }, { withheld: true }, { withheld: true }, { op: 'fetch', n: 2 }]);
assert.equal(receiptHistory(dataRoot, { limit: 10 }).entries[1].a, 'plainword', 'with no secrets nothing is withheld');
});
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]' });
});
+122
View File
@@ -0,0 +1,122 @@
// #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('a short Mosaic key glued to a word or an underscore is redacted', () => {
for (const key of Object.values(SHORT)) {
for (const glued of [`x${key}`, `_${key}`, `id=x${key}`, `9${key.toUpperCase()}`]) {
const safe = redactLine(`proxy said ${glued} was refused`);
assert.equal(safe.redacted, true, glued);
assert.equal(safe.text.toLowerCase().includes(key.slice(4)), false, glued);
assert.match(safe.text, / was refused$/);
}
}
});
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:[email protected]/v1?key=abc Authorization: Bearer abcdefgh api_key=hunter2 token "quoted value" '
+ 'by [email protected] 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 &#112;lainwordsonly']) {
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, and Mosaic's glued-prefix line
// right after it.
test('the redaction list matches failure-notice.mjs line for line, with only the prefixes and one line 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');
const at = expected.findIndex(line => line.includes('(?:sk|msk|mso|mst|msp|rk|'));
expected.splice(at + 1, 0, '/ms[kotp][-_]\\S+/gi');
assert.deepEqual(block(ours), expected);
});
+22 -2
View File
@@ -45,6 +45,8 @@ import { composeSnapshot, readSystemConfig, readOrgConfig } from './triage-snaps
import { busesStopped } from '../../cli/src/proxy-admin-host.mjs';
import { agentLevelsWriteRoutes } from './agent-levels-write.mjs';
import { triageRouteRoutes } from './triage-route-http.mjs';
import { keyState, ridingOrgs, triageKeyCall } from './triage-access.mjs';
import { readKey as readTriageKey } from '../../bus/src/triage-key-file.mjs';
import { RESTART_EXIT } from '../../cli/src/org-console.mjs';
import { ID_PATTERN, systemOnly } from '../../organization/src/vocabulary.mjs';
import { selectorScope } from '../../organization/src/selector.mjs';
@@ -226,7 +228,7 @@ try {
// (read only) and, through `call`, from its bus as the owner. A file that cannot be read gives
// undefined fields, which Ride all names as unreadable. The change log is read with the writer's
// own check (no symlink, a regular file this user owns, not group or world writable).
const rideRiders = async () => {
const rideRiders = async ({ timeoutMs = 5000, deadline } = {}) => {
const writer = organizationWriter({ dir: configDir(), rolesDir: rolesDir() });
const local = id => readRider({ id, read: () => writer.read(id).document, readLog: () => ownedText(writer.logFile(id), { mask: 0o022 }), isFixture: orgUsesFixture });
const down = async () => { throw Object.assign(new Error('the bus is not reachable'), { code: 'no-bus-host' }); };
@@ -235,7 +237,7 @@ try {
const out = [];
for (const org of await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })) {
if (org.state !== 'active') continue;
let call = down; try { const paths = orgPaths(org.root); call = busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }); } catch {}
let call = down; try { const paths = orgPaths(org.root); call = busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs, ...(deadline ? { deadline } : {}) }); } catch {}
// The organization admin page's stopped test reads this bus status (its process id).
out.push({ ...local(org.id), call, status: () => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, org.id) });
}
@@ -292,6 +294,8 @@ try {
const triage = triageRoute ? createTriageHost({
dataRoot: system.dataRoot, route: triageRoute, proxyPort: triageProxyPort, tokenPattern: triageTokenPattern(configDir()),
devOwner: Boolean(devOwner), log: line => console.log(line),
// proxy-scope slice 4: a session on a key past its retireAt stops with triage-key-rotated.
keyRecord: () => readTriageKey(configDir()),
readSnapshot: () => composeSnapshot({
orgs: () => listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance }),
busStatus: id => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, id),
@@ -325,6 +329,22 @@ try {
// next admit.
const triageRoutes = system && (devOwner || ssoOn) ? [triageRouteRoutes({
dataRoot: system.dataRoot, log: line => console.log(line),
// proxy-scope slice 4: the Triage key through one riding organization's bus (proxy.triage.key),
// as Proxy setup's init asks one bus. The Console reads the key file's state only; it never
// loads the proxy management client or the key verbs' module.
access: {
state: () => keyState(configDir()),
// The same list the key walk asks (cliproxy, not a fixture), read from local files only.
// The owner's proxy must be set up (proxy.json names a port), as ownerModels reads it.
riding: async () => {
let proxy = false;
try { proxy = Number.isInteger(loadProxy(configDir(), system.dataRoot)?.port); } catch {}
return proxy && ridingOrgs(await rideRiders()).length > 0;
},
// One 30 s deadline over the whole walk, not 30 s for each bus.
key: op => { const deadline = Date.now() + 30000; return triageKeyCall({ riders: () => rideRiders({ timeoutMs: 30000, deadline }), op }); },
stop: () => (triage ? triage.stop() : Promise.resolve()),
},
catalogues: async () => {
const read = async call => { try { return (await call('routes'))?.catalogue ?? { status: 'unknown' }; } catch { return { status: 'bus-unavailable' }; } };
if (!organizations) return ownerCall ? [await read(ownerCall)] : [];
+22
View File
@@ -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');
+13 -2
View File
@@ -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,19 @@ 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; }
// All four recorded verbs answer a plain object; any other answer is passed on unmarked.
if (recorded === false && value && typeof value === 'object' && !Array.isArray(value)) value = { ...value, recorded: false };
}
return done(200, value);
}
+93 -16
View File
@@ -703,7 +703,14 @@
<h2 id="b-for-you">Open decisions <span class="count">${rows.length}</span></h2>${body}
<p class="small muted">Open a decision for its seen, DM and closing history.</p>`;
}
const messageText = m => m.from_role !== 'human' && typeof m.body === 'string' && m.body.startsWith('The turn failed: ') ? `The assistant couldn't reply. Try again, or check Agents.<span class="source">Details: ${txt(m.body.slice('The turn failed: '.length))}</span>` : txt(m.body);
// #1873 settings slice 5: a failed turn whose body carries its own "\nDetails: " part (chat.js
// messageBody) shows its cause and that part once.
const messageText = m => {
if (m.from_role === 'human' || typeof m.body !== 'string' || !m.body.startsWith('The turn failed: ')) return txt(m.body);
const rest = m.body.slice('The turn failed: '.length), at = rest.indexOf('\nDetails: ');
if (at > 0) return `The assistant couldn't reply: ${txt(rest.slice(0, at))}<span class="source">Details: ${txt(rest.slice(at + '\nDetails: '.length))}</span>`;
return `The assistant couldn't reply. Try again, or check Agents.<span class="source">Details: ${txt(rest)}</span>`;
};
async function messagesView(get, q) {
const after = q.get('after');
if (after !== null && !SAFE.test(after)) return notFound('The message cursor is not a message id.');
@@ -1299,6 +1306,9 @@
}
const routesApplyMarkup=()=>routesApply?.length?`<ul class="routes-apply" aria-label="How the change reaches each agent">${routesApply.map(a=>`<li><b>${txt(a.name)}</b>: ${txt(a.text)}${a.restart&&canSend&&!isTester?` ${window.MosaicAgents?.restartMarkup(a.name,a.thread)??''}`:''}</li>`).join('')}</ul>`:'';
let harnessSettings=null, harnessDraft=null, harnessLoading=false, harnessReceipt='', harnessBusy=false;
// #1873 settings slice 5: the organization's one choice, Use your models (the cliproxy module in
// its model-provider list, from the plugins read above) or its own model service (Coming later).
let modelsReceipt='', modelsReceiptKind='', modelsBusy=false, modelsFocus=false;
function readHarnesses(){
if(harnessLoading || harnessSettings !== null || !canSend || isTester)return; harnessLoading=true;const epoch=orgEpoch;
fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'}).then(async r=>{const v=await r.json();if(epoch!==orgEpoch)return;if(!r.ok || !/^[a-f0-9]{64}$/.test(v.revision??'') || !Array.isArray(v.available?.harness) || !v.available.harness.every(n=>typeof n==='string') || !Array.isArray(v.plugins?.harness??[]))throw Error();harnessSettings=v;}).catch(()=>{if(epoch!==orgEpoch)return;harnessSettings=false;harnessReceipt='Harnesses could not be read.';}).finally(()=>{if(epoch!==orgEpoch)return;harnessLoading=false;if(routeOf().split('?')[0]==='/settings/routing')render(false);});
@@ -1345,11 +1355,48 @@
if(owner&&serviceState==='not-running')return `<p class="small warn" id="routes-catalogue">${lead} The model service is not running. ${setupLink('Open Model setup')}. ${thinking}</p>${words}`;
if(owner&&(serviceLoading||(serviceState===null&&triageOwner)))return `<p class="small warn" id="routes-catalogue">${lead} Checking the model service. ${thinking}</p>`;
if(owner&&serviceState===false)return `<div class="banner routes-catalogue" id="routes-catalogue" role="status"><p>${lead}${plain} The model service's status could not be read. ${thinking}</p>${words}<p class="actions">${recheck}</p></div>`;
return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}${owner?' A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it.':''}</p>${words}`;
return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}${owner?' A new model needs the model service: ask the instance owner to set it up, or press Stop using your models when this organization does not need it.':''}</p>${words}`;
}
// Check again rereads Routing; the bus looks for the model service at that read. A draft is kept.
document.addEventListener('click',e=>{if(e.target.id!=='routes-recheck')return;e.target.disabled=true;serviceState=null;routesView=null;last.delete('routes');render(true);});
document.addEventListener('mosaic-org-restarted',e=>{if(e.detail?.id!==window.MosaicOrg?.id)return;serviceState=null;routesView=null;last.delete('routes');const path=routeOf().split('?')[0];if(path==='/settings/routing'||document.querySelector('[data-org-down]'))render(true);});
// The choice reads only the plugins read: before it answers the radios wait, and a failed read
// says so with Read again. Use your models writes at once; Stop using your models is the way back.
// While the organization needs a restart, its banner's Restart is the one primary and the choice waits.
// A Console with no organizations says "this business": lowercase inside a sentence, capitalized
// at its start (cap).
const modelsWho=cap=>window.MosaicOrg?(window.MosaicOrg.label||window.MosaicOrg.id):cap?'This business':'this business';
const modelsWhose=cap=>`${modelsWho(cap)}'s`;
// settings-s5 review P2-3: a choice that is not in force says when the model service behind it is
// not set up or not answering (the owner's status read, as on the catalogue line). The choice
// still writes: riding before setup is the design's "Nothing set up" state.
function modelsService(){
const link=text=>`<a href="#/settings/model-setup">${text}</a>`;
return serviceState==='not-set-up'?`<p class="small warn" id="models-service">Your model service isn't set up. ${link('Set it up in Model setup')}.</p>`
:serviceState==='not-running'?`<p class="small warn" id="models-service">Your model service isn't answering. ${link('Restart it in Model setup')}.</p>`
:serviceState==='fenced'?`<p class="small warn" id="models-service">Your model service is waiting for a restart to finish. ${link('Open Model setup to finish it')}.</p>`:'';
}
function modelsChoice(restartFirst){
const who=txt(modelsWho()), Who=txt(modelsWho(true)), whose=txt(modelsWhose()), Whose=txt(modelsWhose(true));
const names=harnessSettings&&Array.isArray(harnessSettings.plugins?.['model-provider'])?harnessSettings.plugins['model-provider']:[];
const read=!!harnessSettings, on=read&&names.includes('cliproxy'), wait=!read||modelsBusy||restartFirst||out();
if(triageOwner)readService();
const now=harnessSettings===false?`Which models ${who} uses could not be read.`:!read?`Reading ${whose} models…`:on?`Now: ${who} uses your models.`:`Now: ${who} does not use your models. Its agents use only the models in its own organization file.`;
const change=!read?'':restartFirst?`<p class="small" id="models-wait">You can change ${whose} models after it restarts.</p>`
:on?`<p class="small muted" id="models-change">Its agents can use the models your accounts offer. To switch back, press Stop using your models. A route on one of your models then stops working until you change it.</p>`
:`<p class="small muted" id="models-change">Choose Use your models to switch. ${Whose} agents can then use the models your accounts offer. While your model service is down, a launch that needs it is refused. A running agent keeps its model until it starts again.</p>${modelsService()}`;
// P2-1: while the organization needs a restart every control here waits. Stop is left out, as in
// the mockup, since a disabled button here looks no different from an enabled one.
const stop=on&&!restartFirst?`<button type="button" id="models-stop"${modelsBusy||out()?' disabled':''}>${modelsBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Stop using your models'}</button>`:'';
const again=harnessSettings===false?'<button type="button" id="models-read">Read again</button>':'';
// P3-1: Use your models has no button of its own, so its write shows Saving in the status line.
const status=modelsBusy&&!on?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':txt(modelsReceipt);
return `<fieldset class="models-source" id="models-source"><legend>Where ${who} gets its models</legend>`
+`<label class="choice"><input type="radio" name="models-source" id="models-yours" value="yours"${on?' checked':''}${wait?' disabled':''}><strong>Use your models</strong><span class="badge badge-ok">Recommended</span><span class="small muted">${Who} uses the model service and accounts in Model setup. Nothing to sign in to.</span></label>`
+`<label class="choice off"><input type="radio" name="models-source" id="models-own" value="own" disabled><strong>Use its own model service</strong><span class="badge badge-muted">Coming later</span><span class="small muted">${Who} would run a second model service with its own accounts. Planned, not built yet, so you can't choose it today.</span></label>`
+`<p id="models-in-force">${now}</p>${change}<p class="actions">${stop}${again}</p>`
+`<p role="status" id="models-receipt" class="${modelsBusy&&!on?'':modelsReceiptKind}" tabindex="-1" data-focus-key="models-receipt">${status}</p></fieldset>`;
}
function routesSection(view,instanceInfo){
const title='<h2 id="routes-title">Routing</h2>';
readHarnesses();
@@ -1381,7 +1428,7 @@
// settings-p3 (re-check 3 P3-5): a ready catalogue the bus picked up late says agents start on these
// models after a restart; that notice gets the organization's Restart (not primary: Save routes is).
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}${n===window.MosaicConsole?.RESTART_TO_LAUNCH&&window.MosaicOrg?.id?` ${window.MosaicConsole.orgRestartButton(window.MosaicOrg.id,{name:window.MosaicOrg.label||window.MosaicOrg.id})}`:''}</p>`).join('')}`:v.catalogue?.status==='unavailable'?catalogueLine(proxyOn,v.catalogue):'<p class="small muted">Model catalogue not enabled.</p>';
const providerControl=canSend&&!isTester?`<button type="button" id="provider-switch" data-enabled="${proxyOn}">${proxyOn?'Stop using the model service':'Use your models'}</button><p role="status" id="provider-switch-status"></p>`:'';
const providerControl=canSend&&!isTester?modelsChoice(/ data-primary[ >]/.test(catalogueInfo)):'';
const harnessControl=canSend&&!isTester?`<fieldset class="harness-control"><legend>Harnesses</legend>${harnessSettings ? [...new Set([...harnessSettings.available.harness,...(harnessSettings.plugins.harness??[])])].map(name=>`<label><input type="checkbox" data-harness="${esc(name)}"${(harnessDraft??harnessSettings.plugins.harness??[]).includes(name)?' checked':''}${harnessBusy?' disabled':''}> ${txt(name)}</label>`).join('')+` <button type="button" id="harness-save"${harnessBusy?' disabled':''}>Save harnesses</button>` : '<p>Harnesses unavailable.</p><button type="button" id="harness-read">Read harnesses again</button>'}<p role="status" id="harness-status">${txt(harnessReceipt)}</p></fieldset>`:'';
const off=v.harnesses.length?'':'<p class="small warn">No harness is switched on for this organization, so every launch is refused, and so is a save that changes a harness. Switch one on under Harnesses.</p>';
return `<section class="panel routing-panel" aria-labelledby="routes-title"><span class="sr-only">${title}</span>${catalogueInfo}${providerControl}${harnessControl}${off}<form id="routes-form"><div class="table-wrap" tabindex="0" role="region" aria-label="Routes, scroll for all columns"><table id="routes-table"><thead><tr><th scope="col" rowspan="2">Agent</th><th scope="colgroup" colspan="3">Primary</th><th scope="colgroup" colspan="3">Fallback</th></tr><tr>${ROUTE_CELLS.map(([,l])=>`<th scope="col">${l.replace('Fallback ','')}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table></div><p class="small muted">${canSend || isTester?'Changes are checked and logged with your identity.':'Saving requires signed-in send mode.'}</p><div class="settings-actions route-actions${routesDraft?' has-draft':''}"><button type="submit"${/ data-primary[ >]/.test(catalogueInfo)?' class="route-save-quiet"':''}${disabled}>${routesBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Save routes'}</button> <button type="button" id="routes-reload"${routesDraft?'':' hidden'}${routesBusy||!routesDraft?' disabled':''}>Discard draft</button><p role="status" id="routes-receipt" class="${routesReceipt.startsWith('Outcome unknown')?'banner ref':routesReceipt.includes('Draft kept')?'banner err':routesReceipt.includes('saved')?'settings-success':''}">${txt(routesReceipt)}</p></div>${routesApplyMarkup()}</form></section>`;
@@ -1409,7 +1456,7 @@
const moved=Object.entries(routes).flatMap(([name,r])=>{const was=routesView?.instances?.[name]??{};
return [[r.harness,r.model,was.harness,was.model],[r.fallback?.harness,r.fallback?.model,was.fallback?.harness,was.fallback?.model]].filter(([h,m,wh,wm])=>m&&(h!==wh||m!==wm)).map(([,m])=>m);});
const module=key=>routesView?.providerModels?.[key]?.module;
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change does not need the model service: press Stop using the model service, then save again.':'';
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change does not need your models: press Stop using your models, then save again.':'';
}
const routesAnswer=r=>/^[a-f0-9]{64}$/.test(r?.revision??'')&&Array.isArray(r.harnesses)&&Array.isArray(r.models)&&[r.levels,r.instances].every(o=>o&&typeof o==='object'&&!Array.isArray(o));
for(const kind of ['input','change'])document.addEventListener(kind,e=>{const form=e.target?.closest?.('#routes-form');if(!form||!routesView)return;routesDraft=routesFields(form);routesEditVersion++;markSettingsDraft('routing',true);form.querySelector('.settings-actions')?.classList.add('has-draft');const discard=$('routes-reload');if(discard){discard.hidden=false;discard.disabled=false;}
@@ -1429,17 +1476,32 @@
catch{if(epoch!==orgEpoch)return;harnessReceipt='Outcome unknown. Read the harnesses again before trying.';harnessSettings=false;}
finally{if(epoch===orgEpoch){harnessBusy=false;if(!out())render(false);}}
});
document.addEventListener('click',async e=>{if(e.target.id!=='provider-switch'||!canSend||isTester)return;
const button=e.target,status=$('provider-switch-status');if(routesDraft){status.textContent='Save or discard the route draft first.';return;}button.disabled=true;const epoch=orgEpoch;
try {const read=await fetch('/api/proxy/plugins',{cache:'no-store'});const settings=await read.json();if(epoch!==orgEpoch)return;if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??''))throw Error('Could not read provider settings.');
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[];
// The fresh read decides: a stale label never turns the proxy module on when it meant off.
const on=names.includes('cliproxy');if(String(on)!==button.dataset.enabled){button.dataset.enabled=String(on);button.textContent=on?'Stop using the model service':'Use your models';button.disabled=false;status.textContent='The switch now shows the current setting. Press it again to change it.';return;}
const next=on?names.filter(n=>n!=='cliproxy'):[...names,'cliproxy'];
const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
if(epoch!==orgEpoch)return;if(!response.ok)throw Error('Provider setting was refused.');harnessSettings=null;routesView=null;last.delete('routes');render(true);
}catch(error){if(epoch!==orgEpoch)return;status.textContent=error.message;button.disabled=false;}
});
// The fresh read decides: a page that shows a stale choice is redrawn from it and nothing is written.
async function setModels(want){
if(!canSend||isTester||modelsBusy||!harnessSettings)return;
const who=modelsWho(true), shown=(harnessSettings.plugins?.['model-provider']??[]).includes('cliproxy');
let sent=false;
if(routesDraft){modelsReceipt='Save or discard the route draft first.';modelsReceiptKind='banner err';modelsFocus=true;render(false);return;}
modelsBusy=true;modelsReceipt='';modelsReceiptKind='';render(false);const epoch=orgEpoch;
try{const read=await fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'});const settings=await read.json();if(epoch!==orgEpoch)return;
if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??'')||!Array.isArray(settings.available?.harness))throw Error('read');
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[], on=names.includes('cliproxy');
if(on!==shown){harnessSettings=settings;modelsReceipt=`${modelsWhose(true)} models changed since this page read it. The page now shows the current choice; choose again to change it.`;modelsReceiptKind='banner ref';return;}
if(on===want)return;
const next=want?[...names,'cliproxy']:names.filter(n=>n!=='cliproxy');
sent=true;const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
const result=await response.json().catch(()=>({}));if(epoch!==orgEpoch)return;
if(!response.ok){modelsReceipt=`Not changed. ${result.message||result.error||'The change was refused.'}`;modelsReceiptKind='banner err';return;}
modelsReceipt=want?`Saved. ${who} uses your models. An agent picks them up the next time it starts.`:`Saved. ${who} no longer uses your models. An agent on one of them keeps it until it starts again.`;modelsReceiptKind='settings-success';
harnessSettings=null;routesView=null;last.delete('routes');window.MosaicModelDots?.read?.();
// P3-2: a failed read before the write changed nothing and says so, with Read again.
}catch{if(epoch!==orgEpoch)return;if(sent){modelsReceipt='Outcome unknown. Read the page again before trying.';modelsReceiptKind='banner ref';harnessSettings=null;}else{modelsReceipt='Not changed. Nothing was written.';modelsReceiptKind='banner err';harnessSettings=false;}}
// P2-4: the render that shows the outcome moves focus to it (render() below).
// Recheck N2: only while the page is still shown; a switch left mid-write does not take focus later.
finally{if(epoch===orgEpoch){modelsBusy=false;modelsFocus=!!modelsReceipt&&routeOf().split('?')[0]==='/settings/routing';if(!out())render(harnessSettings===null);}}
}
document.addEventListener('change',e=>{if(e.target.id==='models-yours'&&e.target.checked)setModels(true);});
document.addEventListener('click',e=>{if(e.target.closest?.('#models-stop'))setModels(false);else if(e.target.id==='models-read'){harnessSettings=null;harnessReceipt='';modelsReceipt='';modelsReceiptKind='';render(false);}});
document.addEventListener('click',e=>{if(e.target.matches?.('.fallback-toggle'))e.target.closest('tr')?.classList.add('fallback-open');});
document.addEventListener('click',e=>{if(e.target.id!=='routes-reload')return;routesDraft=null;routesView=null;routesReceipt='';routesApply=null;last.delete('routes');render(true);});
document.addEventListener('submit',async e=>{
@@ -1525,6 +1587,9 @@
const notify = typeof n.binding==='string' ? `<code>${txt(n.binding)}</code>` : n.refused ? `Could not be read: <code>${txt(n.refused)}</code>` : '<span class="muted">None set</span>';
const contents={limits:()=>launchForm(s.launch),routing:()=>routesSection(routes,instances),agents:()=>agentsSection(instances)+agentLevels,assistant:()=>assistantSection(s.launch,names),tokens:()=>tokenLimits(limitRows,limitsRefused)+tokenUsage(usage),names:()=>testerNames(names,instances),about:()=>`<section class="panel"><dl class="kv"><dt>Address</dt><dd><code>${txt(s.address)||'unknown'}</code></dd><dt>Release</dt><dd>${txt(s.release)||'unknown'}</dd><dt>Business</dt><dd>${txt(s.business)||none}</dd><dt>Board</dt><dd><code>${txt(s.board)||'unknown'}</code></dd><dt>Notifier binding</dt><dd>${notify}</dd></dl></section>`};
const helpers={limits:'Leave a limit blank for no limit. Zero stops new launches. Running sessions keep running when limits or models change.',routing:"Each agent’s harness, model and thinking, and the fallback a launch takes when the primary harness fails its preflight. A fallback sets all three or none. Running sessions keep their route. The next launch reads the change. A harness is the program that runs the model. Preflight is the check a launch makes before it starts.",agents:'Each agent with its definition, launch membership and runs. A launch refuses until the agent has a route in Routing.',assistant:'The definition stays an assistant one. Holder and credentials stay hand edits.',tokens:'Token limits the bus checks, and token use read from session transcripts.'};
// settings-s5 review P2-2: the header says where the models come from only from the plugins read.
const riding=harnessSettings?(harnessSettings.plugins?.['model-provider']??[]).includes('cliproxy'):null;
if(window.MosaicOrg&&!isTester)helpers.routing=`The models ${modelsWhose()} agents use.${riding===true?' They come from your accounts in Model setup.':riding===false?' They come from its own organization file.':''} ${helpers.routing}`;
return settingsShell(page,contents[page](),`${get.oldest()?`Read ${when(get.oldest())}.`: 'Reading…'} ${helpers[page]||''}`);
}
let settingsFocusDisclosure=false;
@@ -1911,6 +1976,11 @@
if ((navigated || path !== '/settings/organizations') && orgCleanup) {orgCleanup();orgCleanup=null;}
// Leaving a decision discards its confirmation immediately, including a preview in flight.
if (answer && (navigated || path !== (answer.org ? '/inbox' : `/inbox/${answer.id}`))) answer = null;
// Recheck N1: arriving at Models reads the model service again; a status read on an earlier visit may be out of date.
if (navigated && path === '/settings/routing' && (typeof shown === 'string' ? shown.split('?')[0] : shown) !== path && !serviceLoading) serviceState = null;
// settings-s5b: a focus request for the Models outcome line belongs to that page. Going anywhere else drops it,
// including Assistant, Projects and the board, which return before the focus chain at the end of render.
if (navigated && path !== '/settings/routing') modelsFocus = false;
const g = ++gen, routeVersion = routesEditVersion;
const current = () => g === gen && route === routeOf() && !out();
// In organization mode #/ is the cross-organization dashboard; the processing controls stay on the board.
@@ -1923,6 +1993,8 @@
window.MosaicChat?.leave(chatPath);
if (path === '/business') { location.replace('#/settings/business'); return; }
if (path === '/settings/display') { location.replace('#/settings/appearance'); return; }
// #1873 settings slice 5: Members is gone from the nav; its old addresses land on the organization's Agents page.
if (path === '/settings/members') { location.replace(`#/settings/agents${window.MosaicOrg ? `?org=${enc(window.MosaicOrg.id)}` : ''}`); return; }
// #1873 settings slice 4: the owner's page is Model setup; its old address lands there, query kept.
if (path === '/settings/model-proxy') { location.replace(`#/settings/model-setup${query ? `?${query}` : ''}`); return; }
// #1873 SP6: the Assistant page draws its own thread panes (assistant.js); every other page
@@ -2046,7 +2118,11 @@
sections(path);
const h1 = $('bus-view').querySelector('h1');
document.title = path === '/settings/business' && $('settings-page-title') ? `Settings · ${window.MosaicOrg ? 'Organization' : 'Business'} · Mosaic Console` : `${h1 ? h1.textContent : 'Console'} · Mosaic Console`;
if (k) restore(k);
// settings-s5 review P2-4: after a switch on Organization > Models, focus goes to its outcome line.
// Recheck N2: a render that paints no outcome line drops the request instead of keeping it.
const focusModels = modelsFocus && $('models-receipt'); modelsFocus = false;
if (focusModels) { if (k) restore(k); focusModels.focus({ preventScroll: true }); }
else if (k) restore(k);
// Message on the Board (row 95) lands in the form it opened, addressed to the role.
else if (focusSend && $('send-body')) { $('send-body').focus(); announce(`Message to ${draft.to}`); }
// SP17: a step link on an organization's Workflows card lands in that step's title field.
@@ -2261,6 +2337,7 @@
instanceView = null; instanceDrafts = { add: null, change: null }; instanceReceipt = ''; instanceReceiptOp = null; instanceReceipts = Object.create(null);
routesView = null; routesDraft = null; routesReceipt = ''; routesEditVersion++;
harnessSettings = null; harnessDraft = null; harnessReceipt = '';
modelsReceipt = ''; modelsReceiptKind = ''; modelsBusy = false; modelsFocus = false;
serviceState = null; serviceLoading = false;
// A file draft is keyed by project and path only; the page reload that used to drop it is gone.
docKey = null; docStates.clear(); pkAll = []; pkShown = []; pkAt = 0;
+194 -27
View File
@@ -593,7 +593,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const service = '<div id="proxy-setup-next" class="proxy-setup-next" role="status" aria-live="polite"></div>'
+ '<ol id="proxy-setup-progress" class="progress" aria-label="Setup progress" hidden></ol>'
+ '<p id="proxy-setup-message" role="status" aria-live="polite"></p>'
+ '<details id="proxy-setup-lines" hidden><summary>The service\'s last lines</summary><div class="inside"><p class="small muted">This page can\'t read the service\'s lines yet. What the service said last, when the host reported it:</p><pre id="proxy-setup-log" class="setup-log">Nothing reported.</pre></div></details>'
// settings-s5b: the lines come from GET /api/proxy/admin/log, read when the box opens (readLog in the controller).
+ '<details id="proxy-setup-lines" class="proxy-setup-lines" hidden><summary>The service\'s last lines</summary><div class="inside" data-log></div></details>'
+ '<div id="proxy-setup-fixtures" class="banner mk-note" hidden></div>';
const accounts = '<p id="proxy-message" role="status" aria-live="polite">Reading accounts…</p>'
+ '<p id="proxy-readonly" class="muted" hidden>This Console is read-only. Sign-in and account changes are unavailable.</p>'
@@ -637,12 +638,19 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
+ '<dl id="proxy-setup-settings" class="proxy-setup-state" hidden></dl><p id="proxy-setup-settings-note" class="small muted" hidden>Changing these after setup is not built yet.</p></div></details>';
const tech = '<details id="proxy-setup-tech" class="proxy-setup-tech"><summary>Technical details: release, service, history</summary><div class="inside">'
+ '<div data-admin hidden><dl id="proxy-setup-state" class="proxy-setup-state"></dl>'
// settings-s5b: the setup history and the service's lines, read when they open (owner only). The service key is the last
// row of the list above (paintState), and the history follows it, as models-advanced shows them.
+ '<div class="proxy-setup-history"><h4 id="proxy-setup-history-title">History</h4><p id="proxy-setup-history-message" class="small muted" role="status">Not read yet.</p>'
+ '<ol id="proxy-setup-history" aria-labelledby="proxy-setup-history-title"></ol>'
+ '<p class="proxy-setup-history-foot"><button type="button" id="proxy-setup-history-all" aria-expanded="false" aria-controls="proxy-setup-history" hidden>Show all</button>'
+ '<button type="button" id="proxy-setup-history-older" hidden>Show older</button><button type="button" id="proxy-setup-history-retry" hidden>Read again</button></p></div>'
+ '<details id="proxy-setup-tech-lines" class="proxy-setup-lines"><summary>The service\'s last lines</summary><div class="inside" data-log></div></details>'
+ '<div class="proxy-setup-unit"><h4>Service controls</h4><p class="small muted">Install renders the unit the same way as <code>mosaic proxy unit install</code>.</p>'
+ '<div class="proxy-setup-buttons"><button type="button" data-unit="install" data-setup-write disabled>Install</button><button type="button" data-unit="start" data-setup-write disabled>Start</button><button type="button" data-unit="restart" data-setup-write disabled>Restart</button><button type="button" data-unit="stop" data-setup-write disabled>Stop</button><button type="button" id="proxy-setup-render">Show unit file</button></div>'
+ '<pre id="proxy-setup-unit-file" hidden></pre></div>'
+ '<div class="proxy-setup-orgs"><h4>Organizations</h4><div class="table-wrap" tabindex="0" role="region" aria-label="Organizations using the model service"><table><thead><tr><th>Organization</th><th>Proxy</th><th>Catalogue</th><th>Models</th></tr></thead><tbody id="proxy-setup-orgs"></tbody></table></div>'
+ '<p id="proxy-setup-own" class="muted"></p></div>'
+ '<div class="proxy-setup-receipts"><h4>History</h4><ol id="proxy-setup-receipts"><li class="muted">No setup actions on this page yet.</li></ol></div></div>'
+ '</div>'
+ '</div></details>';
const markup = '<div id="proxy-setup" class="model-setup">'
+ card('service', 1, 'Model service', service, true)
@@ -957,29 +965,174 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
}
const say = (text, kind) => receipt('proxy-setup-message', text, kind);
const human = value => value === null || value === undefined ? '—' : typeof value === 'object' ? JSON.stringify(value) : String(value);
function addReceipt(record) {
if (!record || typeof record !== 'object') return;
const list = $('proxy-setup-receipts'); list.querySelector('li.muted')?.remove();
const li = document.createElement('li'), op = document.createElement('strong'); op.textContent = record.op ?? 'action';
const details = Object.entries(record).filter(([k]) => k !== 'op' && k !== 'time').map(([k, v]) => `${k}: ${human(v)}`).join(', ');
li.append(op, ` ${window.MosaicLocalTime(record.time)}${details ? ' — ' + details : ''}`);
list.prepend(li);
// settings-s5b: History, the service key and the service's lines come from their own reads
// (GET /api/proxy/admin/history, service-key and log). Nothing reads them until their box opens,
// and only the instance owner's page starts this controller. A write's receipt reads them again
// when Technical details is open, so the page never shows a raw receipt.
const techOpen = () => $('proxy-setup-tech')?.open === true;
function addReceipt() { if (enabled && techOpen()) { readKey(); readHistory(true); } }
const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
const count = n => Number.isInteger(n) && n > 0 ? n : 0;
// A failed read says what the answer's code means here; a request that got no answer says so. A code
// shaped like a Mosaic key is not shown, even though it passes admin()'s letters-and-hyphens check.
const failText = (error, words) => !error?.code ? (error instanceof TypeError ? 'The Console did not answer.' : String(error?.message ?? 'The Console did not answer.'))
: /ms[kotp][-_]/i.test(error.code) ? 'The Console refused the read.' : words[error.code] ? `${words[error.code]} (${error.code})` : error.message;
const retryButton = (id, action) => { const button = el('button', 'Read again'); button.type = 'button'; if (id) button.id = id; button.addEventListener('click', action); return button; };
// The service's last lines: one read paints every box. The lines show as the answer has them:
// the route removes key-shaped text; this page adds nothing and takes nothing away.
const LOG_WORDS = { 'not-configured': 'The model service is not installed, so it has no lines yet.', 'outcome-unknown': 'The host could not read the service\'s lines.', 'invalid-request': 'The Console refused the request.' };
let logRound = 0, logAnswer = null;
function paintLog() {
for (const box of root.querySelectorAll('[data-log]')) {
if (!logAnswer) { box.replaceChildren(el('p', 'Reading the service\'s lines…', 'small muted')); continue; }
// An uninstalled service has no lines: a plain line, not a fault.
if (logAnswer.none) { box.replaceChildren(el('p', LOG_WORDS['not-configured'], 'small muted'), retryButton(null, readLog)); continue; }
if (logAnswer.error) { box.replaceChildren(el('p', `The service's lines could not be read. ${logAnswer.error}`, 'banner err'), retryButton(null, readLog)); continue; }
const { lines, redacted, dropped } = logAnswer, notes = ['Mosaic removes anything that looks like a key.'];
if (redacted) notes.push(`It removed something from ${plural(redacted, 'line')}.`);
if (dropped) notes.push(`${plural(dropped, 'line')} ${dropped === 1 ? 'was' : 'were'} left out.`);
const parts = [el('p', notes.join(' '), 'small muted')];
parts.push(lines.length ? el('pre', lines.join('\n'), 'setup-log') : el('p', dropped ? 'No line is left to show.' : 'The service has written nothing yet.', 'small muted'));
parts.push(retryButton(null, readLog));
box.replaceChildren(...parts);
}
}
// #1873: receipts survive a reload: status carries the last few from proxy-admin.jsonl.
function paintReceipts() {
if (!Array.isArray(state.receipts) || !state.receipts.length) return;
$('proxy-setup-receipts').replaceChildren(); state.receipts.forEach(addReceipt);
async function readLog() {
if (!enabled) return;
// A Read again pressed in a box keeps focus there once the answer is painted.
const from = [...root.querySelectorAll('[data-log]')].find(box => box.contains(document.activeElement));
const round = ++logRound; logAnswer = null; paintLog();
let answer;
try {
const value = await admin('log?lines=20');
if (!value || !Array.isArray(value.lines)) throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
answer = { lines: value.lines.filter(line => typeof line === 'string'), redacted: count(value.redacted), dropped: count(value.dropped) };
} catch (error) { answer = error?.code === 'not-configured' ? { none: true } : { error: failText(error, LOG_WORDS) }; }
if (round !== logRound || !enabled) return;
logAnswer = answer; paintLog();
from?.querySelector('button')?.focus();
}
// When the service key was made. Never the key: the answer has no key, and this shows only its time.
// It is the last row of the state list; paintState redraws that list, so the row paints from keyView.
const KEY_WORDS = { 'not-configured': 'Model service setup is not available on this Console.', 'outcome-unknown': 'The host could not check the key.' };
let keyRound = 0, keyView = { text: 'Not read yet.', failed: false };
function paintKey() {
const dd = $('proxy-setup-keymade-text')?.parentElement; if (!dd) return;
const line = el(keyView.failed ? 'p' : 'span', keyView.text, keyView.failed ? 'banner err' : keyView.reading ? 'muted' : undefined); line.id = 'proxy-setup-keymade-text';
dd.replaceChildren(line, ...(keyView.failed ? [retryButton('proxy-setup-keymade-retry', readKey)] : []));
}
function keyRow(dl) {
const dt = document.createElement('dt'), dd = document.createElement('dd'), span = el('span'); span.id = 'proxy-setup-keymade-text';
dt.textContent = 'Service key'; dd.append(span); dl.append(dt, dd); paintKey();
}
async function readKey() {
if (!enabled) return;
const round = ++keyRound, refocus = document.activeElement?.id === 'proxy-setup-keymade-retry';
keyView = { text: 'Reading…', failed: false, reading: true }; paintKey();
let text, failed = false;
try {
const value = await admin('service-key');
if (!value || typeof value !== 'object') throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
const renewed = value.renewal !== 'not-built' && Number.isFinite(Date.parse(value.renewedAt)) ? ` Last renewed ${window.MosaicLocalTime(value.renewedAt)}.` : ' Renewing it is not built yet.';
if (value.problem === 'missing') text = 'Not made yet. Set up model service in step 1 makes it. You never see it.';
else if (value.problem === 'unreadable') text = 'Mosaic can\'t tell when it was made: the service\'s settings file is not one it can check. You never see the key.';
else if (Number.isFinite(Date.parse(value.madeAt))) text = `Mosaic made it on ${window.MosaicLocalTime(value.madeAt)}. You never see it.${renewed}`;
else text = `When it was made is not known. You never see it.${renewed}`;
} catch (error) { failed = true; text = `When it was made could not be read. ${failText(error, KEY_WORDS)}`; }
if (round !== keyRound || !enabled) return;
keyView = { text, failed }; paintKey();
if (refocus) { if (failed) $('proxy-setup-keymade-retry')?.focus(); else { const line = $('proxy-setup-keymade-text'); line.tabIndex = -1; line.focus(); } }
}
// Setup history, a page at a time. The first page holds the newest entries, oldest first within
// it; the list shows newest first. A page can be empty and still name an older one.
const HISTORY_WORDS = { 'not-configured': 'Model service setup is not available on this Console.', 'outcome-unknown': 'The host could not read the history.', 'invalid-request': 'The Console refused that page.' };
const FEW = 3;
const hist = { entries: [], next: null, loading: false, expanded: false, error: null, emptyPage: false, round: 0, read: false };
const orgName = id => { const label = typeof id === 'string' ? window.MosaicOrg?.row?.(id)?.label : null; return typeof label === 'string' && label ? label : null; };
const providerOf = p => typeof p === 'string' && [...providerSelect.options].some(o => o.value === p) ? providerShort(p) : null;
// A name shown as written, unless it holds text shaped like a Mosaic key.
const shownName = v => typeof v === 'string' && v && v.length <= 64 && !/ms[kotp][-_]/i.test(v) ? v : null;
function historyText(entry) {
if (!entry || typeof entry !== 'object' || entry.withheld === true) return null;
const org = orgName(entry.org), provider = providerOf(entry.provider), some = org ?? 'An organization';
const n = (v, word) => Number.isInteger(v) && v >= 0 ? plural(v, word) : null;
const labels = {
'account.proxy.apikey.add': provider ? `${provider} account added` : 'Account added',
'account.proxy.login.complete': 'Signed in to an account',
'account.proxy.priority.set': Number.isInteger(entry.priority) ? `Account order changed, priority ${entry.priority}` : 'Account order changed',
'account.proxy.group.models.set': n(entry.models, 'model') ? `Models chosen for an account, ${n(entry.models, 'model')}` : 'Models chosen for an account',
fetch: 'Release downloaded and checked', init: 'Set up', 'init-lock.clear': 'Stale setup lock cleared', 'fence.clear': 'Key writes resumed',
'unit.install': 'Service installed', 'unit.start': 'Started', 'unit.stop': 'Stopped', 'unit.restart': 'Restarted',
'ride-all': 'Organizations switched to your models', 'ride-move': `${some} switched to your models`, 'ride-intent': `Switching ${org ?? 'an organization'} to your models`,
'ride-not-added': `${some} was not switched to your models`, 'ride-removed': `${some} stopped using your models`,
};
const label = typeof entry.op === 'string' && Object.hasOwn(labels, entry.op) ? labels[entry.op] : 'Other setup action';
const inOrg = org && String(entry.op).startsWith('account.') ? ` in ${org}` : '';
const user = entry.user === '[redacted]' ? 'someone whose name Mosaic hid' : shownName(entry.user);
return `${label}${inOrg} · ${window.MosaicLocalTime(entry.time)}${user ? ` · by ${user}` : ''}`;
}
function paintHistory() {
const list = $('proxy-setup-history'), msg = $('proxy-setup-history-message'), all = $('proxy-setup-history-all'), older = $('proxy-setup-history-older'), retry = $('proxy-setup-history-retry');
list.replaceChildren(...hist.entries.map((entry, i) => {
const text = historyText(entry), li = el('li', text ?? 'Withheld. The Console kept this entry back because it may hold a secret.', text ? undefined : 'muted');
if (!text) li.dataset.withheld = '';
li.hidden = !hist.expanded && i >= FEW; return li;
}));
const more = hist.next !== null;
// Show all only when some entries are folded away; Show older whenever there is an older page and
// nothing read is folded away, so an empty page offers it at once. After an empty page it stays while
// the list is folded, since the line below names it.
all.hidden = !hist.read || hist.entries.length <= FEW;
all.textContent = hist.expanded ? 'Show fewer' : 'Show all'; all.setAttribute('aria-expanded', String(hist.expanded));
older.hidden = !more || Boolean(hist.error) || (!hist.expanded && hist.entries.length > FEW && !hist.emptyPage);
older.disabled = hist.loading; older.textContent = hist.loading ? 'Reading…' : 'Show older';
retry.hidden = !hist.error;
msg.className = hist.error ? 'banner err' : 'small muted';
msg.textContent = hist.error ? `History could not be read. ${hist.error}`
: hist.loading && !hist.entries.length ? 'Reading…'
: !hist.read ? 'Not read yet.'
: hist.emptyPage && more ? 'That page of history had no entries to show. Show older reads further back.'
: !hist.entries.length && !more ? 'No setup history yet.' : '';
}
async function readHistory(reset) {
if (!enabled || (hist.loading && !reset)) return;
if (reset) Object.assign(hist, { entries: [], next: null, expanded: false, read: false, emptyPage: false });
const round = ++hist.round, before = hist.next, from = ['proxy-setup-history-older', 'proxy-setup-history-retry'].find(id => document.activeElement?.id === id);
Object.assign(hist, { loading: true, error: null }); paintHistory();
try {
const value = await admin(`history?limit=25${before === null ? '' : `&before=${encodeURIComponent(before)}`}`);
const next = value?.next;
// An older page is further back than the one asked for; one that is not would repeat entries.
if (!value || !Array.isArray(value.entries) || !(next === null || (Number.isInteger(next) && next >= 0 && (before === null || next < before)))) throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
if (round !== hist.round || !enabled) return;
hist.entries.push(...value.entries.slice().reverse());
Object.assign(hist, { next, read: true, emptyPage: value.entries.length === 0 });
} catch (error) { if (round !== hist.round || !enabled) return; hist.error = failText(error, HISTORY_WORDS); }
hist.loading = false; paintHistory();
// The button pressed keeps focus while it stays; when it goes, focus lands on Read again, Show older,
// Show fewer or the heading, in that order.
if (from) { const back = [$(from), $('proxy-setup-history-retry'), $('proxy-setup-history-older'), $('proxy-setup-history-all')].find(b => !b.hidden); if (back) back.focus(); else { const h = $('proxy-setup-history-title'); h.tabIndex = -1; h.focus(); } }
}
$('proxy-setup-history-all').addEventListener('click', () => { hist.expanded = !hist.expanded; paintHistory(); });
// Show older shows what it reads: the list stays open from then on.
$('proxy-setup-history-older').addEventListener('click', () => { if (!hist.loading && hist.next !== null) { hist.expanded = true; readHistory(false); } });
$('proxy-setup-history-retry').addEventListener('click', () => readHistory(!hist.read));
$('proxy-setup-tech').addEventListener('toggle', () => { if (techOpen() && enabled) { readKey(); readHistory(true); } });
$('proxy-setup-tech-lines').addEventListener('toggle', () => { if ($('proxy-setup-tech-lines').open && enabled) readLog(); });
function row(dl, term, text) { const dt = document.createElement('dt'), dd = document.createElement('dd'); dt.textContent = term; dd.textContent = text; dl.append(dt, dd); }
function paintState() {
// #1873 settings slice 5: the timeouts init chose, from the same read. Null is not set in
// proxy.json, so the model service uses its default.
const timeouts = s => !s || typeof s !== 'object' ? '' : `, wait for a first answer${s.firstOutputSeconds == null ? ': the default' : ` ${human(s.firstOutputSeconds)} seconds`}, old key kept${s.rotateGraceMinutes == null ? ' after a new one: the default' : ` ${human(s.rotateGraceMinutes)} minutes after a new one`}`;
const { release, init, unit, fence, initLock } = state, dl = $('proxy-setup-state'); dl.replaceChildren();
row(dl, 'Release', !release.fetched ? `Not fetched (pinned ${release.version}, panel ${release.panelVersion})` : release.verified ? `Fetched ${release.version}, panel ${release.panelVersion}, hashes verified` : `Fetched ${release.version}, hashes not verified (${release.problem})`);
const files = init.files.filter(f => f.present).map(f => f.label).join(', ') || 'none';
row(dl, 'Initialized', init.initialized ? `Yes, port ${init.settings?.port ?? '—'}` : init.partial ? `Partly (${init.problem ?? 'incomplete'}). Present: ${files}` : init.problem ? `No (${init.problem})` : 'No');
row(dl, 'Initialized', init.initialized ? `Yes, port ${init.settings?.port ?? '—'}${timeouts(init.settings)}` : init.partial ? `Partly (${init.problem ?? 'incomplete'}). Present: ${files}` : init.problem ? `No (${init.problem})` : 'No');
row(dl, 'Service', `${unit.unit}: ${unit.installed ? 'installed' : 'not installed'}, ${unit.active}${unit.pid ? `, pid ${unit.pid}` : ''}${unit.port ? `, port ${unit.port} ${unit.listening ? 'answering' : 'not answering'}` : ''}${unit.error ? ` (${unit.error})` : ''}`);
row(dl, 'Fence', !fence.set ? 'Clear' : fence.invalid ? 'Set (unreadable fence file)' : `Set after ${fence.op ?? 'a key write'}${fence.org ? ` for ${fence.org}` : ''}${fence.time ? ` at ${window.MosaicLocalTime(fence.time)}` : ''}`);
row(dl, 'Init lock', !initLock.present ? 'None' : initLock.clearable ? 'Stale: the bus is stopped and no model service files exist' : `Held: ${initLock.blockers.join('; ')}`);
if (state.restart?.confirmed) row(dl, 'Last restart', `Confirmed at ${window.MosaicLocalTime(state.restart.observedAt)}, new pid ${state.restart.pid}`);
if (enabled) keyRow(dl);
}
// settings-p3 (re-check 3 P3-1): where the hand steps for a held init lock or a partial init are written.
const README_STEPS = ['The hand steps for a stale init lock and a partial init are in ', 'packages/model-proxy/README.md'];
@@ -1031,8 +1184,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
if (failed && (CHAIN.includes(next) || next === 'unit-restart')) {
setCard('service', 'bad', `${failed.reason} The steps that finished are kept. No organization was touched.`, { badge: ['badge-danger', 'Setup stopped'] });
box.replaceChildren(el('p', 'Try again starts from the step that failed.', 'small muted'), goButton('Try again', next, !sendOk || Boolean(state.busy), runChain));
paintProgress(true); lines.hidden = false; lines.open = true;
$('proxy-setup-log').textContent = state.unit?.error ? String(state.unit.error) : 'Nothing reported.';
paintProgress(true);
if (lines.hidden) { lines.hidden = false; lines.open = true; readLog(); }
return;
}
lines.hidden = true;
@@ -1118,7 +1271,16 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
function paintOrgsCard() {
const line = $('setup-step-organizations').querySelector('[data-step-summary]'), go = $('proxy-ride-go');
go.className = 'btn'; delete line.dataset.next;
if (!running() || !accountCount) { setCard('organizations', 'wait', 'Opens after your first account.'); return; }
// settings-s5: before the first account, an organization the sidebar already marks "can't start" is
// named here, so the card and the mark agree.
if (!running() || !accountCount) {
const blocked = running() ? cantStart().map(f => nameOf(f.id)) : [];
if (!blocked.length) { setCard('organizations', 'wait', 'Opens after your first account.'); return; }
const one = blocked.length === 1;
// The card stays closed (Move needs a model from an account), with the mark's word on its badge.
setCard('organizations', 'wait', `Opens after your first account. ${listNames(blocked)} can't start now: ${one ? 'it uses' : 'they use'} stand-in models and ${one ? 'its bus is' : 'their buses are'} stopped. After your first account, move ${one ? 'it' : 'them'} to your models under Use your models in every organization, then start ${one ? 'its bus' : 'their buses'}.`, { badge: ['badge-danger', "Can't start"] });
return;
}
const step = orgStep(), names = needRestart().filter(restartHelps).map(o => nameOf(o.id));
// settings-p3 (rebase re-check P3-1, settings-s4 P3): the Ride all box still lists an organization,
// so not "every". One that turned the model service off is not waiting on anything: it is named.
@@ -1200,7 +1362,11 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
// After init, Advanced shows the settings init wrote, read-only.
const dl = $('proxy-setup-settings'), s = init.initialized && init.settings && typeof init.settings === 'object' ? init.settings : null;
dl.hidden = !s; $('proxy-setup-settings-note').hidden = !s; dl.replaceChildren();
if (s) { row(dl, 'Port', human(s.port)); if (s.firstOutputSeconds !== undefined) row(dl, 'Wait for a first answer', `${human(s.firstOutputSeconds)} seconds`); }
if (s) {
row(dl, 'Port', human(s.port));
if (s.firstOutputSeconds !== undefined) row(dl, 'Wait for a first answer', s.firstOutputSeconds === null ? 'The default' : `${human(s.firstOutputSeconds)} seconds`);
if (s.rotateGraceMinutes !== undefined) row(dl, 'Old key kept after a new one', s.rotateGraceMinutes === null ? 'The default' : `${human(s.rotateGraceMinutes)} minutes`);
}
}
// Programs that drive models: the harnesses this Console offers an organization, read on open.
let programsRead = false;
@@ -1255,15 +1421,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
+ 'Admission gets stricter there: every launch route is checked, direct Anthropic routes too, and while the model service is down or fenced every launch in that organization is refused. '
+ (ready ? `${ready} ${ready === 1 ? 'organization can' : 'organizations can'} ride now.` : 'No organization is waiting to ride.');
const go = $('proxy-ride-go'); go.disabled = !sendOk || Boolean(state.busy) || !ready;
$('proxy-ride-skips').replaceChildren(...rideSkips().map(s => li(`Skipped ${s.id}: ${rideReason(s.reason)}`)));
$('proxy-ride-skips').replaceChildren(...rideSkips().map(s => li(`Skipped ${nameOf(s.id)}: ${rideReason(s.reason)}`)));
const listedFixtures = rideResult?.fixtures ?? fixtures.map(f => ({ id: f.id, running: f.running }));
$('proxy-ride-fixtures').replaceChildren(...listedFixtures.map(f => {
// running null: no bus status here (the single-business Console), so moving is not available.
const name = nameOf(f.id);
if (f.running === null) return li(`${name} uses stand-in models. Moving it is not available on this Console.`);
// settings-s4 review F2: running false is what the sidebar marks "can't start"; say so, and the fix.
const item = li(f.running === false ? `${name} can't start: it uses stand-in models and its bus is stopped. Move it to the owner's models, then start its bus. `
: `${name} uses stand-in models, can be moved to the owner's models.${f.running === true ? ' Its bus is running: stop it first.' : ''} `);
const item = li(f.running === false ? `${name} can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus. `
: `${name} uses stand-in models, can be moved to your models.${f.running === true ? ' Its bus is running: stop it first.' : ''} `);
const move = document.createElement('button'); move.type = 'button'; move.className = 'btn'; move.textContent = `Move ${name}`;
move.dataset.rideMove = f.id; move.disabled = !sendOk || Boolean(state.busy);
move.addEventListener('click', () => { if (!move.disabled) rideMove(f.id); });
@@ -1281,22 +1447,22 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
});
};
const rideMove = id => {
if (!window.confirm(`Move ${id} to your models? Its stand-in models are replaced by a model your model service lists. After this, its agents spend real tokens on your account. Its bus stays stopped: start it when you are ready.`)) return;
if (!window.confirm(`Move ${nameOf(id)} to your models? Its stand-in models are replaced by a model your model service lists. After this, its agents spend real tokens on your account. Its bus stays stopped: start it when you are ready.`)) return;
return act('ride-move', async () => {
const result = await admin('ride-move', { org: id });
if (!result.moved) { rideSay(`${id} was not moved. ${rideReason(result.reason)}`, 'error'); return; }
if (!result.moved) { rideSay(`${nameOf(id)} was not moved. ${rideReason(result.reason)}`, 'error'); return; }
addReceipt(result.receipt);
if (rideResult) rideResult = { ...rideResult, fixtures: rideResult.fixtures.filter(f => f.id !== id) };
rideSay(`${id} now uses ${result.model}. Start its bus when you are ready. It spends real tokens from now on.`, 'success');
rideSay(`${nameOf(id)} now uses ${result.model}. Start its bus when you are ready. It spends real tokens from now on.`, 'success');
});
};
$('proxy-ride-go').addEventListener('click', () => { if (!$('proxy-ride-go').disabled) rideAll(); });
function paint() {
paintState(); paintControls(); paintReceipts(); paintService(); paintRestart(); paintOrgsCard(); paintTriageCard(); paintAccountCard();
paintState(); paintControls(); paintService(); paintRestart(); paintOrgsCard(); paintTriageCard(); paintAccountCard();
const job = state.fetch;
if (job.state === 'running') say(`Downloading: ${STEPS[job.step] ?? job.step ?? 'starting'}…`);
else if (job.state === 'failed' && seenFetch !== 'failed') { say(`Fetch failed. ${explain(job.error)}`, 'error'); seenFetch = 'failed'; }
else if (job.state === 'done' && job.receipt && seenFetch !== job.receipt.time) { seenFetch = job.receipt.time; if (!state.receipts?.some(r => r.op === 'fetch' && r.time === job.receipt.time)) addReceipt(job.receipt); say(`Fetched ${job.receipt.version}; archive, panel and executable hashes verified.`, 'success'); }
else if (job.state === 'done' && job.receipt && seenFetch !== job.receipt.time) { seenFetch = job.receipt.time; addReceipt(job.receipt); say(`Fetched ${job.receipt.version}; archive, panel and executable hashes verified.`, 'success'); }
clearTimeout(timer); timer = null;
if (enabled && !chain?.running && (job.state === 'running' || state.busy)) timer = setTimeout(load, 1000);
// The sidebar's model marks read the same status (MosaicModelDots).
@@ -1494,5 +1660,6 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
document.addEventListener('mosaic-org-restarted', () => { read(); });
const begin = () => { (window.MosaicOrg?.ready ?? Promise.resolve()).then(read, () => {}); };
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', begin, { once: true }); else begin();
window.MosaicModelDots = { get: id => marks.get(id) ?? null };
// settings-s5: a page that changes what the status says (an organization's Models choice) asks for a fresh read.
window.MosaicModelDots = { get: id => marks.get(id) ?? null, read };
})();
+18 -1
View File
@@ -119,7 +119,10 @@ table.s1-table td code{font-size:12.5px;white-space:nowrap}
.proxy-setup-next{display:flex;flex-wrap:wrap;align-items:center;gap:8px 16px;margin:0 0 12px}.proxy-setup-next p{margin:0;flex:1 1 280px}
.proxy-setup-buttons{display:flex;flex-wrap:wrap;gap:8px}.proxy-setup-buttons button{min-height:44px}
#proxy-setup pre{overflow-x:auto;max-width:100%;font-size:12px}#proxy-setup h3{margin:16px 0 4px}#proxy-setup details{margin:0 0 12px}#proxy-setup summary{min-height:44px;display:flex;align-items:center;cursor:pointer}
#proxy-setup-receipts{padding-left:20px;overflow-wrap:anywhere;font-size:13px}
/* settings-s5b: the setup history (GET /api/proxy/admin/history), the service key and the service's lines. */
#proxy-setup-history{list-style:none;padding-left:0;overflow-wrap:anywhere;font-size:13px;margin:0 0 8px}#proxy-setup-history li{padding:2px 0}
.proxy-setup-history-foot{display:flex;flex-wrap:wrap;gap:8px;margin:0}.proxy-setup-history-foot button,[data-log] button,#proxy-setup-keymade-retry{min-height:44px}
[data-log] .setup-log{margin:8px 0}[data-log] p{margin:0 0 8px}#proxy-setup-history-message:empty{display:none}
/* #1873 settings slice 1 (D3, D4): the kept restart list and Technical details. */
.proxy-setup-restart{margin:0 0 12px}
.proxy-setup-restart-list{list-style:none;margin:8px 0 0;padding:0;display:grid;gap:8px}
@@ -339,6 +342,7 @@ button:disabled,[aria-disabled=true]{cursor:not-allowed}
.rows li{display:grid;grid-template-columns:7rem minmax(0,1fr) auto;gap:6px var(--gap,12px);align-items:center;padding:10px 0;border-top:1px solid var(--line)}
.rows li>span:first-child{font-weight:600;color:var(--strong)}
.rows li>.account-reason{grid-column:2/-1;margin:0}
.rows li.muted{display:block}
.progress{list-style:none;margin:var(--gap,12px) 0 0;padding:0;display:grid;gap:6px}
.progress li::before{display:inline-block;width:1.4em;color:var(--muted)}
.progress .ok::before{content:"✓";color:var(--success)}.progress .run::before{content:"●";color:var(--action)}.progress .todo::before{content:"○"}.progress .bad::before{content:"✕";color:var(--danger)}
@@ -375,6 +379,19 @@ button:disabled,[aria-disabled=true]{cursor:not-allowed}
.settings-content fieldset.harness-control{display:flex;flex-wrap:wrap;align-items:center;gap:6px 12px}
.settings-content fieldset.harness-control>legend{flex-basis:100%}
.settings-content fieldset.harness-control>:is(button,p){flex-basis:100%}
/* #1873 settings slice 5: an organization's one choice (mockup org-models). A choice not built yet is dashed and disabled. */
/* settings-s5 review P3-4: the choice cards sit in the form column, as .settings-form does. */
.settings-content fieldset.models-source{display:grid;gap:8px;max-width:28rem}
.settings-content fieldset.models-source>legend{font-size:14px;color:var(--strong);margin-bottom:8px}
.settings-content fieldset.models-source>p{margin:0}
.choice{display:grid;grid-template-columns:auto 1fr auto;gap:4px 10px;align-items:start;padding:12px;border:1px solid var(--border);border-radius:var(--r);cursor:pointer}
.choice input{margin-top:4px}
.choice:has(input:checked){border-color:var(--action);background:var(--raised)}
.choice:has(input:disabled){cursor:default}
.choice.off{color:var(--muted);cursor:not-allowed;border-style:dashed;background:transparent}
.choice strong{color:var(--strong)}.choice.off strong{color:var(--muted)}
.choice .small{grid-column:2/4;margin:0}
.choice:has(input:focus-visible){outline:2px solid var(--focus);outline-offset:2px}
.settings-content :is(.instance-form,.level-form) textarea,.settings-content .assistant-form textarea{display:block;width:100%}
.route-definition{display:none}.settings-spinner{display:inline-block;width:16px;height:16px;border:2px solid currentColor;border-right-color:transparent;border-radius:50%;vertical-align:middle;animation:settings-spin .8s linear infinite}@keyframes settings-spin{to{transform:rotate(360deg)}}@media(prefers-reduced-motion:reduce){.settings-spinner{animation:none}}
@media(max-width:759px){#routes-table .route-definition{display:inline;float:right;color:var(--muted);font-size:12px;font-weight:400}}
+46 -3
View File
@@ -8,6 +8,8 @@
const $ = id => document.getElementById(id);
const esc = s => String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
const PATH = '/api/triage/route';
// proxy-scope slice 4 (#1873): Repair access and Turn Triage off (triage-route-http.mjs).
const ACCESS_PATH = '/api/triage/access';
// The time zones this browser knows, offered as suggestions only; the server decides.
const zones = (() => { try { return Intl.supportedValuesOf('timeZone'); } catch { return []; } })();
// draft holds the typed fields; base is the revision they were read at, which a save sends, so a
@@ -68,10 +70,47 @@
+ `</form>${send ? '' : '<p class="small muted" id="triage-route-readonly">This Console is read-only, so the route cannot be saved here.</p>'}`;
}
// proxy-scope slice 4: the key's state, ids and days only, and the two access buttons.
let accessLine = '';
function access() {
const a = data?.access;
if (!a || typeof a !== 'object') return '';
const state = a.key === 'issued' ? `Triage key ${esc(a.keyId)} is issued. It rotates on ${esc(a.rotateBy)}.`
: a.key === 'missing' ? 'No Triage key is issued, so Triage will not start.'
: 'The Triage key file is not safe to use, so Triage will not start.';
const warn = [a.rotation === 'rotation overdue' ? 'Key rotation overdue.' : '', a.code === 'triage-no-riding-bus' ? `${a.message}.` : ''].filter(Boolean).join(' ');
const off = busy || data?.send !== true ? ' disabled' : '';
return `<div id="triage-access" data-key="${esc(a.key)}" data-code="${esc(a.code ?? '')}" data-rotation="${esc(a.rotation ?? '')}"><p class="small">${state}</p>`
+ (warn ? `<p class="small warn" id="triage-access-warn">${esc(warn)}</p>` : '')
+ `<div class="settings-actions"><button type="button" class="btn" id="triage-access-repair"${off}>Repair access</button> <button type="button" class="btn" id="triage-access-off"${off}>Turn Triage off</button> <span role="status" id="triage-access-line" tabindex="-1">${esc(accessLine)}</span></div></div>`;
}
// Each key action in its own plain sentence (proxy.triage.key answers).
const ACTION_LINE = {
issued: 'A Triage key was issued.', replaced: 'A new Triage key replaced one the proxy no longer held.',
held: 'The Triage key is in place.', revoked: 'Triage is off. Its key was removed.', none: 'Triage is off. No key was held.',
};
async function accessOp(op) {
if (busy || data?.send !== true) return;
if (op === 'off' && typeof window.confirm === 'function' && !window.confirm('Turn Triage off? This stops any Triage session and removes its key. Repair access issues a new one.')) return;
busy = true; accessLine = op === 'off' ? 'Turning Triage off…' : 'Repairing access…'; repaint();
let r, a = null;
try { r = await window.fetch(ACCESS_PATH, { cache: 'no-store', redirect: 'manual', method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ op }) }); }
catch { busy = false; accessLine = 'Outcome unknown. Reload the page to see the key state.'; repaint(); return; }
try { a = await r.json(); } catch { /* refused below */ }
busy = false;
if (a?.access && data) data = { ...data, access: a.access };
if (r.type === 'opaqueredirect') accessLine = 'Sign in again, then retry.';
else if (r.ok) accessLine = ACTION_LINE[a?.key?.action] ?? (op === 'off' ? 'Triage is off.' : 'Access was repaired.');
else accessLine = typeof a?.message === 'string' ? a.message : 'The Triage key was not changed.';
repaint();
$('triage-access-line')?.focus?.();
}
function markup() {
const body = data === null
? `<p class="small warn">${esc(readLine || 'The Triage route could not be read.')}</p><p role="status" id="triage-route-line" tabindex="-1">${esc(line)}</p>`
: `${stored()}${form()}<p class="small muted" id="triage-route-note">${esc(data.note ?? 'Saving a route does not start Triage. Triage also needs its key.')}</p>`;
: `${stored()}${access()}${form()}<p class="small muted" id="triage-route-note">${esc(data.note ?? 'Saving a route does not start Triage. Triage also needs its key.')}</p>`;
return `<section class="panel" id="triage-route" aria-labelledby="triage-route-title"><h3 id="triage-route-title">Triage model route</h3>${body}</section>`;
}
const repaint = () => { const panel = $('triage-route'); if (panel) panel.outerHTML = markup(); };
@@ -93,7 +132,7 @@
if (r.ok && a?.route) {
data = { ...data, route: a.route, revision: a.revision, routeMessage: undefined };
draft = fromRoute(a.route); base = a.revision;
line = `Saved ${savedAt(a.route.updatedAt)}.`;
line = `Saved ${savedAt(a.route.updatedAt)}.` + (a.key?.error ? ` ${a.key.message}` : ACTION_LINE[a.key?.action] ? ` ${ACTION_LINE[a.key.action]}` : '');
repaint();
$('triage-route-line')?.focus?.();
return;
@@ -127,7 +166,11 @@
repaint(); $('triage-route-model')?.focus();
});
document.addEventListener('submit', e => { if (e.target?.id !== 'triage-route-form') return; e.preventDefault(); save(); });
document.addEventListener('click', e => { if (e.target?.id === 'triage-route-reload') reload(); });
document.addEventListener('click', e => {
if (e.target?.id === 'triage-route-reload') reload();
if (e.target?.id === 'triage-access-repair') accessOp('repair');
if (e.target?.id === 'triage-access-off') accessOp('off');
});
const hasDraft = () => !!(draft && data && JSON.stringify(draft) !== JSON.stringify(fromRoute(data.route)));
window.MosaicTriageRoute = { section, hasDraft };
+2 -1
View File
@@ -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
+87
View File
@@ -0,0 +1,87 @@
// proxy-scope slice 4 (#1873): the Console's side of the Triage key. The Console never holds the
// proxy management key, so it never issues or removes a Triage key itself: it asks one riding
// organization's bus to, through the bus verb `proxy.triage.key` (op ensure or revoke), as the owner,
// the way Proxy setup's init asks one bus for `proxy.init` (packages/model-proxy/src/admin-control.mjs).
// A riding organization lists cliproxy and is not a fixture organization; its bus decides for itself
// whether it holds the owner's proxy client, and refuses triage-no-riding-bus when it does not.
//
// A bus that is down or not riding did nothing, so it is passed over and the next one is asked. A bus
// whose outcome is unknown (a timeout, or an answer that could not be read) may have done the work, so
// the walk stops there and the caller shows the key file's state. Any other refusal is the answer.
// With no bus left the answer is triage-no-riding-bus.
//
// The key file is read only through packages/bus/src/triage-key-file.mjs, the reader with no proxy
// client and no lock. No answer here holds a key: only ids, days and codes.
import { readKey } from '../../bus/src/triage-key-file.mjs';
export const NO_RIDING_MESSAGE = "Triage needs one organization that uses the owner's models";
// A bus sweep runs every 30 s; a rotation still not done this long after its day began means no
// riding bus could act.
export const OVERDUE_ALLOWANCE_MS = 10 * 60 * 1000;
// A refusal that says only "not this bus": ask the next one.
const NEXT = new Set(['triage-no-riding-bus', 'not-configured', 'no-bus-host', 'unknown-verb', 'bus-unavailable']);
// An outcome the Console cannot know (webui bus.mjs OPEN): stop, and answer outcome-unknown.
const OPEN = new Set(['outcome-unknown', 'invalid-response', 'response-too-large']);
const ACTIONS = new Set(['issued', 'held', 'replaced', 'revoked', 'none']);
const KEY_ID = /^[0-9a-f]{12}$/;
const DAY = /^\d{4}-\d{2}-\d{2}$/;
const ids = v => (Array.isArray(v) ? v.filter(x => typeof x === 'string' && KEY_ID.test(x)) : []);
// The fields the Console keeps from a bus answer, re-checked here: ids and a day, never a key.
const clean = (op, a) => ({
ok: true, op,
action: ACTIONS.has(a?.action) ? a.action : 'unknown',
addedKeyIds: ids(a?.addedKeyIds), removedKeyIds: ids(a?.removedKeyIds),
...(op === 'ensure' && typeof a?.keyId === 'string' && KEY_ID.test(a.keyId) ? { keyId: a.keyId } : {}),
...(op === 'ensure' && typeof a?.rotateBy === 'string' && DAY.test(a.rotateBy) ? { rotateBy: a.rotateBy } : {}),
});
// triageKeyCall({ riders, op }) -> { ok: true, op, action, addedKeyIds, removedKeyIds, keyId?, rotateBy?, org }
// | { ok: false, code, org? }
// riders async () -> [{ id, fixture, cliproxy, call }] (webui cli.mjs rideRiders)
// The organizations whose bus may hold the Triage key: they list cliproxy and are not fixtures. The
// status reads the same list, so it says no riding organization exactly when the walk has none to ask.
export const ridingOrgs = list => (Array.isArray(list) ? list : []).filter(r => r?.cliproxy === true && r.fixture !== true && typeof r.call === 'function');
export async function triageKeyCall({ riders, op }) {
if (op !== 'ensure' && op !== 'revoke') return { ok: false, code: 'invalid-request' };
let list = [];
try { list = await riders(); } catch { list = []; }
for (const r of ridingOrgs(list)) {
let answer;
try { answer = await r.call('proxy.triage.key', { op }); }
catch (e) {
const code = typeof e?.code === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(e.code) ? e.code : 'outcome-unknown';
if (NEXT.has(code)) continue;
return { ok: false, code: OPEN.has(code) ? 'outcome-unknown' : code, org: r.id };
}
return { ...clean(op, answer), org: r.id };
}
return { ok: false, code: 'triage-no-riding-bus' };
}
// The key's state from the file alone, for Settings > Triage: never the key, only whether one is
// held, its id, its rotation day, how many old keys are in grace, and whether the rotation is overdue.
// { key: 'missing' } | { key: 'unsafe' } | { key: 'issued', keyId, rotateBy, retiring, overdue }
export function keyState(configDir, { now = () => Date.now(), keyOptions = {} } = {}) {
let record;
try { record = readKey(configDir, keyOptions); } catch { return { key: 'unsafe' }; }
if (!record) return { key: 'missing' };
const due = Date.parse(`${record.rotateBy}T00:00:00Z`);
return {
key: 'issued', keyId: record.keyId, rotateBy: record.rotateBy, retiring: record.retiring.length,
due: Number.isFinite(due) && now() >= due,
overdue: Number.isFinite(due) && now() > due + OVERDUE_ALLOWANCE_MS,
};
}
// The status Settings > Triage shows: the key state, and the named code when no organization rides
// the owner's models (so no bus can issue, rotate or retire the key). The rotation is overdue when
// its day has begun and no riding bus can act, or when it is still not done well after (a riding
// organization whose bus did not rotate it).
export function accessStatus(state, { riding }) {
const out = { ...state, riding: riding === true };
if (riding !== true) Object.assign(out, { code: 'triage-no-riding-bus', message: NO_RIDING_MESSAGE });
if (state.key === 'issued' && (state.overdue || (state.due && riding !== true))) out.rotation = 'rotation overdue';
return out;
}
+74 -1
View File
@@ -91,6 +91,12 @@ export const USAGE_NOT_READ = "Triage could not read its token usage or its cap,
// #1873 triage-wiring: two turns in a row whose usage reads unknown end the session (cap fail closed).
export const UNKNOWN_TURNS_MAX = 2;
export const USAGE_UNKNOWN_ENDED = "Triage ended this session: the token usage of two turns in a row could not be read, so the daily cap could not be kept. The next message starts a new session.";
// proxy-scope slice 4 (#1873): a session still running on a key whose grace has ended (its retireAt
// in the key file has passed, or the key is gone from the file) stops with this code, before the bus
// sweep removes the key from the proxy (the sweep waits 30 s past retireAt).
export const KEY_ROTATED_CODE = "triage-key-rotated";
export const KEY_ROTATED = "Triage stopped this session: its key was rotated and the old key's grace ended. The next message starts a new session on the current key.";
export const KEY_POLL_MS = 5000;
// #1873 triage-wiring: the route's refusals (triage-route.mjs), each with the one plain line the
// drawer shows. None carries a path, a key or an env value.
export const ROUTE_REFUSALS = Object.freeze({
@@ -323,13 +329,18 @@ export function createRelay({ socket, cap, take, read, onSend, usage = null, sto
// repository's packages/plugins/harness/<name> by default
// home HOME, which no mount may reach outside the stack's own code; the Console user's by default
// usageSource { readTurn({ harness, root }) } the transcript usage-source; the repository's own by default
export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null, proxyPort = null, tokenPattern = null, harnessModule = repoHarnessModule, home = homedir(), usageSource = { readTurn } }) {
// keyRecord () -> the Triage key file's record (packages/bus/src/triage-key-file.mjs readKey) or
// null; throws when unsafe. With it, a session on a key past its retireAt, or a key
// gone from the file, stops with triage-key-rotated. Without it, nothing is checked.
// keyPollMs how often a running session's key is checked
export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null, proxyPort = null, tokenPattern = null, harnessModule = repoHarnessModule, home = homedir(), usageSource = { readTurn }, keyRecord = null, keyPollMs = KEY_POLL_MS }) {
if (typeof dataRoot !== "string" || !dataRoot.startsWith("/")) throw new TriageError("triage-no-data-root", "no data root");
const validPort = (p) => Number.isInteger(p) && p > 0 && p <= 65535;
if (proxyPort !== null && typeof proxyPort !== "function" && !validPort(proxyPort)) throw new TypeError("proxyPort must be a port number, null or a function");
if (tokenPattern !== null && !(tokenPattern instanceof RegExp)) throw new TypeError("tokenPattern must be a RegExp or null");
if (typeof harnessModule !== "function") throw new TypeError("harnessModule must be a function");
if (typeof usageSource?.readTurn !== "function") throw new TypeError("usageSource must have readTurn");
if (keyRecord !== null && typeof keyRecord !== "function") throw new TypeError("keyRecord must be a function or null");
const tokenShape = tokenPattern && new RegExp(`^(?:${tokenPattern.source})$`, tokenPattern.flags.replace(/[gmy]/g, ""));
const tokenAnywhere = tokenPattern && new RegExp(tokenPattern.source, tokenPattern.flags.replace(/[gmy]/g, "") + "g");
// What no mount source may lie in or around, besides the run directory and the fixed list. HOME
@@ -355,6 +366,11 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
// host/ too, so a Console restart between the end and the next message keeps it.
let freshSession = false;
const badSeen = new Set();
// proxy-scope slice 4: the key the running session holds (memory only, never written or logged),
// the timer that checks it, and the last stop the host made for a rotated key.
let heldKey = null;
let keyTimer = null;
let lastStop = null;
const ensureDirs = () => {
mkdirSync(dataRoot, { recursive: true, mode: 0o700 });
@@ -765,6 +781,49 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
return true;
};
// proxy-scope slice 4. Where the held key stands in the key file: "current", the retireAt (ms) of
// the retiring entry that holds it, "gone", or "unknown" (no reader, no key, or an unsafe file:
// nothing is decided on a file that cannot be read; the next admit refuses it).
const keyStanding = (held) => {
if (!keyRecord || typeof held !== "string" || !held) return "unknown";
let r;
try { r = keyRecord(); } catch { return "unknown"; }
if (!r) return "gone";
if (r.key === held) return "current";
const old = Array.isArray(r.retiring) ? r.retiring.find((x) => x?.key === held) : null;
if (!old) return "gone";
const at = Date.parse(old.retireAt);
return Number.isFinite(at) ? at : "gone";
};
const keyDue = (held) => {
const s = keyStanding(held);
return s === "gone" || (typeof s === "number" && s <= now().getTime());
};
// SIGTERM, then SIGKILL after the grace; resolves when the process has exited (or 2 s after SIGKILL).
const endChild = (c, graceMs) => new Promise((resolve) => {
if (!c || c.exitCode !== null || c.signalCode !== null) return resolve();
let kill = null, last = null;
c.once("exit", () => { clearTimeout(kill); clearTimeout(last); resolve(); });
try { process.kill(-c.pid, "SIGTERM"); } catch {}
kill = setTimeout(() => {
try { process.kill(-c.pid, "SIGKILL"); } catch {}
last = setTimeout(resolve, 2000);
}, graceMs);
});
// The session on a rotated key stops: a host line says why, the runner is told its session is gone
// at its next state or receive, and the process group ends. Queued messages get their lines at exit.
let rotating = null;
const stopRotated = (c, { graceMs = 5000 } = {}) => rotating ??= (async () => {
if (!c || child !== c) return;
if (usage) usage.halted = true;
lastStop = { code: KEY_ROTATED_CODE, at: now().toISOString() };
log(`triage host: stopping the session: ${KEY_ROTATED_CODE}`);
try { append({ at: now().toISOString(), from: "host", text: KEY_ROTATED }); }
catch { log("triage host: transcript write failed"); }
await endChild(c, graceMs);
})().finally(() => { rotating = null; });
const clearKeyTimer = () => { if (keyTimer) clearInterval(keyTimer); keyTimer = null; };
const start = async ({ admitted, installRoots, transcriptRoot, mod }) => {
ensureDirs();
const { run, harnessFiles } = writeBundle(admitted, mod);
@@ -837,6 +896,8 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
if (child !== mine) return;
lastExit = { code: Number.isInteger(code) ? code : null, signal: signal ?? null, at: now().toISOString() };
child = null;
heldKey = null;
clearKeyTimer();
// A turn the session began and never ended (killed, crashed) still spent tokens: it gets its line.
// The open turns are read when this runs, after any usage.end already in the chain.
chainUsage(async () => { for (const k of [...u.baselines.keys()]) await finishTurn(u, k); });
@@ -857,6 +918,13 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
log(`triage host: launcher did not run: ${e.code ?? "error"}`);
throw new TriageError("triage-start-failed", "the Triage session did not start");
}
// proxy-scope slice 4: the key this session holds is checked while it runs.
heldKey = key;
clearKeyTimer();
if (keyRecord && key) {
keyTimer = setInterval(() => { if (child === mine && keyDue(key)) stopRotated(mine).catch(() => {}); }, keyPollMs);
keyTimer.unref?.();
}
};
// The cap is the route's to count. Once it answers over the cap with a time in the next two days,
@@ -908,6 +976,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
resetsAt: unset ? "not set" : c.resetsAt ?? "not read",
running: child !== null,
lastExit,
lastStop,
snapshot: last,
transcript: transcript(),
};
@@ -935,6 +1004,9 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: e?.code === "triage-route-invalid" ? ROUTE_REFUSED : NOT_STARTED }); } catch {}
throw e instanceof TriageError ? e : new TriageError("triage-route-invalid", "the model route's answer is not usable");
}
// proxy-scope slice 4: a session on a key past its grace stops before this message is queued,
// so the message starts a new session on the key the route answered with.
if (child && keyDue(heldKey)) await stopRotated(child);
queue.push({ id, body: text, at, delivered: false });
if (!child) {
starting ??= start(checked).finally(() => { starting = null; });
@@ -952,6 +1024,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
return { id, at };
},
async stop({ graceMs = 5000 } = {}) {
clearKeyTimer();
const c = child;
if (c) {
try { process.kill(-c.pid, "SIGTERM"); } catch {}
+79 -2
View File
@@ -19,8 +19,12 @@ import { fileURLToPath } from 'node:url';
import { checkRoutes } from '../../organization/src/launch-settings.mjs';
import { isDailyModelQuota } from '../../plugins/src/model-quota.mjs';
import { readRoute, writeRoute } from './triage-route-store.mjs';
import { NO_RIDING_MESSAGE, accessStatus } from './triage-access.mjs';
export const TRIAGE_ROUTE_PATH = '/api/triage/route';
// proxy-scope slice 4 (#1873): Repair access (ensure) and Turn Triage off (stop, then revoke).
export const TRIAGE_ACCESS_PATH = '/api/triage/access';
export const ACCESS_OPS = Object.freeze(['repair', 'off']);
export const BODY_MAX = 16384;
export const POST_KEYS = Object.freeze(['model', 'harness', 'cap', 'timeZone', 'revision']);
export const NOT_SET_MESSAGE = 'No Triage route is set.';
@@ -63,6 +67,7 @@ const STATUS = Object.freeze({
'triage-route-unreadable': 503,
'triage-route-unrecorded': 500,
'outcome-unknown': 503,
'triage-no-riding-bus': 503,
});
// Fixed words for each code. The store's own messages name lock files, so none is forwarded.
const MESSAGES = Object.freeze({
@@ -85,7 +90,16 @@ const MESSAGES = Object.freeze({
'triage-route-unreadable': 'The stored route could not be read.',
'triage-route-unrecorded': 'The route was saved, but its receipt line was not written.',
'outcome-unknown': 'The route service did not answer.',
'triage-no-riding-bus': `${NO_RIDING_MESSAGE}. Start an organization that uses them, then choose Repair access.`,
});
// proxy-scope slice 4: a bus refusal of proxy.triage.key, in fixed words. The code is a bus code
// (lowercase and dashes); nothing from the bus's text is shown.
const keyFailed = code => code === 'triage-no-riding-bus' ? MESSAGES['triage-no-riding-bus']
: `The Triage key was not changed. The organization's bus refused with ${/^[a-z][a-z0-9-]{0,63}$/.test(code ?? '') ? code : 'an unknown code'}.`;
// What a key step answers in a response: ids, action and day, or the code and its fixed words.
const keyView = r => r?.ok === true
? { action: r.action, ...(r.keyId ? { keyId: r.keyId } : {}), ...(r.rotateBy ? { rotateBy: r.rotateBy } : {}) }
: { error: r?.code ?? 'outcome-unknown', message: keyFailed(r?.code) };
const json = (res, status, value) => {
res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
@@ -191,7 +205,25 @@ async function readBody(req) {
// Registers both routes. `catalogues` returns each active organization's `routes` catalogue (or a
// status when its bus did not answer); `harnesses` lists the installed harness modules.
export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedHarnesses, log = () => {} }) {
// proxy-scope slice 4: `access`, when given, is the Triage key's side:
// state() the key file's state (triage-access.mjs keyState), never the key
// riding() async -> true when one organization rides the owner's models
// key(op) async -> triageKeyCall's answer for op ensure or revoke, through one riding bus
// stop() async -> stops a running Triage session (the host's stop)
// A route save with no key held runs ensure once; POST /api/triage/access runs Repair access
// (ensure) or Turn Triage off (stop, then revoke). With no access, neither happens.
export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedHarnesses, log = () => {}, access = null }) {
const accessNow = async () => {
if (!access) return undefined;
let state;
try { state = access.state(); } catch { state = { key: 'unsafe' }; }
let riding = false;
try { riding = (await access.riding()) === true; } catch { riding = false; }
return accessStatus(state, { riding });
};
const keyStep = async op => {
try { return await access.key(op); } catch { return { ok: false, code: 'outcome-unknown' }; }
};
async function catalogue() {
let list;
try { list = await catalogues(); } catch { list = []; }
@@ -222,9 +254,11 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
let doc;
try { doc = readRoute(dataRoot); } catch (error) { return refuse(error?.code === 'triage-route-unreadable' ? 'triage-route-unreadable' : 'outcome-unknown'); }
const route = view(doc);
const status = await accessNow();
return done(200, {
route, ...(route ? {} : { routeMessage: NOT_SET_MESSAGE }), revision: route ? route.revision : 0,
choices: choices(await catalogue()), send: context.send === true, note: NOT_STARTED_NOTE,
...(status ? { access: status } : {}),
});
}
if (context.send !== true) return refuse('read-only');
@@ -247,7 +281,17 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
if (by === null) return refuse('human-required');
try {
const doc = writeRoute(dataRoot, { model, harness, limit: cap, timeZone: zone, by, revision });
return done(200, { route: view(doc), revision: doc.revision, note: NOT_STARTED_NOTE });
// proxy-scope slice 4: the owner's first save (the one that creates the route, at revision 0),
// with no key held, asks a riding bus for one. A later save never does: after Turn Triage off
// only Repair access brings a key back. A key that is not issued leaves the route saved; the
// answer says why.
let key;
if (access && revision === 0) {
let state;
try { state = access.state(); } catch { state = { key: 'unsafe' }; }
if (state.key === 'missing') key = keyView(await keyStep('ensure'));
}
return done(200, { route: view(doc), revision: doc.revision, note: NOT_STARTED_NOTE, ...(key ? { key } : {}) });
} catch (error) {
const code = typeof error?.code === 'string' && Object.hasOwn(MESSAGES, error.code) && error.code.startsWith('triage-route-') ? error.code : 'outcome-unknown';
if (code !== 'triage-route-stale') return refuse(code);
@@ -256,7 +300,40 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
return refuse(code, { revision: stored ? stored.revision : 0 });
}
}
// POST /api/triage/access { op: 'repair' | 'off' }: the owner's Repair access and Turn Triage off.
async function handleAccess(req, res, context) {
const done = (status, value) => {
log(`${new Date().toISOString()} ${req.method} ${TRIAGE_ACCESS_PATH} ${status}`);
return json(res, status, value);
};
const refuse = code => done(STATUS[code] ?? 503, { error: code, message: MESSAGES[code] ?? MESSAGES['outcome-unknown'] });
if (req.method !== 'POST') return refuse('method-not-allowed');
if (context.owner !== true || !context.session) return refuse('human-required');
if (one(req, 'origin') !== context.origin) return refuse('cross-origin');
if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse('cross-site');
if (context.send !== true) return refuse('read-only');
if (!access) return refuse('outcome-unknown');
let op;
try {
if ((req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase() !== 'application/json') throw Error();
const chunks = []; let size = 0;
for await (const chunk of req) { size += chunk.length; if (size > BODY_MAX) throw Error(); chunks.push(chunk); }
const body = JSON.parse(Buffer.concat(chunks));
if (!plain(body) || Object.keys(body).length !== 1 || !ACCESS_OPS.includes(body.op)) throw Error();
op = body.op;
} catch { return done(400, { error: 'invalid-request', message: 'The request takes op, repair or off.' }); }
if (op === 'off') {
// The session stops first, so nothing runs on a key while it is removed.
try { await access.stop(); } catch { log('triage access: the session stop failed'); }
}
const result = await keyStep(op === 'repair' ? 'ensure' : 'revoke');
const key = keyView(result);
const status = await accessNow();
if (result?.ok === true) return done(200, { op, key, access: status });
return done(STATUS[result?.code] ?? 502, { op, ...key, key, access: status });
}
return registered => {
registered.add('POST', TRIAGE_ACCESS_PATH, handleAccess);
registered.add('GET', TRIAGE_ROUTE_PATH, handle);
registered.add('POST', TRIAGE_ROUTE_PATH, handle);
};
+2 -2
View File
@@ -1,7 +1,7 @@
// #1873 triage-wiring: the Triage host's model route, resolved again at each admit (design report
// reports/triage-route-design.md slice 5). Four sources, each read fresh:
// the route store harness name, model key and cap (triage-route-store.mjs)
// the key file <configDir>/secrets/triage/model (packages/cli/src/triage-key-file.mjs, the
// the key file <configDir>/secrets/triage/model (packages/bus/src/triage-key-file.mjs, the
// key verbs' own reader and checks; never the module that holds the proxy client)
// the model catalogue model and provider for the key, read from each active organization's bus
// `routes` verb and merged (mergeCatalogues), then held to checkRoutes, the
@@ -32,7 +32,7 @@ import { lstatSync, readdirSync } from "node:fs";
import { join } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { checkRoutes } from "../../organization/src/launch-settings.mjs";
import { SECRET, keyPrefix, readKey } from "../../cli/src/triage-key-file.mjs";
import { SECRET, keyPrefix, readKey } from "../../bus/src/triage-key-file.mjs";
import { readRoute } from "./triage-route-store.mjs";
import { ROUTE_KEY_NAMES, ROUTE_REFUSALS, refusedHarnessName } from "./triage-host.mjs";
import { checkedTransport } from "../../harness/src/bundle.mjs";
+172 -2
View File
@@ -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);
});
@@ -26,9 +26,12 @@ const scenario = (status, config = {}) => ({ '/api/config': { send: true, devOwn
const writes = b => b.evaluate('window.__writes.filter(w=>w.path.startsWith("/api/proxy/admin/")).map(w=>({path:w.path,body:JSON.parse(w.body)}))');
// Step 3's line names the step it holds in data-next.
const STEP3 = '#setup-step-organizations [data-step-summary]';
// settings-s5b: Technical details reads the setup history from GET /api/proxy/admin/history, not from receipts.
const history = entries => ({ '/api/proxy/admin/history?limit=25': { entries, next: null }, '/api/proxy/admin/service-key': { madeAt: T, renewedAt: null, renewal: 'not-built', problem: null } });
const historyItems = b => b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].map(li=>li.textContent.split(" · ")[0])');
test('a fresh instance shows Set up model service as one button, the not-built own proxy, and no terminal note', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(base), 'POST /api/proxy/admin/fetch': { status: 202, body: { state: 'running' } } } });
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(base), 'POST /api/proxy/admin/fetch': { status: 202, body: { state: 'running' } }, '/api/proxy/admin/log?lines=20': { unit: 'mosaic-proxy.service', lines: [], redacted: 0, dropped: 0 } } });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="fetch"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup").hidden'), false);
@@ -46,6 +49,8 @@ test('a fresh instance shows Set up model service as one button, the not-built o
await wait('document.querySelector("#setup-step-service").dataset.state==="bad"');
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/fetch', body: {} }]);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Try again');
// settings-s5b: a failed step 1 opens the service's last lines, read from the log route.
await wait('document.querySelector("#proxy-setup-lines").open && /written nothing yet/.test(document.querySelector("#proxy-setup-lines [data-log]").textContent)');
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
@@ -59,7 +64,7 @@ test('without send the next-step button is disabled and nothing is posted', { ti
});
test('init always sends generate; there is no pasted key, and Try again sends generate again', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fetched), 'POST /api/proxy/admin/init': { body: { settings: { port: 18432 }, receipt: { op: 'init', time: T, port: 18432, generated: true } } } } });
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fetched), ...history([{ op: 'init', time: T }]), 'POST /api/proxy/admin/init': { body: { settings: { port: 18432 }, receipt: { op: 'init', time: T, port: 18432, generated: true } } } } });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="init"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Continue setup');
@@ -73,7 +78,11 @@ test('init always sends generate; there is no pasted key, and Try again sends ge
await b.evaluate('(()=>{const f=document.querySelector("#proxy-setup-init");f.elements.port.value="18432";document.querySelector("#proxy-setup-go").click();})()');
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/init")');
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/init', body: { generate: true, port: 18432 } }]);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-receipts").textContent'), /init/);
// settings-s5b: the receipt is not shown raw; the history read under Technical details names it.
assert.doesNotMatch(await b.evaluate('document.querySelector("#proxy-setup").textContent'), /generated/);
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
assert.deepEqual(await historyItems(b), ['Set up']);
// The status still names init, so the run stops there; Try again starts from it.
await wait('document.querySelector("#proxy-setup-go")?.textContent==="Try again" && !document.querySelector("#proxy-setup-init [data-setup-write]").disabled');
await b.evaluate('(()=>{const f=document.querySelector("#proxy-setup-init");f.elements.port.value="";document.querySelector("#proxy-setup-go").click();})()');
@@ -82,14 +91,20 @@ test('init always sends generate; there is no pasted key, and Try again sends ge
});
test('after a confirmed restart the next step clears the fence and shows the receipt', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fenced), 'POST /api/proxy/admin/fence/clear': { body: { cleared: true, receipt: { op: 'fence.clear', time: T, pid: 4242 } } } } });
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fenced), ...history([]), 'POST /api/proxy/admin/fence/clear': { body: { cleared: true, receipt: { op: 'fence.clear', time: T, pid: 4242 } } } } });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="fence-clear"');
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
await wait('document.querySelector("#proxy-setup-history-message").textContent === "No setup history yet."');
await b.evaluate(`window.__scenario['/api/proxy/admin/history?limit=25'] = { entries: [{ op: 'fence.clear', time: '${T}' }], next: null }`);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-state").textContent'), /new pid 4242/);
await b.evaluate('document.querySelector("#proxy-setup-go").click()');
await wait('document.querySelector("#proxy-setup-message").textContent.includes("Fence cleared")');
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/fence/clear', body: {} }]);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-receipts").textContent'), /fence\.clear.*pid: 4242/);
// settings-s5b: with Technical details open, the write reads the history again.
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
assert.deepEqual(await historyItems(b), ['Key writes resumed']);
assert.doesNotMatch(await b.evaluate('document.querySelector("#proxy-setup").textContent'), /pid: 4242/);
});
test('a stopped proxy hides the account panels with a setup note, and starting the service brings them back', { timeout: 90000 }, async t => {
@@ -143,13 +158,16 @@ test('a fence with no readable time names the --proxy-restarted path instead of
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-next details.proxy-setup-cli p").textContent'), 'Run this in a terminal on this machine: mosaic proxy fence clear --proxy-restarted');
});
test('after a reload the receipts come from status, and an initialized proxy shows its settings read-only', { timeout: 90000 }, async t => {
test('after a reload the history comes from the history read, not the status receipts, and an initialized proxy shows its settings read-only', { timeout: 90000 }, async t => {
const initialized = { ...base, release: fetched.release, init: { initialized: true, partial: false, settings: { port: 18432 }, files: [] },
receipts: [{ op: 'fetch', time: T, version: '8.0.42' }, { op: 'init', time: T, generated: true, port: 18432 }], next: ['unit-install'] };
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(initialized), 'POST /api/proxy/admin/unit/install': { body: { receipt: { op: 'unit.install', time: T } } } } });
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(initialized), ...history([{ op: 'fetch', time: T }, { op: 'init', time: T }]), 'POST /api/proxy/admin/unit/install': { body: { receipt: { op: 'unit.install', time: T } } } } });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="unit-install"');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-receipts li strong")].map(s=>s.textContent)'), ['init', 'fetch'], 'newest first, from proxy-admin.jsonl');
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 0, 'nothing is read before Technical details opens');
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
assert.deepEqual(await historyItems(b), ['Set up', 'Release downloaded and checked'], 'newest first, from the history read');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-init").hidden'), true, 'init is done, so its form is gone');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-settings").textContent'), 'Port18432');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-settings-note").textContent'), 'Changing these after setup is not built yet.');
@@ -177,7 +195,7 @@ test('Ride all confirms the stricter admission, paints skips and stand-in organi
await wait(`document.querySelector("#proxy-ride")?.checkVisibility() && document.querySelector(${JSON.stringify(STEP3)})?.dataset.next==="ride-all"`);
assert.equal(await b.evaluate('document.querySelector("#proxy-ride-go").className'), 'btn primary');
assert.match(await b.evaluate('document.querySelector("#proxy-ride-text").textContent'), /every launch route is checked, direct Anthropic routes too.*2 organizations can ride now/);
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /^west uses stand-in models, can be moved to the owner's models\./);
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /^west uses stand-in models, can be moved to your models\./);
// The first Ride all's own reload paints, then waits on the accounts read for good.
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/ride-all")');
@@ -399,7 +417,7 @@ test('settings-p3: a stand-in organization with no bus status is not offered a M
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-ride-fixtures li")');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-ride-fixtures li")].map(li => li.firstChild.textContent.trim())'),
['west uses stand-in models. Moving it is not available on this Console.', "east uses stand-in models, can be moved to the owner's models."]);
['west uses stand-in models. Moving it is not available on this Console.', "east uses stand-in models, can be moved to your models."]);
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=west]")'), null);
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=east]").disabled'), false);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
@@ -446,8 +464,8 @@ test('settings-s1 B4: only the next step has a button; done steps, Fence, Init l
assert.deepEqual(await b.evaluate(`${visible('.settings-content .primary')}.map(e=>e.id||e.textContent)`), ['proxy-login-go'], 'one primary button on the page');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go")'), null, 'step 1 is done, so it has no button');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-init").checkVisibility()'), false, 'init is done, so its form is gone');
const tech = await b.evaluate('(()=>{const d=document.querySelector("#proxy-setup-tech");return {summary:d.querySelector("summary").textContent,open:d.open,terms:[...d.querySelectorAll("dt")].map(x=>x.textContent),units:d.querySelectorAll("[data-unit]").length,receipts:!!d.querySelector("#proxy-setup-receipts")}})()');
assert.deepEqual(tech, { summary: 'Technical details: release, service, history', open: false, terms: ['Release', 'Initialized', 'Service', 'Fence', 'Init lock'], units: 4, receipts: true });
const tech = await b.evaluate('(()=>{const d=document.querySelector("#proxy-setup-tech");return {summary:d.querySelector("summary").textContent,open:d.open,terms:[...d.querySelectorAll("dt")].map(x=>x.textContent),units:d.querySelectorAll("[data-unit]").length,history:!!d.querySelector("#proxy-setup-history")}})()');
assert.deepEqual(tech, { summary: 'Technical details: release, service, history', open: false, terms: ['Release', 'Initialized', 'Service', 'Fence', 'Init lock', 'Service key'], units: 4, history: true });
assert.equal(await b.evaluate(`${visible('#proxy-setup dt, #proxy-setup [data-unit]')}.length`), 0, 'nothing technical shows until it is opened');
// Technical details opens by keyboard and shows the controls.
await b.evaluate('document.querySelector("#proxy-setup-tech summary").focus()');
+12 -7
View File
@@ -197,8 +197,9 @@ test('Routing switch writes the model-provider setting and keeps other modules',
await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`const original=window.fetch;window.posts=[];window.fetch=async(url,options={})=>{if(url==='/api/config')return new Response(JSON.stringify({send:true}));if(url==='/api/proxy/plugins')return new Response(JSON.stringify(${JSON.stringify(settings)}));if(url==='/api/proxy/plugins/set'){posts.push(JSON.parse(options.body));return new Promise(r=>window.answer=(status,body)=>r(new Response(JSON.stringify(body),{status})));}return original(url,options);};`});
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
await wait('document.querySelector("#provider-switch")?.textContent.startsWith("Use your models")');
await b.evaluate('document.querySelector("#provider-switch").click();true');
// settings-s5: the switch is the Use your models choice; choosing it writes at once.
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use your models")&&!document.querySelector("#models-yours").disabled');
await b.evaluate('document.querySelector("#models-yours").click();true');
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
assert.deepEqual(payload.plugins,{'model-provider':['cliproxy']});
const before=JSON.parse(readFileSync(file,'utf8')).plugins;
@@ -271,7 +272,7 @@ test('quick fallback edits survive the harness redraw', {timeout:60000}, async t
// organization's catalogue is ready with no proxy, and its switch reads Enable.
test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disable and removes cliproxy only; a fixture-only org reads Enable', {timeout:90000}, async t => {
for (const [providers, label, line, next] of [
[['fixture','cliproxy'], 'Stop using the model service', /can't see your models yet\. Your model service isn't set up yet\. A change to thinking alone still saves\. A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it\./, ['fixture']],
[['fixture','cliproxy'], 'Stop using your models', /can't see your models yet\. Your model service isn't set up yet\. A change to thinking alone still saves\. A new model needs the model service: ask the instance owner to set it up, or press Stop using your models when this organization does not need it\./, ['fixture']],
[['fixture'], 'Use your models', /^Model catalogue, observed /, ['fixture','cliproxy']],
]) {
const root=tmp(t,'d3-switch-'), f=fixture(root,'acme',doc=>{doc.plugins['model-provider']=providers;return doc;});
@@ -287,13 +288,17 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`const original=window.fetch;window.posts=[];window.fetch=async(url,options={})=>{if(url==='/api/config')return new Response(JSON.stringify({send:true}));if(url==='/api/proxy/plugins')return new Response(JSON.stringify(${JSON.stringify(settings)}));if(url==='/api/proxy/plugins/set'){posts.push(JSON.parse(options.body));return new Promise(r=>window.answer=(status,body)=>r(new Response(JSON.stringify(body),{status})));}return original(url,options);};`});
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
await wait(`document.querySelector("#provider-switch")?.textContent.startsWith(${JSON.stringify(label)})&&!!document.querySelector('[data-harness]')`);
// settings-s5: in force, the way back is Stop using your models; not in force, the Use your models choice.
const control=label==='Stop using your models'?'#models-stop':'#models-yours';
await wait(`!!document.querySelector(${JSON.stringify(control)})&&!document.querySelector(${JSON.stringify(control)}).disabled&&!!document.querySelector('[data-harness]')`);
// settings-s5 review P3-3: a Console with no organizations says "this business" mid-sentence.
assert.equal(await b.evaluate('document.querySelector("#models-source legend").textContent'),'Where this business gets its models');
const [info,...notices]=await b.evaluate('[document.querySelector(".routing-panel > p.small")?.textContent,...[...document.querySelectorAll(".routing-panel > p.small.warn")].slice(1).map(p=>p.textContent)]');
assert.match(info,line,providers.join(','));
// proxy-pickup (#1873): the bus's cause reads as a plain line; its own words sit under Technical details.
assert.deepEqual(notices,[],providers.join(','));
assert.deepEqual(await b.evaluate('[...document.querySelectorAll(".routing-panel > details.routes-cause-detail p")].map(p=>p.textContent)'),label==='Stop using the model service'?['The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.']:[],providers.join(','));
await b.evaluate('document.querySelector("#provider-switch").click();true');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll(".routing-panel > details.routes-cause-detail p")].map(p=>p.textContent)'),label==='Stop using your models'?['The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.']:[],providers.join(','));
await b.evaluate(`document.querySelector(${JSON.stringify(control)}).click();true`);
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
assert.deepEqual(payload.plugins,{'model-provider':next},providers.join(','));
const result=await call('plugins.set',payload);await b.evaluate(`window.answer(200,${JSON.stringify(result)});true`);
@@ -309,7 +314,7 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
test('D3 Routing: a catalogue refusal names Disable only when it can make the save apply, and sends a tester to the owner', {timeout:90000}, async t => {
const refusal=code=>({error:code,message:`${code}: the reason. Nothing changed.`,sent:false});
for (const [providers, tester, instance, code, expect] of [
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change does not need the model service: press Stop using the model service, then save again\. Draft kept\.$/],
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change does not need your models: press Stop using your models, then save again\. Draft kept\.$/],
[['fixture','cliproxy'], false, 'reviewer', 'model-catalogue-unavailable', /Nothing changed\. Draft kept\.$/],
[['fixture'], false, 'reviewer', 'model-provider-unavailable', /Nothing changed\. Draft kept\.$/],
[['fixture','cliproxy'], true, 'coder', 'model-catalogue-unavailable', /Nothing changed\. Ask the organization's owner to set up the model service, or to stop using it when the change does not need it\. Draft kept\.$/],
@@ -187,7 +187,7 @@ test('settings-s4 review F2: a stand-in organization with its bus stopped reads
assert.equal(await text(STEP3), "The model service is set up. Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations").dataset.state'), 'bad');
const item = await b.evaluate('document.querySelector("#proxy-ride-fixtures li").firstChild.textContent.trim()');
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to the owner's models, then start its bus.");
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=gamma]").textContent'), 'Move Gamma Home');
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=gamma]").checkVisibility()'), true);
// The organizations that need nothing get no mark.
@@ -0,0 +1,455 @@
// #1873 settings slice 5 (DESIGN.md 3.4, 12 slice 5, mockups org-models and org-models-restart): an
// organization's Models page offers one choice, "Use your models" (the cliproxy model-provider module
// through plugins.set) or "Use its own model service" (Coming later), says from the plugins read which
// one is in force and what a switch changes, and switches both ways. Also the items slice 4 left: the
// Ride all lines name an organization by its display name, step 3 and the "can't start" mark agree
// before the first account, the sidebar marks follow a switch, a failed turn shows "Details:" once in
// Messages, the old Members addresses land on Agents, and Technical details shows the port and
// timeouts the status read carries.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { fileURLToPath } from 'node:url';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
import { ReadError } from '../src/reads.mjs';
const LIST = [
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true },
{ id: 'gamma', label: 'Gamma Home', theme: 'rosewood', busHealthy: false, busStopped: true },
{ id: 'north', label: 'North Works', theme: 'cobalt', busHealthy: true },
];
const VIEW = {
business: 'acme', revision: 'a'.repeat(64), harnesses: ['pi'], models: ['fixture-deterministic'],
providerModels: { 'fixture-deterministic': { module: 'fixture', upstream: 'fixture', model: 'fixture-deterministic' } },
levels: { pi: ['off', 'low'] }, instances: {}, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] },
};
async function orgFixture({ routes = {}, messages = [] } = {}) {
const { checkRootAgents } = await import('../../organization/src/index.mjs');
const rolesDir = fileURLToPath(new URL('../../../roles', import.meta.url));
const root = { state: 'ok', ...checkRootAgents({ agentsVersion: 1, agents: {} }, { rolesDir }) };
const empty = () => Promise.resolve([]);
const member = org => ({
id: org.id, doc: { appearance: { theme: org.theme }, roles: { chief: { definition: 'chief-of-staff' } }, projects: {} },
status: async () => (org.busHealthy ? { healthy: true, pid: 4242, boot: null } : { healthy: false, boot: { ok: false, at: new Date().toISOString(), lastGood: null, reason: 'stopped by the owner' } }),
options: () => ({ bus: { inbox: empty, agents: empty, 'thread.claims': empty, tasks: empty, usage: () => Promise.resolve({}), limits: () => Promise.resolve({}), decisions: empty }, chat: { threads: empty, projects: empty } }),
});
const organizations = {
list: async () => LIST,
members: async () => LIST.map(member),
resolve: async id => {
const org = LIST.find(o => o.id === id); if (!org) return null;
if (!org.busHealthy) return { busHealthy: false, reads: { settings: async () => { throw new ReadError('bus-unavailable'); } }, bus: {}, chat: { projects: empty, threads: empty } };
return {
busHealthy: true,
reads: { business: async () => ({ business: { id, human: 'jason', projects: [], appearance: { theme: org.theme } } }), settings: async () => ({ business: id, release: 'fixture', notifier: {} }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
bus: { messages: async () => ({ messages, unread: 0, total: messages.length }), agents: empty, 'thread.claims': empty, inbox: empty, tasks: empty, usage: async () => ({}), routes: async () => ({ ...VIEW, ...(routes[id] ?? {}), business: id }), instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
chat: { projects: empty, threads: empty },
};
},
};
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
}
// The model service is set up and answering. init.settings is what the status read carries after init
// (model-proxy admin.mjs initState).
const SERVICE_UP = { next: ['accounts'], init: { initialized: true, partial: false, problem: null, settings: { port: 18432, rotateGraceMinutes: 30, firstOutputSeconds: 90 }, files: [] },
release: { fetched: true, verified: true, version: '8.0.42', panelVersion: '1.26.7' },
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', port: 18432, listening: true, healthy: true }, fence: { set: false }, initLock: { present: false, blockers: [] }, fetch: { state: 'idle' }, organizations: [], ride: [] };
const SERVICE_DOWN = { ...SERVICE_UP, next: ['unit-start'], unit: { ...SERVICE_UP.unit, active: 'inactive', listening: false, healthy: false } };
const REV = n => String(n).repeat(64).slice(0, 64);
const pluginsRead = providers => ({ revision: REV('b'), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': providers } });
// The instance owner's flags and every model service read and write, by path suffix (display.js
// scopes some reads under /api/orgs/<id>/). plugins.set merges the module lists the way the bus does
// and may carry a new setup status (__s5.afterSet). window.confirm answers yes and records its text.
const ownerStub = ({ service = SERVICE_UP, plugins = pluginsRead(['fixture']), accounts = [], posts = {}, afterSet = null, setStatus = 200 } = {}) => `(() => {
const real = window.fetch.bind(window);
window.__s5 = ${JSON.stringify({ service, plugins, accounts, posts, afterSet, setStatus })}; window.__sets = []; window.__writes = []; window.__confirms = [];
window.confirm = text => { window.__confirms.push(text); return true; };
const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
window.fetch = async (input, init = {}) => {
const url = new URL(typeof input === 'string' ? input : input.url, location.href), path = url.pathname, method = (init.method || 'GET').toUpperCase();
if (method !== 'GET' && path.endsWith('/proxy/plugins/set')) {
const body = JSON.parse(init.body); window.__sets.push({ path, body });
if (__s5.setStatus !== 200) return json({ error: 'plugins-refused', message: 'The bus refused the change (plugins-refused).' }, __s5.setStatus);
__s5.plugins = { ...__s5.plugins, revision: String(__s5.sets = (__s5.sets ?? 0) + 1).repeat(64).slice(0, 64), plugins: { ...__s5.plugins.plugins, ...body.plugins } };
if (__s5.afterSet) __s5.service = __s5.afterSet;
return json({ revision: __s5.plugins.revision, plugins: __s5.plugins.plugins });
}
if (method !== 'GET' && /\\/proxy\\//.test(path)) { window.__writes.push(path); const key = Object.keys(__s5.posts).find(k => path.endsWith(k)); const a = key ? __s5.posts[key] : { status: 500, body: { error: 'stub' } };
if (a.service) __s5.service = a.service; return json(a.body ?? {}, a.status ?? 200); }
if (method !== 'GET') return real(input, init);
if (/\\/api\\/(orgs\\/[^/]+\\/)?config$/.test(path)) { const c = await (await real(input, init)).json(); return json({ ...c, orgSetup: true, proxyAdmin: true, proxyAdminSend: true, ...(/\\/orgs\\//.test(path) ? { settingsSend: true } : {}) }); }
if (path.endsWith('/proxy/plugins')) return json(__s5.plugins);
if (path.endsWith('/proxy/admin/status')) return json(__s5.service);
if (path.endsWith('/proxy/accounts')) return json({ accounts: __s5.accounts });
if (path.endsWith('/proxy/keys')) return json({ keys: [] });
if (path.endsWith('/triage/route')) return json({ route: null });
return real(input, init);
};
})();`;
async function setup(t, { path, viewport = [1440, 900], fixture = {}, stub = {} } = {}) {
const { organizations, agentLevels } = await orgFixture(fixture);
const server = await startServer({ port: 0, sso: createDevOwner(), organizations, agentLevels, triage: null, send: async () => ({}), log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: ownerStub(stub) });
await b.navigate(`http://127.0.0.1:${server.address().port}${path}`);
const wait = expression => b.evaluate(`(async()=>{for(let i=0;i<250;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error("wait failed: "+${JSON.stringify(expression)}+" HASH "+location.hash)})()`);
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
const click = sel => b.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(sel)}); if (!el) throw Error("no ${sel.replace(/"/g, '')}"); el.click(); return true; })()`);
return { b, wait, text, click };
}
const mark = id => `document.querySelector('[data-workspace-org=${id}] .ws-dot')?.title`;
const STEP3 = '#setup-step-organizations [data-step-summary]';
// ---- Organization > Models --------------------------------------------------------------------
test('settings-s5: Acme Studio\'s models reads which choice is in force from the plugins read, switches to your models and back', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-source") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
assert.equal(await text('#settings-page-title'), "Acme Studio's models");
assert.equal(await text('#models-source legend'), 'Where Acme Studio gets its models');
// Review P2-2: the header says where the models come from only from the plugins read.
assert.match(await text('.settings-helper'), /The models Acme Studio's agents use\. They come from its own organization file\./);
assert.doesNotMatch(await text('.settings-helper'), /your accounts/);
// Not in force: the radio is not checked, and the line says what is in force and what a switch changes.
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
assert.equal(await text('#models-in-force'), "Now: Acme Studio does not use your models. Its agents use only the models in its own organization file.");
assert.match(await text('#models-change'), /^Choose Use your models to switch\. Acme Studio's agents can then use the models your accounts offer\./);
// Use its own model service: dashed, disabled, Coming later.
assert.equal(await b.evaluate('document.querySelector("#models-own").disabled'), true);
assert.equal(await b.evaluate('document.querySelector("#models-own").closest("label").classList.contains("off")'), true);
assert.equal(await b.evaluate('document.querySelector("#models-own").closest("label").querySelector(".badge").textContent'), 'Coming later');
assert.match(await b.evaluate('document.querySelector("#models-own").closest("label").textContent'), /Planned, not built yet, so you can't choose it today\./);
assert.equal(await b.evaluate('getComputedStyle(document.querySelector("#models-own").closest("label")).borderTopStyle'), 'dashed');
// The old button is gone.
assert.equal(await b.evaluate('!!document.querySelector("#provider-switch")'), false);
// Switch to your models: one write, the model-provider list only, with cliproxy added.
await click('#models-yours');
await wait('window.__sets.length === 1');
assert.deepEqual(await b.evaluate('window.__sets[0].body'), { revision: REV_B, plugins: { 'model-provider': ['fixture', 'cliproxy'] } });
await wait('document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses your models")');
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), true);
assert.match(await text('#models-receipt'), /^Saved\. Acme Studio uses your models\./);
assert.equal(await b.evaluate('document.querySelector("#models-receipt").classList.contains("settings-success")'), true);
assert.match(await text('#models-change'), /Stop using your models/);
// Review P2-4: focus moves to the Saved line.
await wait('document.activeElement?.id === "models-receipt"');
await wait('/They come from your accounts in Model setup\./.test(document.querySelector(".settings-helper")?.textContent ?? "")');
// And back: Stop using your models removes cliproxy and keeps the other module.
await click('#models-stop');
await wait('window.__sets.length === 2');
assert.deepEqual(await b.evaluate('window.__sets[1].body.plugins'), { 'model-provider': ['fixture'] });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use your models")');
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
assert.match(await text('#models-receipt'), /^Saved\. Acme Studio no longer uses your models\./);
assert.equal(await b.evaluate('!!document.querySelector("#models-stop")'), false);
await wait('document.activeElement?.id === "models-receipt"');
});
const REV_B = REV('b');
test('settings-s5: a refused switch says so and the page keeps the choice the read shows', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { setStatus: 409 } });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await click('#models-yours');
await wait('window.__sets.length === 1 && /refused/.test(document.querySelector("#models-receipt")?.textContent ?? "")');
assert.equal(await text('#models-receipt'), 'Not changed. The bus refused the change (plugins-refused).');
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
assert.match(await text('#models-in-force'), /does not use your models/);
});
test('settings-s5: a stale page does not write, it shows the current choice first', { timeout: 90000 }, async t => {
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
// Someone else switched Acme Studio on since the page read it.
await b.evaluate('__s5.plugins = { ...__s5.plugins, plugins: { ...__s5.plugins.plugins, "model-provider": ["fixture", "cliproxy"] } }; true');
await click('#models-yours');
await wait('document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses your models")');
assert.equal(await b.evaluate('window.__sets.length'), 0);
assert.match(await b.evaluate('document.querySelector("#models-receipt").textContent'), /changed since this page read it/);
});
test('settings-s5: while the plugins read is out the choice waits, and a failed read says so with Read again', { timeout: 90000 }, async t => {
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { plugins: { broken: true } } });
await wait('/could not be read/.test(document.querySelector("#models-in-force")?.textContent ?? "")');
assert.equal(await text('#models-in-force'), "Which models Acme Studio uses could not be read.");
assert.equal(await b.evaluate('document.querySelector("#models-yours").disabled'), true);
assert.equal(await b.evaluate('!!document.querySelector("#models-read")'), true);
});
test('settings-s5: an organization that needs a restart shows the banner with Restart as the one primary, and the choice waits', { timeout: 90000 }, async t => {
const routes = { acme: { catalogue: { status: 'unavailable', notices: [], models: [] } } };
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', fixture: { routes }, stub: { plugins: pluginsRead(['fixture', 'cliproxy']) } });
await wait('document.querySelector("#routes-catalogue.banner [data-primary]") && document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses")');
assert.match(await text('#routes-catalogue'), /Acme Studio can't see your models yet\./);
assert.match(await text('#routes-catalogue [data-primary]'), /Restart Acme Studio/);
// The banner sits above the choice.
assert.equal(await b.evaluate('!!(document.querySelector("#routes-catalogue").compareDocumentPosition(document.querySelector("#models-source")) & Node.DOCUMENT_POSITION_FOLLOWING)'), true);
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked && document.querySelector("#models-yours").disabled'), true);
assert.equal(await text('#models-wait'), "You can change Acme Studio's models after it restarts.");
// Review P2-1: Stop using your models waits too: it is not offered until the restart.
assert.equal(await b.evaluate('!!document.querySelector("#models-stop")'), false);
// One primary: the routes Save is quiet.
assert.equal(await b.evaluate('document.querySelector("#routes-form [type=submit]").classList.contains("route-save-quiet")'), true);
});
// Review P2-3: a choice not in force says when the model service behind it is not set up or not
// answering, with a link to Model setup. The choice itself still writes.
test('settings-s5: Use your models says when the model service is not set up or not answering', { timeout: 90000 }, async t => {
for (const [service, line, link] of [
[{ ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } }, "Your model service isn't set up. Set it up in Model setup.", 'Set it up in Model setup'],
[SERVICE_DOWN, "Your model service isn't answering. Restart it in Model setup.", 'Restart it in Model setup'],
]) {
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service } });
await wait('document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
assert.equal(await text('#models-service'), line);
assert.deepEqual(await b.evaluate('[document.querySelector("#models-service a").textContent, document.querySelector("#models-service a").getAttribute("href")]'), [link, '#/settings/model-setup']);
assert.equal(await b.evaluate('document.querySelector("#models-yours").disabled'), false);
}
// Up and answering: no line.
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await new Promise(r => setTimeout(r, 300));
assert.equal(await b.evaluate('!!document.querySelector("#models-service")'), false);
});
// Review P3-1: while Use your models writes, the status line says Saving.
test('settings-s5: Use your models shows Saving while its write is out', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await b.evaluate(`(() => { const f = window.fetch; window.fetch = async (input, init = {}) => { if ((init.method || 'GET') !== 'GET' && String(input).endsWith('/proxy/plugins/set')) await new Promise(r => { window.__release = r; }); return f(input, init); }; return true; })()`);
await click('#models-yours');
await wait('typeof window.__release === "function" && document.querySelector("#models-receipt")?.textContent.trim() === "Saving…"');
assert.equal((await text('#models-receipt')).trim(), 'Saving…');
assert.equal(await b.evaluate('!!document.querySelector("#models-receipt .settings-spinner")'), true);
await b.evaluate('window.__release(); true');
await wait('/^Saved\./.test(document.querySelector("#models-receipt")?.textContent ?? "")');
});
// Recheck N1: the not set up line goes once the owner sets the service up and comes back to Models.
test('settings-s5: coming back to Models after setting the service up reads it again, and the not set up line goes', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service: { ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } } } });
await wait('document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await b.evaluate(`window.__s5.service = ${JSON.stringify(SERVICE_UP)}; location.hash = '#/settings/agents?org=acme'; true`);
await wait('location.hash.startsWith("#/settings/agents") && !document.querySelector("#models-in-force") && document.querySelector("#settings-page-title")');
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use") && !document.querySelector("#models-service")');
});
// Recheck N2: a switch left while it writes does not move focus on the next visit to Models.
test('settings-s5: leaving Models while a switch writes, the next visit focuses the page title, not the outcome line', { timeout: 90000 }, async t => {
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await b.evaluate(`(() => { const f = window.fetch; window.fetch = async (input, init = {}) => { if ((init.method || 'GET') !== 'GET' && String(input).endsWith('/proxy/plugins/set')) await new Promise(r => { window.__release = r; }); return f(input, init); }; return true; })()`);
await click('#models-yours');
await wait('typeof window.__release === "function"');
await b.evaluate(`location.hash = '#/settings/agents?org=acme'; true`);
await wait('location.hash.startsWith("#/settings/agents") && !document.querySelector("#models-in-force") && document.querySelector("#settings-page-title")');
await b.evaluate('window.__release(); true');
await wait('window.__sets.length === 1');
await new Promise(r => setTimeout(r, 400));
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
await wait('document.querySelector("#models-in-force")?.textContent.includes("uses your models") && /^Saved\./.test(document.querySelector("#models-receipt")?.textContent ?? "")');
await new Promise(r => setTimeout(r, 300));
assert.equal(await b.evaluate('document.activeElement?.id'), 'settings-page-title');
});
// Review P3-2: a failed read before the write says nothing was written, and offers Read again.
test('settings-s5: a switch whose first read fails says Not changed, not Outcome unknown', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
await b.evaluate('__s5.plugins = { broken: true }; true');
await click('#models-yours');
await wait('/^Not changed/.test(document.querySelector("#models-receipt")?.textContent ?? "")');
assert.equal(await text('#models-receipt'), 'Not changed. Nothing was written.');
assert.equal(await b.evaluate('window.__sets.length'), 0);
assert.equal(await b.evaluate('!!document.querySelector("#models-read")'), true);
assert.equal(await text('#models-in-force'), 'Which models Acme Studio uses could not be read.');
});
test('settings-s5: at 390 the Models page does not scroll sideways and the choice takes a visible focus', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme', viewport: [390, 844] });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true);
await b.evaluate('document.querySelector("#models-yours").focus(); true');
assert.notEqual(await b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none');
});
// Review P3-4: at 1440 the choice cards sit in the form column, not the whole card width.
test('settings-s5: at 1440 the choice sits in the form column', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
const [choice, panel] = await b.evaluate('[document.querySelector("#models-source").getBoundingClientRect().width, document.querySelector(".routing-panel").getBoundingClientRect().width]');
assert.ok(choice <= 448 + 1 && panel > choice + 200, `${choice} in ${panel}`);
});
// ---- Sidebar marks follow a switch -------------------------------------------------------------
test('settings-s5: the sidebar marks read the setup status again after an organization stops using your models', { timeout: 90000 }, async t => {
const paused = { ...SERVICE_DOWN, ride: [{ id: 'acme', state: 'already' }] };
const after = { ...SERVICE_DOWN, ride: [{ id: 'acme', state: 'removed' }] };
const { wait, click } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service: paused, plugins: pluginsRead(['fixture', 'cliproxy']), afterSet: after } });
await wait(`${mark('acme')} === 'paused' && document.querySelector("#models-stop")`);
await click('#models-stop');
await wait(`window.__sets.length === 1 && ${mark('acme')} === 'bus running'`);
});
// ---- Model setup: display names, step 3 and the mark ------------------------------------------
test('settings-s5: Move, its result and the skipped lines name the organization by its display name, in the Ride line\'s words', { timeout: 90000 }, async t => {
const service = { ...SERVICE_UP, organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'ready' } }],
ride: [{ id: 'acme', state: 'already' }, { id: 'north', state: 'bus-down' }, { id: 'gamma', state: 'fixture', running: false }] };
const moved = { ...service, ride: [{ id: 'acme', state: 'already' }, { id: 'north', state: 'bus-down' }, { id: 'gamma', state: 'already' }] };
const accounts = [{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'active', priority: 1 }];
const { b, wait, text, click } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts, posts: { '/admin/ride-move': { body: { moved: true, model: 'Claude Sonnet 5.5', receipt: { op: 'ride-move', time: '2026-11-19T10:00:00.000Z' } }, service: moved } } } });
await wait('document.querySelector("[data-ride-move=gamma]")');
assert.equal(await text('#proxy-ride-skips li'), 'Skipped North Works: Its bus is not running. Start it, then ride again.');
const item = await b.evaluate('document.querySelector("#proxy-ride-fixtures li").firstChild.textContent.trim()');
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
// Step 3 uses the same words.
assert.match(await text(STEP3), /Gamma Home can't start: it uses stand-in models and its bus is stopped\. Move it to your models under Use your models in every organization, then start its bus\./);
await click('[data-ride-move=gamma]');
await wait('window.__confirms.length === 1');
assert.match(await b.evaluate('window.__confirms[0]'), /^Move Gamma Home to your models\?/);
await wait('/now uses/.test(document.querySelector("#proxy-ride-message")?.textContent ?? "")');
assert.equal(await text('#proxy-ride-message'), 'Gamma Home now uses Claude Sonnet 5.5. Start its bus when you are ready. It spends real tokens from now on.');
});
test('settings-s5: a Move that is refused names the organization by its display name', { timeout: 90000 }, async t => {
const service = { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] };
const accounts = [{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'active', priority: 1 }];
const { wait, text, click } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts, posts: { '/admin/ride-move': { body: { moved: false, reason: 'bus-down' } } } } });
await wait('document.querySelector("[data-ride-move=gamma]")');
await click('[data-ride-move=gamma]');
await wait('/not moved/.test(document.querySelector("#proxy-ride-message")?.textContent ?? "")');
assert.equal(await text('#proxy-ride-message'), 'Gamma Home was not moved. Its bus is not running. Start it, then ride again.');
});
test('settings-s5: before the first account, step 3 names the organization the sidebar marks "can\'t start"', { timeout: 90000 }, async t => {
const service = { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] };
const { b, wait, text } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts: [] } });
await wait(`${mark('gamma')} === "can't start" && document.querySelector("#setup-step-organizations")?.dataset.state`);
await wait(`/Gamma Home/.test(document.querySelector(${JSON.stringify(STEP3)})?.textContent ?? "")`);
assert.equal(await text(STEP3), "Opens after your first account. Gamma Home can't start now: it uses stand-in models and its bus is stopped. After your first account, move it to your models under Use your models in every organization, then start its bus.");
// The card stays closed until there is an account to move it with, and its badge carries the mark's word.
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations").dataset.state'), 'wait');
assert.equal(await text('#setup-step-organizations [data-step-badge]'), "Can't start");
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations [data-step-badge]").classList.contains("badge-danger")'), true); // The empty account list reads as one line, not squeezed into the name column.
assert.equal(await b.evaluate('(() => { const li = document.querySelector("#proxy-accounts li.muted"); const r = document.createRange(); r.selectNodeContents(li); return li.textContent === "No accounts yet." && r.getClientRects().length === 1; })()'), true);
});
test('settings-s5: Technical details and Advanced show the port and timeouts the status read carries', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { path: '/#/settings/model-setup' });
await wait('document.querySelector("#proxy-setup-state dd")');
const rows = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-state dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
assert.equal(rows.Initialized, 'Yes, port 18432, wait for a first answer 90 seconds, old key kept 30 minutes after a new one');
const advanced = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-settings dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
assert.deepEqual(advanced, { Port: '18432', 'Wait for a first answer': '90 seconds', 'Old key kept after a new one': '30 minutes' });
});
test('settings-s5: timeouts init left at the default read as the default', { timeout: 90000 }, async t => {
const service = { ...SERVICE_UP, init: { ...SERVICE_UP.init, settings: { port: 18432, rotateGraceMinutes: null, firstOutputSeconds: null } } };
const { b, wait } = await setup(t, { path: '/#/settings/model-setup', stub: { service } });
await wait('document.querySelector("#proxy-setup-state dd")');
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-state dt")].find(dt => dt.textContent === "Initialized").nextElementSibling.textContent'),
'Yes, port 18432, wait for a first answer: the default, old key kept after a new one: the default');
const advanced = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-settings dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
assert.deepEqual(advanced, { Port: '18432', 'Wait for a first answer': 'The default', 'Old key kept after a new one': 'The default' });
});
// ---- Messages and the old Members addresses ---------------------------------------------------
test('settings-s5: a failed turn in Messages shows its cause, and "Details:" once', { timeout: 90000 }, async t => {
const messages = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true,
body: 'The turn failed: Acme Studio can\'t see your models yet. Restart it in Settings.\nDetails: model-catalogue-unavailable' }];
const { b, wait } = await setup(t, { path: '/#/orgs/acme/messages', fixture: { messages } });
await wait('document.querySelector(".s1-message")');
const shown = await b.evaluate('document.querySelector(".s1-message").textContent');
assert.equal(shown.match(/Details:/g)?.length, 1, shown);
assert.match(shown, /^The assistant couldn't reply: Acme Studio can't see your models yet\. Restart it in Settings\.Details: model-catalogue-unavailable$/);
});
test('settings-s5: a failed turn without a Details part keeps the general line', { timeout: 90000 }, async t => {
const messages = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true, body: 'The turn failed: spawn-refused' }];
const { b, wait } = await setup(t, { path: '/#/orgs/acme/messages', fixture: { messages } });
await wait('document.querySelector(".s1-message")');
assert.equal(await b.evaluate('document.querySelector(".s1-message").textContent'), "The assistant couldn't reply. Try again, or check Agents.Details: spawn-refused");
});
test('settings-s5: #/settings/members and #/orgs/<id>/settings/members land on that organization\'s Agents page', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { path: '/#/orgs/north/settings/members' });
await wait('location.hash === "#/settings/agents?org=north" && document.querySelector("#settings-nav a[href=\'#/settings/agents?org=north\'][aria-current=page]")');
await b.evaluate('location.hash = "#/settings/members"; true');
await wait('location.hash === "#/settings/agents?org=north" && document.querySelector("#settings-page-title")?.textContent === "Agents"');
});
// Shots for the build report, beside the mockups: run with MOSAIC_UX_SHOTS=<dir>. Each page is shot whole
// at 390 and 1440, light and dark, and measured: nothing scrolls sideways, and every control Tab reaches
// shows a focus ring.
test('shots', { timeout: 900000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
const { mkdir, writeFile } = await import('node:fs/promises');
const { join } = await import('node:path');
const dir = process.env.MOSAIC_UX_SHOTS; await mkdir(dir, { recursive: true });
const settle = () => new Promise(r => setTimeout(r, 1000));
const reasons = [
{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'unavailable', priority: 2, reason: 'The account is out of usage. It resets at 2026-11-20 05:00 UTC. Wait until then, or add another account.' },
{ accountId: 'a2', provider: 'codex', displayName: 'Codex home', status: 'error', priority: 1, reason: 'The account needs to sign in again. Sign in again, or add another account.' },
{ accountId: 'a3', provider: 'codex', displayName: 'Codex work', status: 'active', priority: 0 },
];
const failed = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true,
body: 'The turn failed: Acme Studio can\'t see your models yet. Restart it in Settings.\nDetails: model-catalogue-unavailable' }];
const PAGES = [
{ name: 'org-models', path: '/#/settings/routing?org=acme', ready: 'document.querySelector("#models-in-force")?.textContent.includes("does not use")' },
{ name: 'org-models-riding', path: '/#/settings/routing?org=acme', ready: 'document.querySelector("#models-in-force")?.textContent.includes("does not use")',
after: async (b, wait) => { await b.evaluate('document.querySelector("#models-yours").click(); true'); await wait('/^Saved/.test(document.querySelector("#models-receipt")?.textContent ?? "")'); } },
{ name: 'org-models-not-set-up', path: '/#/settings/routing?org=acme', stub: { service: { ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } } },
ready: 'document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")' },
{ name: 'org-models-restart', path: '/#/settings/routing?org=acme', fixture: { routes: { acme: { catalogue: { status: 'unavailable', notices: [], models: [] } } } }, stub: { plugins: pluginsRead(['fixture', 'cliproxy']) },
ready: 'document.querySelector("#routes-catalogue.banner [data-primary]") && document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses")' },
{ name: 'account-reasons', path: '/#/settings/model-setup?step=accounts', stub: { accounts: reasons }, ready: 'document.querySelectorAll("#proxy-accounts .account-reason").length === 2' },
{ name: 'step3-cant-start', path: '/#/settings/model-setup', stub: { service: { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] }, accounts: [] },
ready: `/Gamma Home/.test(document.querySelector(${JSON.stringify(STEP3)})?.textContent ?? "")` },
{ name: 'technical-details', path: '/#/settings/model-setup', ready: 'document.querySelector("#proxy-setup-state dd")',
after: async b => { await b.evaluate('document.querySelector("#proxy-setup-advanced").open = true; document.querySelector("#proxy-setup-tech").open = true; true'); } },
{ name: 'messages-details', path: '/#/orgs/acme/messages', fixture: { messages: failed }, ready: 'document.querySelector(".s1-message")' },
];
const report = [];
for (const page of PAGES) for (const scheme of ['light', 'dark']) for (const width of [390, 1440]) {
const { b, wait } = await setup(t, { path: page.path, fixture: page.fixture, stub: page.stub, viewport: [width, width === 390 ? 844 : 900] });
await b.call('Emulation.setScrollbarsHidden', { hidden: true });
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
await wait(`(${page.ready}) && !!window.MosaicAppearance`);
await b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
if (page.after) await page.after(b, wait, width);
await settle();
const sideways = await b.evaluate('document.documentElement.scrollWidth > document.documentElement.clientWidth');
const noRing = [], seen = new Set();
for (let i = 0; i < 120; i++) {
await b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
await b.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
const r = await b.evaluate(`(() => { const e = document.activeElement; if (!e || e === document.body) return null; const cs = getComputedStyle(e);
const ring = (cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) > 0) || (cs.boxShadow && cs.boxShadow !== 'none');
return { key: e.id || e.getAttribute('href') || e.tagName + ':' + (e.textContent || '').trim().slice(0, 30), ring }; })()`);
if (!r || seen.has(r.key)) break; seen.add(r.key);
if (!r.ring) noRing.push(r.key);
}
await b.evaluate('document.activeElement?.blur(); window.scrollTo(0, 0); true'); await settle();
const shot = `${page.name}-${width}-${scheme}.png`;
let metrics = await b.call('Page.getLayoutMetrics'), size = metrics.cssContentSize || metrics.contentSize;
await b.viewport(width, Math.ceil(size.height)); await settle();
metrics = await b.call('Page.getLayoutMetrics'); size = metrics.cssContentSize || metrics.contentSize;
const { data } = await b.call('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true, clip: { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 } });
await writeFile(join(dir, shot), Buffer.from(data, 'base64'));
report.push({ page: page.name, width, scheme, shot, sideways, noRing });
await b.close();
}
await writeFile(join(dir, 'measure.json'), JSON.stringify(report, null, 1));
for (const r of report) {
assert.equal(r.sideways, false, `${r.shot} scrolls sideways`);
assert.deepEqual(r.noRing, [], `${r.shot}: controls with no visible focus ring`);
}
});
@@ -0,0 +1,516 @@
// #1873 settings-s5b (DESIGN.md 3.1, mockups models-setup-failed and models-advanced): Model setup
// shows the service's last lines (GET /api/proxy/admin/log) on step 1 when setup stopped and under
// Technical details, when the service key was made (GET /api/proxy/admin/service-key), and the setup
// history a page at a time (GET /api/proxy/admin/history). All three are the instance owner's: a page
// without proxyAdmin shows none of them and sends no /api/proxy/admin/ request. Also: a focus request
// for an organization's Models outcome line is dropped when the owner goes to any other page.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { fileURLToPath } from 'node:url';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
const LIST = [
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true },
{ id: 'gamma', label: 'Gamma Home', theme: 'rosewood', busHealthy: true },
];
const VIEW = {
business: 'acme', revision: 'a'.repeat(64), harnesses: ['pi'], models: ['fixture-deterministic'],
providerModels: { 'fixture-deterministic': { module: 'fixture', upstream: 'fixture', model: 'fixture-deterministic' } },
levels: { pi: ['off', 'low'] }, instances: {}, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] },
};
async function orgFixture() {
const { checkRootAgents } = await import('../../organization/src/index.mjs');
const rolesDir = fileURLToPath(new URL('../../../roles', import.meta.url));
const root = { state: 'ok', ...checkRootAgents({ agentsVersion: 1, agents: {} }, { rolesDir }) };
const empty = () => Promise.resolve([]);
const member = org => ({
id: org.id, doc: { appearance: { theme: org.theme }, roles: { chief: { definition: 'chief-of-staff' } }, projects: {} },
status: async () => ({ healthy: true, pid: 4242, boot: null }),
options: () => ({ bus: { inbox: empty, agents: empty, 'thread.claims': empty, tasks: empty, usage: () => Promise.resolve({}), limits: () => Promise.resolve({}), decisions: empty }, chat: { threads: empty, projects: empty } }),
});
const organizations = {
list: async () => LIST,
members: async () => LIST.map(member),
resolve: async id => {
const org = LIST.find(o => o.id === id); if (!org) return null;
return {
busHealthy: true,
reads: { business: async () => ({ business: { id, human: 'jason', projects: [], appearance: { theme: org.theme } } }), settings: async () => ({ business: id, release: 'fixture', notifier: {} }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
bus: { messages: async () => ({ messages: [], unread: 0, total: 0 }), agents: empty, 'thread.claims': empty, inbox: empty, tasks: empty, usage: async () => ({}), routes: async () => ({ ...VIEW, business: id }), instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
chat: { projects: empty, threads: empty },
};
},
};
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
}
const T = n => `2026-11-19T10:0${n}:00.000Z`;
const SERVICE_UP = { next: ['accounts'], init: { initialized: true, partial: false, problem: null, settings: { port: 18432, rotateGraceMinutes: 30, firstOutputSeconds: 90 }, files: [] },
release: { fetched: true, verified: true, version: '8.0.42', panelVersion: '1.26.7' },
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', port: 18432, listening: true, healthy: true }, fence: { set: false }, initLock: { present: false, blockers: [] }, fetch: { state: 'idle' }, organizations: [], ride: [] };
// Setup stopped: the download failed, so step 1 says so and opens the service's last lines.
const SERVICE_FAILED = { ...SERVICE_UP, next: ['fetch'], release: { fetched: false, verified: false, version: '8.0.42', panelVersion: '1.26.7' },
init: { initialized: false, partial: false, problem: null, files: [] }, unit: { unit: 'mosaic-proxy.service', installed: false, active: 'inactive' },
fetch: { state: 'failed', error: 'proxy-install-invalid' } };
// Setup stopped at the start step: the service is installed but did not answer, so the start was refused.
const SERVICE_START = { ...SERVICE_UP, next: ['unit-start'], unit: { unit: 'mosaic-proxy.service', installed: true, active: 'inactive', port: 18432, listening: false, healthy: false } };
const START_REFUSED = { 'POST unit/start': { status: 503, body: { error: 'proxy-unit-unhealthy' } } };
const LOG_OK = { unit: 'mosaic-proxy.service', lines: ['Nov 19 10:00:01 host proxy[4242]: listening on 127.0.0.1:18432', 'Nov 19 10:00:02 host proxy[4242]: loaded key [redacted]'], redacted: 1, dropped: 2 };
const KEY_OK = { madeAt: T(3), renewedAt: null, renewal: 'not-built', problem: null };
// Three pages, newest first: the first holds four entries (one withheld), the second is empty but
// names a third, and the third holds the oldest entry.
const PAGE1 = { entries: [{ op: 'unit.start', time: T(4), user: 'jason' }, { op: 'init', time: T(5), user: '[redacted]' }, { withheld: true },
{ op: 'account.proxy.apikey.add', time: T(7), org: 'acme', accountId: 'a1b2c3d4e5f6', user: 'jason' }], next: 3 };
const PAGE2 = { entries: [], next: 1 };
const PAGE3 = { entries: [{ op: 'ride-move', time: T(1), org: 'gamma', user: 'jason' }], next: null };
const PAGES = { 'history?limit=25': PAGE1, 'history?limit=25&before=3': PAGE2, 'history?limit=25&before=1': PAGE3 };
const LOG = 'log?lines=20';
const OK = { [LOG]: LOG_OK, 'service-key': KEY_OK, ...PAGES };
// The instance owner's flags (or not), the setup status, and the three reads by name and query. An
// answer may be a list: each read takes the next one and the last one stays. window.__admin records
// every /api/proxy/admin/ request the page sends, window.__holds pauses a read by name, and window.__queue
// pauses every request to a name, each until its own resolver runs. A write answers from admin['POST name'].
const stub = ({ owner = true, service = SERVICE_UP, admin = OK } = {}) => `(() => {
const real = window.fetch.bind(window);
window.__s5b = ${JSON.stringify({ owner, service, admin })}; window.__admin = []; window.__writes = []; window.__holds = {}; window.__queue = {};
const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
window.fetch = async (input, init = {}) => {
const url = new URL(typeof input === 'string' ? input : input.url, location.href), path = url.pathname, method = (init.method || 'GET').toUpperCase();
const at = path.indexOf('/proxy/admin/');
if (at >= 0) {
const name = path.slice(at + 13) + url.search; window.__admin.push(method + ' ' + name);
if (method !== 'GET') { window.__writes.push(path); const w = __s5b.admin[method + ' ' + name]; return w ? json(w.body, w.status) : json({ error: 'stub' }, 500); }
if (name === 'status') return json(__s5b.service);
if (window.__holds[name]) await new Promise(r => { window.__holds[name] = r; });
if (window.__queue[name]) await new Promise(r => window.__queue[name].push(r));
let a = __s5b.admin[name];
if (Array.isArray(a)) a = a.length > 1 ? a.shift() : a[0];
if (!a) return json({ error: 'fixture-unexpected-api' }, 403);
return a.status ? json(a.body, a.status) : json(a);
}
if (method !== 'GET' && /\\/proxy\\//.test(path)) { window.__writes.push(path); return json({ error: 'stub' }, 500); }
if (method !== 'GET') return real(input, init);
if (/\\/api\\/(orgs\\/[^/]+\\/)?config$/.test(path)) { const c = await (await real(input, init)).json(); return json({ ...c, orgSetup: true, proxyAdmin: __s5b.owner, proxyAdminSend: __s5b.owner, ...(/\\/orgs\\//.test(path) ? { settingsSend: true } : {}) }); }
if (path.endsWith('/proxy/plugins')) return json({ revision: 'b'.repeat(64), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': ['fixture'] } });
if (path.endsWith('/proxy/accounts')) return json({ accounts: [] });
if (path.endsWith('/proxy/keys')) return json({ keys: [] });
if (path.endsWith('/triage/route')) return json({ route: null });
return real(input, init);
};
})();`;
async function setup(t, { path = '/#/settings/model-setup', viewport = [1440, 900], ...options } = {}) {
const { organizations, agentLevels } = await orgFixture();
const server = await startServer({ port: 0, sso: createDevOwner(), organizations, agentLevels, triage: null, send: async () => ({}), log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: stub(options) });
await b.navigate(`http://127.0.0.1:${server.address().port}${path}`);
const wait = expression => b.evaluate(`(async()=>{for(let i=0;i<250;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error("wait failed: "+${JSON.stringify(expression)}+" HASH "+location.hash)})()`);
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
const click = sel => b.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(sel)}); if (!el) throw Error("no ${sel.replace(/"/g, '')}"); el.click(); return true; })()`);
const reads = () => b.evaluate('window.__admin.filter(r => r !== "GET status")');
return { b, wait, text, click, reads };
}
const READY = 'document.querySelector("#proxy-setup-state dd") && !document.querySelector("#setup-step-service").hidden';
const openTech = b => b.evaluate('(() => { const d = document.querySelector("#proxy-setup-tech"); d.open = true; return true; })()');
const items = b => b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].map(li => ({ text: li.textContent, hidden: li.hidden, withheld: li.hasAttribute("data-withheld") }))');
const KEY_TEXT = /ms[kotp]-[A-Za-z0-9_-]{4,}/i;
// ---- Each part renders from its read ---------------------------------------------------------
test('settings-s5b: Technical details shows when the service key was made, the service\'s last lines and the newest history, and reads none of them until it opens', { timeout: 90000 }, async t => {
const { b, wait, text, click, reads } = await setup(t);
await wait(READY);
await new Promise(r => setTimeout(r, 300));
assert.deepEqual(await reads(), [], 'nothing is read before Technical details opens');
await openTech(b);
await wait('/Mosaic made it on/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "") && document.querySelectorAll("#proxy-setup-history li").length === 4');
// The service key: when it was made, that renewal is not built, never the key.
// It is the last row of the state list, after Release and Service, as models-advanced shows it.
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-state dt")].at(-1).textContent'), 'Service key');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").closest("dl").id'), 'proxy-setup-state');
const key = await text('#proxy-setup-keymade-text');
assert.match(key, /^Mosaic made it on .+\. You never see it\. Renewing it is not built yet\.$/);
assert.equal(key.includes(await b.evaluate(`window.MosaicLocalTime(${JSON.stringify(T(3))})`)), true);
// History, newest first, three shown with Show all; the withheld entry is a plain row.
const list = await items(b);
assert.deepEqual(list.map(i => i.hidden), [false, false, false, true]);
assert.match(list[0].text, /^Account added in Acme Studio · .+ · by jason$/);
assert.equal(list[1].text, 'Withheld. The Console kept this entry back because it may hold a secret.');
assert.equal(list[1].withheld, true);
assert.match(list[2].text, /^Set up · .+ · by someone whose name Mosaic hid$/);
assert.match(list[3].text, /^Started · .+ · by jason$/);
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), true);
// The lines: read when their box opens, shown as the answer has them, with what was removed.
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25']);
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
assert.equal(await text('#proxy-setup-tech-lines summary'), 'The service\'s last lines');
assert.equal(await text('#proxy-setup-tech-lines pre.setup-log'), LOG_OK.lines.join('\n'));
assert.equal(await text('#proxy-setup-tech-lines [data-log] p'), 'Mosaic removes anything that looks like a key. It removed something from 1 line. 2 lines were left out.');
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET log?lines=20']);
// Read again reads the lines once more.
await click('#proxy-setup-tech-lines [data-log] button');
await wait('window.__admin.filter(r => r === "GET log?lines=20").length === 2 && document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
});
test('settings-s5b: when setup stops, step 1 opens the service\'s last lines from the log read', { timeout: 90000 }, async t => {
const { b, wait, text, reads } = await setup(t, { service: SERVICE_START, admin: { ...OK, ...START_REFUSED } });
await wait(READY + ' && document.querySelector("#proxy-setup-go") && !document.querySelector("#proxy-setup-go").hidden');
await b.evaluate('document.querySelector("#proxy-setup-go").click(); true');
await wait('document.querySelector("#proxy-setup-lines pre.setup-log")');
assert.deepEqual(await b.evaluate('window.__writes.map(p => p.slice(p.indexOf("/proxy/admin/") + 13))'), ['unit/start']);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").hidden'), false);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").open'), true);
assert.equal(await text('#proxy-setup-lines pre.setup-log'), LOG_OK.lines.join('\n'));
assert.match(await text('#proxy-setup-lines [data-log] p'), /^Mosaic removes anything that looks like a key\./);
assert.doesNotMatch(await text('#proxy-setup-lines'), /can't read the service's lines yet|Nothing reported/);
// The status read polls; the lines are read once, not on every paint.
await new Promise(r => setTimeout(r, 1500));
assert.deepEqual(await reads(), ['POST unit/start', 'GET log?lines=20']);
});
test('settings-s5b: a service that is not installed has no lines, and step 1 says so plainly, not as a failed read', { timeout: 90000 }, async t => {
const { b, wait, text } = await setup(t, { service: SERVICE_FAILED, admin: { ...OK, [LOG]: { status: 503, body: { error: 'not-configured' } } } });
await wait('document.querySelector("#proxy-setup-lines [data-log] p")');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").open'), true);
assert.equal(await text('#proxy-setup-lines [data-log] p'), 'The model service is not installed, so it has no lines yet.');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines [data-log] p").className'), 'small muted');
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-lines .banner.err")'), false);
assert.doesNotMatch(await text('#proxy-setup-lines'), /could not be read/);
});
test('settings-s5b: a service key that is not made yet, or that cannot be checked, says so', { timeout: 90000 }, async t => {
const { b, wait, text } = await setup(t, { admin: { ...OK, 'service-key': [{ madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'missing' }, { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'unreadable' }] } });
await wait(READY); await openTech(b);
await wait('/Not made yet/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
assert.equal(await text('#proxy-setup-keymade-text'), 'Not made yet. Set up model service in step 1 makes it. You never see it.');
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
await new Promise(r => setTimeout(r, 100));
await openTech(b);
await wait('/can.t tell/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
assert.match(await text('#proxy-setup-keymade-text'), /^Mosaic can't tell when it was made/);
});
// ---- Failed reads -----------------------------------------------------------------------------
test('settings-s5b: each failed read shows its line with Read again, and Read again works', { timeout: 90000 }, async t => {
const fail = code => ({ status: 503, body: { error: code } });
const { b, wait, text, click, reads } = await setup(t, { admin: { ...OK, [LOG]: [fail('outcome-unknown'), LOG_OK], 'service-key': [fail('not-configured'), KEY_OK], 'history?limit=25': [fail('outcome-unknown'), PAGE1] } });
await wait(READY); await openTech(b);
// The service key.
await wait('document.querySelector("#proxy-setup-keymade-retry")');
assert.equal(await text('#proxy-setup-keymade-text'), 'When it was made could not be read. Model service setup is not available on this Console. (not-configured)');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").className'), 'banner err', 'the same failure style as the history and the lines');
await b.evaluate('document.querySelector("#proxy-setup-keymade-retry").focus(); document.querySelector("#proxy-setup-keymade-retry").click(); true');
await wait('/Mosaic made it on/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-keymade-retry")'), false);
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-keymade-text', 'focus stays on the answer, not the page');
// History.
await wait('!document.querySelector("#proxy-setup-history-retry").hidden');
assert.equal(await text('#proxy-setup-history-message'), 'History could not be read. The host could not read the history. (outcome-unknown)');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-message").className'), 'banner err');
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 0);
await click('#proxy-setup-history-retry');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-retry").hidden'), true);
assert.equal(await text('#proxy-setup-history-message'), '');
// The lines.
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-tech-lines [data-log] .banner.err")');
assert.equal(await text('#proxy-setup-tech-lines [data-log] .banner.err'), 'The service\'s lines could not be read. The host could not read the service\'s lines. (outcome-unknown)');
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-tech-lines pre")'), false);
await b.evaluate('(() => { const r = document.querySelector("#proxy-setup-tech-lines [data-log] button"); r.focus(); r.click(); return true; })()');
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
assert.equal(await b.evaluate('document.activeElement?.closest("[data-log]") !== null && document.activeElement.textContent === "Read again"'), true);
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET service-key', 'GET history?limit=25', 'GET log?lines=20', 'GET log?lines=20']);
});
// ---- Owner only -------------------------------------------------------------------------------
test('settings-s5b: a page that is not the instance owner\'s shows none of the three and sends no /api/proxy/admin/ request', { timeout: 90000 }, async t => {
// The owner's page, as the control: the three parts are there and read.
{
const { b, wait } = await setup(t, { service: SERVICE_FAILED });
await wait('document.querySelector("#proxy-setup-lines pre.setup-log")');
await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && /Mosaic made it/.test(document.querySelector("#proxy-setup-keymade-text").textContent)');
}
const { b, wait } = await setup(t, { owner: false, service: SERVICE_FAILED });
await wait('window.MosaicProxy && document.querySelector("#proxy-setup") && document.querySelector("#settings-page-title")');
await new Promise(r => setTimeout(r, 800));
// Opening every box on the page, even the hidden ones, still reads nothing.
await b.evaluate('document.querySelectorAll("#proxy-setup details").forEach(d => { d.open = true; }); true');
await new Promise(r => setTimeout(r, 800));
assert.deepEqual(await b.evaluate('window.__admin'), []);
const shown = sel => b.evaluate(`(() => { const e = document.querySelector(${JSON.stringify(sel)}); return !!e && e.getClientRects().length > 0; })()`);
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup dt")].some(d => d.textContent === "Service key")'), false);
for (const sel of ['#proxy-setup-keymade-text', '#proxy-setup-keymade-retry', '#proxy-setup-tech-lines', '#proxy-setup-lines', '#proxy-setup-history', '#proxy-setup-history-message', '#proxy-setup-history-all'])
assert.equal(await shown(sel), false, `${sel} is not shown`);
assert.equal(await b.evaluate('document.querySelectorAll("[data-log] pre, [data-log] .banner, #proxy-setup-history li").length'), 0);
});
// ---- History paging ---------------------------------------------------------------------------
test('settings-s5b: history pages back one page at a time, shows each entry once, and an empty page with an older one still offers it', { timeout: 90000 }, async t => {
const { b, wait, text, click, reads } = await setup(t);
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
await click('#proxy-setup-history-all');
assert.deepEqual((await items(b)).map(i => i.hidden), [false, false, false, false]);
assert.equal(await text('#proxy-setup-history-all'), 'Show fewer');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").getAttribute("aria-expanded")'), 'true');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
// Two quick presses send one read.
await b.evaluate('window.__holds["history?limit=25&before=3"] = true; true');
await b.evaluate('(() => { const o = document.querySelector("#proxy-setup-history-older"); o.focus(); o.click(); o.click(); return true; })()');
await wait('typeof window.__holds["history?limit=25&before=3"] === "function"');
assert.equal(await text('#proxy-setup-history-older'), 'Reading…');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").disabled'), true);
await b.evaluate('window.__holds["history?limit=25&before=3"](); true');
// The empty page: no new entry, a line that says so, and Show older still there.
await wait('/no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
assert.equal(await text('#proxy-setup-history-message'), 'That page of history had no entries to show. Show older reads further back.');
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 4);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-older');
// Folding the list keeps Show older, because the line above still names it.
await click('#proxy-setup-history-all');
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
assert.equal(await text('#proxy-setup-history-message'), 'That page of history had no entries to show. Show older reads further back.');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
await click('#proxy-setup-history-all');
await click('#proxy-setup-history-older');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 5');
const list = await items(b);
assert.match(list[4].text, /^Gamma Home switched to your models · .+ · by jason$/);
assert.equal(new Set(list.map(i => i.text)).size, list.length, 'each entry once');
// The last page: no Show older, focus goes to Show fewer, no empty-page line.
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), true);
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-all');
assert.equal(await text('#proxy-setup-history-message'), '');
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET history?limit=25&before=3', 'GET history?limit=25&before=1']);
// Closing and opening Technical details starts from the newest page again.
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
await new Promise(r => setTimeout(r, 100));
await openTech(b);
await wait('window.__admin.filter(r => r === "GET history?limit=25").length === 2 && document.querySelectorAll("#proxy-setup-history li").length === 4');
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
});
test('settings-s5b: a history with no entries says so, and a first page that is empty but names an older one offers it', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { admin: { ...OK, 'history?limit=25': [{ entries: [], next: null }, { entries: [], next: 1 }] } });
await wait(READY); await openTech(b);
await wait('document.querySelector("#proxy-setup-history-message").textContent === "No setup history yet."');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
await new Promise(r => setTimeout(r, 100));
await openTech(b);
await wait('/no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
// Nothing is folded away, so there is no Show all, and Show older is offered at once.
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
await click('#proxy-setup-history-older');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
assert.match((await items(b))[0].text, /^Gamma Home switched to your models/);
assert.equal(await text('#proxy-setup-history-message'), '');
});
test('settings-s5b: a short first page offers Show older at once, and what it reads stays open', { timeout: 90000 }, async t => {
const e = (op, n) => ({ op, time: T(n), user: 'jason' });
const { b, wait, click } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [e('unit.start', 8), e('unit.stop', 9)], next: 7 }, 'history?limit=25&before=7': { entries: [e('init', 4), e('unit.install', 5), e('unit.restart', 6)], next: null } } });
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
await click('#proxy-setup-history-older');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 5');
assert.deepEqual((await items(b)).map(i => i.hidden), [false, false, false, false, false], 'the older entries it read are shown');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").textContent'), 'Show fewer');
});
test('settings-s5b: an older page that is not further back than the one asked for is not shown', { timeout: 90000 }, async t => {
const { b, wait, text, click } = await setup(t, { admin: { ...OK, 'history?limit=25&before=3': [{ entries: [{ op: 'init', time: T(2), user: 'jason' }], next: 3 }, PAGE2] } });
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
await click('#proxy-setup-history-all');
await b.evaluate('document.querySelector("#proxy-setup-history-older").focus(); document.querySelector("#proxy-setup-history-older").click(); true');
await wait('!document.querySelector("#proxy-setup-history-retry").hidden');
assert.match(await text('#proxy-setup-history-message'), /^History could not be read\./);
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 4, 'the repeated page adds nothing');
// The pressed button went away, so focus lands on Read again.
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-retry');
// Read again answers; it goes away, and focus lands on Show older, not Show fewer.
await b.evaluate('document.querySelector("#proxy-setup-history-retry").click(); true');
await wait('document.querySelector("#proxy-setup-history-retry").hidden && /no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-older');
});
test('settings-s5b: a history answer from before Technical details was closed and opened again is dropped', { timeout: 90000 }, async t => {
const STALE = { entries: [{ op: 'init', time: T(1), user: 'stale' }], next: null };
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': [PAGE1, STALE] } });
await wait(READY);
await b.evaluate('window.__queue["history?limit=25"] = []; true');
await openTech(b);
await wait('window.__queue["history?limit=25"].length === 1');
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
await new Promise(r => setTimeout(r, 100));
await openTech(b);
await wait('window.__queue["history?limit=25"].length === 2');
// The newer read answers first, then the older one.
await b.evaluate('window.__queue["history?limit=25"][1](); true');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
await b.evaluate('window.__queue["history?limit=25"][0](); true');
await new Promise(r => setTimeout(r, 500));
const list = await items(b);
assert.equal(list.length, 4);
assert.equal(list.some(i => /stale/.test(i.text)), false, 'the older answer is not painted');
assert.equal(new Set(list.map(i => i.text)).size, 4, 'one copy of each entry');
});
test('settings-s5b: a history entry whose action is not a known one reads Other setup action', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [{ op: 'toString', time: T(1), user: 'jason' }, { op: 'constructor', time: T(2), user: 'jason' }, { op: 'something.new', time: T(3), user: 'jason' }], next: null } } });
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 3');
for (const item of await items(b)) assert.match(item.text, /^Other setup action · .+ · by jason$/);
});
test('settings-s5b: a withheld entry shows as withheld and nothing else from it', { timeout: 90000 }, async t => {
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [{ withheld: true, op: 'init', time: T(2), user: 'jason', org: 'acme' }, { withheld: true }], next: null } } });
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
for (const item of await items(b)) {
assert.equal(item.text, 'Withheld. The Console kept this entry back because it may hold a secret.');
assert.equal(item.withheld, true);
}
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].every(li => li.classList.contains("muted"))'), true);
});
// ---- No key text ------------------------------------------------------------------------------
test('settings-s5b: key-shaped text in an unexpected field of any answer never reaches the page', { timeout: 90000 }, async t => {
const k = p => `${p}-AAAAbbbbCCCCdddd0123456789`;
const admin = {
[LOG]: { unit: k('msk'), lines: ['plain line'], redacted: 0, dropped: 0, key: k('mso'), note: k('mst') },
'service-key': { madeAt: k('msk'), renewedAt: k('mso'), renewal: k('mst'), problem: k('msp'), key: k('msk') },
'history?limit=25': { entries: [
{ op: k('msk'), time: k('mso'), user: k('mst'), org: k('msp'), provider: k('msk'), accountId: k('mso'), models: k('mst'), priority: k('msp'), note: k('msk') },
{ op: 'account.proxy.apikey.add', time: T(2), user: `x${k('msk')}`, org: k('mso'), provider: k('mst') },
{ op: 'ride-move', time: T(3), org: `${k('msp')}`, user: 'jason' },
{ withheld: true, note: k('msk') },
], next: null },
};
{
const { b, wait } = await setup(t, { admin });
await wait(READY); await openTech(b);
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && !/Reading/.test(document.querySelector("#proxy-setup-keymade-text").textContent)');
await b.evaluate('document.querySelector("#proxy-setup-history-all").click(); document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
const page = await b.evaluate('document.querySelector("#proxy-setup").textContent + "\\n" + document.body.innerText');
assert.doesNotMatch(page, KEY_TEXT);
const list = await items(b);
assert.match(list[3].text, /^Other setup action · unknown$/);
assert.match(list[2].text, /^Account added · /);
assert.match(list[1].text, /^An organization switched to your models · /);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").textContent'), /^When it was made is not known\./);
}
// A refusal whose code is shaped like a key.
const refused = { status: 400, body: { error: 'msk-abcdefghijklmnop' } };
const { b, wait } = await setup(t, { admin: { [LOG]: refused, 'service-key': refused, 'history?limit=25': refused } });
await wait(READY); await openTech(b);
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-keymade-retry") && !document.querySelector("#proxy-setup-history-retry").hidden && document.querySelector("#proxy-setup-tech-lines .banner.err")');
const page = await b.evaluate('document.querySelector("#proxy-setup").textContent + "\\n" + document.body.innerText');
assert.doesNotMatch(page, KEY_TEXT);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-history-message").textContent'), /^History could not be read\. The Console refused the read\.$/);
});
// ---- Models focus follow-up -------------------------------------------------------------------
// The settings-s5 re-check left one window: a switch whose follow-up read is still out when the owner
// goes to a page that returns before render's focus chain (Assistant, Projects, the board) kept its focus request.
for (const [name, away] of [['Assistant', '#/assistant'], ['the board', '#/board']])
test(`settings-s5b: leaving Models for ${name} while a switch's follow-up read is out, the next visit does not focus the outcome line`, { timeout: 90000 }, async t => {
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
// plugins.set succeeds; the routes read that the render after it awaits waits until released.
await b.evaluate(`(() => { const f = window.fetch; window.__sets = 0;
window.fetch = async (input, init = {}) => { const u = new URL(String(input?.url ?? input), location.href).pathname, m = (init.method || 'GET').toUpperCase();
if (m !== 'GET' && u.endsWith('/proxy/plugins/set')) { window.__sets++; return new Response(JSON.stringify({ revision: 'c'.repeat(64) }), { status: 200, headers: { 'content-type': 'application/json' } }); }
if (m === 'GET' && u.endsWith('/proxy/plugins') && window.__sets) return new Response(JSON.stringify({ revision: 'c'.repeat(64), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] } }), { status: 200, headers: { 'content-type': 'application/json' } });
if (m === 'GET' && u.endsWith('/routes') && window.__sets && !window.__released) { await new Promise(r => { window.__release = r; }); window.__released = true; }
return f(input, init); }; return true; })()`);
await click('#models-yours');
await wait('typeof window.__release === "function"');
await b.evaluate(`location.hash = ${JSON.stringify(away)}; true`);
await wait('!location.hash.startsWith("#/settings/") && !document.querySelector("#models-in-force")');
await new Promise(r => setTimeout(r, 300));
await b.evaluate('window.__release(); true');
await new Promise(r => setTimeout(r, 400));
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
await wait('/^Saved\\./.test(document.querySelector("#models-receipt")?.textContent ?? "") && document.querySelector("#models-in-force")?.textContent.includes("uses your models")');
await new Promise(r => setTimeout(r, 300));
assert.notEqual(await b.evaluate('document.activeElement?.id'), 'models-receipt');
});
// ---- Shots ------------------------------------------------------------------------------------
test('shots', { timeout: 900000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
const { mkdir, writeFile } = await import('node:fs/promises');
const { join } = await import('node:path');
const dir = process.env.MOSAIC_UX_SHOTS; await mkdir(dir, { recursive: true });
const settle = () => new Promise(r => setTimeout(r, 1000));
const fail = { status: 503, body: { error: 'outcome-unknown' } };
const SHOTS = [
{ name: 'setup-start-failed', options: { service: SERVICE_START, admin: { ...OK, ...START_REFUSED } }, ready: READY + ' && document.querySelector("#proxy-setup-go") && !document.querySelector("#proxy-setup-go").hidden',
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-go").click(); true'); await wait('document.querySelector("#proxy-setup-lines pre.setup-log")'); } },
{ name: 'setup-failed-no-lines', options: { service: SERVICE_FAILED, admin: { ...OK, [LOG]: { status: 503, body: { error: 'not-configured' } } } }, ready: 'document.querySelector("#proxy-setup-lines [data-log] p")' },
{ name: 'technical-details', ready: READY,
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; true');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && /Mosaic made it/.test(document.querySelector("#proxy-setup-keymade-text").textContent)'); } },
{ name: 'technical-details-all', ready: READY,
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; true');
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
await b.evaluate('document.querySelector("#proxy-setup-history-all").click(); document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")'); } },
{ name: 'technical-details-failed', options: { admin: { [LOG]: fail, 'service-key': fail, 'history?limit=25': fail } }, ready: READY,
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; document.querySelector("#proxy-setup-tech-lines").open = true; true');
await wait('document.querySelector("#proxy-setup-keymade-retry") && !document.querySelector("#proxy-setup-history-retry").hidden && document.querySelector("#proxy-setup-tech-lines .banner.err")'); } },
];
const report = [];
for (const shot of SHOTS) for (const scheme of ['light', 'dark']) for (const width of [390, 1440]) {
const { b, wait } = await setup(t, { ...(shot.options ?? {}), viewport: [width, width === 390 ? 844 : 900] });
await b.call('Emulation.setScrollbarsHidden', { hidden: true });
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
await wait(`(${shot.ready}) && !!window.MosaicAppearance`);
await b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
if (shot.after) await shot.after(b, wait);
await settle();
const sideways = await b.evaluate('document.documentElement.scrollWidth > document.documentElement.clientWidth');
const noRing = [], seen = new Set();
for (let i = 0; i < 160; i++) {
await b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
await b.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
const r = await b.evaluate(`(() => { const e = document.activeElement; if (!e || e === document.body) return null; const cs = getComputedStyle(e);
const ring = (cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) > 0) || (cs.boxShadow && cs.boxShadow !== 'none');
return { key: e.id || e.getAttribute('href') || e.tagName + ':' + (e.textContent || '').trim().slice(0, 30), ring }; })()`);
if (!r || seen.has(r.key)) break; seen.add(r.key);
if (!r.ring) noRing.push(r.key);
}
await b.evaluate('document.activeElement?.blur(); window.scrollTo(0, 0); true'); await settle();
const file = `${shot.name}-${width}-${scheme}.png`;
let metrics = await b.call('Page.getLayoutMetrics'), size = metrics.cssContentSize || metrics.contentSize;
await b.viewport(width, Math.ceil(size.height)); await settle();
metrics = await b.call('Page.getLayoutMetrics'); size = metrics.cssContentSize || metrics.contentSize;
const { data } = await b.call('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true, clip: { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 } });
await writeFile(join(dir, file), Buffer.from(data, 'base64'));
report.push({ page: shot.name, width, scheme, shot: file, sideways, noRing });
await b.close();
}
await writeFile(join(dir, 'measure.json'), JSON.stringify(report, null, 1));
for (const r of report) {
assert.equal(r.sideways, false, `${r.shot} scrolls sideways`);
assert.deepEqual(r.noRing, [], `${r.shot}: controls with no visible focus ring`);
}
});
+316
View File
@@ -0,0 +1,316 @@
// proxy-scope slice 4 (#1873): the Console's side of the Triage key. The Console asks one riding
// organization's bus for proxy.triage.key (it never holds the management key); a bus that is down or
// not riding is passed over; with none left the status is triage-no-riding-bus with its named
// message. Settings > Triage shows "rotation overdue" when the day has passed and no riding bus can
// act. The owner's first save with no key held runs ensure; Repair access runs ensure; Turn Triage
// off stops the session, then runs revoke. No answer, response or log line holds a key.
import test from 'node:test';
import assert from 'node:assert/strict';
import { request } from 'node:http';
import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { keyIdOf, keyPrefix } from '../../bus/src/triage-key-file.mjs';
import { NO_RIDING_MESSAGE, OVERDUE_ALLOWANCE_MS, accessStatus, keyState, ridingOrgs, triageKeyCall } from '../src/triage-access.mjs';
import { ACCESS_OPS, TRIAGE_ACCESS_PATH, TRIAGE_ROUTE_PATH, triageRouteRoutes } from '../src/triage-route-http.mjs';
const scratch = prefix => mkdtempSync(join(process.env.TMPDIR, prefix));
const T = '2026-11-18T12:00:00.000Z';
const SECRET = 'S'.repeat(20) + 'e_-' + 'c'.repeat(20);
const KEY = `mst-0123456789ab-triage-${SECRET}`;
const busError = code => Object.assign(new Error(`bus said ${code} ${KEY}`), { code });
// A rider as webui cli.mjs rideRiders lists them; `answer` is what its bus does with the call.
const rider = (id, answer, over = {}) => {
const r = { id, fixture: false, cliproxy: true, calls: [], call: async (verb, args) => { r.calls.push([verb, args]); return answer(args); }, ...over };
return r;
};
const ISSUED = () => ({ op: 'ensure', action: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-18', addedKeyIds: ['0123456789ab'], removedKeyIds: [], key: KEY, retiring: [{ key: KEY }] });
test('triageKeyCall asks the first riding bus as the owner, passes over a bus that is down or not riding, and skips fixture and non-cliproxy organizations', async () => {
const fixtureOrg = rider('fix', ISSUED, { fixture: true });
const ownProxy = rider('own', ISSUED, { cliproxy: false });
const down = rider('down', () => { throw busError('no-bus-host'); });
const notRiding = rider('other', () => { throw busError('triage-no-riding-bus'); });
const good = rider('alpha', ISSUED);
const after = rider('beta', ISSUED);
const r = await triageKeyCall({ riders: async () => [fixtureOrg, ownProxy, down, notRiding, good, after], op: 'ensure' });
assert.deepEqual(r, { ok: true, op: 'ensure', action: 'issued', addedKeyIds: ['0123456789ab'], removedKeyIds: [], keyId: '0123456789ab', rotateBy: '2026-12-18', org: 'alpha' });
assert.deepEqual(good.calls, [['proxy.triage.key', { op: 'ensure' }]]);
for (const x of [fixtureOrg, ownProxy, after]) assert.deepEqual(x.calls, [], x.id);
for (const x of [down, notRiding]) assert.equal(x.calls.length, 1, x.id);
assert.equal(JSON.stringify(r).includes(SECRET), false, 'no key in the answer');
});
test('triageKeyCall: a bus whose outcome is unknown (a timeout, an unreadable or oversized answer) may have done the work, so the walk stops there and asks no other bus', async () => {
for (const c of ['outcome-unknown', 'invalid-response', 'response-too-large']) {
const slow = rider('slow', () => { throw busError(c); });
const next = rider('beta', ISSUED);
for (const op of ['ensure', 'revoke'])
assert.deepEqual(await triageKeyCall({ riders: async () => [slow, next], op }), { ok: false, code: 'outcome-unknown', org: 'slow' }, `${c} ${op}`);
assert.deepEqual(next.calls, [], c);
}
// ridingOrgs is the list the walk asks, and the status reads the same list.
const list = [rider('fix', ISSUED, { fixture: true }), rider('own', ISSUED, { cliproxy: false }), rider('alpha', ISSUED), { id: 'nocall', cliproxy: true }, null];
assert.deepEqual(ridingOrgs(list).map(r => r.id), ['alpha']);
assert.deepEqual(ridingOrgs('x'), []);
});
test('triageKeyCall: with no riding bus left the answer is triage-no-riding-bus; any other refusal is the answer and stops the walk', async () => {
for (const list of [[], [rider('own', ISSUED, { cliproxy: false })], [rider('fix', ISSUED, { fixture: true })], [rider('a', () => { throw busError('triage-no-riding-bus'); }), rider('b', () => { throw busError('bus-unavailable'); })]])
assert.deepEqual(await triageKeyCall({ riders: async () => list, op: 'revoke' }), { ok: false, code: 'triage-no-riding-bus' });
assert.deepEqual(await triageKeyCall({ riders: async () => { throw new Error('x'); }, op: 'ensure' }), { ok: false, code: 'triage-no-riding-bus' });
const refused = rider('alpha', () => { throw busError('human-required'); });
const next = rider('beta', ISSUED);
assert.deepEqual(await triageKeyCall({ riders: async () => [refused, next], op: 'ensure' }), { ok: false, code: 'human-required', org: 'alpha' });
assert.deepEqual(next.calls, []);
// A code that is not a bus code is outcome-unknown, which stops the walk.
const odd = rider('odd', () => { throw busError(`rm -rf ${KEY}`); });
assert.deepEqual(await triageKeyCall({ riders: async () => [odd, next], op: 'ensure' }), { ok: false, code: 'outcome-unknown', org: 'odd' });
for (const op of ['rotate', undefined, 'ENSURE']) assert.deepEqual(await triageKeyCall({ riders: async () => [next], op }), { ok: false, code: 'invalid-request' });
assert.deepEqual(next.calls, []);
});
test('triageKeyCall keeps ids and a day only: a key, a key-shaped id or an unknown action from a bus is dropped', async () => {
const leaky = rider('alpha', () => ({ action: 'replaced', keyId: KEY, rotateBy: `${KEY}`, addedKeyIds: [KEY, '0123456789ab'], removedKeyIds: ['ba9876543210', { key: KEY }], key: KEY }));
const r = await triageKeyCall({ riders: async () => [leaky], op: 'ensure' });
assert.deepEqual(r, { ok: true, op: 'ensure', action: 'replaced', addedKeyIds: ['0123456789ab'], removedKeyIds: ['ba9876543210'], org: 'alpha' });
const strange = rider('alpha', () => ({ action: KEY, keyId: '0123456789ab', addedKeyIds: 'x' }));
assert.deepEqual(await triageKeyCall({ riders: async () => [strange], op: 'revoke' }), { ok: true, op: 'revoke', action: 'unknown', addedKeyIds: [], removedKeyIds: [], org: 'alpha' });
});
// A key file as the bus writes it (triage-key.mjs), in a temp config directory.
function keyFile(configDir, { rotateBy = '2026-12-18', mode = 0o600 } = {}) {
const dir = join(configDir, 'secrets', 'triage');
mkdirSync(dir, { recursive: true, mode: 0o700 });
chmodSync(join(configDir, 'secrets'), 0o700);
chmodSync(dir, 0o700);
const key = `${keyPrefix(configDir)}${SECRET}`;
writeFileSync(join(dir, 'model'), JSON.stringify({ version: 1, key, keyId: keyIdOf(key), issuedAt: T, rotateBy, retiring: [] }), { mode });
chmodSync(join(dir, 'model'), mode);
return key;
}
test('keyState reads the file through the reader alone: missing, issued with its id and day, due and overdue, or unsafe; never the key', t => {
const root = scratch('ta-ks-');
t.after(() => rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config');
mkdirSync(configDir, { mode: 0o700 });
assert.deepEqual(keyState(configDir), { key: 'missing' });
const key = keyFile(configDir);
const at = s => () => Date.parse(s);
const before = keyState(configDir, { now: at('2026-12-17T23:59:59Z') });
assert.deepEqual(before, { key: 'issued', keyId: keyIdOf(key), rotateBy: '2026-12-18', retiring: 0, due: false, overdue: false });
assert.equal(JSON.stringify(before).includes(SECRET), false);
assert.deepEqual(keyState(configDir, { now: at('2026-12-18T00:00:00Z') }), { ...before, due: true });
assert.equal(OVERDUE_ALLOWANCE_MS, 600000);
assert.deepEqual(keyState(configDir, { now: at('2026-12-18T00:10:00Z') }), { ...before, due: true });
assert.deepEqual(keyState(configDir, { now: at('2026-12-18T00:10:01Z') }), { ...before, due: true, overdue: true });
chmodSync(join(configDir, 'secrets', 'triage', 'model'), 0o644);
assert.deepEqual(keyState(configDir), { key: 'unsafe' });
rmSync(join(configDir, 'secrets', 'triage', 'model'));
symlinkSync('/dev/null', join(configDir, 'secrets', 'triage', 'model'));
assert.deepEqual(keyState(configDir), { key: 'unsafe' });
});
test('accessStatus: no riding organization names triage-no-riding-bus and its message; rotation overdue shows when the day has passed and no riding bus can act', () => {
const issued = { key: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-18', retiring: 0, due: false, overdue: false };
assert.deepEqual(accessStatus(issued, { riding: true }), { ...issued, riding: true });
assert.deepEqual(accessStatus(issued, { riding: false }), { ...issued, riding: false, code: 'triage-no-riding-bus', message: NO_RIDING_MESSAGE });
assert.equal(NO_RIDING_MESSAGE, "Triage needs one organization that uses the owner's models");
assert.equal(accessStatus({ ...issued, due: true }, { riding: false }).rotation, 'rotation overdue');
assert.equal(accessStatus({ ...issued, due: true }, { riding: true }).rotation, undefined, 'a riding bus has its sweep to act');
assert.equal(accessStatus({ ...issued, due: true, overdue: true }, { riding: true }).rotation, 'rotation overdue', 'still not done well after the day began');
assert.deepEqual(accessStatus({ key: 'missing' }, { riding: false }), { key: 'missing', riding: false, code: 'triage-no-riding-bus', message: NO_RIDING_MESSAGE });
assert.equal(accessStatus({ key: 'missing' }, { riding: 'yes' }).riding, false);
});
// --- Over HTTP ---------------------------------------------------------------------------------
const MODEL = { key: 'sonnet', module: 'anthropic', upstream: 'cliproxy', provider: 'anthropic', model: 'claude-sonnet', label: 'SONNET', available: true, reason: null, harnesses: ['claude-code', 'pi'] };
const READY = () => ({ status: 'ready', observedAt: T, notices: [], models: [MODEL] });
const BODY = { model: 'sonnet', harness: 'claude-code', cap: 200000, timeZone: 'Europe/Berlin', revision: 0 };
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));
});
// A dev-owner Console with the access side wired as cli.mjs wires it: the real keyState over a temp
// config directory and the real triageKeyCall over stand-in riders. A rider's ensure writes the key
// file, as the bus does; its revoke removes it.
async function console_(t, { riders: make = null, serve = {} } = {}) {
const root = scratch('ta-http-');
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 order = [];
const busAnswer = ({ op }) => {
order.push(`bus ${op}`);
if (op === 'ensure') { keyFile(configDir); return ISSUED(); }
rmSync(join(configDir, 'secrets', 'triage', 'model'), { force: true });
return { op: 'revoke', action: 'revoked', addedKeyIds: [], removedKeyIds: ['0123456789ab'], key: KEY };
};
const list = make ? make(busAnswer) : [rider('alpha', busAnswer)];
const logs = [], routeLogs = [];
const access = {
state: () => keyState(configDir, { now: () => Date.parse(T) }),
// As cli.mjs: the same list the walk asks (the proxy is set up in this harness).
riding: async () => ridingOrgs(list).length > 0,
key: op => triageKeyCall({ riders: async () => list, op }),
stop: async () => { order.push('stop'); },
};
const s = await startServer({ port: 0, board: 'http://127.0.0.1:9', sso: createDevOwner(), send: async () => ({}), log: l => logs.push(l),
routes: [triageRouteRoutes({ dataRoot, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'], log: l => routeLogs.push(l), access })], ...serve });
t.after(() => new Promise(r => s.close(r)));
const port = s.address().port;
const read = { host: `127.0.0.1:${port}`, 'sec-fetch-site': 'same-origin' };
const write = { ...read, origin: `http://127.0.0.1:${port}`, 'content-type': 'application/json' };
return {
port, configDir, list, order, logs, routeLogs, write,
get: () => send(port, TRIAGE_ROUTE_PATH, { headers: read }),
save: (body = BODY) => send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers: write, body }),
op: (op, headers = write) => send(port, TRIAGE_ACCESS_PATH, { method: 'POST', headers, body: { op } }),
};
}
test('the first save with no key held asks one riding bus for ensure; a later save, with the key held, does not', async t => {
const f = await console_(t);
const before = await f.get();
assert.deepEqual(before.json.access, { key: 'missing', riding: true });
const first = await f.save();
assert.equal(first.status, 200, first.text);
assert.deepEqual(first.json.key, { action: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-18' });
assert.deepEqual(f.list[0].calls, [['proxy.triage.key', { op: 'ensure' }]]);
const second = await f.save({ ...BODY, revision: 1, cap: 300000 });
assert.equal(second.status, 200, second.text);
assert.equal(Object.hasOwn(second.json, 'key'), false);
assert.equal(f.list[0].calls.length, 1, 'ensure runs once');
assert.equal((await f.get()).json.access.key, 'issued');
});
test('with no riding organization, a save keeps the route and says why; the status names triage-no-riding-bus and its message; Repair answers 503 with it', async t => {
const f = await console_(t, { riders: answer => [rider('own', answer, { cliproxy: false }), rider('fix', answer, { fixture: true })] });
const r = await f.get();
assert.deepEqual(r.json.access, { key: 'missing', riding: false, code: 'triage-no-riding-bus', message: NO_RIDING_MESSAGE });
const saved = await f.save();
assert.equal(saved.status, 200);
assert.equal(saved.json.route.model, 'sonnet', 'the route is saved');
assert.equal(saved.json.key.error, 'triage-no-riding-bus');
assert.match(saved.json.key.message, /^Triage needs one organization that uses the owner's models\./);
const repair = await f.op('repair');
assert.equal(repair.status, 503);
assert.equal(repair.json.error, 'triage-no-riding-bus');
assert.equal(repair.json.access.code, 'triage-no-riding-bus');
for (const x of f.list) assert.deepEqual(x.calls, [], x.id);
});
test('rotation overdue shows when the key day has passed and no organization rides the owner models', async t => {
const f = await console_(t, { riders: answer => [rider('own', answer, { cliproxy: false })] });
keyFile(f.configDir, { rotateBy: '2026-11-17' });
const r = await f.get();
assert.equal(r.json.access.rotation, 'rotation overdue');
assert.equal(r.json.access.code, 'triage-no-riding-bus');
assert.equal(r.json.access.key, 'issued');
});
test('Repair access runs ensure; Turn Triage off stops the session first, then runs revoke', async t => {
const f = await console_(t);
assert.deepEqual(ACCESS_OPS, ['repair', 'off']);
const repair = await f.op('repair');
assert.equal(repair.status, 200, repair.text);
assert.deepEqual(repair.json, { op: 'repair', key: { action: 'issued', keyId: '0123456789ab', rotateBy: '2026-12-18' }, access: { key: 'issued', keyId: repair.json.access.keyId, rotateBy: '2026-12-18', retiring: 0, due: false, overdue: false, riding: true } });
const off = await f.op('off');
assert.equal(off.status, 200, off.text);
assert.deepEqual(off.json, { op: 'off', key: { action: 'revoked' }, access: { key: 'missing', riding: true } });
assert.deepEqual(f.order, ['bus ensure', 'stop', 'bus revoke']);
assert.deepEqual(f.list[0].calls.map(c => c[1].op), ['ensure', 'revoke']);
});
test('after Turn Triage off, a later save does not issue the key again; only Repair access brings it back', async t => {
const f = await console_(t);
assert.equal((await f.save()).json.key.action, 'issued');
assert.equal((await f.op('off')).status, 200);
const again = await f.save({ ...BODY, revision: 1, cap: 300000 });
assert.equal(again.status, 200, again.text);
assert.equal(Object.hasOwn(again.json, 'key'), false);
assert.equal((await f.get()).json.access.key, 'missing');
assert.deepEqual(f.order, ['bus ensure', 'stop', 'bus revoke']);
assert.equal((await f.op('repair')).json.key.action, 'issued');
assert.deepEqual(f.order, ['bus ensure', 'stop', 'bus revoke', 'bus ensure']);
});
test('a bus refusal on Off leaves the key and says why with a fixed line; the session was still stopped', async t => {
const f = await console_(t, { riders: () => [rider('alpha', () => { throw busError('storage-unavailable'); })] });
const off = await f.op('off');
assert.equal(off.status, 502);
assert.equal(off.json.error, 'storage-unavailable');
assert.equal(off.json.message, 'The Triage key was not changed. The organization\'s bus refused with storage-unavailable.');
assert.deepEqual(f.order, ['stop']);
assert.equal(off.text.includes(SECRET), false);
});
test('the access path holds the owner, same-origin and read-only gates, takes op only, and the tester listener cannot reach it', async t => {
const f = await console_(t);
const { origin, ...noOrigin } = f.write;
assert.equal((await f.op('repair', noOrigin)).status, 403);
assert.equal((await f.op('repair', { ...f.write, origin: 'http://evil.example' })).status, 403);
assert.equal((await f.op('repair', { ...f.write, 'sec-fetch-site': 'cross-site' })).status, 403);
const { 'sec-fetch-site': _, ...noSite } = f.write;
assert.equal((await f.op('repair', noSite)).status, 403);
for (const body of [{}, { op: 'ensure' }, { op: 'revoke' }, { op: 'repair', key: KEY }, { op: ['repair'] }, 'repair'])
assert.equal((await send(f.port, TRIAGE_ACCESS_PATH, { method: 'POST', headers: f.write, body })).status, 400, JSON.stringify(body));
assert.equal((await send(f.port, TRIAGE_ACCESS_PATH, { method: 'POST', headers: { ...f.write, 'content-type': 'text/plain' }, body: { op: 'repair' } })).status, 400);
assert.notEqual((await send(f.port, TRIAGE_ACCESS_PATH, { headers: f.write })).status, 200, 'a GET is not an op');
assert.deepEqual(f.list[0].calls, [], 'no refused request reached a bus');
assert.deepEqual(f.order, []);
// The handler's own owner and same-origin lines, behind the serve gate: a caller who is not the
// instance owner, or a doubled Origin or Sec-Fetch-Site, is refused before any bus is asked.
let handler, unitAsked = 0;
const unitAccess = { state: () => ({ key: 'missing' }), riding: async () => true, key: async () => { unitAsked++; return { ok: true }; }, stop: async () => { unitAsked++; } };
triageRouteRoutes({ dataRoot: f.configDir, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'], access: unitAccess })({ add: (method, path, fn) => { if (path === TRIAGE_ACCESS_PATH) handler = fn; } });
const o = 'https://console.example';
const call = (headersDistinct, extra = {}) => new Promise(resolve => {
const res = { writeHead(status) { this.status = status; }, end(text) { resolve({ status: this.status, json: JSON.parse(text) }); } };
const req = { method: 'POST', headersDistinct, headers: { 'content-type': 'application/json' }, async *[Symbol.asyncIterator]() { yield Buffer.from('{"op":"off"}'); } };
handler(req, res, { owner: true, session: { provider: 'local-dev', sub: 'local-dev-owner' }, origin: o, send: true, ...extra });
});
const same = { origin: [o], 'sec-fetch-site': ['same-origin'] };
assert.equal((await call(same, { owner: false })).json.error, 'human-required');
assert.equal((await call(same, { session: null })).json.error, 'human-required');
assert.equal((await call({ ...same, origin: [o, o] })).json.error, 'cross-origin');
assert.equal((await call({ ...same, 'sec-fetch-site': ['same-origin', 'same-origin'] })).json.error, 'cross-site');
assert.equal((await call(same, { send: false })).json.error, 'read-only');
assert.equal(unitAsked, 0);
assert.equal((await call(same)).status, 200);
assert.equal(unitAsked, 2, 'the owner\'s own call stops and revokes');
const ro = await console_(t, { serve: { send: null } });
const r = await ro.op('off');
assert.equal(r.status, 403);
assert.equal(r.json.error, 'read-only');
assert.deepEqual(ro.order, []);
const { startTesterSocket } = await import('../src/tester-socket.mjs');
const { testerRequest } = await import('../../cli/src/tester-http.mjs');
const root = scratch('ta-tester-');
t.after(() => rmSync(root, { recursive: true, force: true }));
let asked = 0;
const access = { state: () => ({ key: 'missing' }), riding: async () => true, key: async () => { asked++; return { ok: true }; }, stop: async () => { asked++; } };
const s = await startTesterSocket({ dataRoot: root, log: () => {}, routes: [triageRouteRoutes({ dataRoot: root, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'], access })] });
t.after(() => new Promise(r2 => s.close(r2)));
for (const op of ['repair', 'off']) assert.equal((await testerRequest({ dataRoot: root, path: TRIAGE_ACCESS_PATH, method: 'POST', body: { op } })).status, 403, op);
assert.equal(asked, 0);
});
test('no response or log line holds a key, even when a bus answers with one', async t => {
const f = await console_(t);
const texts = [];
for (const r of [await f.get(), await f.save(), await f.op('repair'), await f.op('off'), await f.get()]) texts.push(r.text);
const all = texts.join('\n') + f.logs.join('\n') + f.routeLogs.join('\n');
assert.equal(all.includes(SECRET), false);
assert.equal(all.includes(f.configDir), false, 'no config path');
});
+83 -1
View File
@@ -12,7 +12,7 @@ import { REPO, RUNNER_FILES, checkHostedRoute, sandboxProblem } from "../../seat
import { isProviderVariable } from "../../seat/src/session.mjs";
import {
NOT_STARTED, NOT_TAKEN, RELAY_REFUSED, ROUTE_ENV_ALLOW, ROUTE_REFUSED, SPAWN_ENV_ALLOW, SPAWN_PATH_ALLOW, UNANSWERED, createRelay, createTriageHost, hostPrompt,
USAGE_NOT_READ, USAGE_UNKNOWN_ENDED, UNKNOWN_TURNS_MAX, overCapNotTaken, refusedHarnessName, triageEnv,
USAGE_NOT_READ, USAGE_UNKNOWN_ENDED, UNKNOWN_TURNS_MAX, KEY_ROTATED, KEY_ROTATED_CODE, overCapNotTaken, refusedHarnessName, triageEnv,
} from "../src/triage-host.mjs";
import { writeRoute } from "../src/triage-route-store.mjs";
import { appendUsage, readUsage, usagePath } from "../src/triage-usage.mjs";
@@ -1336,3 +1336,85 @@ test("cap fail closed: a Console restart between the unknown end and the next me
assert.deepEqual(readdirSync(join(second.dataRoot, "triage", "agent", "session")), [], "a fresh session directory");
assert.equal(existsSync(marker), false, "the marker is used once");
});
// proxy-scope slice 4 (#1873): a Triage session still running on a key whose grace has ended stops
// with triage-key-rotated: the host line says why, the state names the code, the process ends, and
// no line, log or state holds the key. The key file is read through the keyRecord the Console hands
// the host (packages/bus/src/triage-key-file.mjs readKey); here a stand-in record.
const OLD_KEY = `mst-0123456789ab-triage-${"o".repeat(43)}`;
const NEW_KEY = `mst-0123456789ab-triage-${"n".repeat(43)}`;
const keyed = (root, key) => ({ asked: 0, key, admit: async function () { this.asked++; return answer(root, { env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", ANTHROPIC_AUTH_TOKEN: this.key } }); } });
const recordOf = (key, retiring = []) => ({ version: 1, key, keyId: "000000000000", issuedAt: "2026-11-18T00:00:00.000Z", rotateBy: "2026-12-18", retiring });
test("key rotation: a session on the old key runs through its grace and stops at its retireAt with triage-key-rotated", { timeout: 30000 }, async (t) => {
const root = scratch();
const logs = [];
let clock = Date.parse("2026-11-18T12:00:00.000Z");
let record = recordOf(OLD_KEY);
const { h, dataRoot } = host(t, root, { route: keyed(root, OLD_KEY), bwrap: standIn(root), usageSource: spendSource, now: () => new Date(clock), log: (l) => logs.push(l), keyRecord: () => record, keyPollMs: 50 });
assert.equal(KEY_ROTATED_CODE, "triage-key-rotated");
await h.message("one");
await runnerClient(root, dataRoot);
const pid = h.pid;
// The bus rotates: the old key is retiring until 12:10. Through the grace the session keeps running.
record = recordOf(NEW_KEY, [{ key: OLD_KEY, keyId: "111111111111", issuedAt: "2026-10-18T00:00:00.000Z", retireAt: "2026-11-18T12:10:00.000Z" }]);
clock = Date.parse("2026-11-18T12:09:59.000Z");
await new Promise((r) => setTimeout(r, 300));
assert.equal(h.running, true, "inside the grace the session runs");
assert.equal((await h.state()).lastStop, null);
// At the retireAt it stops, before the sweep (30 s later) removes the key from the proxy.
clock = Date.parse("2026-11-18T12:10:00.000Z");
await waitFor(() => !h.running, 10000);
assert.throws(() => process.kill(pid, 0), "the process is gone");
const s = await h.state();
assert.deepEqual(s.lastStop, { code: "triage-key-rotated", at: "2026-11-18T12:10:00.000Z" });
assert.equal(s.transcript.filter((e) => e.from === "host" && e.text === KEY_ROTATED).length, 1, "one host line says why");
assert.ok(logs.includes("triage host: stopping the session: triage-key-rotated"), logs.join(" | "));
const text = JSON.stringify(s) + logs.join("\n");
for (const k of [OLD_KEY, NEW_KEY]) assert.equal(text.includes(k.slice(-43)), false, "no key in the state or the logs");
});
test("key rotation: a message to a session whose key left the file stops it first, and the message starts a new session on the current key", { timeout: 30000 }, async (t) => {
const root = scratch();
let record = recordOf(OLD_KEY);
const route = keyed(root, OLD_KEY);
// The poll is slow here, so only the message path can stop the session.
const { h, dataRoot } = host(t, root, { route, bwrap: standIn(root), usageSource: spendSource, now: () => new Date("2026-11-18T12:00:00.000Z"), keyRecord: () => record, keyPollMs: 600000 });
await h.message("one");
await runnerClient(root, dataRoot);
const first = h.pid;
// The owner turned Triage off and on: the old key is gone; the route now answers the new key.
record = recordOf(NEW_KEY);
route.key = NEW_KEY;
rmSync(join(root, "stdin.json"));
await h.message("two");
// The stop happens inside message(), before the message is queued: assert it now, so a missing
// stop fails here rather than at the test timeout below.
assert.equal((await h.state()).lastStop?.code, "triage-key-rotated", "message() stops the session on the gone key");
await runnerClient(root, dataRoot);
assert.notEqual(h.pid, first, "a new session");
assert.throws(() => process.kill(first, 0), "the old process is gone");
const s = await h.state();
assert.equal(s.lastStop.code, "triage-key-rotated");
assert.equal(s.transcript.filter((e) => e.from === "host" && e.text === KEY_ROTATED).length, 1);
assert.equal(s.transcript.filter((e) => e.from === "owner").length, 2, "the second message is kept and delivered");
// The new session holds the current key: a message to it does not stop it.
await h.message("three");
assert.equal(h.pid !== first && h.running, true);
assert.equal((await h.state()).transcript.filter((e) => e.text === KEY_ROTATED).length, 1);
});
test("key rotation: with no key reader, or a key file that cannot be read, a running session is not stopped", { timeout: 30000 }, async (t) => {
for (const keyRecord of [null, () => { throw Object.assign(new Error("unsafe"), { code: "triage-key-unsafe" }); }]) {
const root = scratch();
const { h, dataRoot } = host(t, root, { route: keyed(root, OLD_KEY), bwrap: standIn(root), usageSource: spendSource, now: () => new Date("2026-11-18T12:00:00.000Z"), keyRecord, keyPollMs: 50 });
await h.message("one");
await runnerClient(root, dataRoot);
await new Promise((r) => setTimeout(r, 300));
await h.message("two");
assert.equal(h.running, true, String(keyRecord));
assert.equal((await h.state()).lastStop, null);
await h.stop();
}
assert.throws(() => createTriageHost({ dataRoot: "/x", keyRecord: "path" }), /keyRecord/);
});
+3 -3
View File
@@ -23,7 +23,7 @@ import { readUsage, usagePath } from "../src/triage-usage.mjs";
import { startServer } from "../src/serve.mjs";
import { createDevOwner } from "../src/dev-owner.mjs";
import { NO_ROUTE_MESSAGE, capMessage } from "../src/triage-http.mjs";
import { keyIdOf, keyPrefix } from "../../cli/src/triage-key-file.mjs";
import { keyIdOf, keyPrefix } from "../../bus/src/triage-key-file.mjs";
const FIXTURE = fileURLToPath(new URL("./fixtures/triage-adapter.mjs", import.meta.url));
const SRC = fileURLToPath(new URL("../src/", import.meta.url));
@@ -916,8 +916,8 @@ function loaded(t, args) {
return readFileSync(out, "utf8").split("\n").filter(Boolean).map((u) => (u.startsWith("file:") ? fileURLToPath(u) : u));
}
const CLIENT = join(REPO_ROOT, "packages", "model-proxy", "src", "client.mjs");
const KEY_VERBS = join(REPO_ROOT, "packages", "cli", "src", "triage-key.mjs");
const KEY_FILE = join(REPO_ROOT, "packages", "cli", "src", "triage-key-file.mjs");
const KEY_VERBS = join(REPO_ROOT, "packages", "bus", "src", "triage-key.mjs");
const KEY_FILE = join(REPO_ROOT, "packages", "bus", "src", "triage-key-file.mjs");
test("the Console process never imports the proxy management client or the key verbs' module", { timeout: 120000 }, (t) => {
// The control: the hook sees them when a module that uses them loads.