@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/lib/report.js

@@ -33,6 +33,7 @@ __webpack_require__.d(__webpack_exports__, {
     TestRunReportAssembler: ()=>TestRunReportAssembler
 });
 const external_node_fs_namespaceObject = require("node:fs");
+const promises_namespaceObject = require("node:fs/promises");
 const external_node_path_namespaceObject = require("node:path");
 const common_namespaceObject = require("@midscene/shared/common");
 const utils_namespaceObject = require("@midscene/shared/utils");
@@ -41,7 +42,7 @@ const html_utils_js_namespaceObject = require("./dump/html-utils.js");
 const image_reference_js_namespaceObject = require("./dump/image-reference.js");
 const screenshot_store_js_namespaceObject = require("./dump/screenshot-store.js");
 const external_report_stats_js_namespaceObject = require("./report-stats.js");
-const external_test_run_report_js_namespaceObject = require("./test-run-report.js");
+const merge_report_js_namespaceObject = require("./test-runner/reporting/merge-report.js");
 const external_types_js_namespaceObject = require("./types.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 function _define_property(obj, key, value) {
@@ -122,7 +123,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 (0, html_utils_js_namespaceObject.generateAgentReportComment)(mergedReport);
 }
@@ -172,6 +173,8 @@ class ReportMergingTool {
             (0, utils_namespaceObject.logMsg)('No reports to merge');
             return null;
         }
