266916f92a
- Select mode (bar Select or long-press): per-row checkboxes, per-day
Select all/Deselect all over finished runs only, "N selected" with the
selection size, Delete and Done. Active runs get a disabled checkbox
whose semantics give the reason.
- Native destructive confirmation, then delete_runs {run_ids} (batched by
1000); the nested runs_deleted reply removes deleted rows and reports
"Deleted N runs, freed X" plus refusals verbatim. runs_removed pushes
remove rows and close an open detail; a deleted open run closes too.
Delete run in the row and detail menus.
- size_bytes shown compactly in rows (0/absent = unknown, nothing shown),
updated from run_event frames that carry it; Largest first sort (flat,
unknowns last); the sort choice persists.
- Shared AppListRow gains selectionControl and onLongPress.
- Browser probe tool/runs_delete_probe.mjs; fixture server implements
delete_runs/runs_removed.
230 lines
9.9 KiB
JavaScript
230 lines
9.9 KiB
JavaScript
import { execFile, spawn } from 'node:child_process';
|
|
import { promisify } from 'node:util';
|
|
import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
|
|
import { once } from 'node:events';
|
|
import { tmpdir } from 'node:os';
|
|
import { join, resolve } from 'node:path';
|
|
import { setTimeout as delay } from 'node:timers/promises';
|
|
|
|
import { startFixture } from './runs_probe_server.mjs';
|
|
|
|
// Browser evidence for the Runs list's multi-select, delete and size sort.
|
|
//
|
|
// The normal app composition (`flutter build web`) talks to the isolated
|
|
// loopback fixture in runs_probe_server.mjs, which implements `delete_runs`
|
|
// and broadcasts `runs_removed`. Run from app/:
|
|
// flutter build web
|
|
// node tool/runs_delete_probe.mjs build/web /tmp/runs-delete-evidence
|
|
const root = resolve(process.argv[2] ?? 'build/web');
|
|
const output = resolve(process.argv[3] ?? process.env.OPENCODE_ARTIFACT_DIR ?? 'build/runs-delete-evidence');
|
|
await mkdir(output, { recursive: true });
|
|
|
|
const MB = 1024 * 1024;
|
|
const stamp = (daysAgo, hour) => {
|
|
const now = new Date();
|
|
return new Date(now.getFullYear(), now.getMonth(), now.getDate() - daysAgo, hour).toISOString();
|
|
};
|
|
const run = (id, title, status, daysAgo, hour, size, extra = {}) => ({
|
|
id, title, name: 'nightly-report', pipeline_id: 10, status,
|
|
executing: ['running', 'queued'].includes(status),
|
|
created_at: stamp(daysAgo, hour),
|
|
finished_at: ['running', 'queued', 'waiting'].includes(status) ? undefined : stamp(daysAgo, hour + 1),
|
|
...(size == null ? {} : { size_bytes: size }),
|
|
...extra,
|
|
});
|
|
const runs = [
|
|
run(31, 'Index rebuild', 'running', 0, 0, null),
|
|
run(32, 'Model sweep', 'succeeded', 0, 0, Math.round(1.2 * 1024 * MB)),
|
|
run(33, 'Docs refresh', 'failed', 0, 0, 340 * MB),
|
|
run(34, 'Waiting review', 'waiting', 0, 0, 12 * MB),
|
|
run(21, 'Screenshot capture', 'succeeded', 1, 9, 2600 * MB),
|
|
run(22, 'Old import', 'canceled', 1, 8, null),
|
|
run(11, 'Weekly digest', 'succeeded', 3, 10, 48 * MB),
|
|
];
|
|
|
|
const fixture = await startFixture({ root, runs });
|
|
const profile = await mkdtemp(join(tmpdir(), 'runs-delete-chrome-'));
|
|
const chrome = spawn('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', [
|
|
'--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu',
|
|
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
|
|
], { stdio: ['ignore', 'ignore', 'pipe'] });
|
|
let stderr = '';
|
|
chrome.stderr.on('data', (data) => { stderr += data; });
|
|
|
|
const waitFor = async (fn, label, attempts = 150) => {
|
|
for (let i = 0; i < attempts; i++) {
|
|
const value = await fn();
|
|
if (value) return value;
|
|
await delay(100);
|
|
}
|
|
throw new Error(`Timed out waiting for ${label}`);
|
|
};
|
|
|
|
let ws;
|
|
const captures = [];
|
|
const pageErrors = [];
|
|
try {
|
|
const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1], 'Chrome DevTools');
|
|
ws = new WebSocket(endpoint);
|
|
await once(ws, 'open');
|
|
let id = 0;
|
|
const pending = new Map();
|
|
ws.addEventListener('message', (event) => {
|
|
const message = JSON.parse(event.data);
|
|
if (message.method === 'Runtime.exceptionThrown') {
|
|
pageErrors.push(JSON.stringify(message.params?.exceptionDetails?.text));
|
|
}
|
|
if (message.id && pending.has(message.id)) {
|
|
pending.get(message.id)(message);
|
|
pending.delete(message.id);
|
|
}
|
|
});
|
|
const send = (method, params = {}, sessionId) => new Promise((resolveCall) => {
|
|
const callId = ++id;
|
|
pending.set(callId, resolveCall);
|
|
ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) }));
|
|
});
|
|
const target = (await send('Target.createTarget', { url: 'about:blank' })).result.targetId;
|
|
const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId;
|
|
await send('Page.enable', {}, session);
|
|
await send('Runtime.enable', {}, session);
|
|
const evaluate = async (expression) => {
|
|
const response = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, session);
|
|
if (response.result?.exceptionDetails) throw new Error(JSON.stringify(response.result.exceptionDetails));
|
|
return response.result?.result?.value;
|
|
};
|
|
const labels = () => evaluate(`[...document.querySelectorAll('flt-semantics')]
|
|
.map((el) => (el.getAttribute('aria-label') || (!el.children.length && el.innerText) || '').trim())
|
|
.filter(Boolean)`);
|
|
const expectText = async (text) => {
|
|
try {
|
|
await waitFor(async () => (await labels()).some((label) => label.includes(text)), JSON.stringify(text));
|
|
} catch (error) {
|
|
throw new Error(`${error.message}\nLabels: ${JSON.stringify(await labels())}`);
|
|
}
|
|
};
|
|
const expectAbsent = async (text) => {
|
|
await delay(400);
|
|
if ((await labels()).some((label) => label.includes(text))) {
|
|
throw new Error(`Unexpected ${JSON.stringify(text)}: ${JSON.stringify(await labels())}`);
|
|
}
|
|
};
|
|
const click = async (text, { exact = true } = {}) => {
|
|
let clicked = false;
|
|
for (let attempt = 0; attempt < 30 && !clicked; attempt++) {
|
|
if (attempt) await delay(200);
|
|
clicked = await tryClick(text, exact);
|
|
}
|
|
if (!clicked) await capture(`failed-click`);
|
|
if (!clicked) throw new Error(`Could not click ${JSON.stringify(text)}: ${JSON.stringify(await labels())}`);
|
|
await delay(500);
|
|
};
|
|
const tryClick = async (text, exact) => {
|
|
return evaluate(`(() => {
|
|
const wanted = ${JSON.stringify(text)};
|
|
const nodes = [...document.querySelectorAll('flt-semantics')].filter((el) => {
|
|
const label = (el.getAttribute('aria-label') || el.innerText || '').trim();
|
|
return ${exact} ? label === wanted : label.includes(wanted);
|
|
});
|
|
const target = nodes.find((el) => ['button', 'checkbox', 'menuitem', 'tab'].includes(el.getAttribute('role'))) ?? nodes[0];
|
|
if (!target) return false;
|
|
target.click();
|
|
return true;
|
|
})()`);
|
|
};
|
|
const capture = async (name) => {
|
|
await delay(500);
|
|
const data = (await send('Page.captureScreenshot', { format: 'png' }, session)).result.data;
|
|
const path = join(output, `${name}.png`);
|
|
await writeFile(path, Buffer.from(data, 'base64'));
|
|
captures.push(path);
|
|
};
|
|
// Dialog and bar text is canvas-rendered; OCR reads it from the capture.
|
|
const expectOcr = async (texts) => {
|
|
const path = captures[captures.length - 1];
|
|
// Piped through stdin: some sandboxes deny tesseract direct file reads.
|
|
const ocr = promisify(execFile)('tesseract', ['stdin', 'stdout']);
|
|
ocr.child.stdin.end(await readFile(path));
|
|
const { stdout } = await ocr;
|
|
const read = stdout.replace(/\s+/g, ' ');
|
|
for (const text of texts) {
|
|
if (!read.includes(text)) throw new Error(`OCR of ${path} lacks ${JSON.stringify(text)}:\n${read}`);
|
|
}
|
|
};
|
|
const setSize = async (width, height) => {
|
|
await send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: width < 600 }, session);
|
|
await delay(600);
|
|
};
|
|
|
|
await setSize(560, 900);
|
|
await send('Page.navigate', { url: `${fixture.url}/runs` }, session);
|
|
await waitFor(() => evaluate("Boolean(document.querySelector('flt-semantics-placeholder'))"), 'semantics placeholder');
|
|
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
|
|
await expectText('Model sweep');
|
|
await expectText('1.2 GB');
|
|
await expectText('340 MB');
|
|
|
|
// 560 wide: select mode with Today selected, then the confirmation (kept).
|
|
await click('Select');
|
|
// The bar title (`N selected`) is canvas text; the Delete label carries N.
|
|
await expectText('Delete selected runs');
|
|
await click('Select all Today');
|
|
await expectText('Delete 2 selected runs');
|
|
await capture('runs-select-day-560');
|
|
await expectOcr(['2 selected', 'Deselect all']);
|
|
await click('Delete 2 selected runs');
|
|
await expectText('Cancel');
|
|
await capture('runs-confirm-560');
|
|
await expectOcr(['Delete 2 runs?', 'frees about 1.5 GB', 'undone']);
|
|
await click('Cancel');
|
|
await expectAbsent('Cancel');
|
|
if (fixture.deleteRequests.length) throw new Error('Cancel sent a delete');
|
|
await click('Done');
|
|
|
|
await click('Sort runs: Newest first', { exact: false });
|
|
await click('Largest first');
|
|
await expectText('Screenshot capture');
|
|
await capture('runs-largest-560');
|
|
await expectAbsent('Select all Today');
|
|
await click('Sort runs: Largest first', { exact: false });
|
|
await click('Newest first');
|
|
|
|
// 1100 wide: the same with an open detail, then a confirmed delete.
|
|
await setSize(1100, 800);
|
|
await click('Docs refresh', { exact: false });
|
|
await expectText('Summary');
|
|
await click('Select');
|
|
await click('Select all Today');
|
|
await expectText('Delete 2 selected runs');
|
|
await capture('runs-select-day-1100');
|
|
await expectOcr(['2 selected']);
|
|
await click('Delete 2 selected runs');
|
|
await expectText('Cancel');
|
|
// Checked by eye: OCR misses the dialog over the dimmed two-pane page.
|
|
await capture('runs-confirm-1100');
|
|
await click('Delete');
|
|
await expectText('Dismiss');
|
|
await expectAbsent('Docs refresh');
|
|
await capture('runs-deleted-1100');
|
|
await expectOcr(['Deleted 2 runs, freed 1.5 GB.']);
|
|
const sent = fixture.deleteRequests;
|
|
if (sent.length !== 1 || JSON.stringify(sent[0].run_ids) !== '[32,33]') {
|
|
throw new Error(`Unexpected delete_runs: ${JSON.stringify(sent)}`);
|
|
}
|
|
await click('Sort runs: Newest first', { exact: false });
|
|
await click('Largest first');
|
|
await capture('runs-largest-1100');
|
|
|
|
if (pageErrors.length) throw new Error(`Page exceptions: ${pageErrors.join('\n')}`);
|
|
const manifest = { fixture: 'tool/runs_probe_server.mjs', deleteRequests: sent, captures };
|
|
await writeFile(join(output, 'manifest.json'), JSON.stringify(manifest, null, 2));
|
|
console.log(JSON.stringify(manifest, null, 2));
|
|
} finally {
|
|
ws?.close();
|
|
chrome.kill('SIGTERM');
|
|
await Promise.race([once(chrome, 'exit'), delay(3000)]);
|
|
await fixture.close();
|
|
// Chrome may still be flushing its profile; a leftover temp dir is harmless.
|
|
await rm(profile, { recursive: true, force: true, maxRetries: 5 }).catch(() => {});
|
|
}
|