@empiricalrun/test-gen 0.73.1 → 0.74.0

package/dist/tools/trace-dot-zip/types.d.ts

@@ -0,0 +1,86 @@
+export type CapturedNetworkFailure = {
+    endpoint: string;
+    status: number;
+    timestamp: string;
+    distanceFromFailureInMilliseconds: number;
+    method: string;
+    request: {
+        headers: {
+            [any: string]: string;
+        }[] | [];
+    };
+    response: {
+        headers: {
+            [any: string]: string;
+        }[] | [];
+    };
+};
+export type CapturedConsoleLog = {
+    type: "console";
+    messageType: "log" | "info" | "warning" | "error" | string;
+    text: string;
+    args: any[];
+    location: {
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+    };
+    time: number;
+    pageId: string;
+};
+export type PlaywrightNetworkTrace = {
+    type: string;
+    snapshot: {
+        _frameref: string;
+        _monotonicTime: number;
+        startedDateTime: string;
+        time: number;
+        request: {
+            method: string;
+            url: string;
+            httpVersion: string;
+            cookies: any[];
+            headers: any[];
+            queryString: any[];
+            headersSize: number;
+            bodySize: number;
+            postData: {
+                mimeType: string;
+                text: string;
+                params: any[];
+                _sha1: string;
+            };
+        };
+        response: {
+            status: number;
+            statusText: string;
+            httpVersion: string;
+            cookies: any[];
+            headers: any[];
+            headersSize: number;
+            bodySize: number;
+            redirectURL: string;
+            _transferSize: number;
+        };
+        cache: any;
+        timings: {
+            dns: number;
+            connect: number;
+            ssl: number;
+            send: number;
+            wait: number;
+            receive: number;
+        };
+        pageref: string;
+        serverIPAddress: string;
+        _serverPort: number;
+        _securityDetails: {
+            protocol: string;
+            subjectName: string;
+            issuer: string;
+            validFrom: number;
+            validTo: number;
+        };
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/trace-dot-zip/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tools/trace-dot-zip/types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC,EAAE,MAAM,CAAC;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE;QACP,OAAO,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,EAAE,GAAG,EAAE,CAAC;KAC3C,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,EAAE,GAAG,EAAE,CAAC;KAC3C,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,WAAW,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,QAAQ,EAAE;QACR,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACR,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;QACxB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE;YACP,MAAM,EAAE,MAAM,CAAC;YACf,GAAG,EAAE,MAAM,CAAC;YACZ,WAAW,EAAE,MAAM,CAAC;YACpB,OAAO,EAAE,GAAG,EAAE,CAAC;YACf,OAAO,EAAE,GAAG,EAAE,CAAC;YACf,WAAW,EAAE,GAAG,EAAE,CAAC;YACnB,WAAW,EAAE,MAAM,CAAC;YACpB,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE;gBACR,QAAQ,EAAE,MAAM,CAAC;gBACjB,IAAI,EAAE,MAAM,CAAC;gBACb,MAAM,EAAE,GAAG,EAAE,CAAC;gBACd,KAAK,EAAE,MAAM,CAAC;aACf,CAAC;SACH,CAAC;QACF,QAAQ,EAAE;YACR,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;YACnB,WAAW,EAAE,MAAM,CAAC;YACpB,OAAO,EAAE,GAAG,EAAE,CAAC;YACf,OAAO,EAAE,GAAG,EAAE,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;YACpB,QAAQ,EAAE,MAAM,CAAC;YACjB,WAAW,EAAE,MAAM,CAAC;YACpB,aAAa,EAAE,MAAM,CAAC;SACvB,CAAC;QACF,KAAK,EAAE,GAAG,CAAC;QACX,OAAO,EAAE;YACP,GAAG,EAAE,MAAM,CAAC;YACZ,OAAO,EAAE,MAAM,CAAC;YAChB,GAAG,EAAE,MAAM,CAAC;YACZ,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC;QACF,OAAO,EAAE,MAAM,CAAC;QAChB,eAAe,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,MAAM,CAAC;QACpB,gBAAgB,EAAE;YAChB,QAAQ,EAAE,MAAM,CAAC;YACjB,WAAW,EAAE,MAAM,CAAC;YACpB,MAAM,EAAE,MAAM,CAAC;YACf,SAAS,EAAE,MAAM,CAAC;YAClB,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC;KACH,CAAC;CACH,CAAC"}

package/dist/tools/trace-dot-zip/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools/trace-dot-zip/utils/console-trace.d.ts

@@ -0,0 +1,7 @@
+import { CapturedConsoleLog } from "../types";
+type ArgsT = {
+    url: string;
+};
+export declare const generateConsoleTraceFromZipUrl: ({ url, }: ArgsT) => Promise<CapturedConsoleLog[]>;
+export {};
+//# sourceMappingURL=console-trace.d.ts.map

package/dist/tools/trace-dot-zip/utils/console-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-trace.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/console-trace.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAK9C,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAU,UAElD,KAAK,KAAG,OAAO,CAAC,kBAAkB,EAAE,CA2BtC,CAAC"}

package/dist/tools/trace-dot-zip/utils/console-trace.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConsoleTraceFromZipUrl = void 0;
+const extract_zip_1 = require("./extract-zip");
+const TRACE_FILE_NAME = "0-trace.trace";
+const generateConsoleTraceFromZipUrl = async ({ url, }) => {
+    try {
+        const consoleErrors = [];
+        await (0, extract_zip_1.extractFileFromZipFromUrl)({
+            zipUrl: url,
+            fileNames: [TRACE_FILE_NAME],
+            chunkProcessor: () => {
+                let tempBuffer = "";
+                return (chunk) => {
+                    tempBuffer += chunk;
+                    let lines = tempBuffer.split("\n");
+                    lines.slice(0, -1).forEach((line) => {
+                        const parsed = JSON.parse(line);
+                        if (parsed?.type === "console" && parsed?.messageType === "error") {
+                            consoleErrors.push(parsed);
+                        }
+                    });
+                    tempBuffer = lines[lines.length - 1] || "";
+                };
+            },
+        });
+        return consoleErrors;
+    }
+    catch (error) {
+        console.error(`Error fetching or processing the zip file: ${url}`, error);
+    }
+    return [];
+};
+exports.generateConsoleTraceFromZipUrl = generateConsoleTraceFromZipUrl;

package/dist/tools/trace-dot-zip/utils/extract-zip.d.ts

@@ -0,0 +1,21 @@
+import { Buffer } from "buffer";
+export declare const extractFileFromZipFromUrl: ({ zipUrl, fileNames, chunkProcessor, withCache, }: {
+    zipUrl: string;
+    fileNames: string[];
+    chunkProcessor: (breakAndResolve: () => void, currentFileGettingProcessed: string) => (chunk: Buffer) => void;
+    withCache?: boolean;
+}) => Promise<void>;
+/**
+ * Returns a list of file names contained in a zip file located at `zipUrl`.
+ *
+ * @param zipUrl - The URL or file path (file://...) of the zip file.
+ * @param options.withCache - Whether to use cached fetch logic (if available).
+ * @param options.recursive - If `false`, only return top-level files (files with no slash).
+ *                            If `true`, return all files in any subdirectory.
+ * @returns An array of file names in the ZIP.
+ */
+export declare function getFilenamesInZip(zipUrl: string, { withCache, recursive, }?: {
+    withCache?: boolean;
+    recursive?: boolean;
+}): Promise<string[]>;
+//# sourceMappingURL=extract-zip.d.ts.map

package/dist/tools/trace-dot-zip/utils/extract-zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-zip.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/extract-zip.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AA0FhC,eAAO,MAAM,yBAAyB,GAAU,mDAK7C;IACD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,CACd,eAAe,EAAE,MAAM,IAAI,EAC3B,2BAA2B,EAAE,MAAM,KAChC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,OAAO,CAAC,IAAI,CAuEf,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,EACE,SAAiB,EACjB,SAAgB,GACjB,GAAE;IACD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CAChB,GACL,OAAO,CAAC,MAAM,EAAE,CAAC,CAoCnB"}

package/dist/tools/trace-dot-zip/utils/extract-zip.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFileFromZipFromUrl = void 0;
+exports.getFilenamesInZip = getFilenamesInZip;
+const buffer_1 = require("buffer");
+const fs_1 = require("fs");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const yauzl_1 = __importDefault(require("yauzl"));
+const fromBuffer = (0, util_1.promisify)(yauzl_1.default.fromBuffer);
+const convertToNodeReadableStream = (webReadableStream) => {
+    const nodeReadableStream = new stream_1.Readable({
+        read() { },
+    });
+    const reader = webReadableStream.getReader();
+    void (async function readStream() {
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    nodeReadableStream.push(null);
+                    break;
+                }
+                nodeReadableStream.push(value);
+            }
+        }
+        catch (error) {
+            nodeReadableStream.destroy(error);
+        }
+    })();
+    return nodeReadableStream;
+};
+async function streamToBuffer(webStream) {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        const nodeStream = convertToNodeReadableStream(webStream);
+        nodeStream.on("data", (chunk) => chunks.push(chunk));
+        nodeStream.on("end", () => resolve(buffer_1.Buffer.concat(chunks)));
+        nodeStream.on("error", reject);
+    });
+}
+const cache = {};
+const cachedFetch = async (url) => {
+    if (url in cache) {
+        return cache[url];
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    // Convert the stream to a buffer
+    const buffer = await streamToBuffer(response.body);
+    cache[url] = buffer;
+    return buffer;
+};
+/**
+ * Fetches or reads a zip file from URL or file path, then returns a Buffer.
+ */
+async function getZipBuffer(zipUrl, withCache) {
+    if (zipUrl.startsWith("file://")) {
+        const filePath = zipUrl.replace(/^file:\/\//, "");
+        return fs_1.promises.readFile(filePath);
+    }
+    else if (withCache) {
+        return await cachedFetch(zipUrl);
+    }
+    else {
+        const response = await fetch(zipUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        return streamToBuffer(response.body);
+    }
+}
+const extractFileFromZipFromUrl = async ({ zipUrl, fileNames, chunkProcessor, withCache, }) => {
+    try {
+        const buffer = await getZipBuffer(zipUrl, withCache);
+        // Ensure buffer is not empty
+        if (buffer.length === 0) {
+            throw new Error("Empty buffer received.");
+        }
+        // Process the zip file from the buffer
+        const zipfile = await fromBuffer(buffer, { lazyEntries: true });
+        const fileProcessingPromises = [];
+        // Use promises for entry reading
+        await new Promise((resolve) => {
+            zipfile.on("entry", (entry) => {
+                if (fileNames.includes(entry.fileName)) {
+                    const filePromise = new Promise((fileResolve) => {
+                        zipfile.openReadStream(entry, (err, readStream) => {
+                            if (err) {
+                                console.error(`error reading file - ${entry.fileName}`, err);
+                                fileResolve();
+                                return;
+                            }
+                            const done = () => {
+                                fileResolve();
+                            };
+                            const processChunk = chunkProcessor(done, entry.fileName);
+                            readStream.on("data", processChunk);
+                            readStream.on("end", () => {
+                                fileResolve();
+                            });
+                            readStream.on("error", (error) => {
+                                console.error(`error reading file - ${entry.fileName}`, error);
+                                fileResolve();
+                            });
+                        });
+                    });
+                    // Push each file's promise to the array
+                    fileProcessingPromises.push(filePromise);
+                }
+                zipfile.readEntry();
+            });
+            zipfile.on("end", () => {
+                resolve();
+            });
+            zipfile.on("error", (error) => {
+                console.error(`Error reading entry`, error);
+                resolve();
+            });
+            zipfile.readEntry();
+        });
+        await Promise.all(fileProcessingPromises);
+    }
+    catch (error) {
+        console.error(`Error fetching or processing the zip file url - "${zipUrl}"`, error);
+    }
+};
+exports.extractFileFromZipFromUrl = extractFileFromZipFromUrl;
+/**
+ * Returns a list of file names contained in a zip file located at `zipUrl`.
+ *
+ * @param zipUrl - The URL or file path (file://...) of the zip file.
+ * @param options.withCache - Whether to use cached fetch logic (if available).
+ * @param options.recursive - If `false`, only return top-level files (files with no slash).
+ *                            If `true`, return all files in any subdirectory.
+ * @returns An array of file names in the ZIP.
+ */
+async function getFilenamesInZip(zipUrl, { withCache = false, recursive = true, } = {}) {
+    // 1. Get the zip contents as a Buffer
+    const buffer = await getZipBuffer(zipUrl, withCache);
+    // 2. Parse the zip file with yauzl
+    const zipfile = await fromBuffer(buffer, { lazyEntries: true });
+    const fileNames = [];
+    await new Promise((resolve, reject) => {
+        zipfile.on("entry", (entry) => {
+            // Identify directories by trailing slash
+            const isDirectory = entry.fileName.endsWith("/");
+            // We don't list directories, only files
+            if (!isDirectory) {
+                if (recursive) {
+                    // Include all files
+                    fileNames.push(entry.fileName);
+                }
+                else {
+                    // Only include top-level files (no slash in the path)
+                    if (!entry.fileName.includes("/")) {
+                        fileNames.push(entry.fileName);
+                    }
+                }
+            }
+            // Proceed to the next entry
+            zipfile.readEntry();
+        });
+        zipfile.on("error", (err) => reject(err));
+        zipfile.on("end", () => resolve());
+        zipfile.readEntry();
+    });
+    return fileNames;
+}

package/dist/tools/trace-dot-zip/utils/network-trace.d.ts

@@ -0,0 +1,21 @@
+import { CapturedNetworkFailure } from "../types";
+type ArgsT = {
+    url: string;
+    logPrefix?: string;
+    failure?: {
+        startTime?: string;
+        location: {
+            file: string;
+            line: number;
+            column: number;
+        } | undefined;
+    };
+};
+export declare const generateNetworkTrace: ({ logPrefix, url, failure, }: ArgsT) => Promise<{
+    allFailedCalls: CapturedNetworkFailure[];
+    failedCallsWithinTimeRange: CapturedNetworkFailure[];
+}>;
+export declare const generateNetworkTraceFromZipUrl: ({ url, }: ArgsT) => Promise<CapturedNetworkFailure[]>;
+export declare const stripIrrelevantInfoFromNetworkFailureArray: (failures: CapturedNetworkFailure[]) => Partial<CapturedNetworkFailure>[];
+export {};
+//# sourceMappingURL=network-trace.d.ts.map

package/dist/tools/trace-dot-zip/utils/network-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-trace.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/network-trace.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,sBAAsB,EAA0B,MAAM,UAAU,CAAC;AAU1E,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,EACJ;YACE,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;SAChB,GACD,SAAS,CAAC;KACf,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,8BAIxC,KAAK,KAAG,OAAO,CAAC;IACjB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,0BAA0B,EAAE,sBAAsB,EAAE,CAAC;CACtD,CA8KA,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAU,UAElD,KAAK,KAAG,OAAO,CAAC,sBAAsB,EAAE,CAmC1C,CAAC;AAoBF,eAAO,MAAM,0CAA0C,GACrD,UAAU,sBAAsB,EAAE,KACjC,OAAO,CAAC,sBAAsB,CAAC,EAUjC,CAAC"}

package/dist/tools/trace-dot-zip/utils/network-trace.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripIrrelevantInfoFromNetworkFailureArray = exports.generateNetworkTraceFromZipUrl = exports.generateNetworkTrace = void 0;
+const date_fns_1 = require("date-fns");
+const extract_zip_1 = require("./extract-zip");
+const NON_RELEVANT_NETWORK_CALL_KEYWORDS = [
+    "sentry",
+    "intercom",
+    "clarity.ms",
+    "nr-data.net",
+];
+const generateNetworkTrace = async ({ logPrefix = "network-trace", url, failure, }) => {
+    let networkFailures = {
+        allFailedCalls: [],
+        failedCallsWithinTimeRange: [],
+    };
+    // first check the test.trace file
+    // and find the exact timestamp when our test failed
+    // then we will look in the 0-trace.network file
+    // to find the network calls that happened before and after the test failure
+    try {
+        let failedTestStatementTimeOffset; // in milliseconds
+        if (!url) {
+            throw new Error(`${logPrefix}: no trace file found for testRunId`);
+        }
+        await (0, extract_zip_1.extractFileFromZipFromUrl)({
+            zipUrl: url,
+            fileNames: ["test.trace"],
+            chunkProcessor: (breakAndResolve) => {
+                let tempBuffer = "";
+                let initialOffset;
+                return (chunk) => {
+                    tempBuffer += chunk;
+                    let lines = tempBuffer.split("\n");
+                    lines.slice(0, -1).forEach((line) => {
+                        const parsedTestTrace = JSON.parse(line);
+                        if (!initialOffset && parsedTestTrace.startTime) {
+                            initialOffset = parsedTestTrace.startTime;
+                        }
+                        if (parsedTestTrace.type === "before" &&
+                            parsedTestTrace.stack.find((errorStack) => {
+                                return (errorStack?.file === failure?.location?.file &&
+                                    errorStack?.column === failure?.location?.column &&
+                                    errorStack?.line === failure?.location?.line);
+                            })) {
+                            failedTestStatementTimeOffset =
+                                parsedTestTrace.startTime - initialOffset;
+                            breakAndResolve();
+                        }
+                    });
+                    tempBuffer = lines[lines.length - 1] || "";
+                };
+            },
+        });
+        const failedCalls = [];
+        await (0, extract_zip_1.extractFileFromZipFromUrl)({
+            zipUrl: url,
+            fileNames: ["0-trace.network"],
+            chunkProcessor: () => {
+                let tempBuffer = "";
+                return (chunk) => {
+                    tempBuffer += chunk;
+                    let lines = tempBuffer.split("\n");
+                    lines.slice(0, -1).forEach((line) => {
+                        const parsedNetworkTrace = JSON.parse(line);
+                        const responseStatus = parsedNetworkTrace?.snapshot?.response?.status;
+                        // const networkTriggerTime =
+                        //   parsedNetworkTrace?.snapshot?.startedDateTime;
+                        if (400 <= responseStatus && responseStatus < 600) {
+                            failedCalls.push(parsedNetworkTrace);
+                        }
+                    });
+                    tempBuffer = lines[lines.length - 1] || "";
+                };
+            },
+        });
+        const failedTestStatementTimestamp = (0, date_fns_1.addMilliseconds)(new Date(failure?.startTime), failedTestStatementTimeOffset);
+        const lowerWindow = 3; // 3 seconds
+        const upperWindow = 2; // 2 seconds
+        const networkFailureLowerWindow = (0, date_fns_1.subSeconds)(new Date(failedTestStatementTimestamp), lowerWindow);
+        const networkFailureUpperWindow = (0, date_fns_1.addSeconds)(new Date(failedTestStatementTimestamp), upperWindow);
+        const { allFailedCalls, failedCallsWithinTimeRange } = failedCalls.reduce((acc, call) => {
+            const url = call?.snapshot?.request?.url ?? "";
+            if (NON_RELEVANT_NETWORK_CALL_KEYWORDS.some((keyword) => url.includes(keyword))) {
+                return acc;
+            }
+            const networkTriggerTime = call?.snapshot?.startedDateTime;
+            const isWithin = (0, date_fns_1.isWithinInterval)(networkTriggerTime, {
+                start: networkFailureLowerWindow,
+                end: networkFailureUpperWindow,
+            });
+            const formattedCall = {
+                endpoint: call?.snapshot?.request?.url,
+                status: call?.snapshot?.response?.status,
+                timestamp: new Date(call?.snapshot?.startedDateTime).toUTCString(),
+                distanceFromFailureInMilliseconds: (0, date_fns_1.differenceInMilliseconds)(networkTriggerTime, failedTestStatementTimestamp),
+                method: call?.snapshot?.request?.method,
+                request: {
+                    headers: call?.snapshot?.request?.headers ?? [],
+                },
+                response: {
+                    headers: call?.snapshot?.response?.headers ?? [],
+                },
+            };
+            acc.allFailedCalls.push(formattedCall);
+            if (isWithin) {
+                acc.failedCallsWithinTimeRange.push(formattedCall);
+            }
+            return acc;
+        }, { allFailedCalls: [], failedCallsWithinTimeRange: [] });
+        const uniqueCallEntries = new Set();
+        const uniqueFailedCalls = [];
+        failedCallsWithinTimeRange.forEach((call) => {
+            const key = `${call.endpoint}|${call.status}`;
+            if (!uniqueCallEntries.has(key)) {
+                uniqueCallEntries.add(key);
+                uniqueFailedCalls.push(call);
+            }
+        });
+        return {
+            allFailedCalls,
+            failedCallsWithinTimeRange: uniqueFailedCalls,
+        };
+    }
+    catch (error) {
+        console.error(`${logPrefix}: Error fetching or processing the zip file: ${url}`, error);
+    }
+    return networkFailures;
+};
+exports.generateNetworkTrace = generateNetworkTrace;
+const generateNetworkTraceFromZipUrl = async ({ url, }) => {
+    try {
+        const failedCalls = [];
+        await (0, extract_zip_1.extractFileFromZipFromUrl)({
+            zipUrl: url,
+            fileNames: ["0-trace.network"],
+            chunkProcessor: () => {
+                let tempBuffer = "";
+                return (chunk) => {
+                    tempBuffer += chunk;
+                    let lines = tempBuffer.split("\n");
+                    lines.slice(0, -1).forEach((line) => {
+                        const parsedNetworkTrace = JSON.parse(line);
+                        const responseStatus = parsedNetworkTrace?.snapshot?.response?.status;
+                        // const networkTriggerTime =
+                        //   parsedNetworkTrace?.snapshot?.startedDateTime;
+                        if (400 <= responseStatus && responseStatus < 600) {
+                            failedCalls.push(parsedNetworkTrace);
+                        }
+                    });
+                    tempBuffer = lines[lines.length - 1] || "";
+                };
+            },
+        });
+        return failedCalls.map(formatNetworkFailure);
+    }
+    catch (error) {
+        console.error(`Error fetching or processing the zip file: ${url}`, error);
+    }
+    return [];
+};
+exports.generateNetworkTraceFromZipUrl = generateNetworkTraceFromZipUrl;
+const formatNetworkFailure = (call) => {
+    return {
+        endpoint: call?.snapshot?.request?.url,
+        status: call?.snapshot?.response?.status,
+        timestamp: new Date(call?.snapshot?.startedDateTime).toUTCString(),
+        distanceFromFailureInMilliseconds: 0,
+        method: call?.snapshot?.request?.method,
+        request: {
+            headers: call?.snapshot?.request?.headers ?? [],
+        },
+        response: {
+            headers: call?.snapshot?.response?.headers ?? [],
+        },
+    };
+};
+const stripIrrelevantInfoFromNetworkFailureArray = (failures) => {
+    return failures.map(({ endpoint, status, timestamp, method }) => {
+        const strippedFailureInfo = {
+            endpoint,
+            status,
+            timestamp,
+            method,
+        };
+        return strippedFailureInfo;
+    });
+};
+exports.stripIrrelevantInfoFromNetworkFailureArray = stripIrrelevantInfoFromNetworkFailureArray;

package/dist/tools/triage-summary/index.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from "@empiricalrun/shared-types";
+export declare const sendTriageSummaryTool: Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/triage-summary/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/triage-summary/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAc,MAAM,4BAA4B,CAAC;AAmB9D,eAAO,MAAM,qBAAqB,EAAE,IA6CnC,CAAC"}

package/dist/tools/triage-summary/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTriageSummaryTool = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("./utils");
+const TriageSummaryInputSchema = zod_1.z.object({
+    issues: zod_1.z
+        .array(zod_1.z.object({
+        id: zod_1.z.number(),
+        action: zod_1.z.enum(["created", "updated"]),
+    }))
+        .describe("A list of issues which were created or updated during a triage session. The 'action' field is either 'created' or 'updated'."),
+});
+exports.sendTriageSummaryTool = {
+    schema: {
+        name: "sendTriageSummary",
+        description: `This tool must be called upon completion of a triage session. It sends a slack update on the summary of the work done in a triage session to users, specifically which issues were creted or updated in that triage session`,
+        parameters: TriageSummaryInputSchema,
+    },
+    needsBrowser: false,
+    isInlineTool: true,
+    execute: async ({ input, apiClient, chatSession }) => {
+        try {
+            const triagedIssuesList = input.issues;
+            if (!triagedIssuesList) {
+                return {
+                    isError: true,
+                    result: "Issues not found",
+                };
+            }
+            if (!apiClient) {
+                throw new Error("Dashboard API client is not available.");
+            }
+            if (!chatSession?.id) {
+                throw new Error("Chat session ID is not available.");
+            }
+            const data = await (0, utils_1.triggerSlackMessageWithTriageSummary)(triagedIssuesList, apiClient, chatSession.id);
+            return {
+                isError: false,
+                result: data,
+            };
+        }
+        catch (error) {
+            console.error("Error sending triage summary to slack", error);
+            return {
+                isError: true,
+                result: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+};

package/dist/tools/triage-summary/types.d.ts

@@ -0,0 +1,5 @@
+export interface TriagedIssue {
+    id: number;
+    action: "created" | "updated";
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tools/triage-summary/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tools/triage-summary/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;CAC/B"}

package/dist/tools/triage-summary/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools/triage-summary/utils.d.ts

@@ -0,0 +1,4 @@
+import { IDashboardAPIClient } from "@empiricalrun/shared-types";
+import { TriagedIssue } from "./types";
+export declare const triggerSlackMessageWithTriageSummary: (issues: TriagedIssue[], apiClient: IDashboardAPIClient, chatSessionId: number) => Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/tools/triage-summary/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/triage-summary/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,eAAO,MAAM,oCAAoC,GAC/C,QAAQ,YAAY,EAAE,EACtB,WAAW,mBAAmB,EAC9B,eAAe,MAAM,KACpB,OAAO,CAAC,MAAM,CAahB,CAAC"}

package/dist/tools/triage-summary/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerSlackMessageWithTriageSummary = void 0;
+const triggerSlackMessageWithTriageSummary = async (issues, apiClient, chatSessionId) => {
+    if (!issues.length)
+        return "message not sent as no issues were created/updated";
+    const response = await apiClient.request("/api/slack/triage-summary", {
+        method: "POST",
+        body: {
+            chat_session_id: chatSessionId,
+            issues: issues,
+        },
+    });
+    return `Triage summary sent to Slack successfully. Response: ${JSON.stringify(response)}`;
+};
+exports.triggerSlackMessageWithTriageSummary = triggerSlackMessageWithTriageSummary;

package/dist/tools/upgrade-packages/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/upgrade-packages/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAyBvD,eAAO,MAAM,mBAAmB,EAAE,IA2HjC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/upgrade-packages/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAoBvD,eAAO,MAAM,mBAAmB,EAAE,IAyHjC,CAAC"}