@resolveio/server-lib 22.3.221 → 22.3.223

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

@@ -1,586 +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 interface ResolveIORunnerEvidenceArtifactRootScanInput {
-	roots?: string[];
-	artifactDirNames?: string[];
-	maxFiles?: number;
-	includeJson?: boolean;
-}
-
-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 '';
-}
-
-function isEvidenceArtifactExtension(filePath: string, includeJson: boolean): boolean {
-	const ext = path.extname(String(filePath || '')).toLowerCase();
-	return ext === '.png'
-		|| ext === '.jpg'
-		|| ext === '.jpeg'
-		|| ext === '.webp'
-		|| ext === '.zip'
-		|| (includeJson && ext === '.json');
-}
-
-function scoreEvidenceArtifactPath(filePath: string): number {
-	const baseName = path.basename(String(filePath || '')).toLowerCase();
-	const ext = path.extname(baseName);
-	let score = 0;
-	if (['.png', '.jpg', '.jpeg', '.webp'].includes(ext)) {
-		score += 100;
-	}
-	if (/\b(invoice|billing|surcharge|tax|inventory|transaction|location|chemical|item|truck|delivery|saved|submit|line|select|modal)\b/i.test(baseName)) {
-		score += 60;
-	}
-	if (/\b(coverage|assert|result|summary|matrix)\b/i.test(baseName)) {
-		score += 20;
-	}
-	if (/\b(auth|bootstrap|ready|client\.log|server\.log|runner|chrome)\b/i.test(baseName)) {
-		score -= 120;
-	}
-	return score;
-}
-
-function collectEvidenceArtifactFilesFromDirectory(
-	dirPath: string,
-	includeJson: boolean,
-	output: Array<{ filePath: string; score: number; mtimeMs: number }>,
-	seen: Set<string>,
-	depth = 0
-): void {
-	if (depth > 2) {
-		return;
-	}
-	let entries: string[] = [];
-	try {
-		entries = fs.readdirSync(dirPath);
-	}
-	catch {
-		return;
-	}
-	for (const entry of entries) {
-		const candidate = path.join(dirPath, entry);
-		let stat: fs.Stats;
-		try {
-			stat = fs.statSync(candidate);
-		}
-		catch {
-			continue;
-		}
-		if (stat.isDirectory()) {
-			collectEvidenceArtifactFilesFromDirectory(candidate, includeJson, output, seen, depth + 1);
-			continue;
-		}
-		if (!stat.isFile() || stat.size <= 0 || !isEvidenceArtifactExtension(candidate, includeJson)) {
-			continue;
-		}
-		const resolved = path.resolve(candidate);
-		if (seen.has(resolved)) {
-			continue;
-		}
-		seen.add(resolved);
-		output.push({
-			filePath: resolved,
-			score: scoreEvidenceArtifactPath(resolved),
-			mtimeMs: Number(stat.mtimeMs || 0)
-		});
-	}
-}
-
-export function collectResolveIORunnerEvidenceArtifactFilesFromRoots(
-	input: ResolveIORunnerEvidenceArtifactRootScanInput = {}
-): string[] {
-	const maxFiles = Math.max(1, Number(input.maxFiles || 12));
-	const includeJson = input.includeJson !== false;
-	const artifactDirNames = (input.artifactDirNames?.length ? input.artifactDirNames : ['qa-artifacts'])
-		.map((entry) => String(entry || '').trim())
-		.filter(Boolean);
-	const roots = Array.from(new Set((input.roots || [])
-		.map((entry) => String(entry || '').trim())
-		.filter(Boolean)
-		.map((entry) => path.resolve(entry))));
-	const artifactDirs = new Set<string>();
-	for (const root of roots) {
-		let stat: fs.Stats | null = null;
-		try {
-			stat = fs.statSync(root);
-		}
-		catch {
-			stat = null;
-		}
-		if (!stat?.isDirectory()) {
-			continue;
-		}
-		const rootBaseName = path.basename(root);
-		if (artifactDirNames.includes(rootBaseName)) {
-			artifactDirs.add(root);
-		}
-		for (const artifactDirName of artifactDirNames) {
-			const directArtifactDir = path.join(root, artifactDirName);
-			try {
-				if (fs.statSync(directArtifactDir).isDirectory()) {
-					artifactDirs.add(directArtifactDir);
-				}
-			}
-			catch {
-				// Ignore missing artifact directories.
-			}
-		}
-	}
-	const seen = new Set<string>();
-	const files: Array<{ filePath: string; score: number; mtimeMs: number }> = [];
-	for (const artifactDir of artifactDirs) {
-		collectEvidenceArtifactFilesFromDirectory(artifactDir, includeJson, files, seen);
-	}
-	return files
-		.sort((left, right) => {
-			if (right.score !== left.score) {
-				return right.score - left.score;
-			}
-			if (left.mtimeMs !== right.mtimeMs) {
-				return left.mtimeMs - right.mtimeMs;
-			}
-			return left.filePath.localeCompare(right.filePath);
-		})
-		.slice(0, maxFiles)
-		.map((entry) => entry.filePath);
-}
-
-export function toResolveIORunnerEvidenceAttachmentsFromRoots(
-	input: ResolveIORunnerEvidenceArtifactRootScanInput = {}
-): ResolveIORunnerEvidenceAttachment[] {
-	return collectResolveIORunnerEvidenceArtifactFilesFromRoots(input).map((filePath) => {
-		const filename = path.basename(filePath);
-		return {
-			filename,
-			path: filePath,
-			contentType: inferResolveIORunnerEvidenceContentType(filename),
-			cid: buildResolveIORunnerEvidenceCid(filePath),
-			caption: inferResolveIORunnerEvidenceCaption(filename)
-		};
-	});
-}
-
-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
-	};
-}