Files
Agent-Workbench/scripts/verify-request-contract-ui.mjs
T
Agent Workbench Dev e306f40cae
Official contracts and Windows source CI / windows-source (push) Has been cancelled
feat(memory): release Mnemo project bridge and schema2 recovery
2026-11-11 03:03:43 +08:00

247 lines
26 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import http from 'node:http';
import net from 'node:net';
import assert from 'node:assert/strict';
import { randomUUID, createHash } from 'node:crypto';
import { chromium, _electron } from 'playwright';
import { expect } from 'playwright/test';
import { fixture, launchWorkbench, until } from '../tests/helpers.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Store } from '../src/server/store.mjs';
import { HostController } from '../src/core/desktop/host-controller.mjs';
import { desktopLaunchCommand } from './desktop-launch.mjs';
import { projectEnvironment } from '../src/core/process-environment.mjs';
import { modelSnapshot } from '../src/shared/contracts/execution.mjs';
import { credentialHeader } from '../src/shared/contracts/model-request-contract.mjs';
import { openWorkbenchTool } from './ui-navigation.mjs';
const desktop = process.argv.includes('--desktop');
assert.ok(process.argv.slice(2).every(value => value === '--desktop'));
assert.ok(process.env.AGENT_WORKBENCH_QA_APP_ROOT, 'Use an independent candidate build');
const appRoot = fs.realpathSync.native(process.env.AGENT_WORKBENCH_QA_APP_ROOT);
const directory = path.resolve(process.env.AGENT_WORKBENCH_QA_EVIDENCE_ROOT ?? '.qa/m2-request-contract-2026-11-07', (desktop ? 'electron-' : 'web-') + randomUUID());
fs.mkdirSync(directory, { recursive: true }); console.log('EVIDENCE ' + directory);
const disposers = [], t = { after: fn => disposers.push(fn) }, f = fixture(t, { modernDefaults: true });
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
const requests = [], checks = [], screenshots = [], errors = [], externalBlocked = [], contrast = [];
const native = { temperature: 0.7, top_p: 0.8, top_k: 5, thinking: { type: 'adaptive', display: 'summarized' }, output_config: { effort: 'high' }, metadata: { preserve: ['owned', { nested: true }] } };
const legacyAttempt = { id: 'owned-old-request', status: 'unknown', model: 'owned-old', usage: null, legacy_extension: { preserve: ['failed network', 'repeated reads', 'unknown usage'] } };
const raw = model => ({ id: model, context_window: 1000000, max_output_tokens: 128000, capabilities: { text: true, tools: true }, vendor_extension: { complete: ['owned', { preserved: true }] } });
const model = http.createServer(async (request, response) => {
try {
const chunks = []; for await (const chunk of request) chunks.push(chunk);
const body = chunks.length ? JSON.parse(Buffer.concat(chunks)) : null;
requests.push({ method: request.method, route: request.url, body, headers: Object.fromEntries(Object.entries(request.headers).map(([name, value]) => [name, credentialHeader(name) ? '{{credential}}' : value])) });
if (request.method === 'GET') {
response.writeHead(200, { 'Content-Type': 'application/json' });
response.end(JSON.stringify(request.url.includes('pageToken=') ? { data: [raw('claude-sonnet-5-5')] } : { data: [raw('claude-opus-5-5')], nextPageToken: 'owned-page-two' }));
} else if (request.url === '/owned/messages') {
response.writeHead(400, { 'Content-Type': 'application/json', 'anthropic-version': '2026-10-21', 'x-request-id': 'owned-invalid-version' });
response.end(JSON.stringify({ error: { type: 'invalid_request_error', message: 'temperature is removed in 2026-10-21', param: 'temperature' } }));
} else if (request.url === '/owned/responses') {
response.writeHead(200, { 'Content-Type': 'application/json', 'openai-version': '2020-10-01', 'openai-project': 'project-owned', 'x-request-id': 'owned-responses-id' });
response.end(JSON.stringify({ id: 'owned-response', model: body.model, status: 'completed', output: [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'OK' }] }], usage: { input_tokens: 11, output_tokens: 1 } }));
} else if (request.url === '/owned/chat') {
response.writeHead(200, { 'Content-Type': 'application/json', 'openai-organization': 'org-owned', 'x-request-id': 'owned-chat-id' });
response.end(JSON.stringify({ id: 'owned-chat', model: body.model, choices: [{ message: { role: 'assistant', content: 'OK' }, finish_reason: 'stop' }], usage: { prompt_tokens: 11, completion_tokens: 1, total_tokens: 12 } }));
} else { response.writeHead(500); response.end('Unexpected owned route'); }
} catch (cause) { response.writeHead(500); response.end(cause.message); }
});
let host, browser, application, controller, page, window, result, claude, responses, chat, childId, originalMetadata, originalCipher, originalSnapshotMetadata, originalSnapshot, desktopStdout = '', desktopStderr = '';
const center = () => page.getByRole('dialog', { name: '模型中心', exact: true });
const form = () => page.getByRole('form', { name: '编辑模型连接', exact: true });
const card = id => page.locator('.mc-connection[data-connection-id="' + id + '"]');
const settings = () => form().locator('.mc-request-settings');
const field = label => form().getByLabel(label, { exact: true });
const current = async id => (await host.api('/model-center')).connections.find(value => value.id === id);
const mark = name => { checks.push(name); console.log('PASS ' + name); };
async function resize(width, height = 960) {
if (window) { await window.evaluate((win, size) => win.setContentSize(size.width, size.height), { width, height }); await until(() => page.evaluate(w => innerWidth === w, width)); }
else await page.setViewportSize({ width, height });
}
async function open() { await openWorkbenchTool(page, '打开模型中心'); await expect(center()).toBeVisible(); }
async function edit(id) { if (!await center().count()) await open(); await card(id).getByRole('button', { name: '编辑', exact: true }).click(); await expect(form()).toBeVisible(); await settings().locator(':scope > summary').click(); }
async function capture(file) {
if (!window) { await page.screenshot({ path: file, scale: 'css' }); return { method: 'playwright-page' }; }
const captured = await window.evaluate(async win => {
const [width, height] = win.getContentSize(), picture = await win.capturePage({ x: 0, y: 0, width, height }, { stayHidden: true, stayAwake: true });
return { png: picture.toPNG().toString('base64'), empty: picture.isEmpty(), size: picture.getSize(), hidden: !win.isVisible() };
});
assert.equal(captured.empty, false); assert.equal(captured.hidden, true); fs.writeFileSync(file, Buffer.from(captured.png, 'base64'));
return { method: 'electron-native-stay-hidden', size: captured.size };
}
async function shot(name, anchor) {
if (anchor) await anchor.scrollIntoViewIfNeeded();
assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), 'No page overflow');
const file = path.join(directory, name + '.png'), captured = await capture(file);
screenshots.push({ file: path.basename(file), sha256: sha(fs.readFileSync(file)), ...captured });
fs.writeFileSync(path.join(directory, name + '.txt'), await center().innerText(), { flag: 'wx' });
}
async function sampleContrast(locator, label) {
const sampled = await locator.evaluate(element => {
const style = getComputedStyle(element); let ancestor = element, background;
while (ancestor) { const color = getComputedStyle(ancestor).backgroundColor; if (color !== 'rgba(0, 0, 0, 0)' && color !== 'transparent') { background = color; break; } ancestor = ancestor.parentElement; }
return { color: style.color, background, fontSize: style.fontSize };
});
const luminance = value => value.match(/[\d.]+/g).slice(0, 3).map(Number).map(c => c / 255).map(c => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4).reduce((sum, c, i) => sum + c * [0.2126, 0.7152, 0.0722][i], 0);
const a = luminance(sampled.color), b = luminance(sampled.background), ratio = (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
contrast.push({ label, ...sampled, ratio }); assert.ok(ratio >= 4.5, label + ' contrast ' + ratio);
}
async function probe(id, count) {
await card(id).getByRole('button', { name: '验证响应(调用模型)', exact: true }).click();
await until(async () => { const state = await host.api('/model-center'); return state.attemptCount === count + 1 && state.attempts.filter(value => value.connectionId === id).every(value => value.status !== 'running'); }, 30000);
await expect(card(id).getByRole('button', { name: '验证响应(调用模型)', exact: true })).toBeEnabled();
}
try {
await new Promise(resolve => model.listen(0, '127.0.0.1', resolve));
const baseUrl = 'http://127.0.0.1:' + model.address().port + '/v1';
f.store.storage.setMeta('modelAttempts', [legacyAttempt]);
originalMetadata = f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get().value;
const provider = Object.assign(Object.create(Provider.prototype), { apiKey: '' }), hub = provider.modelHub(f.store);
claude = hub.upsert({ name: '自有验证 · Claude 请求契约', model: 'claude-opus-5-5', protocol: 'anthropic-messages', baseUrl, apiKey: 'owned-ui-contract-key-only', persistKey: true, nativeParameters: native,
requestContract: { anthropicVersion: '2023-06-01', anthropicBetas: ['owned-old'], completionPath: '/owned/messages', modelsPath: '/owned/models?catalog=one', headers: { 'anthropic-workspace-id': 'workspace-owned-old' } } });
responses = hub.upsert({ name: '自有验证 · Responses 请求', model: 'gpt-6.1-sol', protocol: 'responses', baseUrl, requiresKey: false,
nativeParameters: { reasoning: { effort: 'high', summary: 'auto' }, metadata: { stable: 'owned' } },
requestContract: { completionPath: '/owned/responses', headers: { 'OpenAI-Project': 'project-owned', 'X-Client-Request-Id': 'owned-client-id' } } });
chat = hub.upsert({ name: '自有验证 · Chat 请求', model: 'gpt-6-sol', protocol: 'chat-completions', baseUrl, requiresKey: false,
nativeParameters: { reasoning_effort: 'none', metadata: { stable: ['owned', { nested: true }] } }, requestContract: { completionPath: '/owned/chat', headers: { 'OpenAI-Organization': 'org-owned' } } });
hub.select({ type: 'connection', id: claude.id });
originalSnapshot = modelSnapshot(hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: claude.id }));
f.store.storage.setMeta('ownedModelSnapshot', originalSnapshot);
originalSnapshotMetadata = f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='ownedModelSnapshot'").get().value;
originalCipher = f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelCredentials'").get().value;
fs.writeFileSync(path.join(directory, 'retention-before.json'), JSON.stringify({ modelAttempts: originalMetadata, modelCredentials: originalCipher, modelSnapshot: originalSnapshotMetadata }, null, 2));
hub.save(); f.store.close();
if (desktop) {
const socket = net.createServer(); await new Promise(resolve => socket.listen(0, '127.0.0.1', resolve)); const port = socket.address().port; await new Promise(resolve => socket.close(resolve));
assert.notEqual(port, 4318); controller = new HostController({ appRoot, dataRoot: f.data, port, nodePath: process.execPath, timeoutMs: 60000 }); await controller.start();
host = { url: controller.url, api: (route, input) => controller.api(route, input === undefined ? {} : { method: 'POST', input }) };
application = await _electron.launch({ ...desktopLaunchCommand(appRoot,
['--app-root', appRoot, '--data-root', f.data, '--node', process.execPath, '--port', String(port), '--hidden-window']), cwd: appRoot, env: projectEnvironment({ AGENT_WORKBENCH_API_KEY: '' }), timeout: 60000 });
application.process().stdout?.on('data', bytes => { desktopStdout += bytes.toString('utf8'); }); application.process().stderr?.on('data', bytes => { desktopStderr += bytes.toString('utf8'); });
page = await application.firstWindow(); window = await application.browserWindow(page);
} else {
host = await launchWorkbench(t, f.data, {}, { appRoot }); assert.notEqual(new URL(host.url).port, '4318');
browser = await chromium.launch({ channel: 'msedge', headless: true }); page = await browser.newPage();
}
page.setDefaultTimeout(15000); page.on('pageerror', cause => errors.push(cause.message));
await page.route('**/*', route => { const url = new URL(route.request().url()); if (url.origin === new URL(host.url).origin || ['data:', 'blob:'].includes(url.protocol)) return route.continue(); externalBlocked.push(url.origin); return route.abort(); });
await resize(1280); await page.goto(host.url); await page.waitForLoadState('networkidle'); await open();
await center().getByRole('button', { name: '手动填写(兼容)', exact: true }).click();
await form().getByLabel('服务品牌').selectOption('Anthropic'); await settings().locator(':scope > summary').click();
await expect(field('API 请求版本')).toHaveValue('2026-10-21'); await expect(field('Messages 鉴权').locator('option:checked')).toContainText('Bearer');
await expect(field('省略版本头')).not.toBeChecked(); await shot('official-default-1280', settings().locator(':scope > summary'));
await form().getByRole('button', { name: '取消', exact: true }).click(); assert.equal(requests.length, 0);
mark('New official Anthropic defaults show the recommended version and Bearer without saving or making an external request');
await edit(claude.id); await expect(field('API 请求版本')).toHaveValue('2023-06-01');
await field('API 请求版本').fill('2026-10-21'); await field('Beta 功能').fill('owned-beta,unknown-beta,owned-beta');
const headers = { 'anthropic-workspace-id': 'workspace-owned-new', 'X-Client-Request-Id': 'owned-long-' + 'x'.repeat(200) };
await field('额外请求头 JSON').fill('{ invalid'); await expect(settings().getByRole('alert')).toBeVisible();
await form().getByRole('button', { name: '保存模型连接', exact: true }).click(); assert.equal((await current(claude.id)).revision, claude.revision);
await expect(field('额外请求头 JSON')).toHaveValue('{ invalid'); assert.equal(await form().evaluate(element => element.checkValidity()), false);
await field('额外请求头 JSON').fill(JSON.stringify(headers, null, 2)); await shot('edited-contract-1280', settings().locator(':scope > summary'));
await form().getByRole('button', { name: '保存模型连接', exact: true }).click(); await expect(form()).toHaveCount(0);
let saved = await current(claude.id); assert.deepEqual(saved.nativeParameters, native); assert.equal(saved.savedCredential.status, 'saved');
assert.equal(saved.requestContract.anthropicVersion, '2026-10-21'); assert.deepEqual(saved.requestContract.anthropicBetas, ['owned-beta', 'unknown-beta', 'owned-beta']); assert.deepEqual(saved.requestContract.headers, headers);
await edit(claude.id); await expect(field('API 请求版本')).toHaveValue('2026-10-21'); await expect(field('模型目录路径')).toHaveValue('/owned/models?catalog=one');
await form().getByRole('button', { name: '取消', exact: true }).click();
mark('Invalid header JSON stays visible and saves nothing; valid version/Beta/non-auth edits persist with native siblings and the original encrypted binding');
await probe(claude.id, 1);
const failure = center().locator('.mc-notice .model-error-details'); await failure.locator(':scope > summary').click();
await expect(failure.getByLabel('上游错误原文')).toContainText('temperature is removed in 2026-10-21');
await failure.locator('.mc-request-details > summary').click(); await expect(failure.getByLabel('实际请求头')).toContainText('{{credential}}');
await expect(failure.getByLabel('实际请求头')).toContainText('2026-10-21'); await expect(failure.getByLabel('实际请求头')).toContainText('owned-beta,unknown-beta,owned-beta');
await shot('upstream-error-1280', failure.getByLabel('实际请求头'));
let sent = requests.filter(value => value.method === 'POST')[0]; assert.equal(sent.route, '/owned/messages');
for (const [name, value] of Object.entries(native)) assert.deepEqual(sent.body[name], value);
assert.equal(sent.headers['anthropic-version'], '2026-10-21'); assert.equal(sent.headers['anthropic-workspace-id'], 'workspace-owned-new'); assert.equal(sent.body.max_tokens, 128000);
assert.doesNotMatch(await failure.innerText(), /owned-ui-contract-key-only/); assert.equal(requests.filter(value => value.method === 'POST').length, 1);
mark('One actual owned 400 keeps the original sampling parameters, upstream text, request version/Beta and credential references without replay');
await probe(responses.id, 2); await probe(chat.id, 3);
const posts = requests.filter(value => value.method === 'POST'); assert.equal(posts.length, 3);
assert.equal(posts[1].route, '/owned/responses'); assert.equal(posts[1].headers['openai-project'], 'project-owned'); assert.equal(posts[1].headers['anthropic-version'], undefined);
assert.equal(posts[2].route, '/owned/chat'); assert.equal(posts[2].headers['openai-organization'], 'org-owned'); assert.equal(posts[2].headers['openai-project'], undefined);
assert.deepEqual(posts[1].body.reasoning, responses.nativeParameters.reasoning); assert.deepEqual(posts[2].body.metadata, chat.nativeParameters.metadata);
assert.equal(Object.hasOwn(posts[1].body, 'max_output_tokens'), false); assert.equal(Object.hasOwn(posts[2].body, 'max_tokens'), false);
mark('Responses and Chat send separate paths and headers on actual owned wires; nested native parameters and optional-output omission remain');
await card(claude.id).getByRole('button', { name: '获取同源模型', exact: true }).click();
const catalog = center().getByRole('region', { name: '上游模型目录', exact: true });
await catalog.getByLabel('目录上游连接').selectOption(''); await catalog.locator('.mc-request-settings > summary').click();
await catalog.getByLabel('上游名称').fill('自有新上游草稿'); await catalog.getByLabel('目录接口根地址').fill((await current(claude.id)).baseUrl);
await catalog.getByLabel('目录 API Key').fill('owned-draft-contract-key'); await expect(catalog.getByRole('button', { name: '获取上游模型', exact: true })).toBeEnabled();
await catalog.getByLabel('额外请求头 JSON').fill('{ invalid');
await expect(catalog.getByRole('button', { name: '获取上游模型', exact: true })).toBeDisabled(); await expect(catalog.getByLabel('额外请求头 JSON')).toHaveValue('{ invalid');
await catalog.getByLabel('目录上游连接').selectOption(claude.id); await expect(catalog.getByRole('button', { name: '获取上游模型', exact: true })).toBeEnabled();
await catalog.getByRole('button', { name: '获取上游模型', exact: true }).click();
await expect(catalog.getByLabel('选择模型 claude-sonnet-5-5', { exact: true })).toBeVisible();
await catalog.getByLabel('选择模型 claude-opus-5-5', { exact: true }).check(); await catalog.getByLabel('选择模型 claude-sonnet-5-5', { exact: true }).check();
await catalog.getByRole('button', { name: '保存所选 2 个模型', exact: true }).click(); await expect(catalog).toContainText('已新增 1 个模型,沿用 1 个已有模型');
const state = await host.api('/model-center'), child = state.connections.find(value => value.model === 'claude-sonnet-5-5'); childId = child.id;
saved = state.connections.find(value => value.id === claude.id); assert.deepEqual(child.requestContract, saved.requestContract); assert.equal(child.credentialSource.connectionId, claude.id); assert.equal(child.hasKey, true);
const gets = requests.filter(value => value.method === 'GET'); assert.equal(gets.length, 2);
assert.ok(gets.every(value => value.route.startsWith('/owned/models?catalog=one') && value.headers['anthropic-version'] === '2026-10-21' && value.headers['anthropic-workspace-id'] === 'workspace-owned-new'));
assert.equal(saved.upstreamModel.requestBinding.credentialRevision, saved.credentialRevision); assert.deepEqual(saved.nativeParameters, native);
await catalog.getByRole('button', { name: '关闭目录', exact: true }).click();
mark('Invalid new-source headers cannot send stale settings; switching to a saved source fetches all same-origin pages and shares its contract and credential');
await center().getByRole('button', { name: '请求账本', exact: true }).click();
const ledger = center().getByRole('region', { name: '完整请求账本', exact: true }); await expect(ledger).toContainText('4 条已保存');
const responseEntry = ledger.locator('article').filter({ has: page.getByText('gpt-6.1-sol', { exact: true }) });
await responseEntry.locator('.mc-request-details > summary').first().click(); await expect(responseEntry).toContainText('响应 openai-version 2020-10-01');
await expect(responseEntry.getByLabel('实际请求头')).toContainText('project-owned'); await shot('request-ledger-1280', responseEntry.locator('.mc-request-details'));
const oldEntry = ledger.locator('article').filter({ has: page.getByText('owned-old', { exact: true }) }); await expect(oldEntry).toContainText('用量未知');
assert.equal(await oldEntry.locator('.mc-request-details').count(), 0); assert.doesNotMatch(await ledger.innerText(), /owned-ui-contract-key-only/);
await resize(390, 844); await shot('request-ledger-390', responseEntry.locator('.mc-request-details'));
mark('The complete ledger shows actual request and response versions and header fingerprints; original unknown records receive no invented metadata');
for (const [palette, name] of [['green', '深青绿'], ['blue', '雾蓝'], ['purple', '鸢尾紫']]) {
await page.keyboard.press('Escape'); await page.getByRole('button', { name: '外观', exact: true }).click();
await page.getByRole('dialog', { name: '外观', exact: true }).getByRole('radio', { name, exact: true }).check(); await page.keyboard.press('Escape');
await open(); await center().getByRole('button', { name: '模型连接', exact: true }).click(); await edit(claude.id);
await expect(field('API 请求版本')).toHaveValue('2026-10-21');
await sampleContrast(settings().locator(':scope > summary'), palette + ' request summary'); await sampleContrast(settings().locator('.mc-help').first(), palette + ' request help');
await sampleContrast(field('API 请求版本'), palette + ' version input'); await shot('request-' + palette + '-390', field('额外请求头 JSON'));
await form().getByRole('button', { name: '取消', exact: true }).click();
}
mark('The existing three palettes keep version/header settings readable at 390px with measured text contrast and no page overflow');
const finalCenter = await host.api('/model-center'); assert.equal(finalCenter.attemptCount, 4); assert.deepEqual(finalCenter.attempts.find(value => value.id === legacyAttempt.id), legacyAttempt);
assert.deepEqual(errors, []); assert.deepEqual(externalBlocked, []); fs.writeFileSync(path.join(directory, 'center-final.json'), JSON.stringify(finalCenter, null, 2));
if (application) { await application.close(); application = null; } if (browser) { await browser.close(); browser = null; }
if (controller) { await controller.stop(); controller = null; } await host.close?.(); host = null;
host = await launchWorkbench(t, f.data, {}, { appRoot });
const restored = await host.api('/model-center'), restoredClaude = restored.connections.find(value => value.id === claude.id);
assert.equal(restoredClaude.hasKey, true); assert.equal(restoredClaude.savedCredential.status, 'saved'); assert.deepEqual(restoredClaude.requestContract, saved.requestContract); assert.deepEqual(restoredClaude.nativeParameters, native);
assert.equal(restored.connections.find(value => value.id === childId).hasKey, true); assert.equal(restored.attemptCount, 4); assert.equal(requests.filter(value => value.method === 'POST').length, 3);
const restoredHostUrl = host.url; await host.close(); host = null;
const storage = new Store(f.data); try {
const retainedCipher = storage.storage.database.prepare("SELECT value FROM metadata WHERE key='modelCredentials'").get().value;
const retainedMetadata = storage.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get().value;
const retainedSnapshot = storage.storage.database.prepare("SELECT value FROM metadata WHERE key='ownedModelSnapshot'").get().value;
fs.writeFileSync(path.join(directory, 'retention-after.json'), JSON.stringify({ modelAttempts: retainedMetadata, modelCredentials: retainedCipher, modelSnapshot: retainedSnapshot }, null, 2));
assert.equal(retainedCipher, originalCipher); assert.equal(retainedMetadata, originalMetadata); assert.equal(retainedSnapshot, originalSnapshotMetadata);
assert.deepEqual(storage.storage.meta('ownedModelSnapshot'), JSON.parse(originalSnapshotMetadata)); assert.deepEqual(storage.storage.meta('modelAttempts').find(value => value.id === legacyAttempt.id), legacyAttempt);
} finally { storage.close(); }
mark('An independent candidate host restart restores the original DPAPI cipher and shared credentials; original metadata and frozen snapshot bytes remain exact without replay');
result = { success: true, appRoot, actualElectron: desktop, hostUrl: restoredHostUrl, checks, screenshots, contrast, errors, externalBlocked, syntheticRequests: 3, catalogRequests: 2,
originalUnknownAttempts: 1, originalMetadataExact: true, originalMetadataSha256: sha(originalMetadata), originalCipherExact: true, originalCipherSha256: sha(originalCipher), originalSnapshotExact: true, originalSnapshotSha256: sha(originalSnapshotMetadata),
realModelRequests: 0, realCredentialsRead: 0, productionWrites: 0, viewportWidths: [1280, 390] };
} catch (cause) {
if (page) { await capture(path.join(directory, 'failure.png')).catch(() => {}); fs.writeFileSync(path.join(directory, 'failure.txt'), await page.locator('body').innerText().catch(() => '')); }
result = { success: false, appRoot, actualElectron: desktop, checks, screenshots, contrast, errors, externalBlocked, error: cause.stack, syntheticRequests: requests.filter(value => value.method === 'POST').length, catalogRequests: requests.filter(value => value.method === 'GET').length, realModelRequests: 0 };
} finally {
fs.writeFileSync(path.join(directory, 'requests.json'), JSON.stringify(requests, null, 2));
if (application) await application.close(); if (browser) await browser.close();
if (controller && await controller.health()) await controller.stop(); await host?.close?.();
if (model.listening) await new Promise(resolve => { model.closeAllConnections(); model.close(resolve); });
for (const dispose of disposers.reverse()) await dispose();
if (desktop) { fs.writeFileSync(path.join(directory, 'desktop-stdout.txt'), desktopStdout); fs.writeFileSync(path.join(directory, 'desktop-stderr.txt'), desktopStderr); }
fs.writeFileSync(path.join(directory, 'result.json'), JSON.stringify(result, null, 2));
}
console.log(JSON.stringify({ directory, ...result })); if (!result.success) process.exitCode = 1;