diff --git a/packages/webui/src/cli.mjs b/packages/webui/src/cli.mjs
index 37809f743..5f9b62908 100644
--- a/packages/webui/src/cli.mjs
+++ b/packages/webui/src/cli.mjs
@@ -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 {
diff --git a/packages/webui/src/public/triage-settings.js b/packages/webui/src/public/triage-settings.js
index 383584dfc..30ed5813a 100644
--- a/packages/webui/src/public/triage-settings.js
+++ b/packages/webui/src/public/triage-settings.js
@@ -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 @@
+ ``
+ ``
+ ``
- + `
${conflictButton} ${esc(line)}
`
+ + `${conflictButton} ${esc(line)}
`
+ `${send ? '' : 'This Console is read-only, so the route cannot be saved here.
'}`;
}
function markup() {
const body = data === null
- ? `${esc(readLine || 'The Triage route could not be read.')}
${esc(line)}
`
+ ? `${esc(readLine || 'The Triage route could not be read.')}
${esc(line)}
`
: `${stored()}${form()}${esc(data.note ?? 'Saving a route does not start Triage. The key and the wiring are separate.')}
`;
return `Triage model route
${body}`;
}
@@ -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?.();
diff --git a/packages/webui/src/triage-route-http.mjs b/packages/webui/src/triage-route-http.mjs
index 1a45718d3..4311c6686 100644
--- a/packages/webui/src/triage-route-http.mjs
+++ b/packages/webui/src/triage-route-http.mjs
@@ -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';
diff --git a/packages/webui/tests/triage-route-http.test.mjs b/packages/webui/tests/triage-route-http.test.mjs
index 0e6e32acf..8c527be37 100644
--- a/packages/webui/tests/triage-route-http.test.mjs
+++ b/packages/webui/tests/triage-route-http.test.mjs
@@ -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 }));
diff --git a/packages/webui/tests/triage-settings-browser.test.mjs b/packages/webui/tests/triage-settings-browser.test.mjs
index cf3bf5d45..f971da001 100644
--- a/packages/webui/tests/triage-settings-browser.test.mjs
+++ b/packages/webui/tests/triage-settings-browser.test.mjs
@@ -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');