@flakiness/sdk 0.129.4 → 0.130.0

package/lib/localReportApi.js

@@ -1,7 +1,207 @@
 // src/localReportApi.ts
 import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-import fs from "fs";
+import fs2 from "fs";
+import path2 from "path";
 import { z } from "zod/v4";
+
+// src/localGit.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function listLocalCommits(gitRoot, head, count) {
+  const FIELD_SEPARATOR = "|~|";
+  const RECORD_SEPARATOR = "\0";
+  const prettyFormat = [
+    "%H",
+    // %H:  Full commit hash
+    "%at",
+    // %at: Author date as a Unix timestamp (seconds since epoch)
+    "%an",
+    // %an: Author name
+    "%s"
+    // %s:  Subject (the first line of the commit message)
+  ].join(FIELD_SEPARATOR);
+  const command = `git log ${head} -n ${count} --pretty=format:"${prettyFormat}" -z`;
+  try {
+    const { stdout } = await execAsync(command, { cwd: gitRoot });
+    if (!stdout) {
+      return [];
+    }
+    return stdout.trim().split(RECORD_SEPARATOR).filter((record) => record).map((record) => {
+      const [commitId, timestampStr, author, message] = record.split(FIELD_SEPARATOR);
+      return {
+        commitId,
+        timestamp: parseInt(timestampStr, 10) * 1e3,
+        // Convert timestamp from seconds to milliseconds
+        author,
+        message,
+        walkIndex: 0
+      };
+    });
+  } catch (error) {
+    console.error(`Failed to list commits for repository at ${gitRoot}:`, error);
+    throw error;
+  }
+}
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/report";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import path, { posix as posixPath, win32 as win32Path } from "path";
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
+    const request = protocol.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Set();
+  ReportUtils.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.add(attachment.id);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/localReportApi.ts
+var ReportInfo = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  report;
+  attachmentIdToPath = /* @__PURE__ */ new Map();
+  commits = [];
+  async refresh() {
+    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
+    if (!report) {
+      this.report = void 0;
+      this.commits = [];
+      this.attachmentIdToPath = /* @__PURE__ */ new Map();
+      return;
+    }
+    if (JSON.stringify(report) === JSON.stringify(this.report))
+      return;
+    this.report = report;
+    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
+    const attachmentsDir = this._options.attachmentsFolder;
+    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
+    if (missingAttachments.length) {
+      const first = missingAttachments.slice(0, 3);
+      for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
+        console.warn(`Missing attachment with id ${missingAttachments[i]}`);
+      if (missingAttachments.length > 3)
+        console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
+    }
+    this.attachmentIdToPath = attachmentIdToPath;
+  }
+};
 var t = TypedHTTP.Router.create();
 var localReportRouter = {
   ping: t.get({
@@ -11,7 +211,7 @@ var localReportRouter = {
   }),
   lastCommits: t.get({
     handler: async ({ ctx }) => {
-      return ctx.commits;
+      return ctx.reportInfo.commits;
     }
   }),
   report: {
@@ -20,21 +220,23 @@ var localReportRouter = {
         attachmentId: z.string().min(1).max(100).transform((id) => id)
       }),
       handler: async ({ ctx, input }) => {
-        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs.promises.readFile(idx.path);
+        const buffer = await fs2.promises.readFile(idx.path);
         return TypedHTTP.ok(buffer, idx.contentType);
       }
     }),
     json: t.get({
       handler: async ({ ctx }) => {
-        return ctx.report;
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
       }
     })
   }
 };
 export {
+  ReportInfo,
   localReportRouter
 };
 //# sourceMappingURL=localReportApi.js.map

package/lib/localReportServer.js

@@ -7,9 +7,14 @@ import compression from "compression";
 import debug from "debug";
 import express from "express";
 import "express-async-errors";
-import fs3 from "fs";
 import http2 from "http";
 
+// src/localReportApi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+import fs2 from "fs";
+import path2 from "path";
+import { z } from "zod/v4";
+
 // src/localGit.ts
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -50,46 +55,9 @@ async function listLocalCommits(gitRoot, head, count) {
   }
 }
 
-// src/localReportApi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-import fs from "fs";
-import { z } from "zod/v4";
-var t = TypedHTTP.Router.create();
-var localReportRouter = {
-  ping: t.get({
-    handler: async () => {
-      return "pong";
-    }
-  }),
-  lastCommits: t.get({
-    handler: async ({ ctx }) => {
-      return ctx.commits;
-    }
-  }),
-  report: {
-    attachment: t.rawMethod("GET", {
-      input: z.object({
-        attachmentId: z.string().min(1).max(100).transform((id) => id)
-      }),
-      handler: async ({ ctx, input }) => {
-        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
-        if (!idx)
-          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs.promises.readFile(idx.path);
-        return TypedHTTP.ok(buffer, idx.contentType);
-      }
-    }),
-    json: t.get({
-      handler: async ({ ctx }) => {
-        return ctx.report;
-      }
-    })
-  }
-};
-
 // src/utils.ts
 import { ReportUtils } from "@flakiness/report";
