@resolveio/server-lib 22.3.56 → 22.3.57

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
+	};
+}