@resolveio/server-lib 22.3.29 → 22.3.30

package/src/util/ai-runner-artifacts.ts

@@ -1,430 +0,0 @@
-import { createHash } from 'node:crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface ResolveIORunnerEvidenceAttachment {
-	filename: string;
-	path: string;
-	contentType?: string;
-	cid?: string;
-	caption?: string;
-	file_id?: string;
-	key?: string;
-	content_hash?: string;
-	ticket_url?: string;
-	uploaded_to_support_ticket?: boolean;
-	upload_error?: string;
-}
-
-export interface ResolveIORunnerPersistedEvidenceFile {
-	file_id: string;
-	filename: string;
-	key?: string;
-	contentType?: string;
-	caption?: string;
-	content_hash?: string;
-	ticket_url?: string;
-}
-
-export interface ResolveIORunnerEvidenceUploadInput {
-	filename: string;
-	filePath: string;
-	contentType: string;
-	size: number;
-	contentBuffer: Buffer;
-	contentHash: string;
-}
-
-export interface ResolveIORunnerEvidenceUploadResult {
-	file_id?: string;
-	id_file?: string;
-	_id?: string;
-	key?: string;
-	name?: string;
-	filename?: string;
-}
-
-export interface ResolveIORunnerPersistEvidenceOptions {
-	attachments?: ResolveIORunnerEvidenceAttachment[];
-	evidence?: any;
-	job?: any;
-	ticket?: any;
-	ticketUrl?: string;
-	roots?: string[];
-	previousFiles?: any[];
-	existingFileIds?: any[];
-	maxFiles?: number;
-	uploadFile: any;
-}
-
-export interface ResolveIORunnerPersistEvidenceResult {
-	attachments: ResolveIORunnerEvidenceAttachment[];
-	fileIds: string[];
-	files: ResolveIORunnerPersistedEvidenceFile[];
-	errors: string[];
-}
-
-export function inferResolveIORunnerEvidenceContentType(fileName: string): string {
-	const normalized = String(fileName || '').trim().toLowerCase();
-	if (normalized.endsWith('.png')) {
-		return 'image/png';
-	}
-	if (normalized.endsWith('.jpg') || normalized.endsWith('.jpeg')) {
-		return 'image/jpeg';
-	}
-	if (normalized.endsWith('.webp')) {
-		return 'image/webp';
-	}
-	if (normalized.endsWith('.zip')) {
-		return 'application/zip';
-	}
-	if (normalized.endsWith('.json')) {
-		return 'application/json';
-	}
-	if (normalized.endsWith('.txt') || normalized.endsWith('.log')) {
-		return 'text/plain; charset=utf-8';
-	}
-	return 'application/octet-stream';
-}
-
-export function buildResolveIORunnerEvidenceCid(filePath: string): string {
-	const baseName = path.basename(String(filePath || '').trim()) || 'runner-artifact';
-	const normalized = baseName
-		.toLowerCase()
-		.replace(/[^a-z0-9._-]+/g, '-')
-		.replace(/^-+|-+$/g, '')
-		.slice(0, 80) || 'runner-artifact';
-	const digest = createHash('sha1').update(String(filePath || '')).digest('hex').slice(0, 12);
-	return `${normalized}-${digest}@resolveio-runner`;
-}
-
-export function inferResolveIORunnerEvidenceCaption(fileNameOrPath: string): string {
-	const baseName = path.basename(String(fileNameOrPath || '').trim()).replace(/\.[a-z0-9]+$/i, '');
-	const normalized = baseName
-		.toLowerCase()
-		.replace(/[_-]+/g, ' ')
-		.replace(/\b\d{4,}\b/g, '')
-		.replace(/\s+/g, ' ')
-		.trim();
-	if (!normalized) {
-		return 'QA screenshot captured during validation.';
-	}
-	if (/\bbefore\b/.test(normalized)) {
-		return 'Before: the tested page is loaded at the start of the workflow.';
-	}
-	if (/\bready\b/.test(normalized) && /\bimport\b/.test(normalized)) {
-		return 'Ready to import: the uploaded data was accepted and is displayed for review before submission.';
-	}
-	if (/\bsubmitted\b|\bresult\b|\bafter\b|\bcomplete\b|\bsuccess\b|\bverified\b/.test(normalized)) {
-		return 'After submission: the workflow completed and the result confirms the change worked.';
-	}
-	if (/\bdialog\b|\bmodal\b|\bpopup\b/.test(normalized)) {
-		return 'Dialog: the tested prompt or modal is shown in the expected state.';
-	}
-	if (/\bmobile\b/.test(normalized)) {
-		return 'Mobile view: the tested workflow is shown at the mobile viewport.';
-	}
-	if (/\bdesktop\b|\bwide\b/.test(normalized)) {
-		return 'Desktop view: the tested workflow is shown at a full-width desktop viewport.';
-	}
-	return baseName
-		.replace(/[_-]+/g, ' ')
-		.replace(/\b\w/g, (letter) => letter.toUpperCase())
-		.slice(0, 180);
-}
-
-export function normalizeResolveIORunnerPersistedEvidenceFiles(value: any): ResolveIORunnerPersistedEvidenceFile[] {
-	if (!Array.isArray(value)) {
-		return [];
-	}
-	return value
-		.map((item): ResolveIORunnerPersistedEvidenceFile | null => {
-			const fileId = String(item?.file_id || item?.id_file || item?._id || '').trim();
-			if (!fileId) {
-				return null;
-			}
-			return {
-				file_id: fileId,
-				filename: String(item?.filename || item?.name || '').trim(),
-				key: String(item?.key || '').trim() || undefined,
-				contentType: String(item?.contentType || item?.content_type || '').trim() || undefined,
-				caption: String(item?.caption || '').trim() || undefined,
-				content_hash: String(item?.content_hash || item?.hash || '').trim() || undefined,
-				ticket_url: String(item?.ticket_url || '').trim() || undefined
-			};
-		})
-		.filter((item): item is ResolveIORunnerPersistedEvidenceFile => !!item);
-}
-
-export function mergeResolveIORunnerEvidenceFileIds(...values: any[]): string[] {
-	const ids: string[] = [];
-	const seen = new Set<string>();
-	const push = (value: any) => {
-		if (Array.isArray(value)) {
-			value.forEach(push);
-			return;
-		}
-		const id = String(value?.file_id || value?.id_file || value?._id || value || '').trim();
-		if (!id || seen.has(id)) {
-			return;
-		}
-		seen.add(id);
-		ids.push(id);
-	};
-	values.forEach(push);
-	return ids;
-}
-
-function collectResolveIORunnerEvidenceText(value: any, output: string[]): void {
-	if (value === null || value === undefined) {
-		return;
-	}
-	if (typeof value === 'string') {
-		output.push(value);
-		return;
-	}
-	if (Array.isArray(value)) {
-		value.forEach((entry) => collectResolveIORunnerEvidenceText(entry, output));
-		return;
-	}
-	if (typeof value === 'object') {
-		Object.values(value).forEach((entry) => collectResolveIORunnerEvidenceText(entry, output));
-	}
-}
-
-function normalizeArtifactCandidatePath(value: string): string {
-	return String(value || '')
-		.trim()
-		.replace(/[),.;:'"]+$/g, '')
-		.replace(/\\/g, '/');
-}
-
-function pathExists(filePath: string): boolean {
-	try {
-		return !!filePath && fs.existsSync(filePath) && fs.statSync(filePath).isFile();
-	}
-	catch {
-		return false;
-	}
-}
-
-function resolveArtifactCandidate(candidate: string, roots: string[]): string {
-	const normalized = normalizeArtifactCandidatePath(candidate);
-	if (!normalized) {
-		return '';
-	}
-	if (path.isAbsolute(normalized)) {
-		return pathExists(normalized) ? normalized : '';
-	}
-	for (const root of roots) {
-		const normalizedRoot = String(root || '').trim();
-		if (!normalizedRoot) {
-			continue;
-		}
-		const resolved = path.resolve(normalizedRoot, normalized);
-		if (pathExists(resolved)) {
-			return resolved;
-		}
-	}
-	return '';
-}
-
-export function collectResolveIORunnerEvidenceArtifactPaths(input: {
-	evidence?: any;
-	job?: any;
-	roots?: string[];
-	maxFiles?: number;
-} = {}): string[] {
-	const values: string[] = [];
-	collectResolveIORunnerEvidenceText(input.evidence, values);
-	const job = input.job || {};
-	collectResolveIORunnerEvidenceText(job.responseSummary, values);
-	collectResolveIORunnerEvidenceText(job.lastVerificationSummary, values);
-	collectResolveIORunnerEvidenceText(job.lastRerunReason, values);
-	collectResolveIORunnerEvidenceText(job.artifacts?.agentNotes, values);
-	collectResolveIORunnerEvidenceText(job.artifacts?.supportArtifacts, values);
-	collectResolveIORunnerEvidenceText(job.artifacts?.qaArtifacts, values);
-	collectResolveIORunnerEvidenceText(job.artifacts?.qa_artifacts, values);
-	collectResolveIORunnerEvidenceText(job.qa_artifacts, values);
-	collectResolveIORunnerEvidenceText(job.supportQaArtifacts, values);
-	collectResolveIORunnerEvidenceText(job.runnerEvidenceArtifacts, values);
-	if (Array.isArray(job.tasks)) {
-		for (const task of job.tasks) {
-			collectResolveIORunnerEvidenceText(task?.title, values);
-			collectResolveIORunnerEvidenceText(task?.notes, values);
-			collectResolveIORunnerEvidenceText(task?.artifacts, values);
-			collectResolveIORunnerEvidenceText(task?.evidence, values);
-		}
-	}
-	if (Array.isArray(job.log)) {
-		collectResolveIORunnerEvidenceText(job.log.slice(-160), values);
-	}
-
-	const roots = Array.from(new Set([
-		...(input.roots || []),
-		job.workspacePath,
-		job.projectRoot && job.workspacePath ? path.join(job.workspacePath, job.projectRoot) : '',
-		job.projectDisplayPath && job.workspacePath ? path.join(job.workspacePath, job.projectDisplayPath) : '',
-		job.localPath
-	].map((entry) => String(entry || '').trim()).filter(Boolean)));
-	const candidates: string[] = [];
-	for (const value of values) {
-		const text = String(value || '');
-		for (const match of text.matchAll(/((?:\/tmp\/|\/var\/|\/Users\/)[^\s)'"]+?\.(?:png|jpe?g|webp|zip|json|txt|log))/gi)) {
-			candidates.push(match[1]);
-		}
-		for (const match of text.matchAll(/(?:^|[\s("'`])((?:(?:[\w.-]+\/)*qa-artifacts|qa-artifacts|test-results|playwright-report|\.build-output)\/[^\s)'"]+?\.(?:png|jpe?g|webp|zip|json|txt|log))/gim)) {
-			candidates.push(match[1]);
-		}
-	}
-	const resolved: string[] = [];
-	const seen = new Set<string>();
-	for (const candidate of candidates) {
-		const filePath = resolveArtifactCandidate(candidate, roots);
-		if (!filePath || seen.has(filePath)) {
-			continue;
-		}
-		seen.add(filePath);
-		resolved.push(filePath);
-		if (resolved.length >= (input.maxFiles || 8)) {
-			break;
-		}
-	}
-	return resolved;
-}
-
-export function toResolveIORunnerEvidenceAttachments(input: {
-	evidence?: any;
-	job?: any;
-	roots?: string[];
-	maxFiles?: number;
-} = {}): ResolveIORunnerEvidenceAttachment[] {
-	return collectResolveIORunnerEvidenceArtifactPaths(input).map((filePath) => {
-		const filename = path.basename(filePath);
-		return {
-			filename,
-			path: filePath,
-			contentType: inferResolveIORunnerEvidenceContentType(filename),
-			cid: buildResolveIORunnerEvidenceCid(filePath),
-			caption: inferResolveIORunnerEvidenceCaption(filename)
-		};
-	});
-}
-
-export async function persistResolveIORunnerEvidenceArtifacts(
-	options: ResolveIORunnerPersistEvidenceOptions
-): Promise<ResolveIORunnerPersistEvidenceResult> {
-	const maxFiles = Math.max(1, options.maxFiles || 8);
-	const previousFiles = normalizeResolveIORunnerPersistedEvidenceFiles(options.previousFiles);
-	const existingByHash = new Map<string, ResolveIORunnerPersistedEvidenceFile>();
-	for (const file of previousFiles) {
-		if (file.content_hash) {
-			existingByHash.set(file.content_hash, file);
-		}
-	}
-	const attachments = [
-		...(options.attachments || []),
-		...toResolveIORunnerEvidenceAttachments({
-			evidence: options.evidence,
-			job: options.job,
-			roots: options.roots,
-			maxFiles
-		})
-	];
-	const persistedFiles = [...previousFiles];
-	const fileIds = mergeResolveIORunnerEvidenceFileIds(options.existingFileIds, previousFiles.map((file) => file.file_id));
-	const errors: string[] = [];
-	const nextAttachments: ResolveIORunnerEvidenceAttachment[] = [];
-	const seenPaths = new Set<string>();
-
-	for (const attachment of attachments) {
-		if (nextAttachments.length >= maxFiles) {
-			break;
-		}
-		const filePath = String(attachment?.path || '').trim();
-		if (!filePath || seenPaths.has(filePath)) {
-			continue;
-		}
-		seenPaths.add(filePath);
-		const filename = String(attachment?.filename || path.basename(filePath) || 'runner-qa-artifact.png').trim();
-		const contentType = String(attachment?.contentType || inferResolveIORunnerEvidenceContentType(filename)).trim();
-		if (!pathExists(filePath)) {
-			const error = `${filename}: evidence file was not found before S3 upload.`;
-			errors.push(error);
-			nextAttachments.push({ ...attachment, filename, upload_error: error });
-			continue;
-		}
-		const stat = await fs.promises.stat(filePath);
-		if (!stat.isFile() || stat.size <= 0) {
-			const error = `${filename}: evidence file was empty before S3 upload.`;
-			errors.push(error);
-			nextAttachments.push({ ...attachment, filename, upload_error: error });
-			continue;
-		}
-		const contentBuffer = await fs.promises.readFile(filePath);
-		const contentHash = createHash('sha1').update(new Uint8Array(contentBuffer)).digest('hex');
-		const existing = existingByHash.get(contentHash);
-		if (existing) {
-			fileIds.push(existing.file_id);
-			nextAttachments.push({
-				...attachment,
-				filename,
-				file_id: existing.file_id,
-				key: existing.key,
-				caption: attachment.caption || existing.caption || inferResolveIORunnerEvidenceCaption(filename),
-				content_hash: contentHash,
-				ticket_url: options.ticketUrl || existing.ticket_url,
-				uploaded_to_support_ticket: true
-			});
-			continue;
-		}
-		try {
-			const uploaded = await options.uploadFile({
-				filename,
-				filePath,
-				contentType,
-				size: stat.size,
-				contentBuffer,
-				contentHash
-			});
-			const fileId = String(uploaded?.file_id || uploaded?.id_file || uploaded?._id || '').trim();
-			if (!fileId) {
-				throw new Error('artifact upload returned no file id');
-			}
-			const persisted: ResolveIORunnerPersistedEvidenceFile = {
-				file_id: fileId,
-				filename: String(uploaded?.filename || uploaded?.name || filename).trim() || filename,
-				key: String(uploaded?.key || '').trim() || undefined,
-				contentType,
-				caption: String(attachment?.caption || '').trim() || inferResolveIORunnerEvidenceCaption(filename),
-				content_hash: contentHash,
-				ticket_url: String(options.ticketUrl || '').trim() || undefined
-			};
-			persistedFiles.push(persisted);
-			existingByHash.set(contentHash, persisted);
-			fileIds.push(fileId);
-			nextAttachments.push({
-				...attachment,
-				filename,
-				file_id: fileId,
-				key: persisted.key,
-				caption: persisted.caption,
-				content_hash: contentHash,
-				ticket_url: persisted.ticket_url,
-				uploaded_to_support_ticket: true
-			});
-		}
-		catch (error) {
-			const message = `${filename}: ${(error as Error)?.message || error}`;
-			errors.push(message);
-			nextAttachments.push({ ...attachment, filename, content_hash: contentHash, upload_error: message });
-		}
-	}
-
-	return {
-		attachments: nextAttachments,
-		fileIds: mergeResolveIORunnerEvidenceFileIds(fileIds),
-		files: persistedFiles,
-		errors
-	};
-}

package/src/util/ai-runner-qa-auth.ts

@@ -1,252 +0,0 @@
-export interface ResolveIORunnerQaAuthBootstrapScriptOptions {
-	defaultUsername?: string;
-	defaultPassword?: string;
-}
-
-export function buildResolveIORunnerQaAuthBootstrapScript(options: ResolveIORunnerQaAuthBootstrapScriptOptions = {}): string {
-	const defaultUsername = options.defaultUsername || 'admin';
-	const defaultPassword = options.defaultPassword || '';
-	return [
-		'#!/usr/bin/env node',
-		"'use strict';",
-		'',
-		'const fs = require("fs");',
-		'const http = require("http");',
-		'const https = require("https");',
-		'const path = require("path");',
-		'',
-		'const projectRoot = path.resolve(process.argv[2] || process.cwd());',
-		'const routeArg = process.argv[3] || process.env.RESOLVEIO_RUNNER_QA_TARGET_ROUTE || process.env.RESOLVEIO_SUPPORT_QA_TARGET_ROUTE || process.env.RESOLVEIO_SUPPORT_QA_LAST_URL || "/";',
-		'const targetRoute = routeArg.startsWith("/") ? routeArg : `/${routeArg}`;',
-		'const clientUrl = stripTrailingSlash(process.env.RESOLVEIO_RUNNER_QA_CLIENT_URL || process.env.RESOLVEIO_SUPPORT_QA_CLIENT_URL || `http://localhost:${process.env.RESOLVEIO_SUPPORT_QA_CLIENT_PORT || "4200"}`);',
-		'const serverUrl = stripTrailingSlash(process.env.RESOLVEIO_RUNNER_QA_SERVER_URL || process.env.RESOLVEIO_SUPPORT_QA_SERVER_URL || "http://localhost:8080");',
-		`const username = process.env.RESOLVEIO_RUNNER_QA_USERNAME || process.env.RESOLVEIO_SUPPORT_QA_USERNAME || ${JSON.stringify(defaultUsername)};`,
-		`const password = process.env.RESOLVEIO_RUNNER_QA_PASSWORD || process.env.RESOLVEIO_SUPPORT_QA_PASSWORD || ${JSON.stringify(defaultPassword)};`,
-		'const artifactDir = path.resolve(process.env.RESOLVEIO_RUNNER_QA_ARTIFACT_DIR || process.env.RESOLVEIO_SUPPORT_QA_ARTIFACT_DIR || path.join(projectRoot, "qa-artifacts"));',
-		'const viewportWidth = Number(process.env.RESOLVEIO_RUNNER_QA_VIEWPORT_WIDTH || process.env.RESOLVEIO_SUPPORT_QA_VIEWPORT_WIDTH || 1920);',
-		'const viewportHeight = Number(process.env.RESOLVEIO_RUNNER_QA_VIEWPORT_HEIGHT || process.env.RESOLVEIO_SUPPORT_QA_VIEWPORT_HEIGHT || 1080);',
-		'const resultPath = path.join(artifactDir, "auth-bootstrap-result.json");',
-		'const readyScreenshotPath = path.join(artifactDir, "auth-bootstrap-ready.png");',
-		'const failureScreenshotPath = path.join(artifactDir, "auth-bootstrap-failed.png");',
-		'',
-		'function stripTrailingSlash(value) {',
-		'	return String(value || "").replace(/\\/+$/, "");',
-		'}',
-		'',
-		'function writeResult(payload) {',
-		'	fs.mkdirSync(artifactDir, { recursive: true });',
-		'	fs.writeFileSync(resultPath, JSON.stringify(payload, null, 2));',
-		'}',
-		'',
-		'function requestJson(url, payload) {',
-		'	return new Promise((resolve, reject) => {',
-		'		const body = JSON.stringify(payload || {});',
-		'		const parsed = new URL(url);',
-		'		const mod = parsed.protocol === "https:" ? https : http;',
-		'		const req = mod.request(parsed, {',
-		'			method: "POST",',
-		'			timeout: 20000,',
-		'			headers: {',
-		'				"content-type": "application/json",',
-		'				"content-length": Buffer.byteLength(body),',
-		'				"origin": clientUrl',
-		'			}',
-		'		}, (res) => {',
-		'			let raw = "";',
-		'			res.setEncoding("utf8");',
-		'			res.on("data", (chunk) => { raw += chunk; });',
-		'			res.on("end", () => {',
-		'				let json = null;',
-		'				try { json = raw ? JSON.parse(raw) : {}; }',
-		'				catch (error) {',
-		'					reject(new Error(`${url} returned non-JSON HTTP ${res.statusCode}: ${raw.slice(0, 300)}`));',
-		'					return;',
-		'				}',
-		'				if (!res.statusCode || res.statusCode >= 400) {',
-		'					reject(new Error(`${url} returned HTTP ${res.statusCode}: ${JSON.stringify(json).slice(0, 500)}`));',
-		'					return;',
-		'				}',
-		'				resolve(json);',
-		'			});',
-		'		});',
-		'		req.on("timeout", () => req.destroy(new Error(`${url} timed out`)));',
-		'		req.on("error", reject);',
-		'		req.write(body);',
-		'		req.end();',
-		'	});',
-		'}',
-		'',
-		'function requirePuppeteer() {',
-		'	const candidates = [',
-		'		path.join(projectRoot, "server", "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
-		'		path.join(projectRoot, "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
-		'		path.join(process.cwd(), "server", "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
-		'		path.join(process.cwd(), "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
-		'		"puppeteer"',
-		'	];',
-		'	for (const candidate of candidates) {',
-		'		try { return require(candidate); }',
-		'		catch (error) {}',
-		'	}',
-		'	throw new Error("Unable to require puppeteer from project/server node_modules or global resolution");',
-		'}',
-		'',
-		'async function login() {',
-		'	if (!password) {',
-		'		throw new Error("QA password is empty; source .resolveio-support-tools/env.sh or set RESOLVEIO_RUNNER_QA_PASSWORD before auth bootstrap");',
-		'	}',
-		'	const loginJson = await requestJson(`${serverUrl}/login`, { username, password });',
-		'	const refreshToken = loginJson && loginJson.result && loginJson.result.token;',
-		'	if (loginJson.error || !refreshToken) {',
-		'		throw new Error(`Login failed: ${JSON.stringify(loginJson).slice(0, 800)}`);',
-		'	}',
-		'	const accessJson = await requestJson(`${serverUrl}/accessToken`, { refreshToken });',
-		'	const accessToken = accessJson && accessJson.result && accessJson.result.token;',
-		'	const user = accessJson && accessJson.result && accessJson.result.user;',
-		'	if (accessJson.error || !accessToken || !user) {',
-		'		throw new Error(`Access token failed: ${JSON.stringify(accessJson).slice(0, 800)}`);',
-		'	}',
-		'	return { refreshToken, accessToken, user };',
-		'}',
-		'',
-		'async function launchBrowser(puppeteer) {',
-		'	const browserUrl = process.env.RESOLVEIO_RUNNER_QA_BROWSER_URL || process.env.RESOLVEIO_SUPPORT_QA_BROWSER_URL || "";',
-		'	if (browserUrl) {',
-		'		return puppeteer.connect({ browserURL: browserUrl, protocolTimeout: 30000, defaultViewport: null });',
-		'	}',
-		'	const launchOptions = {',
-		'		headless: true,',
-		'		defaultViewport: { width: viewportWidth, height: viewportHeight },',
-		'		args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage", `--window-size=${viewportWidth},${viewportHeight}`]',
-		'	};',
-		'	if (process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_BIN) {',
-		'		launchOptions.executablePath = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_BIN;',
-		'	}',
-		'	return puppeteer.launch(launchOptions);',
-		'}',
-		'',
-		'async function resetBrowserState(page) {',
-		'	await page.goto(clientUrl, { waitUntil: "domcontentloaded", timeout: 45000 });',
-		'	await page.evaluate(async () => {',
-		'		try {',
-		'			const registrations = await navigator.serviceWorker.getRegistrations();',
-		'			await Promise.all(registrations.map((registration) => registration.unregister().catch(() => false)));',
-		'		} catch (error) {}',
-		'		try {',
-		'			if (window.caches && window.caches.keys) {',
-		'				const keys = await window.caches.keys();',
-		'				await Promise.all(keys.map((key) => window.caches.delete(key).catch(() => false)));',
-		'			}',
-		'		} catch (error) {}',
-		'		try {',
-		'			if (window.indexedDB && window.indexedDB.databases) {',
-		'				const databases = await window.indexedDB.databases();',
-		'				await Promise.all(databases.filter((database) => database && database.name).map((database) => new Promise((resolve) => {',
-		'					const request = window.indexedDB.deleteDatabase(database.name);',
-		'					request.onsuccess = () => resolve(true);',
-		'					request.onerror = () => resolve(false);',
-		'					request.onblocked = () => resolve(false);',
-		'				})));',
-		'			}',
-		'		} catch (error) {}',
-		'		localStorage.clear();',
-		'		sessionStorage.clear();',
-		'	});',
-		'}',
-		'',
-		'async function seedAuth(page, auth) {',
-		'	await page.evaluate((payload) => {',
-		'		localStorage.setItem("refreshToken", payload.refreshToken);',
-		'		localStorage.setItem("accessToken", payload.accessToken);',
-		'		localStorage.setItem("user", JSON.stringify(payload.user));',
-		'		localStorage.setItem("lastURL", payload.lastURL);',
-		'		localStorage.setItem("resolveio.runnerQaAuthBootstrappedAt", payload.bootstrappedAt);',
-		'	}, { ...auth, lastURL: targetRoute, bootstrappedAt: new Date().toISOString() });',
-		'}',
-		'',
-		'async function waitForAuthenticatedApp(page) {',
-		'	const url = `${clientUrl}${targetRoute}`;',
-		'	await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });',
-		'	await page.waitForFunction(() => {',
-		'		const text = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();',
-		'		const hasTokens = !!localStorage.getItem("refreshToken") && !!localStorage.getItem("accessToken") && !!localStorage.getItem("user");',
-		'		const hasLogin = /Employee\\/Customer Login|Employee Sign In|Customer Access|Unable to sign in/i.test(text);',
-		'		const hasOffline = text.includes("*** OFFLINE MODE ***");',
-		'		return hasTokens && !hasLogin && !hasOffline && text.length > 40;',
-		'	}, { timeout: Number(process.env.RESOLVEIO_RUNNER_QA_AUTH_TIMEOUT_MS || process.env.RESOLVEIO_SUPPORT_QA_AUTH_TIMEOUT_MS || 60000) });',
-		'	await page.waitForTimeout(1000);',
-		'}',
-		'',
-		'async function pageSummary(page) {',
-		'	return page.evaluate(() => {',
-		'		const bodyText = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();',
-		'		return {',
-		'			url: location.href,',
-		'			title: document.title,',
-		'			hasAngularDebug: !!window.ng,',
-		'			hasRefreshToken: !!localStorage.getItem("refreshToken"),',
-		'			hasAccessToken: !!localStorage.getItem("accessToken"),',
-		'			hasUser: !!localStorage.getItem("user"),',
-		'			hasOfflineModeText: bodyText.includes("*** OFFLINE MODE ***"),',
-		'			hasLoginText: /Employee\\/Customer Login|Employee Sign In|Customer Access|Unable to sign in/i.test(bodyText),',
-		'			bodyTextSnippet: bodyText.slice(0, 800),',
-		'			localStorageKeys: Object.keys(localStorage).sort()',
-		'		};',
-		'	});',
-		'}',
-		'',
-		'(async () => {',
-		'	fs.mkdirSync(artifactDir, { recursive: true });',
-		'	const auth = await login();',
-		'	const puppeteer = requirePuppeteer();',
-		'	const browser = await launchBrowser(puppeteer);',
-		'	let page;',
-		'	try {',
-		'		page = await browser.newPage();',
-		'		await page.setViewport({ width: viewportWidth, height: viewportHeight });',
-		'		page.on("console", (msg) => {',
-		'			const text = msg.text();',
-		'			if (["error", "warning"].includes(msg.type()) || /error/i.test(text)) {',
-		'				console.log("[browser console]", msg.type(), text);',
-		'			}',
-		'		});',
-		'		page.on("pageerror", (error) => console.log("[pageerror]", error.message));',
-		'		await resetBrowserState(page);',
-		'		await seedAuth(page, auth);',
-		'		await waitForAuthenticatedApp(page);',
-		'		await page.screenshot({ path: readyScreenshotPath, fullPage: true });',
-		'		const summary = {',
-		'			status: "pass",',
-		'			clientUrl,',
-		'			serverUrl,',
-		'			targetRoute,',
-		'			screenshot: readyScreenshotPath,',
-		'			user: { _id: auth.user && auth.user._id, username: auth.user && auth.user.username, fullname: auth.user && auth.user.fullname },',
-		'			page: await pageSummary(page)',
-		'		};',
-		'		writeResult(summary);',
-		'		console.log(JSON.stringify(summary, null, 2));',
-		'	}',
-		'	catch (error) {',
-		'		let summary = { status: "fail", clientUrl, serverUrl, targetRoute, screenshot: failureScreenshotPath, error: error && error.stack || String(error) };',
-		'		try {',
-		'			if (page) {',
-		'				await page.screenshot({ path: failureScreenshotPath, fullPage: true });',
-		'				summary.page = await pageSummary(page);',
-		'			}',
-		'		} catch (screenshotError) {',
-		'			summary.screenshotError = screenshotError && screenshotError.stack || String(screenshotError);',
-		'		}',
-		'		writeResult(summary);',
-		'		console.error(JSON.stringify(summary, null, 2));',
-		'		process.exitCode = 1;',
-		'	}',
-		'	finally {',
-		'		if (browser && typeof browser.close === "function") {',
-		'			await browser.close().catch(() => undefined);',
-		'		}',
-		'	}',
-		'})();',
-		''
-	].join('\n');
-}