@resolveio/server-lib 22.3.27 → 22.3.29

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

@@ -0,0 +1,430 @@
+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

@@ -0,0 +1,252 @@
+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');
+}