Merge branch 'main' into flutter/chat-messages
This commit is contained in:
@@ -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();
|
||||
@@ -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
@@ -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)}`);
|
||||
|
||||
@@ -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({
|
||||
|
||||
Reference in New Issue
Block a user