Mm 67896 manual cherry pick onto release 10.11 (#35989)

* improves time limit checks

* consistently check for presence of patch fields

* fix variable shadowing in test

* allow idempotent pinning operations with time limit expired

* new utility function for post limit time check

* fix style issue

* Add missing E2E CI files and delivery-platform migration for release-10.11

- Add calculate-playwright-results and calculate-cypress-results GitHub Actions
  (referenced by e2e-tests-playwright-template.yml and e2e-tests-cypress-template.yml
  but never backported to release-10.11)
- Add e2e-tests/playwright/merge.config.mjs (required by merge-reports step)
- Add run-specs Makefile target and server.run_specs.sh (required by run-failed-tests job)
- Fix merge-shard-results step: pin @playwright/test version and add fallback
  for when no blob reports exist (json reporter output used directly)
- Remove pull_request trigger from e2e-tests-ci.yml (delivery-platform migration)
- Remove dead e2e-fulltests-ci.yml and e2e-tests-ci-template.yml

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Mattermost Build <build@mattermost.com>
Co-authored-by: yasserfaraazkhan <attitude3cena.yf@gmail.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

.github/actions/calculate-cypress-results/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.env

.github/actions/calculate-cypress-results/action.yaml

@@ -0,0 +1,50 @@
+name: Calculate Cypress Results
+description: Calculate Cypress test results with optional merge of retest results
+author: Mattermost
+
+inputs:
+  original-results-path:
+    description: Path to the original Cypress results directory (e.g., e2e-tests/cypress/results)
+    required: true
+  retest-results-path:
+    description: Path to the retest Cypress results directory (optional - if not provided, only calculates from original)
+    required: false
+  write-merged:
+    description: Whether to write merged results back to the original directory (default true)
+    required: false
+    default: "true"
+
+outputs:
+  # Merge outputs
+  merged:
+    description: Whether merge was performed (true/false)
+
+  # Calculation outputs (same as calculate-cypress-test-results)
+  passed:
+    description: Number of passed tests
+  failed:
+    description: Number of failed tests
+  pending:
+    description: Number of pending/skipped tests
+  total_specs:
+    description: Total number of spec files
+  commit_status_message:
+    description: Message for commit status (e.g., "X failed, Y passed (Z spec files)")
+  failed_specs:
+    description: Comma-separated list of failed spec files (for retest)
+  failed_specs_count:
+    description: Number of failed spec files
+  failed_tests:
+    description: Markdown table rows of failed tests (for GitHub summary)
+  total:
+    description: Total number of tests (passed + failed)
+  pass_rate:
+    description: Pass rate percentage (e.g., "100.00")
+  color:
+    description: Color for webhook based on pass rate (green=100%, yellow=99%+, orange=98%+, red=<98%)
+  test_duration:
+    description: Wall-clock test duration (earliest start to latest end across all specs, formatted as "Xm Ys")
+
+runs:
+  using: node24
+  main: dist/index.js

.github/actions/calculate-cypress-results/jest.config.js

@@ -0,0 +1,15 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    testMatch: ["**/*.test.ts"],
+    moduleFileExtensions: ["ts", "js"],
+    transform: {
+        "^.+\\.ts$": [
+            "ts-jest",
+            {
+                useESM: false,
+            },
+        ],
+    },
+};

.github/actions/calculate-cypress-results/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "calculate-cypress-results",
+  "private": true,
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsup",
+    "prettier": "npx prettier --write \"src/**/*.ts\"",
+    "local-action": "local-action . src/main.ts .env",
+    "test": "jest --verbose",
+    "test:watch": "jest --watch --verbose",
+    "test:silent": "jest --silent",
+    "tsc": "tsc -b"
+  },
+  "dependencies": {
+    "@actions/core": "3.0.0"
+  },
+  "devDependencies": {
+    "@github/local-action": "7.0.0",
+    "@types/jest": "30.0.0",
+    "@types/node": "25.2.0",
+    "jest": "30.2.0",
+    "ts-jest": "29.4.6",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3"
+  }
+}

