droboticflow/scripts/fanyu-100-browser-acceptance.mjs
2026-08-31 16:47:46 +08:00

611 lines
27 KiB
JavaScript
Executable File

import fs from "node:fs";
import path from "node:path";
import { chromium } from "playwright";
const apiURL = String(process.env.FANYU_API_URL || "http://120.48.180.80").replace(/\/+$/, "");
const statePath = process.env.FANYU_ACCEPTANCE_STATE_PATH;
const outputDir = process.env.FANYU_ACCEPTANCE_BROWSER_OUTPUT || "/tmp/fanyu-100-browser-acceptance";
if (!statePath) throw new Error("FANYU_ACCEPTANCE_STATE_PATH is required");
const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
const projectId = String(state.projectId || "").trim();
const workflowId = String(state.workflowId || "").trim();
const browserFixture = state.browserFixture;
const reportPath = path.join(outputDir, "browser-acceptance.json");
fs.mkdirSync(outputDir, { recursive: true });
const checks = [];
const screenshots = [];
const diagnostics = [];
let browser;
let fatalError = "";
function requireEnv(name) {
const value = String(process.env[name] || "").trim();
if (!value) throw new Error(`${name} is required`);
return value;
}
function required(value, label) {
const normalized = String(value || "").trim();
if (!normalized) throw new Error(`state.browserFixture.${label} is required`);
return normalized;
}
function record(name, passed, evidence = {}) {
const item = { name, passed: Boolean(passed), evidence };
checks.push(item);
if (!item.passed) throw new Error(`${name} failed: ${JSON.stringify(evidence)}`);
return item;
}
async function runCheck(name, action) {
try {
const evidence = (await action()) || {};
checks.push({ name, passed: true, evidence });
return true;
} catch (error) {
checks.push({ name, passed: false, evidence: { error: error instanceof Error ? error.message : String(error) } });
return false;
}
}
function validateFixtureContract() {
const issues = [];
if (!projectId) issues.push("projectId");
if (!workflowId) issues.push("workflowId");
if (!browserFixture || typeof browserFixture !== "object") {
issues.push("browserFixture");
} else {
for (const stage of ["annotation", "quality", "acceptance"]) {
if (!browserFixture[stage] || typeof browserFixture[stage] !== "object") issues.push(`browserFixture.${stage}`);
}
if (!browserFixture.member || typeof browserFixture.member !== "object") issues.push("browserFixture.member");
const annotation = browserFixture.annotation || {};
const quality = browserFixture.quality || {};
const acceptance = browserFixture.acceptance || {};
const member = browserFixture.member || {};
if (!annotation.captureDirectory) issues.push("browserFixture.annotation.captureDirectory");
if (!annotation.taskId) issues.push("browserFixture.annotation.taskId");
if (!quality.captureDirectory) issues.push("browserFixture.quality.captureDirectory");
if (!quality.taskId) issues.push("browserFixture.quality.taskId");
if (!acceptance.captureDirectory) issues.push("browserFixture.acceptance.captureDirectory");
if (!acceptance.humanItemId) issues.push("browserFixture.acceptance.humanItemId");
if (!member.userId) issues.push("browserFixture.member.userId");
if (!member.email) issues.push("browserFixture.member.email");
if (member.disposable !== true) issues.push("browserFixture.member.disposable=true");
}
if (issues.length) {
throw new Error(
`browser fixture is incomplete (${issues.join(", ")}); refusing to replace real interaction acceptance with a title-only smoke test`,
);
}
}
function watchPage(page, name) {
const state = { name, consoleIssues: [], pageErrors: [], requestFailures: [], serverErrors: [] };
page.on("console", (message) => {
if (["error", "warning"].includes(message.type())) {
state.consoleIssues.push(`${message.type()}: ${message.text()}`);
}
});
page.on("pageerror", (error) => state.pageErrors.push(error.message));
page.on("requestfailed", (request) => {
const failure = request.failure()?.errorText || "failed";
if (failure === "net::ERR_ABORTED") return;
if (new URL(request.url()).origin !== apiURL) return;
state.requestFailures.push(`${request.method()} ${request.url()} ${failure}`);
});
page.on("response", (response) => {
if (response.status() >= 500 && new URL(response.url()).origin === apiURL) {
state.serverErrors.push(`${response.status()} ${response.url()}`);
}
});
diagnostics.push(state);
return state;
}
function assertDiagnosticsHealthy(state, checkpoint) {
const issues = [
...state.consoleIssues,
...state.pageErrors.map((value) => `pageerror: ${value}`),
...state.requestFailures.map((value) => `requestfailed: ${value}`),
...state.serverErrors.map((value) => `server: ${value}`),
];
if (issues.length) throw new Error(`${checkpoint} emitted browser/network errors: ${issues.join(" | ")}`);
return { console: 0, pageErrors: 0, requestFailures: 0, serverErrors: 0 };
}
async function authenticatedContext(emailName, passwordName, allowedRoles, viewport = { width: 1920, height: 1080 }) {
const email = requireEnv(emailName).toLowerCase();
const context = await browser.newContext({ baseURL: apiURL, viewport });
const response = await context.request.post("/api/auth/login", {
data: { email, password: requireEnv(passwordName) },
});
if (!response.ok()) throw new Error(`${emailName} login failed: ${response.status()}`);
const meResponse = await context.request.get("/api/auth/me");
if (!meResponse.ok()) throw new Error(`${emailName} identity lookup failed: ${meResponse.status()}`);
const session = await meResponse.json();
const actualEmail = String(session?.user?.email || "").toLowerCase();
const actualRole = String(session?.user?.role || "");
record(`identity_${emailName.toLowerCase()}`, actualEmail === email && allowedRoles.includes(actualRole), {
expectedEmail: email,
actualEmail,
allowedRoles,
actualRole,
userId: session?.user?.id,
});
return { context, session };
}
async function capture(page, name, fullPage = false) {
const file = path.join(outputDir, `${name}.png`);
await page.screenshot({ path: file, fullPage });
screenshots.push(file);
return file;
}
async function unique(locator, label) {
await locator.waitFor({ state: "visible", timeout: 30_000 });
const count = await locator.count();
if (count !== 1) throw new Error(`${label} expected exactly one element, found ${count}`);
return locator;
}
function annotationURL(route, fixture) {
const params = new URLSearchParams({
projectId,
workflowId,
capture: required(fixture.captureDirectory, `${route}.captureDirectory`),
});
if (fixture.taskId) params.set("taskId", fixture.taskId);
if (fixture.runId) params.set("runId", fixture.runId);
return `/plugins/annotation-qa/workflows/${workflowId}/${route}?${params}`;
}
async function selectPool(page, pool) {
const button = page.getByTestId(`human-task-pool-${pool}`);
if ((await button.count()) !== 1) return;
if ((await button.getAttribute("aria-pressed")) === "true") return;
const responsePromise = page.waitForResponse((response) => {
const url = new URL(response.url());
return url.pathname === "/api/human-items" && url.searchParams.get("pool") === pool;
});
await button.click();
const response = await responsePromise;
if (!response.ok()) throw new Error(`task pool ${pool} failed to load: ${response.status()}`);
}
async function locateFixturePool(page, fixture, { acceptance = false } = {}) {
const selector = acceptance
? `[data-testid="acceptance-human-item"][data-human-item-id="${required(fixture.humanItemId, "acceptance.humanItemId")}"]`
: `[data-testid="annotation-task-card"][data-task-id="${required(fixture.taskId, "taskId")}"]`;
const candidates = [...new Set([fixture.pool, "mine", "available"].filter(Boolean))];
for (const pool of candidates) {
await selectPool(page, pool);
const target = page.locator(selector);
try {
await target.waitFor({ state: "visible", timeout: 10_000 });
return pool;
} catch {
// A resumable fixture can be unclaimed on the first run and already
// claimed by the same role account on a later run.
}
}
throw new Error(`fixture is not visible in task pools ${candidates.join(", ")}`);
}
async function assertHierarchy(page, fixture, { taskRequired = true } = {}) {
const projectSelect = await unique(page.getByLabel("1. 项目", { exact: true }), "project selector");
const workflowSelect = await unique(page.getByLabel("2. 工作流", { exact: true }), "workflow selector");
const captureSelect = await unique(page.getByLabel("3. Capture 子目录", { exact: true }), "Capture selector");
const captureDirectory = required(fixture.captureDirectory, "captureDirectory");
if ((await projectSelect.inputValue()) !== projectId)
throw new Error("project selector does not hold the fixture project");
if ((await workflowSelect.inputValue()) !== workflowId)
throw new Error("workflow selector does not hold the fixture workflow");
if ((await captureSelect.inputValue()) !== captureDirectory)
throw new Error("Capture selector does not hold the fixture directory");
const url = new URL(page.url());
if (url.searchParams.get("projectId") !== projectId || url.searchParams.get("workflowId") !== workflowId) {
throw new Error(`project/workflow URL scope is wrong: ${url}`);
}
if (url.searchParams.get("capture") !== captureDirectory) throw new Error(`Capture URL scope is wrong: ${url}`);
let taskEvidence = {};
if (taskRequired) {
const taskId = required(fixture.taskId, "taskId");
const card = await unique(
page.locator(`[data-testid="annotation-task-card"][data-task-id="${taskId}"]`),
"fixture task card",
);
const displayedCapture = await card.getAttribute("data-capture-directory");
const firstLine =
String(await card.innerText())
.split("\n")
.map((value) => value.trim())
.filter(Boolean)[0] || "";
if (displayedCapture !== captureDirectory || firstLine !== captureDirectory) {
throw new Error(`task card does not lead with Capture (${displayedCapture}; ${firstLine})`);
}
taskEvidence = { taskId, displayedCapture, firstLine };
}
return { projectId, workflowId, captureDirectory, url: page.url(), ...taskEvidence };
}
async function exerciseHierarchyCascade(page, fixture) {
const captureDirectory = required(fixture.captureDirectory, "annotation.captureDirectory");
const taskId = required(fixture.taskId, "annotation.taskId");
await page.goto(`/plugins/annotation-qa/workflows/all/annotate?projectId=${encodeURIComponent(projectId)}`, {
waitUntil: "domcontentloaded",
timeout: 60_000,
});
const projectSelect = await unique(page.getByLabel("1. 项目", { exact: true }), "cascade project selector");
if ((await projectSelect.inputValue()) !== projectId) await projectSelect.selectOption(projectId);
const workflowSelect = await unique(page.getByLabel("2. 工作流", { exact: true }), "cascade workflow selector");
await workflowSelect.selectOption(workflowId, { timeout: 30_000 });
await page.waitForURL((url) => url.searchParams.get("workflowId") === workflowId, { timeout: 30_000 });
const captureSelect = await unique(page.getByLabel("3. Capture 子目录", { exact: true }), "cascade Capture selector");
let captureReady = false;
for (let attempt = 0; attempt < 60; attempt += 1) {
const options = await captureSelect.locator("option").allTextContents();
if (options.includes(captureDirectory)) {
captureReady = true;
break;
}
await page.waitForTimeout(500);
}
if (!captureReady) throw new Error(`Capture option ${captureDirectory} did not load after workflow selection`);
await captureSelect.selectOption(captureDirectory, { timeout: 30_000 });
await page.waitForURL((url) => url.searchParams.get("capture") === captureDirectory, { timeout: 30_000 });
await selectPool(page, "all");
const card = await unique(
page.locator(`[data-testid="annotation-task-card"][data-task-id="${taskId}"]`),
"cascade fixture task card",
);
await card.click();
await page.waitForURL((url) => url.searchParams.get("taskId") === taskId, { timeout: 30_000 });
return assertHierarchy(page, fixture);
}
function rectanglesOverlap(left, right) {
return (
Math.max(0, Math.min(left.right, right.right) - Math.max(left.left, right.left)) > 1 &&
Math.max(0, Math.min(left.bottom, right.bottom) - Math.max(left.top, right.top)) > 1
);
}
async function assertWorkbenchLayout(page, viewport) {
await page.setViewportSize(viewport);
const editor = await unique(page.getByTestId("annotation-workbench-editor"), "annotation editor");
await editor.scrollIntoViewIfNeeded();
const toolbarLocator = await unique(page.getByTestId("sticky-annotation-toolbar"), "annotation toolbar");
await toolbarLocator.scrollIntoViewIfNeeded();
const layout = await page.evaluate(() => {
const rect = (selector) => {
const element = document.querySelector(selector);
if (!element) return null;
const value = element.getBoundingClientRect();
return {
left: value.left,
right: value.right,
top: value.top,
bottom: value.bottom,
width: value.width,
height: value.height,
};
};
const toolbarElement = document.querySelector('[data-testid="sticky-annotation-toolbar"]');
const toolbarRect = toolbarElement?.getBoundingClientRect();
const toolbarHit = toolbarRect
? document.elementFromPoint(toolbarRect.left + toolbarRect.width / 2, toolbarRect.top + toolbarRect.height / 2)
: null;
return {
viewport: { width: window.innerWidth, height: window.innerHeight },
editor: rect('[data-testid="annotation-workbench-editor"]'),
video: rect('[data-testid="annotation-workbench-editor"] video'),
timeline: rect('[data-testid="compact-annotation-timeline"]'),
toolbar: rect('[data-testid="sticky-annotation-toolbar"]'),
actions: rect('[data-testid="annotation-sticky-actions"]'),
navigator: rect('[data-testid="slice-event-navigator"]'),
toolbarUncovered: Boolean(toolbarElement && toolbarHit && toolbarElement.contains(toolbarHit)),
};
});
for (const key of ["editor", "video", "timeline", "toolbar", "actions", "navigator"]) {
if (!layout[key] || layout[key].width <= 0 || layout[key].height <= 0)
throw new Error(`${key} has no rendered box`);
}
if (rectanglesOverlap(layout.toolbar, layout.actions))
throw new Error("annotation toolbar is covered by submit actions");
if (rectanglesOverlap(layout.navigator, layout.actions))
throw new Error("slice navigator is covered by submit actions");
if (layout.toolbar.top < 0 || layout.toolbar.bottom > layout.viewport.height || !layout.toolbarUncovered) {
throw new Error("annotation toolbar is outside the viewport or covered by another layer");
}
const screenshot = await capture(page, `annotator-layout-${viewport.width}x${viewport.height}`);
return { ...layout, screenshot };
}
async function openMembers(page) {
await page.goto(`/project/${projectId}`, { waitUntil: "domcontentloaded", timeout: 60_000 });
const membersTab = await unique(page.getByTestId("project-members-tab"), "members tab");
await membersTab.click();
await unique(page.getByTestId("project-members-panel"), "project members panel");
}
function memberRow(page, userId) {
return page.locator(`[data-testid="project-member-row"][data-user-id="${userId}"]`);
}
async function searchMember(page, email, role = "all") {
await page.getByTestId("project-member-search").fill(email);
await page.getByTestId("project-member-role-filter").selectOption(role);
}
async function ensureDisposableMember(page, fixture) {
const userId = required(fixture.userId, "member.userId");
const email = required(fixture.email, "member.email");
await searchMember(page, email);
if ((await memberRow(page, userId).count()) === 1) return;
await page.getByTestId("project-member-add").click();
await unique(page.getByTestId("project-member-editor"), "member editor");
await page.getByTestId("project-member-user").selectOption(userId);
if (fixture.supplierId) await page.getByTestId("project-member-supplier").selectOption(fixture.supplierId);
const initialRoles = fixture.initialRoles || ["annotator"];
for (const role of ["annotator", "quality_reviewer", "acceptance_reviewer"]) {
await page.getByTestId(`project-member-role-${role}`).setChecked(initialRoles.includes(role));
}
const responsePromise = page.waitForResponse(
(response) =>
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members`),
);
await page.getByTestId("project-member-save").click();
const response = await responsePromise;
if (!response.ok()) throw new Error(`member fixture creation failed: ${response.status()}`);
await searchMember(page, email);
await memberRow(page, userId).waitFor({ state: "visible", timeout: 30_000 });
}
async function exerciseMemberBulkOperations(page, fixture) {
if (fixture.disposable !== true) throw new Error("member fixture must be explicitly disposable");
const userId = required(fixture.userId, "member.userId");
const email = required(fixture.email, "member.email");
const targetRoles = fixture.bulkRoles || ["annotator", "quality_reviewer"];
await ensureDisposableMember(page, fixture);
await searchMember(page, email, "annotator");
let row = await unique(memberRow(page, userId), "disposable member row after search/filter");
const selection = row.getByLabel(`选择成员 ${email}`, { exact: true });
await selection.check();
for (const role of ["annotator", "quality_reviewer", "acceptance_reviewer"]) {
await page.getByTestId(`project-member-bulk-role-${role}`).setChecked(targetRoles.includes(role));
}
const setRolesResponse = page.waitForResponse(
(response) =>
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members/bulk`),
);
await page.getByTestId("project-member-bulk-set-roles").click();
const updated = await setRolesResponse;
if (!updated.ok()) throw new Error(`bulk role update failed: ${updated.status()}`);
await searchMember(page, email, targetRoles[0]);
row = await unique(memberRow(page, userId), "member row after bulk role update");
const renderedRoles = await row
.locator("[data-role]")
.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-role")));
if (targetRoles.some((role) => !renderedRoles.includes(role)) || renderedRoles.length !== targetRoles.length) {
throw new Error(`bulk roles were not rendered exactly: ${JSON.stringify(renderedRoles)}`);
}
await capture(page, "admin-project-members-bulk-roles");
await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 });
const membersTab = await unique(page.getByTestId("project-members-tab"), "members tab after reload");
await membersTab.click();
await searchMember(page, email, targetRoles[0]);
row = await unique(memberRow(page, userId), "persisted member row");
const persistedRoles = await row
.locator("[data-role]")
.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-role")));
if (JSON.stringify([...persistedRoles].sort()) !== JSON.stringify([...targetRoles].sort())) {
throw new Error(`bulk role update did not persist: ${JSON.stringify(persistedRoles)}`);
}
await page.getByTestId("project-member-role-filter").selectOption("all");
row = await unique(memberRow(page, userId), "member row before bulk removal");
await row.getByLabel(`选择成员 ${email}`, { exact: true }).check();
const removeResponse = page.waitForResponse(
(response) =>
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members/bulk`),
);
await page.getByTestId("project-member-bulk-remove").click();
const removed = await removeResponse;
if (!removed.ok()) throw new Error(`bulk member removal failed: ${removed.status()}`);
await memberRow(page, userId).waitFor({ state: "detached", timeout: 30_000 });
await capture(page, "admin-project-members-bulk-removed");
return { userId, email, targetRoles, persistedRoles, removed: true };
}
async function inspectRoleWorkbench({ name, emailName, passwordName, allowedRoles, route, expectedText, fixture }) {
const { context, session } = await authenticatedContext(emailName, passwordName, allowedRoles);
const page = await context.newPage();
const pageDiagnostics = watchPage(page, `${name}-workbench`);
try {
await page.goto(annotationURL(route, fixture), { waitUntil: "domcontentloaded", timeout: 60_000 });
await unique(page.getByRole("link", { name: expectedText, exact: true }), `${name} workbench navigation`);
const pool = await locateFixturePool(page, fixture, { acceptance: name === "acceptance" });
const hierarchy = await assertHierarchy(page, fixture, { taskRequired: name !== "acceptance" });
if (name === "annotator") {
const claim = page.getByText("领取标注任务", { exact: true });
if ((await claim.count()) === 1) {
await claim.click();
await unique(page.getByText("释放任务", { exact: true }), "claimed annotator task");
} else {
await unique(page.getByText("释放任务", { exact: true }), "annotator task already claimed by this user");
}
await unique(page.getByTestId("annotation-workbench-editor"), "annotator workbench editor");
} else if (name === "quality") {
const claim = page.getByText("领取标注审核", { exact: true });
if ((await claim.count()) === 1) {
await claim.click();
await unique(page.getByText("释放任务", { exact: true }), "claimed quality task");
} else {
await unique(page.getByText("释放任务", { exact: true }), "quality task already claimed by this user");
}
await unique(page.getByTestId("materialized-slice-workbench"), "quality materialized slice workbench");
} else {
const humanItemId = required(fixture.humanItemId, "acceptance.humanItemId");
const item = await unique(
page.locator(`[data-testid="acceptance-human-item"][data-human-item-id="${humanItemId}"]`),
"acceptance fixture item",
);
const claim = item.getByText("领取最终验收", { exact: true });
if ((await claim.count()) === 1) {
await claim.click();
await unique(item.getByText("释放任务", { exact: true }), "claimed final acceptance task");
} else {
await unique(item.getByText("释放任务", { exact: true }), "acceptance task already claimed by this user");
}
await unique(item.getByTestId("materialized-slice-workbench"), "acceptance materialized slice workbench");
}
await capture(page, `${name}-workbench-1920x1080`);
return {
session: { id: session.user.id, email: session.user.email, role: session.user.role },
pool,
hierarchy,
diagnostics: assertDiagnosticsHealthy(pageDiagnostics, `${name} workbench`),
};
} finally {
await context.close();
}
}
async function run() {
validateFixtureContract();
record("browser_fixture_contract", true, {
projectId,
workflowId,
annotation: {
captureDirectory: browserFixture.annotation.captureDirectory,
taskId: browserFixture.annotation.taskId,
humanItemId: browserFixture.annotation.humanItemId,
runId: browserFixture.annotation.runId,
},
quality: {
captureDirectory: browserFixture.quality.captureDirectory,
taskId: browserFixture.quality.taskId,
humanItemId: browserFixture.quality.humanItemId,
runId: browserFixture.quality.runId,
},
acceptance: {
captureDirectory: browserFixture.acceptance.captureDirectory,
humanItemId: browserFixture.acceptance.humanItemId,
runId: browserFixture.acceptance.runId,
},
member: {
userId: browserFixture.member.userId,
email: browserFixture.member.email,
supplierId: browserFixture.member.supplierId,
bulkRoles: browserFixture.member.bulkRoles,
disposable: browserFixture.member.disposable,
},
});
browser = await chromium.launch({
headless: true,
executablePath:
process.env.CHROME_EXECUTABLE_PATH || "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
});
const { context: adminContext } = await authenticatedContext(
"DROBOTICFLOW_ACCEPTANCE_EMAIL",
"DROBOTICFLOW_ACCEPTANCE_PASSWORD",
["admin", "organization_admin"],
);
const adminPage = await adminContext.newPage();
const adminDiagnostics = watchPage(adminPage, "admin");
try {
await runCheck("project_member_real_bulk_operations", async () => {
await openMembers(adminPage);
return exerciseMemberBulkOperations(adminPage, browserFixture.member);
});
await runCheck("admin_project_workflow_capture_cascade", async () => {
const hierarchy = await exerciseHierarchyCascade(adminPage, browserFixture.annotation);
await capture(adminPage, "admin-project-workflow-capture");
return hierarchy;
});
await runCheck("annotation_layout_1920_no_overlap", () =>
assertWorkbenchLayout(adminPage, { width: 1920, height: 1080 }),
);
await runCheck("annotation_layout_1366_no_overlap", () =>
assertWorkbenchLayout(adminPage, { width: 1366, height: 768 }),
);
await runCheck("admin_browser_diagnostics", () => assertDiagnosticsHealthy(adminDiagnostics, "admin interactions"));
} finally {
await adminContext.close();
}
const rolePages = [
{
name: "annotator",
emailName: "FANYU_ANNOTATOR_EMAIL",
passwordName: "FANYU_ANNOTATOR_PASSWORD",
allowedRoles: ["member", "annotator", "data_operator"],
route: "annotate",
expectedText: "切分与语义标注",
fixture: browserFixture.annotation,
},
{
name: "quality",
emailName: "FANYU_QUALITY_EMAIL",
passwordName: "FANYU_QUALITY_PASSWORD",
allowedRoles: ["member", "quality_reviewer", "qa_reviewer", "auditor"],
route: "quality",
expectedText: "切分与标注审核",
fixture: browserFixture.quality,
},
{
name: "acceptance",
emailName: "FANYU_ACCEPTANCE_EMAIL",
passwordName: "FANYU_ACCEPTANCE_PASSWORD",
allowedRoles: ["member", "acceptance_reviewer"],
route: "acceptance",
expectedText: "最终验收",
fixture: browserFixture.acceptance,
},
];
for (const rolePage of rolePages) {
await runCheck(`${rolePage.name}_real_fixture_workbench`, () => inspectRoleWorkbench(rolePage));
}
}
try {
await run();
} catch (error) {
fatalError = error instanceof Error ? error.message : String(error);
checks.push({ name: "fatal_browser_acceptance", passed: false, evidence: { error: fatalError } });
} finally {
if (browser) await browser.close();
const report = {
schemaVersion: "droboticflow.fanyu.browser-acceptance/v2",
projectId,
workflowId,
passed: !fatalError && checks.length > 0 && checks.every((item) => item.passed),
checks,
diagnostics,
screenshots,
statePath,
createdAt: new Date().toISOString(),
...(fatalError ? { error: fatalError } : {}),
};
fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
console.log(
JSON.stringify({ passed: report.passed, reportPath, screenshots, error: fatalError || undefined }, null, 2),
);
if (!report.passed) process.exitCode = 1;
}