Files
stack/packages/webui/tests/routes-apply-browser.test.mjs

138 lines
11 KiB
JavaScript

// F3: after a route save, Settings > Routing says how the change reaches each saved agent, read
// from the instances: the launcher and a stopped agent take it at their next start, a running
// session keeps its old route until it ends (a thread when it goes idle), and a running agent
// offers "Restart now". Restart now terminates with the reason "route change", waits for the
// session to end and launches it again; a thread is only terminated. Real server under the dev
// local owner, a stub bus, every write gated by the browser's own Origin and recorded in the trail.
import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { browser } from './browser.mjs';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { actionTrail } from '../src/action-trail.mjs';
import { close } from './fixture.mjs';
const REV = 'a'.repeat(64), REV2 = 'b'.repeat(64);
const END = '10000000-0000-4000-8000-0000000000e1', LAUNCH = '10000000-0000-4000-8000-0000000000a1', END2 = '10000000-0000-4000-8000-0000000000e2';
const DEV = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner', name: 'Local operator' };
const route = thinking => ({ harness: 'claude', model: 'opus', thinking, fallback: null });
// A real server with the stub bus, on Settings > Routing. `refusal` closes coder's end request with that code.
async function stage(t, { refusal = null } = {}) {
const root = mkdtempSync(join(tmpdir(), 'f3r-')); t.after(() => rmSync(root, { recursive: true, force: true }));
const entry = (definition, extra) => ({ definition, vars: {}, launched: true, launcher: false, protected: false, kept: false, running: [], alive: [], ...extra });
const instances = {
chief: entry('chief', { launcher: true }),
coder: entry('coder', { running: ['run-1'], alive: ['run-1'] }),
assistant: entry('assistant', { running: ['run-a'], alive: ['run-a'] }),
reviewer: entry('reviewer', { launched: false }),
};
const view = () => structuredClone({ business: 'acme', revision: REV, launch: true, noHire: [], retired: [], instances,
definitions: Object.fromEntries(Object.values(instances).map(e => [e.definition, { services: [], accepted: true }])) });
let routes = { revision: REV, harnesses: ['claude'], models: ['opus'], levels: { claude: ['low', 'high'] },
instances: Object.fromEntries(Object.keys(instances).map(n => [n, route('high')])) };
const asked = [], requests = new Map();
const bus = { messages: async () => ({ messages: [], unread: 0 }), usage: async () => { throw Error('no usage'); }, instances: async () => view(), routes: async () => structuredClone(routes) };
const routesWrite = async args => {
asked.push(['routes.set', args]);
routes = { ...routes, revision: REV2, instances: { ...routes.instances, ...structuredClone(args.routes) } };
return structuredClone(routes);
};
const agentWrite = async (verb, args) => {
asked.push([verb, args]);
if (verb === 'instance.end') {
const id = args.instance === 'coder' ? END : END2;
requests.set(id, { instance: args.instance, action: 'end' });
// The session ends a moment after the request closes, so the page has to wait for it.
setTimeout(() => { instances[args.instance].running = []; instances[args.instance].alive = []; }, 400);
return { request: id, runs: [...instances[args.instance].running], cancelled: [], taken: [] };
}
if (verb === 'instance.launch') { requests.set(LAUNCH, { instance: args.instance, action: 'launch' }); instances[args.instance].running = ['run-2']; return { request: LAUNCH }; }
if (verb === 'instance.request') {
const r = requests.get(args.request);
return { request: args.request, instance: r.instance, action: r.action, state: 'closed', done: { run: r.action === 'launch' ? 'run-2' : null, transaction: null, refusal: r.action === 'end' && r.instance === 'coder' ? refusal : null }, cancelled: null };
}
throw Error(`unexpected ${verb}`);
};
const dir = join(root, 'console');
const web = await startServer({ port: 0, board: 'http://127.0.0.1:9', sso: createDevOwner(), send: async () => ({}), bus, routesWrite, agentWrite,
reads: { settings: () => ({ business: 'acme', release: 'fixture', notifier: {} }) }, trail: actionTrail(dir), log: () => {} });
t.after(() => close(web));
const b = await browser(); t.after(() => b.close());
const wait = (expr, ms = 20000) => b.evaluate(`(async()=>{const end=Date.now()+${ms};for(;;){if(${expr})return true;if(Date.now()>end)throw Error('wait failed: '+${JSON.stringify(expr)});await new Promise(r=>setTimeout(r,30));}})()`);
const cell = (name, key) => `[...document.querySelectorAll('[data-route]')].find(e=>e.dataset.route===${JSON.stringify(JSON.stringify([name, key]))})`;
const items = () => b.evaluate(`[...document.querySelectorAll('.routes-apply li')].map(li=>{const c=li.cloneNode(true);c.querySelector('.agent-restart')?.remove();return c.textContent.trim();})`);
await b.viewport(1440, 900);
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
await wait(`${cell('coder', 'thinking')}&&!${cell('coder', 'thinking')}.disabled`);
assert.equal(await b.evaluate(`!!document.querySelector('.routes-apply')`), false, 'nothing is listed before a save');
for (const name of ['chief', 'coder', 'assistant', 'reviewer']) await b.evaluate(`(()=>{const s=${cell(name, 'thinking')};s.value='low';s.dispatchEvent(new Event('change',{bubbles:true}));return true;})()`);
await b.evaluate(`document.getElementById('routes-form').requestSubmit();true`);
await wait(`document.querySelector('.routes-apply')`);
return { b, wait, asked, items, dir };
}
test('F3 Settings > Routing: a save lists how the change reaches each agent, and Restart now moves a running one', { timeout: 120000 }, async t => {
const { b, wait, asked, items, dir } = await stage(t);
assert.deepEqual(asked, [['routes.set', { revision: REV, routes: { chief: route('low'), coder: route('low'), assistant: route('low'), reviewer: route('low') } }]]);
assert.equal(await b.evaluate(`document.getElementById('routes-receipt').textContent`), 'Routes saved for chief, coder, assistant, reviewer. The next launch of each uses the new route.');
assert.deepEqual(await items(), [
'chief: The launcher. It takes the new route at its next start.',
'coder: Running. Its session keeps the old route until it ends. Restart it to move it now.',
'assistant: Running. Its session keeps the old route until the thread goes idle; the next message after that starts it on the new route. Restart it to move it now.',
'reviewer: Not running. Its next start uses the new route.',
]);
// Only the running agents offer the restart, and the thread is marked as one.
assert.deepEqual(await b.evaluate(`[...document.querySelectorAll('.routes-apply [data-agent-restart]')].map(e=>[e.dataset.agentRestart,e.dataset.agentThread,e.textContent])`),
[['coder', 'no', 'Restart coder now'], ['assistant', 'yes', 'Restart assistant now']]);
// Restart now on a session: terminate with the reason, wait for it to end, then one launch.
await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').click();true`);
await wait(`document.querySelector('[data-agent-restart-status="coder"]')?.textContent==='Restarted coder on the new route (run run-2).'`, 30000);
assert.deepEqual(asked.slice(1).filter(([v]) => v !== 'instance.request'), [['instance.end', { instance: 'coder', reason: 'route change' }], ['instance.launch', { instance: 'coder' }]]);
assert.equal(asked.filter(([v, a]) => v === 'instance.launch' && a.instance === 'coder').length, 1, 'one launch, after the session ended');
// A thread is terminated, not launched: its next message starts it on the new route.
await b.evaluate(`document.querySelector('[data-agent-restart="assistant"]').click();true`);
await wait(`/^Terminated assistant at .+\\. Its next message starts it on the new route\\.$/.test(document.querySelector('[data-agent-restart-status="assistant"]')?.textContent??'')`, 30000);
assert.equal(asked.filter(([v, a]) => v === 'instance.launch' && a.instance === 'assistant').length, 0);
// The trail names the dev owner for the save and each lifecycle write.
const trail = readFileSync(join(dir, 'actions.jsonl'), 'utf8').split('\n').filter(Boolean).map(l => { const { at, ...e } = JSON.parse(l); assert.match(at, /^\d{4}-\d\d-\d\dT/); return e; });
assert.deepEqual(trail.map(e => [e.action, e.by?.provider, e.outcome?.split(' ')[0]]), [
['routes.set', 'local-dev', 'done'], ['instance.end', 'local-dev', 'done'], ['instance.launch', 'local-dev', 'done'], ['instance.end', 'local-dev', 'done'],
]);
assert.deepEqual(trail[0].by, DEV);
await b.viewport(390, 844);
assert.equal(await b.evaluate(`document.documentElement.scrollWidth<=390`), true, 'no sideways scroll at phone width');
});
// SP19 (#1873): the drawer's Restart shares this chain. The route-change flow keeps its reason, its
// unprefixed routes and every line it shows, step by step, and its refusal line.
const WATCH = name => `(()=>{window.__seen=[];const snap=()=>{const s=document.querySelector('[data-agent-restart-status="${name}"]')?.textContent??'';if(s&&s!==window.__seen.at(-1))window.__seen.push(s);};new MutationObserver(snap).observe(document.body,{subtree:true,childList:true,characterData:true});return true;})()`;
test('SP19: Restart now keeps its reason and its words', { timeout: 120000 }, async t => {
const { b, wait, asked } = await stage(t);
const posts = [];
await b.evaluate(`(()=>{const f=window.fetch;window.__urls=[];window.fetch=(u,o)=>{window.__urls.push(String(u));return f(u,o);};return true;})()`);
await b.evaluate(WATCH('coder'));
await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').click();true`);
await wait(`document.querySelector('[data-agent-restart-status="coder"]')?.textContent==='Restarted coder on the new route (run run-2).'`, 30000);
assert.deepEqual(await b.evaluate('window.__seen'), ['Terminating coder…', 'Terminated coder. Waiting for its session to end…', 'Launching coder…', 'Restarted coder on the new route (run run-2).']);
assert.deepEqual(asked.filter(([v]) => v === 'instance.end'), [['instance.end', { instance: 'coder', reason: 'route change' }]]);
posts.push(...(await b.evaluate('window.__urls')).filter(u => /\/api\/agent\/(terminate|launch|regenerate)/.test(u)));
assert.deepEqual(posts, ['/api/agent/terminate', '/api/agent/launch']);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').textContent`), 'Restart coder now');
});
test('SP19: Restart now says when the end is refused, in its own words', { timeout: 120000 }, async t => {
const { b, wait, asked } = await stage(t, { refusal: 'instance-kept' });
await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').click();true`);
await wait(`/It was not restarted/.test(document.querySelector('[data-agent-restart-status="coder"]')?.textContent??'')`, 30000);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart-status="coder"]').textContent`), 'coder: the instance is kept; unkeep it first. It was not restarted.');
assert.equal(asked.filter(([v]) => v === 'instance.launch').length, 0);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').disabled`), false);
});