.github/actions/calculate-cypress-results/src/index.ts

@@ -0,0 +1,3 @@
+import { run } from "./main";
+
+run();

.github/actions/calculate-cypress-results/src/main.ts

@@ -0,0 +1,101 @@
+import * as core from "@actions/core";
+import {
+    loadSpecFiles,
+    mergeResults,
+    writeMergedResults,
+    calculateResultsFromSpecs,
+} from "./merge";
+
+export async function run(): Promise<void> {
+    const originalPath = core.getInput("original-results-path", {
+        required: true,
+    });
+    const retestPath = core.getInput("retest-results-path"); // Optional
+    const shouldWriteMerged = core.getInput("write-merged") !== "false"; // Default true
+
+    core.info(`Original results: ${originalPath}`);
+    core.info(`Retest results: ${retestPath || "(not provided)"}`);
+
+    let merged = false;
+    let specs;
+
+    if (retestPath) {
+        // Check if retest path has results
+        const retestSpecs = await loadSpecFiles(retestPath);
+
+        if (retestSpecs.length > 0) {
+            core.info(`Found ${retestSpecs.length} retest spec files`);
+
+            // Merge results
+            core.info("Merging results...");
+            const mergeResult = await mergeResults(originalPath, retestPath);
+            specs = mergeResult.specs;
+            merged = true;
+
+            core.info(`Retested specs: ${mergeResult.retestFiles.join(", ")}`);
+            core.info(`Total merged specs: ${specs.length}`);
+
+            // Write merged results back to original directory
+            if (shouldWriteMerged) {
+                core.info("Writing merged results to original directory...");
+                const writeResult = await writeMergedResults(
+                    originalPath,
+                    retestPath,
+                );
+                core.info(`Updated files: ${writeResult.updatedFiles.length}`);
+                core.info(
+                    `Removed duplicates: ${writeResult.removedFiles.length}`,
+                );
+            }
+        } else {
+            core.warning(
+                `No retest results found at ${retestPath}, using original only`,
+            );
+            specs = await loadSpecFiles(originalPath);
+        }
+    } else {
+        core.info("No retest path provided, using original results only");
+        specs = await loadSpecFiles(originalPath);
+    }
+
+    core.info(`Calculating results from ${specs.length} spec files...`);
+
+    // Handle case where no results found
+    if (specs.length === 0) {
+        core.setFailed("No Cypress test results found");
+        return;
+    }
+
+    // Calculate all outputs from final results
+    const calc = calculateResultsFromSpecs(specs);
+
+    // Log results
+    core.startGroup("Final Results");
+    core.info(`Passed: ${calc.passed}`);
+    core.info(`Failed: ${calc.failed}`);
+    core.info(`Pending: ${calc.pending}`);
+    core.info(`Total: ${calc.total}`);
+    core.info(`Pass Rate: ${calc.passRate}%`);
+    core.info(`Color: ${calc.color}`);
+    core.info(`Spec Files: ${calc.totalSpecs}`);
+    core.info(`Failed Specs Count: ${calc.failedSpecsCount}`);
+    core.info(`Commit Status Message: ${calc.commitStatusMessage}`);
+    core.info(`Failed Specs: ${calc.failedSpecs || "none"}`);
+    core.info(`Test Duration: ${calc.testDuration}`);
+    core.endGroup();
+
+    // Set all outputs
+    core.setOutput("merged", merged.toString());
+    core.setOutput("passed", calc.passed);
+    core.setOutput("failed", calc.failed);
+    core.setOutput("pending", calc.pending);
+    core.setOutput("total_specs", calc.totalSpecs);
+    core.setOutput("commit_status_message", calc.commitStatusMessage);
+    core.setOutput("failed_specs", calc.failedSpecs);
+    core.setOutput("failed_specs_count", calc.failedSpecsCount);
+    core.setOutput("failed_tests", calc.failedTests);
+    core.setOutput("total", calc.total);
+    core.setOutput("pass_rate", calc.passRate);
+    core.setOutput("color", calc.color);
+    core.setOutput("test_duration", calc.testDuration);
+}