-import fs2 from "fs";
+import fs from "fs";
 import http from "http";
 import https from "https";
 import path, { posix as posixPath, win32 as win32Path } from "path";
@@ -200,7 +168,7 @@ async function resolveAttachmentPaths(report, attachmentsDir) {
   return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
 }
 async function listFilesRecursively(dir, result = []) {
-  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path.join(dir, entry.name);
     if (entry.isDirectory())
@@ -213,17 +181,27 @@ async function listFilesRecursively(dir, result = []) {
 var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
 var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
 
-// src/localReportServer.ts
-var logHTTPServer = debug("fk:http");
-var LocalReportServer = class _LocalReportServer {
-  constructor(_server, _port, _authToken) {
-    this._server = _server;
-    this._port = _port;
-    this._authToken = _authToken;
+// src/localReportApi.ts
+var ReportInfo = class {
+  constructor(_options) {
+    this._options = _options;
   }
-  static async create(options) {
-    const report = JSON.parse(await fs3.promises.readFile(options.reportPath, "utf-8"));
-    const attachmentsDir = options.attachmentsFolder;
+  report;
+  attachmentIdToPath = /* @__PURE__ */ new Map();
+  commits = [];
+  async refresh() {
+    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
+    if (!report) {
+      this.report = void 0;
+      this.commits = [];
+      this.attachmentIdToPath = /* @__PURE__ */ new Map();
+      return;
+    }
+    if (JSON.stringify(report) === JSON.stringify(this.report))
+      return;
+    this.report = report;
+    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
+    const attachmentsDir = this._options.attachmentsFolder;
     const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
     if (missingAttachments.length) {
       const first = missingAttachments.slice(0, 3);
@@ -232,7 +210,52 @@ var LocalReportServer = class _LocalReportServer {
       if (missingAttachments.length > 3)
         console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
     }
-    const commits = await listLocalCommits(process.cwd(), report.commitId, 100);
+    this.attachmentIdToPath = attachmentIdToPath;
+  }
+};
+var t = TypedHTTP.Router.create();
+var localReportRouter = {
+  ping: t.get({
+    handler: async () => {
+      return "pong";
+    }
+  }),
+  lastCommits: t.get({
+    handler: async ({ ctx }) => {
+      return ctx.reportInfo.commits;
+    }
+  }),
+  report: {
+    attachment: t.rawMethod("GET", {
+      input: z.object({
+        attachmentId: z.string().min(1).max(100).transform((id) => id)
+      }),
+      handler: async ({ ctx, input }) => {
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
+        if (!idx)
+          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
+        const buffer = await fs2.promises.readFile(idx.path);
+        return TypedHTTP.ok(buffer, idx.contentType);
+      }
+    }),
+    json: t.get({
+      handler: async ({ ctx }) => {
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
+      }
+    })
+  }
+};
+
+// src/localReportServer.ts
+var logHTTPServer = debug("fk:http");
+var LocalReportServer = class _LocalReportServer {
+  constructor(_server, _port, _authToken) {
+    this._server = _server;
+    this._port = _port;
+    this._authToken = _authToken;
+  }
+  static async create(options) {
     const app = express();
     app.set("etag", false);
     const authToken = randomUUIDBase62();
@@ -255,9 +278,10 @@ var LocalReportServer = class _LocalReportServer {
       });
       next();
     });
+    const reportInfo = new ReportInfo(options);
     app.use("/" + authToken, createTypedHttpExpressMiddleware({
       router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ report, commits, attachmentIdToPath })
+      createRootContext: async ({ req, res, input }) => ({ reportInfo })
     }));
     app.use((err, req, res, next) => {
       if (err instanceof TypedHTTP2.HttpError)

package/lib/playwright-test.js

@@ -2,13 +2,13 @@
 import { ReportUtils as ReportUtils2 } from "@flakiness/report";
 import { Multimap } from "@flakiness/shared/common/multimap.js";
 import chalk2 from "chalk";
-import fs8 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 
 // src/cli/cmd-show-report.ts
 import chalk from "chalk";
 import open from "open";
-import path4 from "path";
+import path5 from "path";
 
 // src/flakinessConfig.ts
 import fs2 from "fs";
@@ -429,9 +429,14 @@ import compression from "compression";
 import debug from "debug";
 import express from "express";
 import "express-async-errors";
-import fs5 from "fs";
 import http2 from "http";
 
+// src/localReportApi.ts
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
+import fs4 from "fs";
+import path4 from "path";
+import { z } from "zod/v4";
+
 // src/localGit.ts
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -473,9 +478,37 @@ async function listLocalCommits(gitRoot, head, count) {
 }
 
 // src/localReportApi.ts
-import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
-import fs4 from "fs";
-import { z } from "zod/v4";
+var ReportInfo = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  report;
+  attachmentIdToPath = /* @__PURE__ */ new Map();
+  commits = [];
+  async refresh() {
+    const report = await fs4.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
+    if (!report) {
+      this.report = void 0;
+      this.commits = [];
+      this.attachmentIdToPath = /* @__PURE__ */ new Map();
+      return;
+    }
+    if (JSON.stringify(report) === JSON.stringify(this.report))
+      return;
+    this.report = report;
+    this.commits = await listLocalCommits(path4.dirname(this._options.reportPath), report.commitId, 100);
+    const attachmentsDir = this._options.attachmentsFolder;
+    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
+    if (missingAttachments.length) {
+      const first = missingAttachments.slice(0, 3);
+      for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
+        console.warn(`Missing attachment with id ${missingAttachments[i]}`);
+      if (missingAttachments.length > 3)
+        console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
+    }
+    this.attachmentIdToPath = attachmentIdToPath;
+  }
+};
 var t = TypedHTTP2.Router.create();
 var localReportRouter = {
   ping: t.get({
@@ -485,7 +518,7 @@ var localReportRouter = {
   }),
   lastCommits: t.get({
     handler: async ({ ctx }) => {
-      return ctx.commits;
+      return ctx.reportInfo.commits;
     }
   }),
   report: {
@@ -494,7 +527,7 @@ var localReportRouter = {
         attachmentId: z.string().min(1).max(100).transform((id) => id)
       }),
       handler: async ({ ctx, input }) => {
-        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
         const buffer = await fs4.promises.readFile(idx.path);
@@ -503,7 +536,8 @@ var localReportRouter = {
     }),
     json: t.get({
       handler: async ({ ctx }) => {
-        return ctx.report;
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
       }
     })
   }
@@ -518,17 +552,6 @@ var LocalReportServer = class _LocalReportServer {
     this._authToken = _authToken;
   }
   static async create(options) {
-    const report = JSON.parse(await fs5.promises.readFile(options.reportPath, "utf-8"));
-    const attachmentsDir = options.attachmentsFolder;
-    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
-    if (missingAttachments.length) {
-      const first = missingAttachments.slice(0, 3);
-      for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
-        console.warn(`Missing attachment with id ${missingAttachments[i]}`);
-      if (missingAttachments.length > 3)
-        console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
-    }
-    const commits = await listLocalCommits(process.cwd(), report.commitId, 100);
     const app = express();
     app.set("etag", false);
     const authToken = randomUUIDBase62();
@@ -551,9 +574,10 @@ var LocalReportServer = class _LocalReportServer {
       });
       next();
     });
+    const reportInfo = new ReportInfo(options);
     app.use("/" + authToken, createTypedHttpExpressMiddleware({
       router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ report, commits, attachmentIdToPath })
+      createRootContext: async ({ req, res, input }) => ({ reportInfo })
     }));
     app.use((err2, req, res, next) => {
       if (err2 instanceof TypedHTTP3.HttpError)
@@ -587,7 +611,7 @@ var LocalReportServer = class _LocalReportServer {
 
 // src/cli/cmd-show-report.ts
 async function cmdShowReport(reportFolder) {
-  const reportPath = path4.join(reportFolder, "report.json");
+  const reportPath = path5.join(reportFolder, "report.json");
   const session = await FlakinessSession.load();
   const config = await FlakinessConfig.load();
   const projectPublicId = config.projectPublicId();
@@ -610,12 +634,12 @@ async function cmdShowReport(reportFolder) {
 
 // src/createTestStepSnippets.ts
 import { codeFrameColumns } from "@babel/code-frame";
-import fs6 from "fs";
+import fs5 from "fs";
 function createTestStepSnippets(filepathToSteps) {
   for (const [filepath, steps] of filepathToSteps) {
     let source;
     try {
-      source = fs6.readFileSync(filepath, "utf-8");
+      source = fs5.readFileSync(filepath, "utf-8");
     } catch (e) {
       continue;
     }
@@ -640,7 +664,7 @@ function createTestStepSnippets(filepathToSteps) {
 // src/reportUploader.ts
 import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
 import assert2 from "assert";
-import fs7 from "fs";
+import fs6 from "fs";
 import { URL } from "url";
 var ReportUploader = class _ReportUploader {
   static optionsFromEnv(overrides) {
@@ -738,16 +762,16 @@ var ReportUpload = class {
           url: uploadUrl,
           headers: {
             "Content-Type": attachment.contentType,
-            "Content-Length": (await fs7.promises.stat(attachmentPath)).size + ""
+            "Content-Length": (await fs6.promises.stat(attachmentPath)).size + ""
           },
           method: "put"
         });
-        fs7.createReadStream(attachmentPath).pipe(request);
+        fs6.createReadStream(attachmentPath).pipe(request);
         await responseDataPromise;
       }, HTTP_BACKOFF);
       return;
     }
-    let buffer = attachment.body ? attachment.body : attachment.path ? await fs7.promises.readFile(attachment.path) : void 0;
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs6.promises.readFile(attachment.path) : void 0;
     assert2(buffer);
     const encoding = compressable ? "br" : void 0;
     if (compressable)
@@ -844,7 +868,7 @@ var err = (txt) => console.error(chalk2.red(`[flakiness.io] ${txt}`));
 var FlakinessReporter = class {
   constructor(_options = {}) {
     this._options = _options;
-    this._outputFolder = path5.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
+    this._outputFolder = path6.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
   }
   _config;
   _rootSuite;
@@ -947,7 +971,7 @@ var FlakinessReporter = class {
       location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
     };
     if (pwStep.location) {
-      const resolvedPath = path5.resolve(pwStep.location.file);
+      const resolvedPath = path6.resolve(pwStep.location.file);
       this._filepathToSteps.set(resolvedPath, step);
     }
     if (pwStep.error)
@@ -996,10 +1020,10 @@ var FlakinessReporter = class {
     const environmentsMap = createEnvironments(this._config.projects);
     if (this._options.collectBrowserVersions) {
       try {
-        let playwrightPath = fs8.realpathSync(process.argv[1]);
-        while (path5.basename(playwrightPath) !== "test")
-          playwrightPath = path5.dirname(playwrightPath);
-        const module = await import(path5.join(playwrightPath, "index.js"));
+        let playwrightPath = fs7.realpathSync(process.argv[1]);
+        while (path6.basename(playwrightPath) !== "test")
+          playwrightPath = path6.dirname(playwrightPath);
+        const module = await import(path6.join(playwrightPath, "index.js"));
         for (const [project, env] of environmentsMap) {
           const { browserName = "chromium", channel, headless } = project.use;
           let browserType;
@@ -1048,19 +1072,19 @@ var FlakinessReporter = class {
     for (const unaccessibleAttachment of context.unaccessibleAttachmentPaths)
       warn(`cannot access attachment ${unaccessibleAttachment}`);
     this._report = report;
-    const reportPath = path5.join(this._outputFolder, "report.json");
-    const attachmentsFolder = path5.join(this._outputFolder, "attachments");
-    await fs8.promises.rm(this._outputFolder, { recursive: true, force: true });
-    await fs8.promises.mkdir(this._outputFolder, { recursive: true });
-    await fs8.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+    const reportPath = path6.join(this._outputFolder, "report.json");
+    const attachmentsFolder = path6.join(this._outputFolder, "attachments");
+    await fs7.promises.rm(this._outputFolder, { recursive: true, force: true });
+    await fs7.promises.mkdir(this._outputFolder, { recursive: true });
+    await fs7.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
     if (context.attachments.size)
-      await fs8.promises.mkdir(attachmentsFolder);
+      await fs7.promises.mkdir(attachmentsFolder);
     for (const attachment of context.attachments.values()) {
-      const attachmentPath = path5.join(attachmentsFolder, attachment.id);
+      const attachmentPath = path6.join(attachmentsFolder, attachment.id);
       if (attachment.path)
-        await fs8.promises.cp(attachment.path, attachmentPath);
+        await fs7.promises.cp(attachment.path, attachmentPath);
       else if (attachment.body)
-        await fs8.promises.writeFile(attachmentPath, attachment.body);
+        await fs7.promises.writeFile(attachmentPath, attachment.body);
       this._attachments.push({
         contentType: attachment.contentType,
         id: attachment.id,
@@ -1084,8 +1108,8 @@ var FlakinessReporter = class {
     if (shouldOpen) {
       await cmdShowReport(this._outputFolder);
     } else {
-      const defaultOutputFolder = path5.join(process.cwd(), "flakiness-report");
-      const folder = defaultOutputFolder === this._outputFolder ? "" : path5.relative(process.cwd(), this._outputFolder);
+      const defaultOutputFolder = path6.join(process.cwd(), "flakiness-report");
+      const folder = defaultOutputFolder === this._outputFolder ? "" : path6.relative(process.cwd(), this._outputFolder);
       console.log(`
 To open last Flakiness report run: