fix(webui): Triage route review round: a save sends the revision its fields were read at, so a route saved elsewhere answers as stale instead of being written over, and an untouched page follows the store; a read follows the repo GET convention, so a LAN dev host with no Fetch Metadata reads the route while a write still needs one matching Origin and same-origin; a zone in another case is stored in its canonical spelling; focus lands on the saved line; the organization catalogues are read in parallel (#1873, lane triage-settings)

This commit is contained in:
jason.woltje committed 2026-11-18 14:40:22 -06:00
1 parent 561ff77e48
commit dab07f0ff5
5 files changed
+104 -28

No files matched your search

+6 -7
View File
@@ -271,13 +271,12 @@ try {
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)] : [];
const out = [];
for (const org of await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })) {
if (org.state !== 'active') continue;
let paths; try { paths = orgPaths(org.root); } catch { out.push({ status: 'bus-unavailable' }); continue; }
out.push(await read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 })));
}
return out;
// Every active organization is asked at once, so a hung bus costs one timeout, not one each.
const active = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).filter(org => org.state === 'active');
return Promise.all(active.map(org => {
let paths; try { paths = orgPaths(org.root); } catch { return { status: 'bus-unavailable' }; }
return read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }));
}));
},
})] : [];
try {
+10 -6
View File
@@ -10,7 +10,9 @@
const PATH = '/api/triage/route';
// The time zones this browser knows, offered as suggestions only; the server decides.
const zones = (() => { try { return Intl.supportedValuesOf('timeZone'); } catch { return []; } })();
let data = null, readLine = '', draft = null, busy = false, line = '', conflict = false;
// draft holds the typed fields; base is the revision they were read at, which a save sends, so a
// change saved elsewhere since then answers as stale instead of being written over.
let data = null, readLine = '', draft = null, base = 0, busy = false, line = '', conflict = false;
const call = init => window.fetch(PATH, { cache: 'no-store', redirect: 'manual', ...init });
// The stored route's fields, or empty ones: there is no default model, harness, cap or zone.
@@ -23,8 +25,10 @@
try { a = await r.json(); } catch { /* refused below */ }
if (r.type === 'opaqueredirect') { data = null; readLine = 'Sign in again, then reload.'; return; }
if (!r.ok || !a || typeof a !== 'object') { data = null; readLine = typeof a?.message === 'string' ? a.message : 'The Triage route could not be read.'; return; }
// An untouched page follows the store; typed fields stay, with the revision they were read at.
const untouched = draft === null || JSON.stringify(draft) === JSON.stringify(fromRoute(data?.route ?? null));
data = a;
if (draft === null) draft = fromRoute(a.route);
if (untouched) { draft = fromRoute(a.route); base = Number.isSafeInteger(a.revision) ? a.revision : 0; }
}
const models = () => (Array.isArray(data?.choices?.models) ? data.choices.models : []);
@@ -59,13 +63,13 @@
+ `<label>Reset <input id="triage-route-reset" value="00:00" readonly aria-readonly="true"></label>`
+ `<label>Time zone <input id="triage-route-zone" list="triage-route-zones" autocomplete="off" spellcheck="false" placeholder="Region/City" value="${esc(d.timeZone)}"${off}></label>`
+ `</div><datalist id="triage-route-zones">${zones.map(z => `<option value="${esc(z)}"></option>`).join('')}</datalist>`
+ `<div class="settings-actions"><button type="submit" id="triage-route-save"${off}>${busy ? 'Saving…' : 'Save'}</button>${conflictButton} <span role="status" id="triage-route-line">${esc(line)}</span></div>`
+ `<div class="settings-actions"><button type="submit" id="triage-route-save"${off}>${busy ? 'Saving…' : 'Save'}</button>${conflictButton} <span role="status" id="triage-route-line" tabindex="-1">${esc(line)}</span></div>`
+ `</form>${send ? '' : '<p class="small muted" id="triage-route-readonly">This Console is read-only, so the route cannot be saved here.</p>'}`;
}
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">${esc(line)}</p>`
? `<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. The key and the wiring are separate.')}</p>`;
return `<section class="panel" id="triage-route" aria-labelledby="triage-route-title"><h3 id="triage-route-title">Triage model route</h3>${body}</section>`;
}
@@ -78,7 +82,7 @@
if (busy || data?.send !== true) return;
const d = draft ?? fromRoute(null);
const cap = /^\d+$/.test(d.cap.trim()) ? Number(d.cap.trim()) : d.cap.trim() === '' ? null : Number.NaN;
const body = { model: d.model, harness: d.harness, cap: Number.isFinite(cap) ? cap : d.cap, timeZone: d.timeZone.trim(), revision: data.revision ?? 0 };
const body = { model: d.model, harness: d.harness, cap: Number.isFinite(cap) ? cap : d.cap, timeZone: d.timeZone.trim(), revision: base };
busy = true; conflict = false; line = 'Saving…'; repaint();
let r, a = null;
try { r = await call({ method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }); }
@@ -87,7 +91,7 @@
busy = false;
if (r.ok && a?.route) {
data = { ...data, route: a.route, revision: a.revision, routeMessage: undefined };
draft = fromRoute(a.route);
draft = fromRoute(a.route); base = a.revision;
line = `Saved. Revision ${a.revision}.`;
repaint();
$('triage-route-line')?.focus?.();
+21 -7
View File
@@ -34,6 +34,14 @@ const ACTOR = /^[a-z][a-z0-9-]{0,31}$/;
// The store's zone rule (its knownZone): isDailyModelQuota's zone shape, then Intl.
const knownZone = zone => typeof zone === 'string' && zone !== ''
&& isDailyModelQuota('000000000000', { limit: 0, since: '2000-01-01T00:00:00.000Z', reset: '00:00', timeZone: zone });
// The zone as Intl names it, so "america/chicago" is kept as "America/Chicago". A known zone that
// Intl renames to something the store would not take is kept as typed.
export function canonicalZone(zone) {
try {
const named = new Intl.DateTimeFormat('en-US', { timeZone: zone }).resolvedOptions().timeZone;
return knownZone(named) ? named : zone;
} catch { return zone; }
}
const STATUS = Object.freeze({
'human-required': 403,
@@ -199,12 +207,17 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
if (req.method !== 'GET' && req.method !== 'POST') return refuse('method-not-allowed');
// The proxy-admin gate: the instance owner's own session, never a tester or a granted user.
if (context.owner !== true || !context.session) return refuse('human-required');
// A page's same-origin read carries Fetch Metadata and, when it carries an Origin, this one.
// A browser sends no Origin on a same-origin GET, so a read is held to Sec-Fetch-Site; a write
// is held to both, exactly once each.
const origins = req.headersDistinct.origin ?? [];
if (req.method === 'POST' ? one(req, 'origin') !== context.origin : origins.length > 1 || (origins.length === 1 && origins[0] !== context.origin)) return refuse('cross-origin');
if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse('cross-site');
// A write needs this Console's Origin and same-origin Fetch Metadata, exactly once each. A read
// refuses another site's Origin or Fetch Metadata and lets their absence through, as the packs and
// request reads do: a browser sends no Origin on a same-origin GET, and Chromium sends no
// Fetch Metadata to a LAN http origin (serve.mjs marks only a LAN write).
if (req.method === 'POST') {
if (one(req, 'origin') !== context.origin) return refuse('cross-origin');
if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse('cross-site');
} else {
if (req.headersDistinct.origin && one(req, 'origin') !== context.origin) return refuse('cross-origin');
if (req.headersDistinct['sec-fetch-site'] && !['same-origin', 'none'].includes(one(req, 'sec-fetch-site'))) return refuse('cross-site');
}
if (req.method === 'GET') {
let doc;
try { doc = readRoute(dataRoot); } catch (error) { return refuse(error?.code === 'triage-route-unreadable' ? 'triage-route-unreadable' : 'outcome-unknown'); }
@@ -223,6 +236,7 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
if (!Number.isSafeInteger(cap) || cap < 1) return refuse('triage-cap-invalid');
if (timeZone === undefined || timeZone === null || timeZone === '') return refuse('triage-zone-required');
if (!knownZone(timeZone)) return refuse('triage-zone-unknown');
const zone = canonicalZone(timeZone);
if (!Number.isSafeInteger(revision) || revision < 0) return refuse('invalid-request');
try { checkTriageRoute({ model, harness, catalogue: await catalogue(), harnesses: harnesses() }); }
catch (error) {
@@ -232,7 +246,7 @@ export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedH
const by = ownerActor(context.session);
if (by === null) return refuse('human-required');
try {
const doc = writeRoute(dataRoot, { model, harness, limit: cap, timeZone, by, revision });
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 });
} catch (error) {
const code = typeof error?.code === 'string' && Object.hasOwn(MESSAGES, error.code) && error.code.startsWith('triage-route-') ? error.code : 'outcome-unknown';
@@ -187,6 +187,10 @@ test('a missing or unknown time zone is refused; there is no default', async t =
assert.equal(r.json.error, 'triage-zone-unknown', String(zone));
}
assert.equal(readRoute(f.root), null);
const lower = await f.post({ ...BODY, timeZone: 'america/chicago' });
assert.equal(lower.status, 200, JSON.stringify(lower.json));
assert.equal(readRoute(f.root).cap.timeZone, 'America/Chicago', 'a zone in another case is stored in its canonical spelling');
assert.equal(lower.json.route.timeZone, 'America/Chicago');
});
test('a cap that is not a positive whole number is refused', async t => {
@@ -214,15 +218,19 @@ test('a body with another key, a bad revision, a wrong type or too many bytes is
assert.equal(readRoute(f.root), null);
});
test('both routes refuse a cross-origin request and a missing origin; a write needs both checks exactly once', async t => {
test('both routes refuse a cross-origin request; a read may omit the metadata; a write needs both checks exactly once', async t => {
const f = await devServer(t);
// Read: a foreign Origin, missing Fetch Metadata, cross-site Fetch Metadata.
assert.equal((await f.get({ ...f.read, origin: 'http://evil.example' })).status, 403);
const noMeta = { host: f.read.host };
const bare = await f.get(noMeta);
assert.equal(bare.status, 403);
assert.equal(bare.json.error, 'cross-site');
assert.equal((await f.get({ ...f.read, 'sec-fetch-site': 'cross-site' })).status, 403);
// Read: a foreign Origin or cross-site Fetch Metadata is refused. Missing metadata is the repo GET convention.
const evil = await f.get({ ...f.read, origin: 'http://evil.example' });
assert.equal(evil.status, 403);
assert.match(evil.json.error, /^cross-origin/, 'the serve gate or the handler refuses it');
const bare = await f.get({ host: f.read.host });
assert.equal(bare.status, 200, 'a read with no Origin and no Fetch Metadata is allowed');
assert.equal((await f.get({ ...f.read, 'sec-fetch-site': 'none' })).status, 200, 'a typed address is allowed');
const cross = await f.get({ ...f.read, 'sec-fetch-site': 'cross-site' });
assert.equal(cross.status, 403);
assert.equal(cross.json.error, 'cross-site');
assert.equal((await f.get({ host: f.read.host, 'sec-fetch-site': 'same-site' })).status, 403);
assert.equal((await f.get({ ...f.read, origin: `http://127.0.0.1:${f.port}` })).status, 200, 'a matching Origin on a read is fine');
// Write: missing Origin, foreign Origin, missing or cross-site Fetch Metadata.
const { origin, ...noOrigin } = f.write;
@@ -237,6 +245,20 @@ test('both routes refuse a cross-origin request and a missing origin; a write ne
assert.deepEqual(receipts(f.root), []);
});
test('a LAN dev host reads the route with no Fetch Metadata and writes with its own Origin', async t => {
const f = await devServer(t, { devAllowHosts: ['lanbox'] });
const host = `lanbox:${f.port}`;
const r = await f.get({ host });
assert.equal(r.status, 200);
assert.equal(r.json.route, null);
const w = await f.post(BODY, { host, origin: `http://${host}`, 'content-type': 'application/json' });
assert.equal(w.status, 200, JSON.stringify(w.json));
assert.equal(readRoute(f.root).model, BODY.model);
const foreign = await f.post(BODY, { host, origin: 'http://evil.example', 'content-type': 'application/json' });
assert.equal(foreign.status, 403);
assert.equal(readRoute(f.root).revision, 1);
});
test('the handler holds the same-origin line itself: a doubled Origin or Sec-Fetch-Site is refused', async t => {
const root = mkdtempSync(join(tmpdir(), 'tr-unit-'));
t.after(() => rmSync(root, { recursive: true, force: true }));
@@ -74,6 +74,7 @@ test('Save posts the fields and the read revision once, then shows the stored ro
await fill(b, { zone: ' America/Chicago ' });
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('document.getElementById("triage-route-line")?.textContent==="Saved. Revision 1."');
assert.equal(await b.evaluate('document.activeElement?.id'), 'triage-route-line', 'focus lands on the saved line, not the page body');
assert.deepEqual(await writes(b), [{ method: 'POST', body: { model: 'sonnet', harness: 'claude-code', cap: 150000, timeZone: 'America/Chicago', revision: 0 } }]);
assert.match(await text(b, 'triage-route-stored'), /Stored route: sonnet on claude-code, cap 150,000 tokens a day, reset 00:00 America\/Chicago\. Revision 1/);
assert.equal(await value(b, 'triage-route-cap'), '150000');
@@ -143,6 +144,42 @@ test('a stale revision says so, keeps the fields, and Reload route reads the sto
assert.equal((await writes(b)).at(-1).body.revision, 2, 'the save after a re-read carries the stored revision');
});
test('an untouched page follows the store; typed fields keep the revision they were read at, so a later save is stale', { timeout: 90000 }, async t => {
const stored = (over, revision) => ({ ...unset, route: route({ revision, ...over }), routeMessage: undefined, revision });
const message = 'The Triage route changed since this page read it. Reload the route, then save again.';
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(stored({}, 1), { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 3 } } }) });
const away = async () => {
await b.evaluate('location.hash="#/settings/appearance"');
await wait('!document.getElementById("triage-route")');
await b.evaluate('location.hash="#/settings/triage"');
await wait('document.getElementById("triage-route-cap")');
};
const dot = 'document.querySelector(\'#settings-nav a[href="#/settings/triage"] .settings-dot\') !== null';
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-model")?.value==="sonnet"');
// Saved elsewhere while this page sat untouched: the page shows the new route, with no unsaved mark.
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored({ model: 'glm-flash', cap: 42 }, 2))}`);
await away();
assert.equal(await value(b, 'triage-route-model'), 'glm-flash');
assert.equal(await value(b, 'triage-route-cap'), '42');
assert.match(await text(b, 'triage-route-stored'), /Revision 2/);
assert.equal(await b.evaluate(dot), false);
// Typed at revision 2, then saved elsewhere again: the typed fields stay and the save sends revision 2.
await type(b, 'triage-route-cap', '9000');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored({ model: 'sonnet', cap: 1 }, 3))}`);
await away();
assert.equal(await value(b, 'triage-route-model'), 'glm-flash');
assert.equal(await value(b, 'triage-route-cap'), '9000');
assert.match(await text(b, 'triage-route-stored'), /Revision 3/);
assert.equal(await b.evaluate(dot), true, 'the typed fields are marked unsaved');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
const last = (await writes(b)).at(-1).body;
assert.equal(last.revision, 2, 'the save carries the revision the typed fields were read at, not the newest read');
assert.equal(last.model, 'glm-flash');
assert.equal(last.cap, 9000);
});
test('a second Save while one runs does nothing', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(unset, { 'POST /api/triage/route': { body: { route: route(), revision: 1, note: NOTE } } }) });
await b.navigate(f.base + '/#/settings/triage');