.github/actions/calculate-cypress-results/src/merge.test.ts

@@ -0,0 +1,271 @@
+import { calculateResultsFromSpecs } from "./merge";
+import type { ParsedSpecFile, MochawesomeResult } from "./types";
+
+/**
+ * Helper to create a mochawesome result for testing
+ */
+function createMochawesomeResult(
+    specFile: string,
+    tests: { title: string; state: "passed" | "failed" | "pending" }[],
+): MochawesomeResult {
+    return {
+        stats: {
+            suites: 1,
+            tests: tests.length,
+            passes: tests.filter((t) => t.state === "passed").length,
+            pending: tests.filter((t) => t.state === "pending").length,
+            failures: tests.filter((t) => t.state === "failed").length,
+            start: new Date().toISOString(),
+            end: new Date().toISOString(),
+            duration: 1000,
+            testsRegistered: tests.length,
+            passPercent: 0,
+            pendingPercent: 0,
+            other: 0,
+            hasOther: false,
+            skipped: 0,
+            hasSkipped: false,
+        },
+        results: [
+            {
+                uuid: "uuid-1",
+                title: specFile,
+                fullFile: `/app/e2e-tests/cypress/tests/integration/${specFile}`,
+                file: `tests/integration/${specFile}`,
+                beforeHooks: [],
+                afterHooks: [],
+                tests: tests.map((t, i) => ({
+                    title: t.title,
+                    fullTitle: `${specFile} > ${t.title}`,
+                    timedOut: null,
+                    duration: 500,
+                    state: t.state,
+                    speed: "fast",
+                    pass: t.state === "passed",
+                    fail: t.state === "failed",
+                    pending: t.state === "pending",
+                    context: null,
+                    code: "",
+                    err: t.state === "failed" ? { message: "Test failed" } : {},
+                    uuid: `test-uuid-${i}`,
+                    parentUUID: "uuid-1",
+                    isHook: false,
+                    skipped: false,
+                })),
+                suites: [],
+                passes: tests
+                    .filter((t) => t.state === "passed")
+                    .map((_, i) => `test-uuid-${i}`),
+                failures: tests
+                    .filter((t) => t.state === "failed")
+                    .map((_, i) => `test-uuid-${i}`),
+                pending: tests
+                    .filter((t) => t.state === "pending")
+                    .map((_, i) => `test-uuid-${i}`),
+                skipped: [],
+                duration: 1000,
+                root: true,
+                rootEmpty: false,
+                _timeout: 60000,
+            },
+        ],
+    };
+}
+
+function createParsedSpecFile(
+    specFile: string,
+    tests: { title: string; state: "passed" | "failed" | "pending" }[],
+): ParsedSpecFile {
+    return {
+        filePath: `/path/to/${specFile}.json`,
+        specPath: `tests/integration/${specFile}`,
+        result: createMochawesomeResult(specFile, tests),
+    };
+}
+
+describe("calculateResultsFromSpecs", () => {
+    it("should calculate all outputs correctly for passing results", () => {
+        const specs: ParsedSpecFile[] = [
+            createParsedSpecFile("login.spec.ts", [
+                {
+                    title: "should login with valid credentials",
+                    state: "passed",
+                },
+            ]),
+            createParsedSpecFile("messaging.spec.ts", [
+                { title: "should send a message", state: "passed" },
+            ]),
+        ];
+
+        const calc = calculateResultsFromSpecs(specs);
+
+        expect(calc.passed).toBe(2);
+        expect(calc.failed).toBe(0);
+        expect(calc.pending).toBe(0);
+        expect(calc.total).toBe(2);
+        expect(calc.passRate).toBe("100.00");
+        expect(calc.color).toBe("#43A047"); // green
+        expect(calc.totalSpecs).toBe(2);
+        expect(calc.failedSpecs).toBe("");
+        expect(calc.failedSpecsCount).toBe(0);
+        expect(calc.commitStatusMessage).toBe("100% passed (2), 2 specs");
+    });
+
+    it("should calculate all outputs correctly for results with failures", () => {
+        const specs: ParsedSpecFile[] = [
+            createParsedSpecFile("login.spec.ts", [
+                {
+                    title: "should login with valid credentials",
+                    state: "passed",
+                },
+            ]),
+            createParsedSpecFile("channels.spec.ts", [
+                { title: "should create a channel", state: "failed" },
+            ]),
+        ];
+
+        const calc = calculateResultsFromSpecs(specs);
+
+        expect(calc.passed).toBe(1);
+        expect(calc.failed).toBe(1);
+        expect(calc.pending).toBe(0);
+        expect(calc.total).toBe(2);
+        expect(calc.passRate).toBe("50.00");
+        expect(calc.color).toBe("#F44336"); // red
+        expect(calc.totalSpecs).toBe(2);
+        expect(calc.failedSpecs).toBe("tests/integration/channels.spec.ts");
+        expect(calc.failedSpecsCount).toBe(1);
+        expect(calc.commitStatusMessage).toBe(
+            "50.0% passed (1/2), 1 failed, 2 specs",
+        );
+        expect(calc.failedTests).toContain("should create a channel");
+    });
+
+    it("should handle pending tests correctly", () => {
+        const specs: ParsedSpecFile[] = [
+            createParsedSpecFile("login.spec.ts", [
+                { title: "should login", state: "passed" },
+                { title: "should logout", state: "pending" },
+            ]),
+        ];
+
+        const calc = calculateResultsFromSpecs(specs);
+
+        expect(calc.passed).toBe(1);
+        expect(calc.failed).toBe(0);
+        expect(calc.pending).toBe(1);
+        expect(calc.total).toBe(1); // Total excludes pending
+        expect(calc.passRate).toBe("100.00");
+    });
+
+    it("should limit failed tests to 10 entries", () => {
+        const specs: ParsedSpecFile[] = [
+            createParsedSpecFile("big-test.spec.ts", [
+                { title: "test 1", state: "failed" },
+                { title: "test 2", state: "failed" },
+                { title: "test 3", state: "failed" },
+                { title: "test 4", state: "failed" },
+                { title: "test 5", state: "failed" },
+                { title: "test 6", state: "failed" },
+                { title: "test 7", state: "failed" },
+                { title: "test 8", state: "failed" },
+                { title: "test 9", state: "failed" },
+                { title: "test 10", state: "failed" },
+                { title: "test 11", state: "failed" },
+                { title: "test 12", state: "failed" },
+            ]),
+        ];
+
+        const calc = calculateResultsFromSpecs(specs);
+
+        expect(calc.failed).toBe(12);
+        expect(calc.failedTests).toContain("...and 2 more failed tests");
+    });
+});
+
+describe("merge simulation", () => {
+    it("should produce correct results when merging original with retest", () => {
+        // Simulate original: 2 passed, 1 failed
+        const originalSpecs: ParsedSpecFile[] = [
+            createParsedSpecFile("login.spec.ts", [
+                { title: "should login", state: "passed" },
+            ]),
+            createParsedSpecFile("messaging.spec.ts", [
+                { title: "should send message", state: "passed" },
+            ]),
+            createParsedSpecFile("channels.spec.ts", [
+                { title: "should create channel", state: "failed" },
+            ]),
+        ];
+
+        // Verify original has failure
+        const originalCalc = calculateResultsFromSpecs(originalSpecs);
+        expect(originalCalc.passed).toBe(2);
+        expect(originalCalc.failed).toBe(1);
+        expect(originalCalc.passRate).toBe("66.67");
+
+        // Simulate retest: channels.spec.ts now passes
+        const retestSpec = createParsedSpecFile("channels.spec.ts", [
+            { title: "should create channel", state: "passed" },
+        ]);
+
+        // Simulate merge: replace original channels.spec.ts with retest
+        const specMap = new Map<string, ParsedSpecFile>();
+        for (const spec of originalSpecs) {
+            specMap.set(spec.specPath, spec);
+        }
+        specMap.set(retestSpec.specPath, retestSpec);
+
+        const mergedSpecs = Array.from(specMap.values());
+
+        // Calculate final results
+        const finalCalc = calculateResultsFromSpecs(mergedSpecs);
+
+        expect(finalCalc.passed).toBe(3);
+        expect(finalCalc.failed).toBe(0);
+        expect(finalCalc.pending).toBe(0);
+        expect(finalCalc.total).toBe(3);
+        expect(finalCalc.passRate).toBe("100.00");
+        expect(finalCalc.color).toBe("#43A047"); // green
+        expect(finalCalc.totalSpecs).toBe(3);
+        expect(finalCalc.failedSpecs).toBe("");
+        expect(finalCalc.failedSpecsCount).toBe(0);
+        expect(finalCalc.commitStatusMessage).toBe("100% passed (3), 3 specs");
+    });
+
+    it("should handle case where retest still fails", () => {
+        // Original: 1 passed, 1 failed
+        const originalSpecs: ParsedSpecFile[] = [
+            createParsedSpecFile("login.spec.ts", [
+                { title: "should login", state: "passed" },
+            ]),
+            createParsedSpecFile("channels.spec.ts", [
+                { title: "should create channel", state: "failed" },
+            ]),
+        ];
+
+        // Retest: channels.spec.ts still fails
+        const retestSpec = createParsedSpecFile("channels.spec.ts", [
+            { title: "should create channel", state: "failed" },
+        ]);
+
+        // Merge
+        const specMap = new Map<string, ParsedSpecFile>();
+        for (const spec of originalSpecs) {
+            specMap.set(spec.specPath, spec);
+        }
+        specMap.set(retestSpec.specPath, retestSpec);
+
+        const mergedSpecs = Array.from(specMap.values());
+        const finalCalc = calculateResultsFromSpecs(mergedSpecs);
+
+        expect(finalCalc.passed).toBe(1);
+        expect(finalCalc.failed).toBe(1);
+        expect(finalCalc.passRate).toBe("50.00");
+        expect(finalCalc.color).toBe("#F44336"); // red
+        expect(finalCalc.failedSpecs).toBe(
+            "tests/integration/channels.spec.ts",
+        );
+        expect(finalCalc.failedSpecsCount).toBe(1);
+    });
+});

