@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/report.mjs

@@ -1,13 +1,14 @@
-import { appendFileSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { copyFile, cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { getMidsceneRunSubDir } from "@midscene/shared/common";
-import { antiEscapeScriptTag, escapeScriptTag, logMsg } from "@midscene/shared/utils";
+import { antiEscapeScriptTag, logMsg, uuid } from "@midscene/shared/utils";
 import { getReportFileName } from "./agent/report-file-name.mjs";
-import { DATA_SCREENSHOT_MODE_ATTR, extractAllDumpScriptsSync, extractLastDumpScriptSync, generateAgentReportComment, getBaseUrlFixScript, streamDumpScriptsSync, streamImageScriptsToFile } from "./dump/html-utils.mjs";
+import { DATA_SCREENSHOT_MODE_ATTR, extractAllDumpScriptsSync, extractLastDumpScriptSync, extractTestRunReportDumpSync, generateAgentReportComment, generateTestRunReportScriptTag, getBaseUrlFixScript, streamDumpScriptsSync, streamImageScriptsToFile } from "./dump/html-utils.mjs";
 import { imageRefFileExtension, normalizeStoredImageRef } from "./dump/image-reference.mjs";
 import { parseBase64ImageDataUrl, resolveImageSource } from "./dump/screenshot-store.mjs";
 import { collectReportSummary } from "./report-stats.mjs";
-import { TEST_RUN_REPORT_SCRIPT_TYPE } from "./test-run-report.mjs";
+import { mergeTestRunReportDumps } from "./test-runner/reporting/merge-report.mjs";
 import { ReportActionDump } from "./types.mjs";
 import { getReportTpl, getVersion, reportHTMLContent } from "./utils.mjs";
 function _define_property(obj, key, value) {
@@ -88,7 +89,7 @@ function mergedAgentReportComment(reports) {
         groupDescription: 'Agent-readable summary for merged report HTML',
         modelBriefs: reports.flatMap((report)=>report.modelBriefs ?? []),
         deviceType: 1 === deviceTypes.length ? deviceTypes[0] : 'mixed',
-        executions: reports.flatMap((report)=>report.executions ?? [])
+        executions: dedupeExecutionsKeepLatest(reports.flatMap((report)=>report.executions ?? []))
     });
     return generateAgentReportComment(mergedReport);
 }
@@ -138,6 +139,8 @@ class ReportMergingTool {
             logMsg('No reports to merge');
             return null;
         }
+        const runnerDumps = this.reportInfos.map((info)=>info.reportFilePath ? extractTestRunReportDumpSync(info.reportFilePath) : void 0);
+        const hasRunnerDump = runnerDumps.some(Boolean);
         const targetDir = outputDir ? resolve(outputDir) : getMidsceneRunSubDir('report');
         if (outputDir) mkdirSync(targetDir, {
             recursive: true
@@ -166,6 +169,7 @@ class ReportMergingTool {
             appendFileSync(outputFilePath, tplWithoutClose);
             if (hasDirectoryModeReport) appendFileSync(outputFilePath, getBaseUrlFixScript());
             const agentReports = [];
+            const runnerSources = [];
             const writtenInlineImageIds = new Set();
             for(let i = 0; i < this.reportInfos.length; i++){
                 const reportInfo = this.reportInfos[i];
@@ -191,16 +195,26 @@ class ReportMergingTool {
                     } else streamImageScriptsToFile(reportInfo.reportFilePath, outputFilePath, writtenInlineImageIds);
                     const allDumps = extractAllDumpScriptsSync(reportInfo.reportFilePath).filter((d)=>d.openTag.includes('data-group-id'));
                     const groupIdMatch = allDumps[0]?.openTag.match(/data-group-id="([^"]+)"/);
-                    if (groupIdMatch) mergedGroupId = decodeURIComponent(groupIdMatch[1]);
+                    if (groupIdMatch && !hasRunnerDump) mergedGroupId = decodeURIComponent(groupIdMatch[1]);
                     const extractedDumpString = allDumps.length > 0 ? this.mergeDumpScripts(allDumps.map((d)=>d.content)) : extractLastDumpScriptSync(reportInfo.reportFilePath);
                     if (extractedDumpString) dumpString = extractedDumpString;
                 }
                 const agentReport = tryParseAgentReportDump(dumpString);
                 if (agentReport) agentReports.push(agentReport);
+                if (hasRunnerDump) runnerSources.push({
+                    reportId: mergedGroupId,
+                    sourcePath: reportInfo.reportFilePath ?? '<skipped-agent-report>',
+                    attributes: reportAttributes,
+                    dump: runnerDumps[i],
+                    timing: agentReport ? agentReportTiming(agentReport, reportAttributes.testDuration) : void 0
+                });
                 const reportHtmlStr = `${reportHTMLContent({
                     dumpString,
                     attributes: {
                         'data-group-id': mergedGroupId,
+                        ...hasRunnerDump ? {
+                            'data-report-id': mergedGroupId
+                        } : {},
                         [DATA_SCREENSHOT_MODE_ATTR]: hasDirectoryModeReport ? 'directory' : 'inline',
                         playwright_test_duration: reportAttributes.testDuration,
                         playwright_test_status: reportAttributes.testStatus,
@@ -212,6 +226,16 @@ class ReportMergingTool {
                 }, void 0, void 0, false)}\n`;
                 appendFileSync(outputFilePath, reportHtmlStr);
             }
+            if (hasRunnerDump) {
+                const summary = collectReportSummary({
+                    executions: dedupeExecutionsKeepLatest(agentReports.flatMap((report)=>report.executions))
+                });
+                appendFileSync(outputFilePath, generateTestRunReportScriptTag(mergeTestRunReportDumps(runnerSources, {
+                    modelCallCount: summary.timing.modelCallCount,
+                    modelTimeMs: summary.timing.modelCallTimeMs,
+                    ...summary.tokens
+                }, uuid())));
+            }
             const agentComment = mergedAgentReportComment(agentReports);
             if (agentComment) appendFileSync(outputFilePath, agentComment);
             appendFileSync(outputFilePath, `${htmlEndTag}\n`);
@@ -240,28 +264,29 @@ class ReportMergingTool {
         _define_property(this, "reportInfos", []);
     }
 }
-const emptyTestRunReportMetrics = ()=>({
-        modelCallCount: 0,
-        modelTimeMs: 0,
-        promptTokens: 0,
-        cachedInputTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0
-    });
+function agentReportTiming(report, durationMs) {
+    const timing = collectReportSummary(report).timing;
+    const executionTimes = report.executions.map((execution)=>execution.logTime).filter((value)=>'number' == typeof value && Number.isFinite(value));
+    const started = timing.wallTimeStart ?? (executionTimes.length ? Math.min(...executionTimes) : void 0);
+    if (void 0 === started) return;
+    const ended = timing.wallTimeEnd ?? Math.max(...executionTimes, started + (Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0));
+    return {
+        startedAt: new Date(started).toISOString(),
+        endedAt: new Date(ended).toISOString(),
+        durationMs: Math.max(0, ended - started)
+    };
+}
 const validateTestRunReportFileName = (fileName)=>{
     if (!fileName || '.' === fileName || '..' === fileName || basename(fileName) !== fileName || fileName.endsWith('.html')) throw new Error(`Midscene Test reportFileName must be one path segment without an extension: ${fileName}`);
 };
 const uniqueTestRunReportSources = (sources)=>{
     const unique = new Map();
-    const scopeBySourcePath = new Map();
     for (const source of sources){
         const scopeId = source.scopeId.trim();
         const sourcePath = resolve(source.sourcePath);
         if (!scopeId) throw new Error('Midscene Test report source scopeId must not be empty.');
-        const previousScope = scopeBySourcePath.get(sourcePath);
-        if (previousScope && previousScope !== scopeId) throw new Error(`Agent report source is shared by multiple test scopes (${previousScope}, ${scopeId}): ${sourcePath}`);
-        scopeBySourcePath.set(sourcePath, scopeId);
-        unique.set(`${scopeId}\u0000${sourcePath}`, {
+        unique.set(`${scopeId}\u0000${source.dumpPath ?? sourcePath}`, {
+            ...source,
             scopeId,
             sourcePath
         });
@@ -270,20 +295,49 @@ const uniqueTestRunReportSources = (sources)=>{
         ...unique.values()
     ];
 };
-const prepareTestRunReportSources = (sources)=>{
+const prepareTestRunReportSources = (sources, loadedDumps)=>{
     const prepared = [];
-    const metrics = emptyTestRunReportMetrics();
     const ownerByScopedExecution = new Map();
+    const preparedByPath = new Map();
     for (const [sourceIndex, source] of uniqueTestRunReportSources(sources).entries()){
-        if (!existsSync(source.sourcePath)) throw new Error(`Agent report does not exist: ${source.sourcePath}`);
-        const sourceVersion = peekReportSdkVersion(source.sourcePath);
+        const sourceKey = source.sourcePath;
+        const shared = preparedByPath.get(sourceKey);
+        if (shared) {
+            if (source.dumpPath) {
+                const snapshot = ReportActionDump.fromSerializedString(loadedDumps?.get(source.dumpPath) ?? readFileSync(source.dumpPath, 'utf8'));
+                shared.dump.executions = dedupeExecutionsKeepLatest([
+                    ...shared.dump.executions,
+                    ...snapshot.executions
+                ]);
+                shared.executionIds.splice(0, shared.executionIds.length, ...shared.dump.executions.flatMap((execution)=>execution.id ? [
+                        execution.id
+                    ] : []));
+            }
+            for (const executionId of shared.executionIds){
+                const key = `${source.scopeId}\u0000${executionId}`;
+                const owner = ownerByScopedExecution.get(key);
+                if (owner && owner !== shared.reportId) throw new Error(`Agent execution ${executionId} is present in multiple reports for test scope ${source.scopeId}: ${owner}, ${shared.reportId}`);
+                ownerByScopedExecution.set(key, shared.reportId);
+            }
+            prepared.push({
+                ...shared,
+                scopeId: source.scopeId
+            });
+            continue;
+        }
+        if (!source.dumpPath && !existsSync(source.sourcePath)) throw new Error(`Agent report does not exist: ${source.sourcePath}`);
+        const sourceVersion = source.dumpPath ? void 0 : peekReportSdkVersion(source.sourcePath);
         const currentVersion = getVersion();
         if (sourceVersion && currentVersion && sourceVersion !== currentVersion && !warnedMismatchedVersions.has(sourceVersion)) {
             warnedMismatchedVersions.add(sourceVersion);
             logMsg(`[@midscene/core] TestRunReportAssembler version mismatch: source report was written by @midscene/core@${sourceVersion} but the assembler is @midscene/core@${currentVersion}. Align the workspace package versions before generating the Midscene Test report.`);
         }
         const reportId = `runner-report-${sourceIndex + 1}`;
-        const { baseDump, executions } = collectDedupedExecutions(source.sourcePath);
+        const snapshot = source.dumpPath ? ReportActionDump.fromSerializedString(loadedDumps?.get(source.dumpPath) ?? readFileSync(source.dumpPath, 'utf8')) : void 0;
+        const { baseDump, executions } = snapshot ? {
+            baseDump: snapshot,
+            executions: snapshot.executions
+        } : collectDedupedExecutions(source.sourcePath);
         const executionIds = [];
         for (const execution of executions){
             if (!execution.id) continue;
@@ -301,32 +355,124 @@ const prepareTestRunReportSources = (sources)=>{
             deviceType: baseDump.deviceType,
             executions
         });
-        const sourceMetrics = collectReportSummary(dump);
-        metrics.modelCallCount += sourceMetrics.timing.modelCallCount;
-        metrics.modelTimeMs += sourceMetrics.timing.modelCallTimeMs;
-        metrics.promptTokens += sourceMetrics.tokens.promptTokens;
-        metrics.cachedInputTokens += sourceMetrics.tokens.cachedInputTokens;
-        metrics.completionTokens += sourceMetrics.tokens.completionTokens;
-        metrics.totalTokens += sourceMetrics.tokens.totalTokens;
-        prepared.push({
+        const preparedSource = {
             reportId,
             scopeId: source.scopeId,
             sourcePath: source.sourcePath,
             executionIds,
             dump,
-            directoryMode: isDirectoryModeReport(source.sourcePath)
-        });
+            directoryMode: !!source.dumpPath || isDirectoryModeReport(source.sourcePath),
+            ...source.dumpPath ? {
+                dumpPath: source.dumpPath
+            } : {}
+        };
+        prepared.push(preparedSource);
+        preparedByPath.set(sourceKey, preparedSource);
     }
+    const summary = collectReportSummary({
+        executions: dedupeExecutionsKeepLatest([
+            ...preparedByPath.values()
+        ].flatMap((source)=>source.dump.executions))
+    });
     return {
         sources: prepared,
-        metrics
+        metrics: {
+            modelCallCount: summary.timing.modelCallCount,
+            modelTimeMs: summary.timing.modelCallTimeMs,
+            ...summary.tokens
+        }
     };
 };
-const runnerDumpScript = (dump)=>{
-    const closeTag = "<\/script>";
-    return '<script type="' + TEST_RUN_REPORT_SCRIPT_TYPE + '">\n' + escapeScriptTag(JSON.stringify(dump)) + '\n' + closeTag + '\n';
-};
 class TestRunReportAssembler {
+    async assembleAsync(options) {
+        validateTestRunReportFileName(options.reportFileName);
+        const loaded = new Map();
+        await Promise.all(options.sources.map(async (source)=>{
+            if (source.dumpPath) loaded.set(source.dumpPath, await readFile(source.dumpPath, 'utf8'));
+        }));
+        const prepared = prepareTestRunReportSources(options.sources, loaded);
+        const dump = options.buildRunnerDump({
+            sources: prepared.sources,
+            metrics: prepared.metrics
+        });
+        if ('test-runner' !== dump.kind || 1 !== dump.schemaVersion) throw new Error('Invalid Runner report dump');
+        const directoryMode = prepared.sources.some((source)=>source.directoryMode);
+        const outputDir = resolve(options.outputDir);
+        await mkdir(outputDir, {
+            recursive: true
+        });
+        const artifact = join(outputDir, options.reportFileName);
+        const finalPath = directoryMode ? join(artifact, 'index.html') : `${artifact}.html`;
+        if (!options.overwrite && (existsSync(artifact) || existsSync(`${artifact}.html`))) throw new Error(`Report artifact already exists: ${artifact}`);
+        const temporary = await mkdtemp(join(outputDir, '.test-run-report-'));
+        const htmlPath = join(temporary, 'index.html');
+        try {
+            const parts = [
+                getReportTpl(),
+                directoryMode ? getBaseUrlFixScript() : ''
+            ];
+            const imageIds = new Set();
+            const reports = [];
+            for (const source of new Map(prepared.sources.map((source)=>[
+                    source.reportId,
+                    source
+                ])).values()){
+                const serialized = source.dump.serialize();
+                if (source.dumpPath) {
+                    const refs = new Map();
+                    JSON.parse(serialized, (_key, value)=>{
+                        const ref = normalizeStoredImageRef(value);
+                        if (ref) refs.set(ref.id, ref);
+                        return value;
+                    });
+                    if (refs.size) await mkdir(join(temporary, 'screenshots'), {
+                        recursive: true
+                    });
+                    for (const ref of refs.values())if (!imageIds.has(ref.id)) {
+                        if ('file' !== ref.storage || !ref.path) throw new Error(`Snapshot image ${ref.id} has no file source`);
+                        await copyFile(resolve(dirname(source.dumpPath), ref.path), join(temporary, 'screenshots', `${ref.id}.${imageRefFileExtension(ref)}`));
+                        imageIds.add(ref.id);
+                    }
+                } else if (source.directoryMode) {
+                    const images = join(dirname(source.sourcePath), 'screenshots');
+                    if (existsSync(images)) await cp(images, join(temporary, 'screenshots'), {
+                        recursive: true
+                    });
+                } else {
+                    const html = await readFile(source.sourcePath, 'utf8');
+                    for (const match of html.matchAll(/<script\b([^>]*)>[\s\S]*?<\/script>/g))if (/(?:^|\s)type=["']midscene-image["']/.test(match[1])) parts.push(match[0]);
+                }
+                reports.push(source.dump);
+                parts.push(reportHTMLContent({
+                    dumpString: serialized,
+                    attributes: {
+                        'data-group-id': source.reportId,
+                        'data-report-id': source.reportId,
+                        'data-runner-scope-id': source.scopeId,
+                        [DATA_SCREENSHOT_MODE_ATTR]: directoryMode ? 'directory' : 'inline'
+                    }
+                }, void 0, void 0, false));
+            }
+            parts.push(generateTestRunReportScriptTag(dump), mergedAgentReportComment(reports));
+            await writeFile(htmlPath, parts.join('\n'));
+            if (options.overwrite) {
+                await rm(artifact, {
+                    recursive: true,
+                    force: true
+                });
+                await rm(`${artifact}.html`, {
+                    force: true
+                });
+            }
+            await rename(directoryMode ? temporary : htmlPath, directoryMode ? artifact : finalPath);
+            return finalPath;
+        } finally{
+            await rm(temporary, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
     assemble(options) {
         validateTestRunReportFileName(options.reportFileName);
         const outputDir = resolve(options.outputDir);
@@ -369,7 +515,10 @@ class TestRunReportAssembler {
             appendFileSync(temporaryReportPath, -1 === htmlEndIndex ? template : template.slice(0, htmlEndIndex));
             if (directoryMode) appendFileSync(temporaryReportPath, getBaseUrlFixScript());
             const agentReports = [];
-            for (const source of prepared.sources){
+            for (const source of new Map(prepared.sources.map((source)=>[
+                    source.reportId,
+                    source
+                ])).values()){
                 if (source.directoryMode) {
                     const screenshotsDir = join(dirname(source.sourcePath), 'screenshots');
                     if (existsSync(screenshotsDir)) {
@@ -391,7 +540,7 @@ class TestRunReportAssembler {
                     }
                 }, void 0, void 0, false)}\n`);
             }
-            appendFileSync(temporaryReportPath, runnerDumpScript(runnerDump));
+            appendFileSync(temporaryReportPath, generateTestRunReportScriptTag(runnerDump));
             const agentComment = mergedAgentReportComment(agentReports);
             if (agentComment) appendFileSync(temporaryReportPath, agentComment);
             appendFileSync(temporaryReportPath, `${htmlEndTag}\n`);