Files
stack/packages/webui/tests/triage-drawer-browser.test.mjs
jason.woltje 17b972b92d feat(triage): the host holds the daily token cap
Each turn's usage goes to <dataRoot>/triage/usage.jsonl, one line per
usage.end, 0600 and owned by the running user; a link, wrong mode or
owner, or a non-file refuses. The host holds the stored cap through
daily-quota mayLaunch and report before each start and each queued
message, lets a crossing turn finish, drains the queue with a host
line, sums the file again after a restart (a torn line counts as an
unknown turn), and GET /api/triage adds usageToday, cap and resetsAt.
With no route stored the fields say "not set". cli.mjs keeps route
null. (#1873, lane triage-cap)
2026-11-18 14:03:50 -06:00

470 lines
33 KiB
JavaScript

// #1873 triage-drawer: the Console's Triage drawer over GET /api/triage and POST /api/triage/message.
// Only the instance owner sees it: the entry, the drawer and every Triage request exist only when the
// unscoped /api/config says triage: true. The real server serves the routes from a fake Triage host,
// so every answer here crossed the real HTTP boundary. One page stub forces the 403 answer, which the
// browser's own same-origin request cannot produce.
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 { TriageError, NOT_STARTED } from '../src/triage-host.mjs';
import { capMessage, NO_ROUTE_MESSAGE } from '../src/triage-http.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
const waitFor = b => (expression, tries = 200) => b.evaluate(`(async()=>{for(let i=0;i<${tries};i++){if(${expression})return;await new Promise(r=>setTimeout(r,30))}throw Error(${JSON.stringify(expression)})})()`);
const sleep = ms => new Promise(r => setTimeout(r, ms));
const at = minutesAgo => new Date(Date.now() - minutesAgo * 60000).toISOString();
const POLL_MS = 4000;
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 LIST = [{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true }];
const empty = (name) => Promise.resolve(['usage', 'limits'].includes(name) ? {} : []);
const opts = () => ({
bus: { inbox: () => empty('inbox'), agents: () => empty('agents'), 'thread.claims': () => empty('claims'), tasks: () => empty('tasks'), usage: () => empty('usage'), limits: () => empty('limits'), decisions: () => empty('decisions') },
chat: { threads: () => empty('threads'), projects: () => empty('projects') },
});
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: opts });
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: {}, launch: { business: id, revision: 'a'.repeat(64), models: {}, limits: { total: 4 }, instances: {}, usage: { total: 0, providers: {}, models: {} } } }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
bus: { messages: async () => ({ messages: [], unread: 0 }), agents: async () => [], 'thread.claims': async () => [], inbox: async () => [], tasks: async () => [], instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
chat: { projects: async () => [], threads: async () => [] },
};
},
};
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
}
const SNAPSHOT = () => ({
snapshotVersion: 1, at: at(1), console: { state: 'answering', at: at(1) }, proxy: 'not read',
systemConfig: { valid: true, exit: 0, code: null },
organizations: { count: 2, list: [
{ id: 'acme', bus: { state: 'running', lastStart: { ok: true, at: at(60) } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } },
{ id: 'gamma', bus: 'not read', processing: 'not read', config: { valid: false, exit: 2, code: 'org-config-invalid' } },
] },
});
// The fake host. `h` is the state the next read returns; `h.next` is an error the next message throws.
// An error marked `recorded` throws after the owner line and the host's "did not start" line are written,
// as the real host does when the session fails to start.
function fakeHost(over = {}) {
const h = { route: 'set', running: false, lastExit: null, overCapUntil: null, snapshot: SNAPSHOT(), transcript: [], reads: 0, sent: [], next: null, ...over };
let n = 0;
const triage = {
snapshotAt: () => Date.now(),
refresh: async () => null,
state: async () => { h.reads += 1; return { route: h.route, running: h.running, lastExit: h.lastExit, overCapUntil: h.overCapUntil, snapshot: h.snapshot, transcript: h.transcript, ...(Object.hasOwn(h, 'usageToday') ? { usageToday: h.usageToday, cap: h.cap, resetsAt: h.resetsAt } : {}) }; },
message: async text => {
h.sent.push(text);
const e = h.next; h.next = null;
if (e && !e.recorded) throw e;
const m = { id: `owner-${String(++n).padStart(12, '0')}`, at: new Date().toISOString() };
h.transcript = [...h.transcript, { at: m.at, from: 'owner', id: m.id, text }];
if (e) { h.transcript = [...h.transcript, { at: new Date().toISOString(), from: 'host', in_reply_to: m.id, text: NOT_STARTED }]; throw e; }
return m;
},
};
return { h, triage };
}
async function setup(t, { host = fakeHost(), triage = host.triage, send = true, sso = createDevOwner(), viewport = [1440, 900], path = '/#/dashboard', init = null } = {}) {
const { organizations, agentLevels } = await orgFixture();
const server = await startServer({ port: 0, sso, organizations, agentLevels, triage, send: send ? async () => ({}) : null, log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
const requests = [];
await b.call('Network.enable');
b.on('Network.requestWillBeSent', p => { const u = new URL(p.request.url); requests.push(`${p.request.method} ${u.pathname}`); });
if (init) await b.call('Page.addScriptToEvaluateOnNewDocument', { source: init });
const base = `http://127.0.0.1:${server.address().port}`;
await b.navigate(`${base}${path}`);
const wait = waitFor(b);
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.innerText ?? null`);
const click = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)}).click()`);
const triageReads = () => requests.filter(r => r === 'GET /api/triage').length;
return { b, base, wait, text, click, requests, triageReads, h: host.h };
}
// The page focuses its heading when its first render ends (bus.js). Open after that, as a person would, or
// that late focus can land after the drawer's own.
const open = async f => { await f.wait('document.querySelector("#triage-open")'); await f.wait('document.activeElement?.tagName === "H1"', 100).catch(() => {}); await f.click('#triage-open'); await f.wait('["off", "cap", "running", "stopped"].includes(document.querySelector("#triage-drawer #triage-state")?.dataset.kind)'); };
const type = async (f, words) => { await f.b.evaluate('document.querySelector("#triage-text").focus()'); await f.b.call('Input.insertText', { text: words }); };
const sendAndWait = async (f, before) => { await f.click('#triage-send'); await f.wait(`document.querySelector("#triage-send-status").textContent.trim() && document.querySelector("#triage-send-status").textContent !== ${JSON.stringify(before)} && !document.querySelector("#triage-send").disabled`); return f.text('#triage-send-status'); };
test('item 1: a session that is not the instance owner gets no entry, no drawer markup and no Triage request', async t => {
// No Triage host wired: the config never says triage.
{
const f = await setup(t, { triage: null });
await f.wait('document.querySelector("#dashboard-kpis")');
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("#triage-open, #triage-drawer, [id^=triage]")'), null);
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
}
// A Triage host, but a signed-in session that is not the root owner.
{
const owner = createDevOwner(), plain = { ...owner.session(), rootOwner: false };
const f = await setup(t, { sso: { ...owner, session: () => plain } });
await f.wait('document.querySelector("#dashboard-kpis")');
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("[id^=triage]")'), null);
assert.equal(await f.b.evaluate('document.body.innerHTML.includes("Triage")'), false, 'no Triage words in the page');
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
}
});
test('item 1: the owner gets one Triage entry in the top bar on the dashboard and inside an organization; nothing is read until it opens', async t => {
const f = await setup(t, { path: '/#/orgs/acme/organization' });
await f.wait('document.querySelector(".cmd-right #triage-open")');
assert.equal(await f.b.evaluate('document.querySelectorAll("#triage-open").length'), 1);
assert.equal(await f.b.evaluate('document.querySelector("#triage-drawer")'), null, 'no drawer markup before it opens');
await sleep(800);
assert.equal(f.triageReads(), 0, 'no read before it opens');
assert.equal(await f.b.evaluate('document.querySelector("#triage-open").getAttribute("aria-expanded")'), 'false');
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-open").getAttribute("aria-expanded")'), 'true');
// From inside an organization the read is still the system route, never the organization's.
assert.ok(f.triageReads() >= 1);
assert.deepEqual(f.requests.filter(r => /triage/.test(r) && r !== 'GET /api/triage'), []);
assert.ok(f.requests.includes('GET /api/config'), 'the unscoped config read');
// The same entry on the system dashboard.
await f.b.evaluate('location.hash = "#/dashboard"');
await f.wait('location.hash === "#/dashboard" && document.querySelector("#triage-open")');
});
test('item 1: at 390 wide the entry stays visible and one click opens the drawer', async t => {
const f = await setup(t, { viewport: [390, 844] });
await f.wait('document.querySelector("#triage-open")');
const box = await f.b.evaluate('(() => { const r = document.querySelector("#triage-open").getBoundingClientRect(); return { w: r.width, h: r.height, right: r.right, top: r.top }; })()');
assert.ok(box.w > 0 && box.h > 0 && box.right <= 390 && box.top >= 0, JSON.stringify(box));
await open(f);
const d = await f.b.evaluate('(() => { const r = document.querySelector("#triage-drawer").getBoundingClientRect(); return { l: r.left, w: r.width, page: document.documentElement.clientWidth }; })()');
assert.ok(d.l <= 1 && d.w >= d.page - 1, `the drawer takes the whole width: ${JSON.stringify(d)}`);
assert.equal(await f.b.evaluate('document.documentElement.scrollWidth <= 390'), true, 'no sideways scroll');
});
test('item 2 and 3: route not set says so, and the message box is off with the reason', async t => {
const f = await setup(t, { host: fakeHost({ route: 'not set' }) });
await open(f);
assert.match(await f.text('#triage-state'), new RegExp(NO_ROUTE_MESSAGE.slice(0, 40)));
assert.equal(await f.b.evaluate('document.querySelector("#triage-text")?.disabled'), true);
assert.equal(await f.b.evaluate('document.querySelector("#triage-send")?.disabled'), true);
assert.match(await f.text('#triage-send-off'), /no model route is set/i);
});
test('item 2: over cap shows the cap message and the time it takes messages again', async t => {
const until = new Date(Date.now() + 3 * 3600000).toISOString();
const f = await setup(t, { host: fakeHost({ overCapUntil: until }) });
await open(f);
const state = await f.text('#triage-state');
assert.ok(state.includes(capMessage(until)), state);
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(until)})`);
assert.ok(state.includes(`Local time: ${local}.`), state);
assert.match(await f.text('#triage-send-off'), /daily token cap/i);
});
test('item 2: running, last exit, and the health snapshot with "not read" shown as that', async t => {
const host = fakeHost({ running: true });
const f = await setup(t, { host });
await open(f);
assert.match(await f.text('#triage-state'), /^Running/);
const health = await f.text('#triage-health');
assert.match(health, /Console: answering/);
assert.match(health, /Proxy: not read/);
assert.match(health, /System config: valid/);
assert.match(health, /acme: bus running, processing on, config valid/);
assert.match(health, /gamma: bus not read, processing not read, config not valid \(org-config-invalid\)/);
assert.doesNotMatch(health.split('\n').find(l => l.startsWith('gamma')), /healthy|running/);
// The next poll picks up a stopped session and its last exit, and a snapshot that read nothing.
host.h.running = false; host.h.lastExit = { code: 1, signal: null, at: at(2) };
host.h.snapshot = { snapshotVersion: 1, at: at(0), console: { state: 'answering', at: at(0) }, proxy: { initialized: true, installed: true, active: 'active', healthy: true, fence: false }, systemConfig: 'not read', organizations: 'not read' };
await f.wait('/Last exit/.test(document.querySelector("#triage-state").textContent)', 300);
assert.match(await f.text('#triage-state'), /Not running\. Last exit: code 1/);
const after = await f.text('#triage-health');
assert.match(after, /Proxy: healthy/);
assert.match(after, /System config: not read/);
assert.match(after, /Organizations: not read/);
// No snapshot at all.
host.h.snapshot = null;
await f.wait('/Health: not read/.test(document.querySelector("#triage-health").textContent)', 300);
});
test('item 2: the transcript shows owner, Triage and host lines, a reply under its message, and cards as text with no Run button', async t => {
const transcript = [
{ at: at(5), from: 'owner', id: 'owner-000000000001', text: 'Why is gamma down?' },
{ at: at(4), from: 'triage', in_reply_to: 'owner-000000000001', text: 'gamma config is not valid. Restart acme after fixing it.', cards: [{ step: 'org-config-validate', org: 'gamma', command: 'mosaic org config validate gamma' }, { step: 'bus-restart', org: 'acme', command: 'mosaic bus restart acme' }], dropped: 2 },
{ at: at(3), from: 'owner', id: 'owner-000000000002', text: 'And beta?' },
{ at: at(2), from: 'host', in_reply_to: 'owner-000000000002', text: 'Triage stopped before it answered this message. Send it again.' },
];
const f = await setup(t, { host: fakeHost({ running: true, transcript }) });
await open(f);
const items = await f.b.evaluate('[...document.querySelectorAll("#triage-transcript > li")].map(li => ({ from: li.dataset.from, text: li.innerText }))');
assert.deepEqual(items.map(i => i.from), ['owner', 'triage', 'owner', 'host']);
assert.match(items[0].text, /You/); assert.match(items[0].text, /Why is gamma down\?/);
assert.match(items[1].text, /Triage/); assert.match(items[1].text, /Reply to: Why is gamma down\?/);
assert.match(items[1].text, /Step: org-config-validate/); assert.match(items[1].text, /Organization: gamma/);
assert.match(items[1].text, /mosaic org config validate gamma/); assert.match(items[1].text, /mosaic bus restart acme/);
assert.match(items[1].text, /2 cards dropped/);
assert.match(items[3].text, /Console/); assert.match(items[3].text, /Reply to: And beta\?/);
assert.equal(await f.b.evaluate('document.querySelectorAll("#triage-transcript button, #triage-transcript a, #triage-transcript input").length'), 0, 'no Run button or link in a card');
assert.equal(await f.b.evaluate('[...document.querySelectorAll("#triage-drawer button")].some(x => /run/i.test(x.textContent))'), false);
});
test('item 3: each send answer has plain words, a refused send keeps the draft, and an unknown outcome is never resent', async t => {
const host = fakeHost({ running: true });
const until = new Date(Date.now() + 2 * 3600000).toISOString();
// The browser's own request is same-origin, so the 403 comes from a page stub over the native fetch.
const init = `(() => { const f = window.fetch.bind(window); window.fetch = (input, init) => (window.__force403 && input === '/api/triage/message') ? Promise.resolve(new Response('{"error":"read-only"}', { status: 403, headers: { 'content-type': 'application/json' } })) : f(input, init); })();`;
const f = await setup(t, { host, init });
await open(f);
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-text', 'the box has focus when the drawer opens');
let status = '';
const draft = () => f.b.evaluate('document.querySelector("#triage-text").value');
const refused = async (setupNext, pattern, label) => {
await setupNext();
status = await sendAndWait(f, status);
assert.match(status, pattern, label);
assert.equal(await draft(), 'is acme healthy?', `${label}: the draft stays`);
};
await type(f, 'is acme healthy?');
await refused(() => { host.h.next = new TriageError('triage-no-route', 'x'); }, /Not sent.*no model route is set/i, '409');
await refused(() => { const e = new TriageError('triage-over-cap', 'x'); e.until = until; host.h.next = e; }, new RegExp(`Not sent.*daily token cap.*${until.slice(0, 16)}`), '429');
await refused(() => { host.h.next = new TriageError('triage-message-too-long', 'x'); }, /Not sent.*too long/i, '400');
await refused(() => f.b.evaluate('window.__force403 = true'), /Not sent.*read-only/i, '403');
await f.b.evaluate('window.__force403 = false');
const before = host.h.sent.length;
await refused(() => { host.h.next = new Error('lost'); }, /may or may not have arrived/i, '503');
assert.equal(host.h.sent.length, before + 1);
await sleep(POLL_MS + 1500);
assert.equal(host.h.sent.length, before + 1, 'an unknown outcome is not sent again');
status = await sendAndWait(f, status);
assert.match(status, /^Sent/);
assert.equal(await draft(), '', 'a sent message clears the box');
await f.wait('[...document.querySelectorAll("#triage-transcript > li")].some(li => li.dataset.from === "owner" && li.textContent.includes("is acme healthy?"))');
// Ctrl+Enter sends too.
await type(f, 'second');
await f.b.key('Enter', 'Enter', 2);
await f.wait('document.querySelector("#triage-text").value === "" && /^Sent/.test(document.querySelector("#triage-send-status").textContent)');
assert.equal(host.h.sent.at(-1), 'second');
});
test('item 3: a read-only Console shows no message box and says why', async t => {
const f = await setup(t, { send: false });
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text")'), null);
assert.match(await f.text('#triage-send-off'), /read-only/i);
});
test('item 3: a send that reached the conversation but did not start Triage says so, not "Not sent", and keeps the draft', async t => {
const host = fakeHost();
const f = await setup(t, { host });
await open(f);
let status = '';
for (const [code, words] of [['triage-start-failed', /session did not start/i], ['triage-route-invalid', /route's answer is not usable/i]]) {
await f.b.evaluate('document.querySelector("#triage-text").value = ""');
await type(f, `try ${code}`);
const e = new TriageError(code, 'x'); e.recorded = true; host.h.next = e;
status = await sendAndWait(f, status);
assert.doesNotMatch(status, /^Not sent/, code);
assert.match(status, /Not delivered/, code);
assert.match(status, words, code);
assert.match(status, /in the conversation/i, code);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), `try ${code}`, `${code}: the draft stays`);
await f.wait(`document.querySelector("#triage-transcript").textContent.includes(${JSON.stringify(NOT_STARTED)})`, 300);
}
// A directory refusal can come before or after the message is written, so the words cover both.
host.h.next = new TriageError('triage-dir-unsafe', 'x');
status = await sendAndWait(f, status);
assert.match(status, /Not delivered.*not safe to use.*check the conversation/i);
assert.doesNotMatch(status, /did not start/i, 'this one can come while a session runs');
});
test('item 3: a read that turns sending off hides the box and keeps the draft; one that turns it on again shows it', async t => {
const init = `(() => { const f = window.fetch.bind(window); window.fetch = (input, init) => (window.__sendOff && input === '/api/triage') ? f(input, init).then(r => r.json()).then(j => new Response(JSON.stringify({ ...j, send: false }), { status: 200, headers: { 'content-type': 'application/json' } })) : f(input, init); })();`;
const f = await setup(t, { host: fakeHost({ running: true }), init });
await open(f);
await type(f, 'keep me');
await f.b.evaluate('window.__sendOff = true');
await f.wait('/read-only/i.test(document.querySelector("#triage-send-off")?.textContent || "")', 300);
const off = await f.b.evaluate('(() => { const x = document.querySelector("#triage-text"); return x && { value: x.value, hidden: x.hidden, disabled: x.disabled, send: document.querySelector("#triage-send").disabled, shown: x.getClientRects().length > 0 }; })()');
assert.deepEqual(off, { value: 'keep me', hidden: true, disabled: true, send: true, shown: false });
await f.b.evaluate('window.__sendOff = false');
await f.wait('document.querySelector("#triage-text").getClientRects().length > 0', 300);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'keep me');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").disabled'), false);
assert.equal(await f.text('#triage-send-off'), '');
});
test('item 4: polling runs only while the drawer is open and stops on close', async t => {
const f = await setup(t, { host: fakeHost({ running: true }) });
await f.wait('document.querySelector("#triage-open")');
await sleep(1000);
assert.equal(f.triageReads(), 0);
await open(f);
await sleep(POLL_MS * 2 + 1000);
const open2 = f.triageReads();
assert.ok(open2 >= 2, `reads while open: ${open2}`);
await f.click('#triage-drawer .x');
await f.wait('!document.querySelector("#triage-drawer") || document.querySelector("#triage-drawer").hidden');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-open', 'focus goes back to the entry');
const closed = f.triageReads();
await sleep(POLL_MS * 2 + 1000);
assert.equal(f.triageReads(), closed, 'no read after close');
// Escape closes it as well, and reopening reads again.
await open(f);
await f.b.evaluate('document.querySelector("#triage-text").focus()');
await f.b.key('Escape');
await f.wait('!document.querySelector("#triage-drawer") || document.querySelector("#triage-drawer").hidden');
});
test('item 4: a poll keeps the draft and the cursor, and keeps the scroll position when the reader has scrolled up', async t => {
const transcript = Array.from({ length: 40 }, (_, i) => ({ at: at(60 - i), from: i % 2 ? 'triage' : 'owner', ...(i % 2 ? { text: `answer ${i}`, cards: [], dropped: 0 } : { id: `owner-${String(i).padStart(12, '0')}`, text: `question ${i}` }) }));
const host = fakeHost({ running: true, transcript });
const f = await setup(t, { host, viewport: [1440, 700] });
await open(f);
const scroller = 'document.querySelector("#triage-transcript")';
// Opening lands on the newest line.
assert.equal(await f.b.evaluate(`(() => { const s = ${scroller}; return s.scrollHeight - s.scrollTop - s.clientHeight < 4; })()`), true);
await type(f, 'half a thought');
await f.b.evaluate('document.querySelector("#triage-text").setSelectionRange(4, 4)');
await f.b.evaluate(`${scroller}.scrollTop = 120`);
host.h.transcript = [...transcript, { at: at(0), from: 'host', text: 'a new line', in_reply_to: null }];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("a new line")', 300);
assert.equal(await f.b.evaluate(`${scroller}.scrollTop`), 120, 'scrolled up: the position stays');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'half a thought');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-text');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").selectionStart'), 4);
// At the bottom, a new line scrolls into view.
await f.b.evaluate(`(() => { const s = ${scroller}; s.scrollTop = s.scrollHeight; })()`);
host.h.transcript = [...host.h.transcript, { at: at(0), from: 'host', text: 'one more line' }];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("one more line")', 300);
assert.equal(await f.b.evaluate(`(() => { const s = ${scroller}; return s.scrollHeight - s.scrollTop - s.clientHeight < 4; })()`), true);
});
test('item 4: at the 200-line cap the oldest lines drop, and a scrolled-up reader keeps the same lines in view, even with an identical line above', async t => {
const line = i => ({ at: new Date(Date.now() - (300 - i) * 60000).toISOString(), from: 'host', text: `line ${i}` });
const transcript = Array.from({ length: 200 }, (_, i) => line(i));
transcript[4] = transcript[8]; // an identical twin of the line that is first in view
const host = fakeHost({ running: true, transcript });
const f = await setup(t, { host, viewport: [1440, 700] });
await open(f);
const firstInView = `(() => { const s = document.querySelector("#triage-transcript"), top = s.getBoundingClientRect().top; const li = [...s.children].find(n => n.getBoundingClientRect().bottom > top + 1); return { text: li.textContent, second: li.nextElementSibling.textContent, off: Math.round(li.getBoundingClientRect().top - top) }; })()`;
await f.b.evaluate('document.querySelector("#triage-transcript").scrollTop = 600');
const before = await f.b.evaluate(firstInView);
assert.match(before.text, /line 8$/, 'the twin line is the one in view');
host.h.transcript = [...transcript.slice(3), line(200), line(201), line(202)];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("line 202")', 300);
const after = await f.b.evaluate(firstInView);
assert.equal(after.text, before.text, 'the same line is first in view');
assert.equal(after.second, before.second, 'and the same line follows it');
assert.ok(Math.abs(after.off - before.off) <= 1, `at the same place: ${before.off} then ${after.off}`);
});
test('item 5: markup and control characters in every field stay text: no element, no link, no script', async t => {
const BAD = '<img src=x onerror="window.__pwned=1"><a href="https://example.test/x">link</a><b>bold</b><script>window.__pwned=2</script>';
const CTRL = '\u0007\u001b[31m\u202eevil\u200b\u2028\ufeff\u00ad\u2060\u034f\ufe0f\u{E0041}\u{E0100}\u{E0002}\u17b4\ufff0';
const v = s => `${BAD}${CTRL}${s}`;
const snapshot = {
snapshotVersion: 1, at: v('at'), console: { state: v('state'), at: v('cat') },
proxy: { initialized: true, installed: true, active: v('active'), healthy: null, fence: false },
systemConfig: { valid: false, exit: 2, code: v('code') },
organizations: { count: 1, list: [{ id: v('org'), bus: { state: v('bus'), lastStart: { ok: false, at: v('ls') } }, processing: { halted: true, invalid: true }, config: { valid: false, exit: 2, code: v('oc') } }] },
};
const transcript = [
{ at: v('t1'), from: 'owner', id: v('id'), text: v('owner text') },
{ at: v('t2'), from: 'triage', in_reply_to: v('id'), text: v('triage text'), cards: [{ step: v('step'), org: v('corg'), command: v('cmd') }], dropped: v('dropped') },
{ at: v('t3'), from: 'host', in_reply_to: v('nope'), text: v('host text') },
{ at: v('t4'), from: v('from'), text: v('unknown sender') },
];
const host = fakeHost({ running: true, transcript, snapshot, lastExit: { code: v('code'), signal: v('sig'), at: v('lat') }, overCapUntil: v('until') });
const f = await setup(t, { host });
await open(f);
await f.wait('document.querySelector("#triage-transcript > li")');
const out = await f.b.evaluate(`(() => {
const d = document.querySelector('#triage-drawer');
return {
pwned: window.__pwned ?? null,
tags: [...d.querySelectorAll('img, a, b, script, iframe, svg image, [onerror], [href]')].map(e => e.outerHTML),
text: d.textContent,
body: document.body.querySelectorAll('img[src="x"], a[href^="https://example.test"]').length,
};
})()`);
assert.equal(out.pwned, null);
assert.deepEqual(out.tags, []);
assert.equal(out.body, 0);
for (const word of ['owner text', 'triage text', 'host text', 'cmd', 'corg', 'step', 'org', 'oc', 'code', 'active']) assert.ok(out.text.includes(word), `${word} shown as text`);
assert.ok(out.text.includes('<img src=x onerror='), 'the markup reads as its own characters');
// eslint-disable-next-line no-control-regex
assert.doesNotMatch(out.text, /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u180e\u2028\u2029\ufeff\u200b-\u200f\u202a-\u202e\u2066-\u2069\u00ad\u2060-\u2064\u034f\ufe00-\ufe0f\u{E0000}-\u{E007F}\u{E0100}-\u{E01EF}\p{Default_Ignorable_Code_Point}]/u, 'no control, direction, invisible or tag characters reach the page');
await sleep(500);
assert.equal(await f.b.evaluate('window.__pwned ?? null'), null);
});
// #1873 triage-followups: the page focuses its heading when its first render ends. A reader who opened
// the drawer before then keeps focus in the drawer. The page holds GET /api/workspace, which the first
// render waits on, until the drawer has opened and taken focus.
const HOLD_WORKSPACE = `(() => { const f = window.fetch; window.__held = 0; window.fetch = (u, o) => { if (String(u?.url ?? u).includes('/api/workspace') && !window.__go) { window.__held += 1; return new Promise(r => { const t = setInterval(() => { if (window.__go) { clearInterval(t); r(f(u, o)); } }, 20); }); } return f(u, o); }; })()`;
test('triage-followups: a drawer opened before the first render ends keeps focus when the render ends', async t => {
const f = await setup(t, { init: HOLD_WORKSPACE });
await f.wait('document.querySelector("#triage-open") && window.__held > 0');
const heading = () => f.b.evaluate('document.querySelector("#bus-view h1")?.textContent ?? null');
await sleep(300);
assert.equal(await heading(), 'Reading…', 'the first render has not ended');
await f.click('#triage-open');
await f.wait('document.querySelector("#triage-drawer")?.contains(document.activeElement)');
await f.b.evaluate('window.__go = true');
await f.wait('document.querySelector("#bus-view h1")?.textContent === "Dashboard"');
await sleep(400);
assert.equal(await f.b.evaluate('document.querySelector("#triage-drawer").contains(document.activeElement)'), true, `focus stays in the drawer, not on ${await f.b.evaluate('document.activeElement?.tagName')}`);
// Escape still closes it and puts focus back on the entry.
await f.b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 });
await f.wait('document.querySelector("#triage-drawer").hidden');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-open');
});
test('triage-followups: with no drawer open the first render still focuses the heading', async t => {
const f = await setup(t);
await f.wait('document.activeElement?.tagName === "H1"');
});
test('triage-cap: one usage line from the read: not set, the count against the cap with the reset, not read, and markup as text', async t => {
const f = await setup(t, { host: fakeHost({ usageToday: 'not set', cap: 'not set', resetsAt: 'not set' }) });
await open(f);
assert.equal(await f.text('#triage-usage'), 'Daily token cap: not set.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").hidden'), false);
const resetsAt = new Date(Date.now() + 5 * 3600000).toISOString();
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(resetsAt)})`);
Object.assign(f.h, { usageToday: { count: 1234, input: 1200, output: 34, cacheWrite: 0, cacheRead: 0, unknownTurns: 2 }, cap: { limit: 200000, reset: '00:00', timeZone: 'UTC' }, resetsAt });
await f.wait('/^Today:/.test(document.querySelector("#triage-usage").textContent)', 400);
const line = await f.text('#triage-usage');
const [count, limit] = await f.b.evaluate('[(1234).toLocaleString(), (200000).toLocaleString()]');
assert.ok(line.startsWith(`Today: ${count} of ${limit} tokens. Resets at `), line);
assert.ok(line.includes(local), line);
assert.ok(line.endsWith(' 2 turns have no usage reading.'), line);
Object.assign(f.h, { usageToday: 'not read', cap: { limit: 200000, reset: '00:00', timeZone: 'UTC' }, resetsAt: 'not read' });
await f.wait('/not read/.test(document.querySelector("#triage-usage").textContent)', 400);
assert.equal(await f.text('#triage-usage'), "Today's token usage: not read.");
// A count that is not a whole number is not shown as one; markup stays text.
Object.assign(f.h, { usageToday: { count: '<img src=x onerror=alert(1)>', unknownTurns: 0 }, cap: { limit: 1.5 }, resetsAt: '<b>x</b>' });
await f.wait('/^Today: not read/.test(document.querySelector("#triage-usage").textContent)', 400);
assert.equal(await f.text('#triage-usage'), 'Today: not read of not read tokens.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").children.length'), 0);
});
test('triage-cap: a read without the usage fields shows no usage line', async t => {
const f = await setup(t);
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").hidden'), true);
});