.github/actions/calculate-cypress-results/src/merge.ts

@@ -0,0 +1,358 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type {
+    MochawesomeResult,
+    ParsedSpecFile,
+    CalculationResult,
+    FailedTest,
+    TestItem,
+    SuiteItem,
+    ResultItem,
+} from "./types";
+
+/**
+ * Find all JSON files in a directory recursively
+ */
+async function findJsonFiles(dir: string): Promise<string[]> {
+    const files: string[] = [];
+
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const subFiles = await findJsonFiles(fullPath);
+                files.push(...subFiles);
+            } else if (entry.isFile() && entry.name.endsWith(".json")) {
+                files.push(fullPath);
+            }
+        }
+    } catch {
+        // Directory doesn't exist or not accessible
+    }
+
+    return files;
+}
+
+/**
+ * Parse a mochawesome JSON file
+ */
+async function parseSpecFile(filePath: string): Promise<ParsedSpecFile | null> {
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        const result: MochawesomeResult = JSON.parse(content);
+
+        // Extract spec path from results[0].file
+        const specPath = result.results?.[0]?.file;
+        if (!specPath) {
+            return null;
+        }
+
+        return {
+            filePath,
+            specPath,
+            result,
+        };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Extract all tests from a result recursively
+ */
+function getAllTests(result: MochawesomeResult): TestItem[] {
+    const tests: TestItem[] = [];
+
+    function extractFromSuite(suite: SuiteItem | ResultItem) {
+        tests.push(...(suite.tests || []));
+        for (const nestedSuite of suite.suites || []) {
+            extractFromSuite(nestedSuite);
+        }
+    }
+
+    for (const resultItem of result.results || []) {
+        extractFromSuite(resultItem);
+    }
+
+    return tests;
+}
+
+/**
+ * Get color based on pass rate
+ */
+function getColor(passRate: number): string {
+    if (passRate === 100) {
+        return "#43A047"; // green
+    } else if (passRate >= 99) {
+        return "#FFEB3B"; // yellow
+    } else if (passRate >= 98) {
+        return "#FF9800"; // orange
+    } else {
+        return "#F44336"; // red
+    }
+}
+
+/**
+ * Calculate results from parsed spec files
+ */
+/**
+ * Format milliseconds as "Xm Ys"
+ */
+function formatDuration(ms: number): string {
+    const totalSeconds = Math.round(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}m ${seconds}s`;
+}
+
+export function calculateResultsFromSpecs(
+    specs: ParsedSpecFile[],
+): CalculationResult {
+    let passed = 0;
+    let failed = 0;
+    let pending = 0;
+    const failedSpecsSet = new Set<string>();
+    const failedTestsList: FailedTest[] = [];
+
+    for (const spec of specs) {
+        const tests = getAllTests(spec.result);
+
+        for (const test of tests) {
+            if (test.state === "passed") {
+                passed++;
+            } else if (test.state === "failed") {
+                failed++;
+                failedSpecsSet.add(spec.specPath);
+                failedTestsList.push({
+                    title: test.title,
+                    file: spec.specPath,
+                });
+            } else if (test.state === "pending") {
+                pending++;
+            }
+        }
+    }
+
+    // Compute test duration from earliest start to latest end across all specs
+    let earliestStart: number | null = null;
+    let latestEnd: number | null = null;
+    for (const spec of specs) {
+        const { start, end } = spec.result.stats;
+        if (start) {
+            const startMs = new Date(start).getTime();
+            if (earliestStart === null || startMs < earliestStart) {
+                earliestStart = startMs;
+            }
+        }
+        if (end) {
+            const endMs = new Date(end).getTime();
+            if (latestEnd === null || endMs > latestEnd) {
+                latestEnd = endMs;
+            }
+        }
+    }
+    const testDurationMs =
+        earliestStart !== null && latestEnd !== null
+            ? latestEnd - earliestStart
+            : 0;
+    const testDuration = formatDuration(testDurationMs);
+
+    const totalSpecs = specs.length;
+    const failedSpecs = Array.from(failedSpecsSet).join(",");
+    const failedSpecsCount = failedSpecsSet.size;
+
+    // Build failed tests markdown table (limit to 10)
+    let failedTests = "";
+    const uniqueFailedTests = failedTestsList.filter(
+        (test, index, self) =>
+            index ===
+            self.findIndex(
+                (t) => t.title === test.title && t.file === test.file,
+            ),
+    );
+
+    if (uniqueFailedTests.length > 0) {
+        const limitedTests = uniqueFailedTests.slice(0, 10);
+        failedTests = limitedTests
+            .map((t) => {
+                const escapedTitle = t.title
+                    .replace(/`/g, "\\`")
+                    .replace(/\|/g, "\\|");
+                return `| ${escapedTitle} | ${t.file} |`;
+            })
+            .join("\n");
+
+        if (uniqueFailedTests.length > 10) {
+            const remaining = uniqueFailedTests.length - 10;
+            failedTests += `\n| _...and ${remaining} more failed tests_ | |`;
+        }
+    } else if (failed > 0) {
+        failedTests = "| Unable to parse failed tests | - |";
+    }
+
+    // Calculate totals and pass rate
+    // Pass rate = passed / (passed + failed), excluding pending
+    const total = passed + failed;
+    const passRate = total > 0 ? ((passed * 100) / total).toFixed(2) : "0.00";
+    const color = getColor(parseFloat(passRate));
+
+    // Build commit status message
+    const rate = total > 0 ? (passed * 100) / total : 0;
+    const rateStr = rate === 100 ? "100%" : `${rate.toFixed(1)}%`;
+    const specSuffix = totalSpecs > 0 ? `, ${totalSpecs} specs` : "";
+    const commitStatusMessage =
+        rate === 100
+            ? `${rateStr} passed (${passed})${specSuffix}`
+            : `${rateStr} passed (${passed}/${total}), ${failed} failed${specSuffix}`;
+
+    return {
+        passed,
+        failed,
+        pending,
+        totalSpecs,
+        commitStatusMessage,
+        failedSpecs,
+        failedSpecsCount,
+        failedTests,
+        total,
+        passRate,
+        color,
+        testDuration,
+    };
+}
+
+/**
+ * Load all spec files from a mochawesome results directory
+ */
+export async function loadSpecFiles(
+    resultsPath: string,
+): Promise<ParsedSpecFile[]> {
+    // Mochawesome results are at: results/mochawesome-report/json/tests/
+    const mochawesomeDir = path.join(
+        resultsPath,
+        "mochawesome-report",
+        "json",
+        "tests",
+    );
+
+    const jsonFiles = await findJsonFiles(mochawesomeDir);
+    const specs: ParsedSpecFile[] = [];
+
+    for (const file of jsonFiles) {
+        const parsed = await parseSpecFile(file);
+        if (parsed) {
+            specs.push(parsed);
+        }
+    }
+
+    return specs;
+}
+
+/**
+ * Merge original and retest results
+ * - For each spec in retest, replace the matching spec in original
+ * - Keep original specs that are not in retest
+ */
+export async function mergeResults(
+    originalPath: string,
+    retestPath: string,
+): Promise<{
+    specs: ParsedSpecFile[];
+    retestFiles: string[];
+    mergedCount: number;
+}> {
+    const originalSpecs = await loadSpecFiles(originalPath);
+    const retestSpecs = await loadSpecFiles(retestPath);
+
+    // Build a map of original specs by spec path
+    const specMap = new Map<string, ParsedSpecFile>();
+    for (const spec of originalSpecs) {
+        specMap.set(spec.specPath, spec);
+    }
+
+    // Replace with retest results
+    const retestFiles: string[] = [];
+    for (const retestSpec of retestSpecs) {
+        specMap.set(retestSpec.specPath, retestSpec);
+        retestFiles.push(retestSpec.specPath);
+    }
+
+    return {
+        specs: Array.from(specMap.values()),
+        retestFiles,
+        mergedCount: retestSpecs.length,
+    };
+}
+
+/**
+ * Write merged results back to the original directory
+ * This updates the original JSON files with retest results
+ */
+export async function writeMergedResults(
+    originalPath: string,
+    retestPath: string,
+): Promise<{ updatedFiles: string[]; removedFiles: string[] }> {
+    const mochawesomeDir = path.join(
+        originalPath,
+        "mochawesome-report",
+        "json",
+        "tests",
+    );
+    const retestMochawesomeDir = path.join(
+        retestPath,
+        "mochawesome-report",
+        "json",
+        "tests",
+    );
+
+    const originalJsonFiles = await findJsonFiles(mochawesomeDir);
+    const retestJsonFiles = await findJsonFiles(retestMochawesomeDir);
+
+    const updatedFiles: string[] = [];
+    const removedFiles: string[] = [];
+
+    // For each retest file, find and replace the original
+    for (const retestFile of retestJsonFiles) {
+        const retestSpec = await parseSpecFile(retestFile);
+        if (!retestSpec) continue;
+
+        const specPath = retestSpec.specPath;
+
+        // Find all original files with matching spec path
+        // Prefer nested path (under integration/), remove flat duplicates
+        let nestedFile: string | null = null;
+        const flatFiles: string[] = [];
+
+        for (const origFile of originalJsonFiles) {
+            const origSpec = await parseSpecFile(origFile);
+            if (origSpec && origSpec.specPath === specPath) {
+                if (origFile.includes("/integration/")) {
+                    nestedFile = origFile;
+                } else {
+                    flatFiles.push(origFile);
+                }
+            }
+        }
+
+        // Update the nested file (proper location) or first flat file if no nested
+        const retestContent = await fs.readFile(retestFile, "utf8");
+
+        if (nestedFile) {
+            await fs.writeFile(nestedFile, retestContent);
+            updatedFiles.push(nestedFile);
+
+            // Remove flat duplicates
+            for (const flatFile of flatFiles) {
+                await fs.unlink(flatFile);
+                removedFiles.push(flatFile);
+            }
+        } else if (flatFiles.length > 0) {
+            await fs.writeFile(flatFiles[0], retestContent);
+            updatedFiles.push(flatFiles[0]);
+        }
+    }
+
+    return { updatedFiles, removedFiles };
+}