+        const runnerDumps = this.reportInfos.map((info)=>info.reportFilePath ? (0, html_utils_js_namespaceObject.extractTestRunReportDumpSync)(info.reportFilePath) : void 0);
+        const hasRunnerDump = runnerDumps.some(Boolean);
         const targetDir = outputDir ? external_node_path_namespaceObject.resolve(outputDir) : (0, common_namespaceObject.getMidsceneRunSubDir)('report');
         if (outputDir) (0, external_node_fs_namespaceObject.mkdirSync)(targetDir, {
             recursive: true
@@ -200,6 +203,7 @@ class ReportMergingTool {
             (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, tplWithoutClose);
             if (hasDirectoryModeReport) (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, (0, html_utils_js_namespaceObject.getBaseUrlFixScript)());
             const agentReports = [];
+            const runnerSources = [];
             const writtenInlineImageIds = new Set();
             for(let i = 0; i < this.reportInfos.length; i++){
                 const reportInfo = this.reportInfos[i];
@@ -225,16 +229,26 @@ class ReportMergingTool {
                     } else (0, html_utils_js_namespaceObject.streamImageScriptsToFile)(reportInfo.reportFilePath, outputFilePath, writtenInlineImageIds);
                     const allDumps = (0, html_utils_js_namespaceObject.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)) : (0, html_utils_js_namespaceObject.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 = `${(0, external_utils_js_namespaceObject.reportHTMLContent)({
                     dumpString,
                     attributes: {
                         'data-group-id': mergedGroupId,
+                        ...hasRunnerDump ? {
+                            'data-report-id': mergedGroupId
+                        } : {},
                         [html_utils_js_namespaceObject.DATA_SCREENSHOT_MODE_ATTR]: hasDirectoryModeReport ? 'directory' : 'inline',
                         playwright_test_duration: reportAttributes.testDuration,
                         playwright_test_status: reportAttributes.testStatus,
@@ -246,6 +260,16 @@ class ReportMergingTool {
                 }, void 0, void 0, false)}\n`;
                 (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, reportHtmlStr);
             }
+            if (hasRunnerDump) {
+                const summary = (0, external_report_stats_js_namespaceObject.collectReportSummary)({
+                    executions: dedupeExecutionsKeepLatest(agentReports.flatMap((report)=>report.executions))
+                });
+                (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, (0, html_utils_js_namespaceObject.generateTestRunReportScriptTag)((0, merge_report_js_namespaceObject.mergeTestRunReportDumps)(runnerSources, {
+                    modelCallCount: summary.timing.modelCallCount,
+                    modelTimeMs: summary.timing.modelCallTimeMs,
+                    ...summary.tokens
+                }, (0, utils_namespaceObject.uuid)())));
+            }
             const agentComment = mergedAgentReportComment(agentReports);
             if (agentComment) (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, agentComment);
             (0, external_node_fs_namespaceObject.appendFileSync)(outputFilePath, `${htmlEndTag}\n`);
@@ -274,28 +298,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 = (0, external_report_stats_js_namespaceObject.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 || external_node_path_namespaceObject.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 = external_node_path_namespaceObject.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
         });
@@ -304,20 +329,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 (!(0, external_node_fs_namespaceObject.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 = external_types_js_namespaceObject.ReportActionDump.fromSerializedString(loadedDumps?.get(source.dumpPath) ?? (0, external_node_fs_namespaceObject.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 && !(0, external_node_fs_namespaceObject.existsSync)(source.sourcePath)) throw new Error(`Agent report does not exist: ${source.sourcePath}`);
+        const sourceVersion = source.dumpPath ? void 0 : peekReportSdkVersion(source.sourcePath);
         const currentVersion = (0, external_utils_js_namespaceObject.getVersion)();
         if (sourceVersion && currentVersion && sourceVersion !== currentVersion && !warnedMismatchedVersions.has(sourceVersion)) {
             warnedMismatchedVersions.add(sourceVersion);
             (0, utils_namespaceObject.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 ? external_types_js_namespaceObject.ReportActionDump.fromSerializedString(loadedDumps?.get(source.dumpPath) ?? (0, external_node_fs_namespaceObject.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;
@@ -335,32 +389,124 @@ const prepareTestRunReportSources = (sources)=>{
             deviceType: baseDump.deviceType,
             executions
         });
-        const sourceMetrics = (0, external_report_stats_js_namespaceObject.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 = (0, external_report_stats_js_namespaceObject.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="' + external_test_run_report_js_namespaceObject.TEST_RUN_REPORT_SCRIPT_TYPE + '">\n' + (0, utils_namespaceObject.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 promises_namespaceObject.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 = external_node_path_namespaceObject.resolve(options.outputDir);
+        await promises_namespaceObject.mkdir(outputDir, {
+            recursive: true
+        });
+        const artifact = external_node_path_namespaceObject.join(outputDir, options.reportFileName);
+        const finalPath = directoryMode ? external_node_path_namespaceObject.join(artifact, 'index.html') : `${artifact}.html`;
+        if (!options.overwrite && ((0, external_node_fs_namespaceObject.existsSync)(artifact) || (0, external_node_fs_namespaceObject.existsSync)(`${artifact}.html`))) throw new Error(`Report artifact already exists: ${artifact}`);
+        const temporary = await promises_namespaceObject.mkdtemp(external_node_path_namespaceObject.join(outputDir, '.test-run-report-'));
+        const htmlPath = external_node_path_namespaceObject.join(temporary, 'index.html');
+        try {
+            const parts = [
+                (0, external_utils_js_namespaceObject.getReportTpl)(),
+                directoryMode ? (0, html_utils_js_namespaceObject.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 = (0, image_reference_js_namespaceObject.normalizeStoredImageRef)(value);
+                        if (ref) refs.set(ref.id, ref);
+                        return value;
+                    });
+                    if (refs.size) await promises_namespaceObject.mkdir(external_node_path_namespaceObject.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 promises_namespaceObject.copyFile(external_node_path_namespaceObject.resolve(external_node_path_namespaceObject.dirname(source.dumpPath), ref.path), external_node_path_namespaceObject.join(temporary, 'screenshots', `${ref.id}.${(0, image_reference_js_namespaceObject.imageRefFileExtension)(ref)}`));
+                        imageIds.add(ref.id);
+                    }
+                } else if (source.directoryMode) {
+                    const images = external_node_path_namespaceObject.join(external_node_path_namespaceObject.dirname(source.sourcePath), 'screenshots');
+                    if ((0, external_node_fs_namespaceObject.existsSync)(images)) await promises_namespaceObject.cp(images, external_node_path_namespaceObject.join(temporary, 'screenshots'), {
+                        recursive: true
+                    });
+                } else {
+                    const html = await promises_namespaceObject.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((0, external_utils_js_namespaceObject.reportHTMLContent)({
+                    dumpString: serialized,
+                    attributes: {
+                        'data-group-id': source.reportId,
+                        'data-report-id': source.reportId,
+                        'data-runner-scope-id': source.scopeId,
+                        [html_utils_js_namespaceObject.DATA_SCREENSHOT_MODE_ATTR]: directoryMode ? 'directory' : 'inline'
+                    }
+                }, void 0, void 0, false));
+            }
+            parts.push((0, html_utils_js_namespaceObject.generateTestRunReportScriptTag)(dump), mergedAgentReportComment(reports));
+            await promises_namespaceObject.writeFile(htmlPath, parts.join('\n'));
+            if (options.overwrite) {
+                await promises_namespaceObject.rm(artifact, {
+                    recursive: true,
+                    force: true
+                });
+                await promises_namespaceObject.rm(`${artifact}.html`, {
+                    force: true
+                });
+            }
+            await promises_namespaceObject.rename(directoryMode ? temporary : htmlPath, directoryMode ? artifact : finalPath);
+            return finalPath;
+        } finally{
+            await promises_namespaceObject.rm(temporary, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
     assemble(options) {
         validateTestRunReportFileName(options.reportFileName);
         const outputDir = external_node_path_namespaceObject.resolve(options.outputDir);
@@ -403,7 +549,10 @@ class TestRunReportAssembler {
             (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, -1 === htmlEndIndex ? template : template.slice(0, htmlEndIndex));
             if (directoryMode) (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, (0, html_utils_js_namespaceObject.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 = external_node_path_namespaceObject.join(external_node_path_namespaceObject.dirname(source.sourcePath), 'screenshots');
                     if ((0, external_node_fs_namespaceObject.existsSync)(screenshotsDir)) {
@@ -425,7 +574,7 @@ class TestRunReportAssembler {
                     }
                 }, void 0, void 0, false)}\n`);
             }
-            (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, runnerDumpScript(runnerDump));
+            (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, (0, html_utils_js_namespaceObject.generateTestRunReportScriptTag)(runnerDump));
             const agentComment = mergedAgentReportComment(agentReports);
             if (agentComment) (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, agentComment);
             (0, external_node_fs_namespaceObject.appendFileSync)(temporaryReportPath, `${htmlEndTag}\n`);