Merge branch 'main' into flutter/chat-messages

This commit is contained in:
2026-10-21 20:44:02 +01:00
41 changed files with 3618 additions and 222 deletions
+236
View File
@@ -0,0 +1,236 @@
// Real-Chrome acceptance for the Pipelines destination in the normal app.
//
// The bundle is `tool/pipelines_wiring_probe_entry.dart`, i.e. the same
// composition as main; the isolated loopback fixture answers the protocol.
// Both native hosts are exercised by changing the browser platform user agent.
//
// Usage: node tool/pipelines_wiring_probe.mjs <build-dir> <capture-dir>
import { execFile } from 'node:child_process';
import { mkdir, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join, resolve } from 'node:path';
import { promisify } from 'node:util';
import {
connect,
launchChrome,
sleep,
waitForPage,
waitForPort,
} from './pipelines_probe_cdp_lib.mjs';
import {
assertName,
axNodes,
capture,
click,
enableSemantics,
waitFor,
} from './pipelines_probe_cdp_input.mjs';
import { startWiringFixture } from './pipelines_wiring_probe_server.mjs';
const CHROME =
process.env.CHROME_PATH ??
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
const buildDir = resolve(process.argv[2] ?? 'build/wiring_web');
const captureDir = resolve(process.argv[3] ?? 'p1-wire-captures');
const fixture = await startWiringFixture({ root: buildDir, refuse: true });
await mkdir(captureDir, { recursive: true });
const profile = join(tmpdir(), `pipelines-wiring-chrome-${process.pid}`);
const chrome = launchChrome(CHROME, profile, 'about:blank');
let connection;
const log = { url: fixture.url, captures: [], checks: [], states: [] };
const semanticText = () =>
connection.evaluate(`(() => {
const chunks = [];
for (const el of document.querySelectorAll('flt-semantics')) {
const label = el.getAttribute('aria-label');
if (label) chunks.push(label);
if (!el.children.length && el.innerText) chunks.push(el.innerText);
}
if (document.body?.innerText) chunks.push(document.body.innerText);
return [...new Set(chunks)].join('\\n');
})()`);
const assertBody = async (text) => {
const ok = await waitFor(
async () => (await semanticText()).includes(text),
12000,
);
if (!ok) {
throw new Error(`Missing text ${JSON.stringify(text)}:\n${(await semanticText()).slice(0, 3000)}`);
}
log.checks.push(`text: ${text}`);
};
const noBody = async (text) => {
if ((await semanticText()).includes(text)) {
throw new Error(`Unexpected text ${JSON.stringify(text)}`);
}
log.checks.push(`absent: ${text}`);
};
const state = async () => fixture.state();
const waitForState = async (check, label) => {
const value = await waitFor(async () => {
const current = await state();
return check(current) ? current : false;
}, 12000);
if (!value) throw new Error(`Timed out waiting for ${label}: ${JSON.stringify(await state())}`);
log.states.push({ label, ...value });
return value;
};
const ocr = async (path) => {
const { stdout } = await promisify(execFile)('tesseract', [path, 'stdout']);
return stdout;
};
const assertOcr = async (name, text) => {
const read = await ocr(join(captureDir, `${name}.png`));
if (!read.toLowerCase().includes(text.toLowerCase())) {
throw new Error(`OCR of ${name} lacks ${JSON.stringify(text)}:\n${read.slice(0, 3000)}`);
}
log.checks.push(`ocr ${name}: ${text}`);
};
const navigate = async (url) => {
await connection.send('Page.navigate', { url });
await waitFor(
() => connection.evaluate("document.querySelector('flutter-view') !== null"),
20000,
);
await sleep(1200);
await enableSemantics(connection);
};
try {
const devtoolsPort = await waitForPort(join(profile, 'DevToolsActivePort'));
const target = await waitForPage(devtoolsPort);
connection = await connect(target.webSocketDebuggerUrl);
await connection.send('Page.enable');
await connection.send('Runtime.enable');
await connection.send('DOM.enable');
await connection.send('Accessibility.enable');
await connection.send('Emulation.setDeviceMetricsOverride', {
width: 1200,
height: 900,
deviceScaleFactor: 1,
mobile: false,
});
// Material host: Linux platform, light mode.
await connection.send('Emulation.setUserAgentOverride', {
userAgent:
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ' +
'(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
platform: 'Linux x86_64',
});
await navigate(`${fixture.url}/pipelines`);
// The first connection is refused: the honest gate must appear and nothing
// may be requested while there is no socket.
await assertBody('Pipelines server unavailable');
const initial = await state();
if (initial.listPipelines !== 0 || initial.listRuns !== 0 || initial.getPipeline !== 0) {
throw new Error(`Premature requests before connection: ${JSON.stringify(initial)}`);
}
log.checks.push('no requests before first connection');
await capture(connection, captureDir, log, '01-gate-refused-material');
await assertOcr('01-gate-refused-material', 'Pipelines server unavailable');
await fetch(`${fixture.url}/fixture/accept`, { method: 'POST' });
await click(connection, 'Retry');
await assertName(connection, 'Release verification', 'real pipeline row', log);
await assertName(connection, 'Nightly documentation', 'second real row', log);
await noBody('Pipelines — Not implemented');
const loaded = await waitForState(
(value) => value.listPipelines >= 1 && value.listRuns >= 1,
'pipeline list after retry',
);
log.checks.push('shell lists real rows');
await capture(connection, captureDir, log, '02-list-material');
await assertOcr('02-list-material', 'Release verification');
await click(connection, 'Release verification');
await assertName(connection, 'Content hash', 'real pipeline detail', log);
await capture(connection, captureDir, log, '03-detail-material');
await assertOcr('03-detail-material', 'sha256:fixture-3-v3');
await click(connection, 'Source');
await capture(connection, captureDir, log, '04-source-material');
await assertOcr('04-source-material', 'name: Release verification');
await assertOcr('04-source-material', 'type: model');
await click(connection, 'Summary');
await assertName(connection, 'Content hash', 'summary restored', log);
// A drop keeps the open detail visible and, once the socket returns, the
// same list and detail are re-read without remounting or losing selection.
await fetch(`${fixture.url}/fixture/refuse`, { method: 'POST' });
await assertBody('Reconnecting to Pipelines…');
await assertName(connection, 'Content hash', 'detail retained after drop', log);
if ((await connection.evaluate('location.pathname')) !== '/pipelines') {
throw new Error(`Drop moved the route to ${await connection.evaluate('location.pathname')}`);
}
await capture(connection, captureDir, log, '05-drop-detail-retained-material');
await fetch(`${fixture.url}/fixture/accept`, { method: 'POST' });
await click(connection, 'Retry');
await waitForState(
(value) =>
value.listPipelines > loaded.listPipelines &&
value.getPipeline > loaded.getPipeline,
'reconnect reload of list and open detail',
);
await assertName(connection, 'Content hash', 'detail refreshed in place', log);
await noBody('Pipelines server unavailable');
await capture(connection, captureDir, log, '06-reconnect-detail-refreshed-material');
// Cupertino host: macOS platform, dark appearance.
await connection.send('Emulation.setUserAgentOverride', {
userAgent:
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
'(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
platform: 'MacIntel',
});
await connection.send('Emulation.setEmulatedMedia', {
features: [{ name: 'prefers-color-scheme', value: 'dark' }],
});
await navigate(`${fixture.url}/pipelines`);
await assertName(connection, 'Release verification', 'cupertino dark row', log);
await noBody('Pipelines — Not implemented');
await capture(connection, captureDir, log, '07-list-cupertino-dark');
await assertOcr('07-list-cupertino-dark', 'Release verification');
await click(connection, 'Release verification');
await assertName(connection, 'Content hash', 'cupertino dark detail', log);
await capture(connection, captureDir, log, '08-detail-cupertino-dark');
await assertOcr('08-detail-cupertino-dark', 'Content hash');
await click(connection, 'Source');
await capture(connection, captureDir, log, '09-source-cupertino-dark');
await assertOcr('09-source-cupertino-dark', 'name: Release verification');
await assertOcr('09-source-cupertino-dark', 'type: model');
const final = await state();
if (final.connections < 1) throw new Error('No shared socket');
log.checks.push('both native hosts rendered real rows, detail and source');
log.final = final;
} catch (error) {
log.error = String(error?.stack ?? error);
try {
log.failureAx = (await axNodes(connection))
.filter((node) => node.name?.value)
.map((node) => `${node.role?.value}: ${node.name.value}`)
.slice(0, 120);
} catch {
// The browser may already be gone; the error itself is still recorded.
}
process.exitCode = 1;
} finally {
await writeFile(join(captureDir, 'probe.json'), JSON.stringify(log, null, 2));
connection?.close();
chrome.kill('SIGTERM');
await fixture.close();
}
@@ -0,0 +1,8 @@
import 'package:pipelines_app/application/bootstrap.dart';
/// Browser acceptance entrypoint for the Pipelines destination wiring.
///
/// It is exactly the normal application composition; every reply comes from the
/// isolated loopback fixture in `tool/pipelines_wiring_probe_server.mjs`, not
/// from app-side fake data and not from a production server.
void main() => runPipelinesApp();
+394
View File
@@ -0,0 +1,394 @@
import { createHash } from 'node:crypto';
import { createServer } from 'node:http';
import { readFile, realpath, stat } from 'node:fs/promises';
import { extname, join, resolve, sep } from 'node:path';
import { once } from 'node:events';
// Isolated loopback fixture for the Pipelines wiring probe. It serves the
// normal application composition and answers the read-only protocol with
// deterministic data. No production server, database or operator data.
const MIME = {
'.html': 'text/html; charset=utf-8',
'.js': 'text/javascript; charset=utf-8',
'.mjs': 'text/javascript; charset=utf-8',
'.json': 'application/json; charset=utf-8',
'.wasm': 'application/wasm',
'.css': 'text/css; charset=utf-8',
'.png': 'image/png',
'.svg': 'image/svg+xml',
'.ico': 'image/x-icon',
'.ttf': 'font/ttf',
'.otf': 'font/otf',
'.woff': 'font/woff',
'.woff2': 'font/woff2',
};
const PIPELINES = [
{
id: 3,
name: 'Release verification',
version: 3,
stages: 4,
created_at: '2026-09-28T10:12:00',
updated_at: '2026-10-21T09:40:00',
scheduled: true,
schedule_count: 2,
enabled_schedule_count: 1,
},
{
id: 7,
name: 'Nightly documentation',
version: 1,
stages: 2,
created_at: '2026-10-02T18:20:00',
updated_at: '2026-10-20T22:05:00',
scheduled: true,
schedule_count: 1,
enabled_schedule_count: 1,
},
];
const RUNS = [
{
id: 488,
pipeline_id: 3,
status: 'succeeded',
created_at: '2026-10-21T09:30:00',
finished_at: '2026-10-21T09:34:12',
executing: false,
},
{
id: 487,
pipeline_id: 7,
status: 'running',
created_at: '2026-10-21T09:20:00',
finished_at: '',
executing: true,
},
];
const VERSIONS = [
{ version: 1, stages: 2, created_at: '2026-09-28T10:12:00' },
{ version: 2, stages: 3, created_at: '2026-10-08T15:44:00' },
{ version: 3, stages: 4, created_at: '2026-10-21T09:12:00' },
];
const SOURCE = `name: Release verification
stages:
inspect:
type: model
output: report
verify:
type: model
output: verdict
`;
const SOURCE_V2 = `${SOURCE} # selected version 2
`;
function detail(id, requestedVersion) {
const summary = PIPELINES.find((pipeline) => pipeline.id === id) ?? PIPELINES[0];
const versions = id === 3 ? VERSIONS : VERSIONS.slice(0, 1);
const latest = versions[versions.length - 1].version;
const version = requestedVersion > 0 ? requestedVersion : latest;
return {
...summary,
version,
stages: versions.find((row) => row.version === version)?.stages ?? summary.stages,
latest_version: id === 3 ? latest : 1,
version_created_at:
versions.find((row) => row.version === version)?.created_at ?? summary.created_at,
content_hash: `sha256:fixture-${id}-v${version}`,
source: id === 3 && version === 2 ? SOURCE_V2 : SOURCE,
versions,
};
}
function accept(key) {
return createHash('sha1')
.update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
.digest('base64');
}
function frame(opcode, payload) {
const length = payload.length;
let header;
if (length < 126) {
header = Buffer.from([0x80 | opcode, length]);
} else if (length < 65536) {
header = Buffer.alloc(4);
header[0] = 0x80 | opcode;
header[1] = 126;
header.writeUInt16BE(length, 2);
} else {
header = Buffer.alloc(10);
header[0] = 0x80 | opcode;
header[1] = 127;
header.writeBigUInt64BE(BigInt(length), 2);
}
return Buffer.concat([header, payload]);
}
class Connection {
constructor(socket, owner) {
this.socket = socket;
this.owner = owner;
this.buffer = Buffer.alloc(0);
this.fragments = [];
this.fragmentOpcode = 0;
}
push(chunk) {
if (chunk?.length) this.buffer = Buffer.concat([this.buffer, chunk]);
this.parse();
}
parse() {
while (this.buffer.length >= 2) {
const first = this.buffer[0];
const second = this.buffer[1];
const fin = (first & 0x80) !== 0;
const opcode = first & 0x0f;
const masked = (second & 0x80) !== 0;
let length = second & 0x7f;
let offset = 2;
if (length === 126) {
if (this.buffer.length < 4) return;
length = this.buffer.readUInt16BE(2);
offset = 4;
} else if (length === 127) {
if (this.buffer.length < 10) return;
length = Number(this.buffer.readBigUInt64BE(2));
offset = 10;
}
const maskOffset = offset;
if (masked) {
if (this.buffer.length < offset + 4) return;
offset += 4;
}
if (this.buffer.length < offset + length) return;
let payload = Buffer.from(this.buffer.subarray(offset, offset + length));
if (masked) {
const mask = this.buffer.subarray(maskOffset, maskOffset + 4);
for (let index = 0; index < payload.length; index++) {
payload[index] ^= mask[index % 4];
}
}
this.buffer = this.buffer.subarray(offset + length);
this.handleFrame(fin, opcode, payload);
}
}
handleFrame(fin, opcode, payload) {
if (opcode === 0x8) return this.close();
if (opcode === 0x9) return void this.socket.write(frame(0x0a, payload));
if (opcode === 0x0a) return;
if (opcode === 0x0) {
this.fragments.push(payload);
if (fin) {
const data = Buffer.concat(this.fragments);
this.fragments = [];
this.message(this.fragmentOpcode, data);
}
return;
}
if (opcode !== 0x1) return;
if (!fin) {
this.fragmentOpcode = opcode;
this.fragments = [payload];
return;
}
this.message(opcode, payload);
}
message(_opcode, payload) {
let request;
try {
request = JSON.parse(payload.toString('utf8'));
} catch {
return;
}
this.owner.onMessage(this, request);
}
send(value) {
if (!this.socket.destroyed) {
this.socket.write(frame(0x1, Buffer.from(JSON.stringify(value))));
}
}
close() {
if (!this.socket.destroyed) this.socket.end();
}
}
async function staticFile(base, pathname, req, res) {
let file = resolve(base, `.${pathname}`);
if (file !== base && !file.startsWith(base + sep)) {
res.writeHead(403).end();
return;
}
try {
if ((await stat(file)).isDirectory()) file = join(file, 'index.html');
} catch {
if (extname(pathname)) {
res.writeHead(404).end('not found');
return;
}
file = join(base, 'index.html');
}
try {
const body = await readFile(file);
res
.writeHead(200, {
'content-type': MIME[extname(file)] ?? 'application/octet-stream',
'cache-control': 'no-store',
})
.end(req.method === 'HEAD' ? undefined : body);
} catch {
res.writeHead(404).end('not found');
}
}
export async function startWiringFixture({ root, refuse = false }) {
const base = await realpath(root);
const connections = new Set();
const sockets = new Set();
const counts = { subscribed: 0, listPipelines: 0, listRuns: 0, getPipeline: 0, dropped: 0 };
let refusing = refuse;
const dropConnections = () => {
for (const connection of connections) connection.close();
connections.clear();
counts.dropped++;
};
const server = createServer(async (req, res) => {
const pathname = new URL(req.url, 'http://fixture').pathname;
if (pathname === '/fixture/drop' && req.method === 'POST') {
dropConnections();
res.writeHead(200).end('{"ok":true}');
return;
}
if (pathname === '/fixture/refuse' && req.method === 'POST') {
refusing = true;
dropConnections();
res.writeHead(200).end('{"ok":true}');
return;
}
if (pathname === '/fixture/accept' && req.method === 'POST') {
refusing = false;
res.writeHead(200).end('{"ok":true}');
return;
}
if (pathname === '/fixture/state') {
res
.writeHead(200, { 'content-type': 'application/json' })
.end(JSON.stringify({ ...counts, connections: connections.size, refusing }));
return;
}
if (req.method !== 'GET' && req.method !== 'HEAD') {
res.writeHead(405).end();
return;
}
await staticFile(base, pathname, req, res);
});
server.on('upgrade', (req, socket, head) => {
if (refusing) {
socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
return;
}
const url = new URL(req.url, 'http://fixture');
if (
url.pathname !== '/connect' ||
req.headers.upgrade?.toLowerCase() !== 'websocket' ||
!req.headers['sec-websocket-key']
) {
socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
return;
}
socket.write(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${accept(req.headers['sec-websocket-key'])}\r\n\r\n`,
);
const connection = new Connection(socket, {
onMessage: (client, request) => {
switch (request.type) {
case 'subscribe':
counts.subscribed++;
return;
case 'unsubscribe':
return;
case 'list_pipelines':
counts.listPipelines++;
client.send({ id: request.id, type: 'pipelines', pipelines: PIPELINES });
return;
case 'list_runs':
counts.listRuns++;
client.send({ id: request.id, type: 'runs', runs: RUNS });
return;
case 'get_pipeline': {
counts.getPipeline++;
const id = request.pipeline_id;
if (!PIPELINES.some((pipeline) => pipeline.id === id)) {
client.send({
id: request.id,
type: 'error',
error: `Fixture pipeline ${id} is unavailable`,
});
return;
}
client.send({
id: request.id,
type: 'pipeline',
detail: detail(id, request.version),
});
return;
}
case 'ping':
client.send({
id: request.id,
type: 'pong',
build: { version: 'Fixture wiring build' },
time: '2026-10-21T12:00:00Z',
});
return;
default:
client.send({
id: request.id,
type: 'error',
error: `Fixture does not implement ${request.type}`,
});
}
},
});
connections.add(connection);
socket.on('data', (chunk) => connection.push(chunk));
socket.on('close', () => connections.delete(connection));
socket.on('error', () => connections.delete(connection));
connection.push(head);
});
server.listen(0, '127.0.0.1');
await once(server, 'listening');
server.on('connection', (socket) => {
sockets.add(socket);
socket.on('close', () => sockets.delete(socket));
});
return {
server,
url: `http://127.0.0.1:${server.address().port}`,
state: async () => (await fetch(`http://127.0.0.1:${server.address().port}/fixture/state`)).json(),
close: () =>
new Promise((resolveClose) => {
for (const connection of connections) connection.close();
server.close(() => resolveClose());
for (const socket of sockets) socket.destroy();
}),
};
}
+60 -2
View File
@@ -110,7 +110,7 @@ try {
const semanticText = () => evaluate(`(() => {
const chunks = [];
for (const el of document.querySelectorAll('flt-semantics')) {
for (const el of document.querySelectorAll('flt-semantics, [aria-label], [aria-valuetext]')) {
const label = el.getAttribute('aria-label');
if (label) chunks.push(label);
const value = el.getAttribute('aria-valuetext');
@@ -153,7 +153,7 @@ try {
return label === wanted || (${contains} && label.includes(wanted));
});
const interactive = candidates.find((el) =>
['button', 'tab', 'link', 'checkbox', 'menuitem'].includes(el.getAttribute('role')),
['button', 'tab', 'link', 'checkbox', 'radio', 'menuitem'].includes(el.getAttribute('role')),
);
const target = interactive ?? candidates[0];
if (!target) return false;
@@ -377,6 +377,25 @@ try {
if ((await path()) !== '/settings') throw new Error('Settings did not update route');
captures.push(await capture('settings-cupertino-registered-phone'));
await clickText('Runs');
await clickText('Fixture cancel run', { contains: true });
await assertBody('Original prompt');
await clickText('Cancel run');
await assertBody('Cancel run 4?');
captures.push(await capture('cancel-cupertino-confirm'));
await clickText('Keep');
await assertBody('Original prompt');
const kept = await (await fetch(`${fixture.url}/fixture/state`)).json();
if (kept.cancelRequests.length) throw new Error('Keep sent a cancellation');
await clickText('Back', { contains: true });
await clickText('Fixture human run', { contains: true });
captures.push(await capture('decision-cupertino-card'));
await assertBody('Waiting for your decision');
await clickText('Decide');
await assertBody('Please review this recorded checkpoint.');
captures.push(await capture('decision-cupertino-confirm'));
await clickText('Cancel');
// Material host: the same deep link and route must render standard Material
// controls (the Cupertino host was selected by the macOS browser above).
await send(
@@ -408,7 +427,46 @@ try {
}
captures.push(await capture('settings-material-registered-phone'));
await clickText('Runs');
await clickText('Fixture cancel run', { contains: true });
await assertBody('Original prompt');
await clickText('Cancel run');
await assertBody('Cancel run 4?');
captures.push(await capture('cancel-material-confirm'));
await clickText('Cancel run');
await assertBody('canceled');
captures.push(await capture('cancel-material-accepted'));
await clickText('Back to list');
await assertBody('Fixture cancel run');
await assertBody('canceled');
await clickText('Fixture human run', { contains: true });
await assertBody('Waiting for your decision');
captures.push(await capture('decision-material-card'));
await clickText('Decide');
await assertBody('Please review this recorded checkpoint.');
captures.push(await capture('decision-material-confirm'));
const pendingDecision = await (await fetch(`${fixture.url}/fixture/state`)).json();
if (pendingDecision.decisionRequests.length) throw new Error('Opening decision sent a reply');
await clickText('approve', { contains: true });
await clickText('Confirm decision');
await assertBody('succeeded');
if ((await semanticText()).includes('Waiting for your decision')) {
throw new Error('Accepted human decision left the waiting card behind');
}
captures.push(await capture('decision-material-accepted'));
await clickText('Back to list');
await assertBody('Fixture cancel run');
await assertBody('canceled');
const fixtureState = await (await fetch(`${fixture.url}/fixture/state`)).json();
if (JSON.stringify(fixtureState.decisionRequests) !==
JSON.stringify([{ run_id: 5, stage: 'gate', option: 'approve' }])) {
throw new Error('Decision sent the wrong payload or repeated the request');
}
if (JSON.stringify(fixtureState.cancelRequests) !== JSON.stringify([{ run_id: 4 }])) {
throw new Error('Cancel sent the wrong payload or repeated the request');
}
if (fixtureState.subscribed < 2) throw new Error(`App never resubscribed: ${JSON.stringify(fixtureState)}`);
if (fixtureState.listRuns < 2) throw new Error(`App never reloaded: ${JSON.stringify(fixtureState)}`);
if (fixtureState.getRun < 2) throw new Error(`Detail was not rehydrated: ${JSON.stringify(fixtureState)}`);
+51 -4
View File
@@ -45,8 +45,30 @@ const RUNS = [
created_at: '2026-10-21T10:00:00Z',
pipeline_id: 10,
},
{
id: 4, title: 'Fixture cancel run', name: 'fixture-cancel',
status: 'running', executing: true,
created_at: '2026-10-21T09:00:00Z', pipeline_id: 10,
},
{
id: 5, title: 'Fixture human run', name: 'fixture-human',
status: 'waiting', executing: false,
created_at: '2026-10-21T08:00:00Z', pipeline_id: 10,
},
];
function humanDetail(accepted) {
return {
...RUNS.find((run) => run.id === 5),
status: accepted ? 'succeeded' : 'waiting', current_stage: 'gate',
input: { prompt: 'Fixture human decision' },
graph: { stages: [{ key: 'gate', type: 'human', edges: { approve: '#success' } }] },
steps: [{ sequence: 1, stage: 'gate', status: accepted ? 'completed' : 'waiting',
output: { prompt: 'Please review this recorded checkpoint.', options: ['approve'] },
}],
};
}
const LIVE_EVENT = {
type: 'run_event',
run_id: 1,
@@ -57,13 +79,15 @@ const LIVE_EVENT = {
finished_at: '2026-10-21T12:05:00Z',
};
function detail(id, live) {
const status = id === 1 && live ? 'succeeded' : id === 3 ? 'failed' : 'running';
function detail(id, live, canceled = false) {
const status = canceled ? 'canceled'
: id === 1 && live ? 'succeeded' : id === 3 ? 'failed' : 'running';
return {
id,
title: RUNS.find((run) => run.id === id)?.title ?? `Run ${id}`,
name: 'fixture-pipeline',
status,
executing: status === 'running',
input: {
prompt: ' fixture prompt with spaces ',
note: 'input payload',
@@ -260,6 +284,10 @@ export async function startFixture({ root }) {
let dropped = 0;
let listRuns = 0;
let getRun = 0;
const canceled = new Set();
const cancelRequests = [];
let decisionAccepted = false;
const decisionRequests = [];
const dropConnections = () => {
for (const connection of connections) connection.close();
@@ -306,6 +334,8 @@ export async function startFixture({ root }) {
dropped,
listRuns,
getRun,
cancelRequests,
decisionRequests,
}));
return;
}
@@ -355,7 +385,9 @@ export async function startFixture({ root }) {
}
if (request.type === 'list_runs') {
listRuns++;
client.send({ id: request.id, type: 'runs', runs: RUNS, usage: null });
client.send({ id: request.id, type: 'runs', runs: RUNS.map((run) =>
canceled.has(run.id) ? { ...run, status: 'canceled', executing: false }
: run.id === 5 && decisionAccepted ? { ...run, status: 'succeeded' } : run), usage: null });
return;
}
if (request.type === 'get_run') {
@@ -377,7 +409,22 @@ export async function startFixture({ root }) {
});
return;
}
client.send({ id: request.id, type: 'run', run_detail: detail(id, live) });
client.send({ id: request.id, type: 'run', run_detail: id === 5
? humanDetail(decisionAccepted) : detail(id, live, canceled.has(id)) });
return;
}
if (request.type === 'cancel_run' && request.run_id === 4) {
cancelRequests.push({ run_id: request.run_id });
canceled.add(4);
client.send({ id: request.id, type: 'run', run_detail: detail(4, live, true) });
return;
}
if (request.type === 'decide_run' && request.run_id === 5 &&
request.stage === 'gate' && request.option === 'approve') {
decisionRequests.push({ run_id: request.run_id, stage: request.stage,
option: request.option, ...(request.feedback ? { feedback: request.feedback } : {}) });
decisionAccepted = true;
client.send({ id: request.id, type: 'run', run_detail: humanDetail(true) });
return;
}
client.send({