.github/actions/calculate-cypress-results/src/types.ts

@@ -0,0 +1,139 @@
+/**
+ * Mochawesome result structure for a single spec file
+ */
+export interface MochawesomeResult {
+    stats: MochawesomeStats;
+    results: ResultItem[];
+}
+
+export interface MochawesomeStats {
+    suites: number;
+    tests: number;
+    passes: number;
+    pending: number;
+    failures: number;
+    start: string;
+    end: string;
+    duration: number;
+    testsRegistered: number;
+    passPercent: number;
+    pendingPercent: number;
+    other: number;
+    hasOther: boolean;
+    skipped: number;
+    hasSkipped: boolean;
+}
+
+export interface ResultItem {
+    uuid: string;
+    title: string;
+    fullFile: string;
+    file: string;
+    beforeHooks: Hook[];
+    afterHooks: Hook[];
+    tests: TestItem[];
+    suites: SuiteItem[];
+    passes: string[];
+    failures: string[];
+    pending: string[];
+    skipped: string[];
+    duration: number;
+    root: boolean;
+    rootEmpty: boolean;
+    _timeout: number;
+}
+
+export interface SuiteItem {
+    uuid: string;
+    title: string;
+    fullFile: string;
+    file: string;
+    beforeHooks: Hook[];
+    afterHooks: Hook[];
+    tests: TestItem[];
+    suites: SuiteItem[];
+    passes: string[];
+    failures: string[];
+    pending: string[];
+    skipped: string[];
+    duration: number;
+    root: boolean;
+    rootEmpty: boolean;
+    _timeout: number;
+}
+
+export interface TestItem {
+    title: string;
+    fullTitle: string;
+    timedOut: boolean | null;
+    duration: number;
+    state: "passed" | "failed" | "pending";
+    speed: string | null;
+    pass: boolean;
+    fail: boolean;
+    pending: boolean;
+    context: string | null;
+    code: string;
+    err: TestError;
+    uuid: string;
+    parentUUID: string;
+    isHook: boolean;
+    skipped: boolean;
+}
+
+export interface TestError {
+    message?: string;
+    estack?: string;
+    diff?: string | null;
+}
+
+export interface Hook {
+    title: string;
+    fullTitle: string;
+    timedOut: boolean | null;
+    duration: number;
+    state: string | null;
+    speed: string | null;
+    pass: boolean;
+    fail: boolean;
+    pending: boolean;
+    context: string | null;
+    code: string;
+    err: TestError;
+    uuid: string;
+    parentUUID: string;
+    isHook: boolean;
+    skipped: boolean;
+}
+
+/**
+ * Parsed spec file with its path and results
+ */
+export interface ParsedSpecFile {
+    filePath: string;
+    specPath: string;
+    result: MochawesomeResult;
+}
+
+/**
+ * Calculation result outputs
+ */
+export interface CalculationResult {
+    passed: number;
+    failed: number;
+    pending: number;
+    totalSpecs: number;
+    commitStatusMessage: string;
+    failedSpecs: string;
+    failedSpecsCount: number;
+    failedTests: string;
+    total: number;
+    passRate: string;
+    color: string;
+    testDuration: string;
+}
+
+export interface FailedTest {
+    title: string;
+    file: string;
+}

.github/actions/calculate-cypress-results/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

.github/actions/calculate-cypress-results/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/main.ts","./src/merge.ts","./src/types.ts"],"version":"5.9.3"}

.github/actions/calculate-cypress-results/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["src/index.ts"],
+    format: ["cjs"],
+    target: "node24",
+    clean: true,
+    minify: false,
+    sourcemap: false,
+    splitting: false,
+    bundle: true,
+    noExternal: [/.*/],
+});