@flakiness/sdk 0.145.0 → 0.146.0

package/lib/playwright-test.js

@@ -2,30 +2,59 @@
 import { ReportUtils as ReportUtils2 } from "@flakiness/report";
 import { Multimap } from "@flakiness/shared/common/multimap.js";
 import chalk2 from "chalk";
-import fs7 from "fs";
-import path6 from "path";
-
-// src/cli/cmd-show-report.ts
-import chalk from "chalk";
-import open from "open";
+import fs6 from "fs";
 import path5 from "path";
 
-// src/flakinessConfig.ts
-import fs2 from "fs";
-import path2 from "path";
+// src/createTestStepSnippets.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import fs from "fs";
+function createTestStepSnippets(filepathToSteps) {
+  for (const [filepath, steps] of filepathToSteps) {
+    let source;
+    try {
+      source = fs.readFileSync(filepath, "utf-8");
+    } catch (e) {
+      continue;
+    }
+    const lines = source.split("\n").length;
+    const highlighted = codeFrameColumns(source, { start: { line: lines, column: 1 } }, { highlightCode: true, linesAbove: lines, linesBelow: 0 });
+    const highlightedLines = highlighted.split("\n");
+    const lineWithArrow = highlightedLines[highlightedLines.length - 1];
+    for (const step of steps) {
+      if (!step.location)
+        continue;
+      if (step.location.line < 2 || step.location.line >= lines)
+        continue;
+      const snippetLines = highlightedLines.slice(step.location.line - 2, step.location.line + 1);
+      const index = lineWithArrow.indexOf("^");
+      const shiftedArrow = lineWithArrow.slice(0, index) + " ".repeat(step.location.column - 1) + lineWithArrow.slice(index);
+      snippetLines.splice(2, 0, shiftedArrow);
+      step.snippet = snippetLines.join("\n");
+    }
+  }
+}
+
+// src/reportUploader.ts
+import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
+import assert2 from "assert";
+import fs3 from "fs";
+import { URL as URL2 } from "url";
+
+// src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
 
 // src/utils.ts
 import { ReportUtils } from "@flakiness/report";
 import assert from "assert";
 import { spawnSync } from "child_process";
 import crypto from "crypto";
-import fs from "fs";
+import fs2 from "fs";
 import http from "http";
 import https from "https";
 import os from "os";
 import path, { posix as posixPath, win32 as win32Path } from "path";
 async function existsAsync(aPath) {
-  return fs.promises.stat(aPath).then(() => true).catch((e) => false);
+  return fs2.promises.stat(aPath).then(() => true).catch((e) => false);
 }
 function extractEnvConfiguration() {
   const ENV_PREFIX = "FK_ENV_";
@@ -36,7 +65,7 @@ function extractEnvConfiguration() {
 function sha1File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash("sha1");
-    const stream = fs.createReadStream(filePath);
+    const stream = fs2.createReadStream(filePath);
     stream.on("data", (chunk) => {
       hash.update(chunk);
     });
@@ -142,18 +171,18 @@ function stripAnsi(str) {
 async function saveReportAndAttachments(report, attachments, outputFolder) {
   const reportPath = path.join(outputFolder, "report.json");
   const attachmentsFolder = path.join(outputFolder, "attachments");
-  await fs.promises.rm(outputFolder, { recursive: true, force: true });
-  await fs.promises.mkdir(outputFolder, { recursive: true });
-  await fs.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  await fs2.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs2.promises.mkdir(outputFolder, { recursive: true });
+  await fs2.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
   if (attachments.length)
-    await fs.promises.mkdir(attachmentsFolder);
+    await fs2.promises.mkdir(attachmentsFolder);
   const movedAttachments = [];
   for (const attachment of attachments) {
     const attachmentPath = path.join(attachmentsFolder, attachment.id);
     if (attachment.path)
-      await fs.promises.cp(attachment.path, attachmentPath);
+      await fs2.promises.cp(attachment.path, attachmentPath);
     else if (attachment.body)
-      await fs.promises.writeFile(attachmentPath, attachment.body);
+      await fs2.promises.writeFile(attachmentPath, attachment.body);
     movedAttachments.push({
       contentType: attachment.contentType,
       id: attachment.id,
@@ -175,7 +204,7 @@ function shell(command, args, options) {
   }
 }
 function readLinuxOSRelease() {
-  const osReleaseText = fs.readFileSync("/etc/os-release", "utf-8");
+  const osReleaseText = fs2.readFileSync("/etc/os-release", "utf-8");
   return new Map(osReleaseText.toLowerCase().split("\n").filter((line) => line.includes("=")).map((line) => {
     line = line.trim();
     let [key, value] = line.split("=");
@@ -247,7 +276,7 @@ async function resolveAttachmentPaths(report, attachmentsDir) {
   return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
 }
 async function listFilesRecursively(dir, result = []) {
-  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path.join(dir, entry.name);
     if (entry.isDirectory())
@@ -317,7 +346,158 @@ function createEnvironments(projects) {
   return result;
 }
 
-// src/flakinessConfig.ts
+// src/serverapi.ts
+function createServerAPI(endpoint, options) {
+  endpoint += "/api/";
+  const fetcher = options?.auth ? (url, init) => fetch(url, {
+    ...init,
+    headers: {
+      ...init.headers,
+      "Authorization": `Bearer ${options.auth}`
+    }
+  }) : fetch;
+  if (options?.retries)
+    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
+  return TypedHTTP.createClient(endpoint, fetcher);
+}
+
+// src/reportUploader.ts
+var ReportUploader = class _ReportUploader {
+  static optionsFromEnv(overrides) {
+    const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
+    if (!flakinessAccessToken)
+      return void 0;
+    const flakinessEndpoint = overrides?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
+    return { flakinessAccessToken, flakinessEndpoint };
+  }
+  static async upload(options) {
+    const uploaderOptions = _ReportUploader.optionsFromEnv(options);
+    if (!uploaderOptions) {
+      if (process.env.CI)
+        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
+      return void 0;
+    }
+    const uploader = new _ReportUploader(uploaderOptions);
+    const upload = uploader.createUpload(options.report, options.attachments);
+    const uploadResult = await upload.upload();
+    if (!uploadResult.success) {
+      options.log?.(`[flakiness.io] X Failed to upload to ${uploaderOptions.flakinessEndpoint}: ${uploadResult.message}`);
+      return { errorMessage: uploadResult.message };
+    }
+    options.log?.(`[flakiness.io] \u2713 Report uploaded ${uploadResult.message ?? ""}`);
+    if (uploadResult.reportUrl)
+      options.log?.(`[flakiness.io] ${uploadResult.reportUrl}`);
+  }
+  _options;
+  constructor(options) {
+    this._options = options;
+  }
+  createUpload(report, attachments) {
+    const upload = new ReportUpload(this._options, report, attachments);
+    return upload;
+  }
+};
+var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
+var ReportUpload = class {
+  _report;
+  _attachments;
+  _options;
+  _api;
+  constructor(options, report, attachments) {
+    this._options = options;
+    this._report = report;
+    this._attachments = attachments;
+    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF, auth: this._options.flakinessAccessToken });
+  }
+  async upload(options) {
+    const response = await this._api.run.startUpload.POST({
+      attachmentIds: this._attachments.map((attachment) => attachment.id)
+    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ result: void 0, error: e }));
+    if (response?.error || !response.result)
+      return { success: false, message: `flakiness.io returned error: ${response.error.message}` };
+    await Promise.all([
+      this._uploadReport(JSON.stringify(this._report), response.result.report_upload_url, options?.syncCompression ?? false),
+      ...this._attachments.map((attachment) => {
+        const uploadURL = response.result.attachment_upload_urls[attachment.id];
+        if (!uploadURL)
+          throw new Error("Internal error: missing upload URL for attachment!");
+        return this._uploadAttachment(attachment, uploadURL, options?.syncCompression ?? false);
+      })
+    ]);
+    const response2 = await this._api.run.completeUpload.POST({
+      upload_token: response.result.upload_token
+    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ error: e, result: void 0 }));
+    const url = response2?.result?.report_url ? new URL2(response2?.result.report_url, this._options.flakinessEndpoint).toString() : void 0;
+    return { success: true, reportUrl: url };
+  }
+  async _uploadReport(data, uploadUrl, syncCompression) {
+    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(compressed) + "",
+      "Content-Encoding": "br"
+    };
+    await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = httpUtils.createRequest({
+        url: uploadUrl,
+        headers,
+        method: "put"
+      });
+      request.write(compressed);
+      request.end();
+      await responseDataPromise;
+    }, HTTP_BACKOFF);
+  }
+  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
+    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
+    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
+    if (!compressable && attachment.path) {
+      const attachmentPath = attachment.path;
+      await retryWithBackoff(async () => {
+        const { request, responseDataPromise } = httpUtils.createRequest({
+          url: uploadUrl,
+          headers: {
+            "Content-Type": attachment.contentType,
+            "Content-Length": (await fs3.promises.stat(attachmentPath)).size + ""
+          },
+          method: "put"
+        });
+        fs3.createReadStream(attachmentPath).pipe(request);
+        await responseDataPromise;
+      }, HTTP_BACKOFF);
+      return;
+    }
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs3.promises.readFile(attachment.path) : void 0;
+    assert2(buffer);
+    const encoding = compressable ? "br" : void 0;
+    if (compressable)
+      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
+    const headers = {
+      "Content-Type": attachment.contentType,
+      "Content-Length": Buffer.byteLength(buffer) + "",
+      "Content-Encoding": encoding
+    };
+    await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = httpUtils.createRequest({
+        url: uploadUrl,
+        headers,
+        method: "put"
+      });
+      request.write(buffer);
+      request.end();
+      await responseDataPromise;
+    }, HTTP_BACKOFF);
+  }
+};
+
+// src/showReport.ts
+import chalk from "chalk";
+import open from "open";
+import path4 from "path";
+
+// src/flakinessProjectConfig.ts
+import fs4 from "fs";
+import path2 from "path";
 function createConfigPath(dir) {
   return path2.join(dir, ".flakiness", "config.json");
 }
@@ -330,7 +510,7 @@ function ensureConfigPath() {
 function computeConfigPath() {
   for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
     const configPath = createConfigPath(p);
-    if (fs2.existsSync(configPath))
+    if (fs4.existsSync(configPath))
       return configPath;
   }
   try {
@@ -340,29 +520,19 @@ function computeConfigPath() {
     return createConfigPath(process.cwd());
   }
 }
-var FlakinessConfig = class _FlakinessConfig {
+var FlakinessProjectConfig = class _FlakinessProjectConfig {
   constructor(_configPath, _config) {
     this._configPath = _configPath;
     this._config = _config;
   }
   static async load() {
     const configPath = ensureConfigPath();
-    const data = await fs2.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const data = await fs4.promises.readFile(configPath, "utf-8").catch((e) => void 0);
     const json = data ? JSON.parse(data) : {};
-    return new _FlakinessConfig(configPath, json);
-  }
-  static async projectOrDie(session) {
-    const config = await _FlakinessConfig.load();
-    const projectPublicId = config.projectPublicId();
-    if (!projectPublicId)
-      throw new Error(`Please link to flakiness project with 'npx flakiness link'`);
-    const project = await session.api.project.getProject.GET({ projectPublicId }).catch((e) => void 0);
-    if (!project)
-      throw new Error(`Failed to fetch linked project; please re-link with 'npx flakiness link'`);
-    return project;
+    return new _FlakinessProjectConfig(configPath, json);
   }
   static createEmpty() {
-    return new _FlakinessConfig(ensureConfigPath(), {});
+    return new _FlakinessProjectConfig(ensureConfigPath(), {});
   }
   path() {
     return this._configPath;
@@ -370,76 +540,15 @@ var FlakinessConfig = class _FlakinessConfig {
   projectPublicId() {
     return this._config.projectPublicId;
   }
+  reportViewerEndpoint() {
+    return this._config.customReportViewerEndpoint ?? "https://report.flakiness.io";
+  }
   setProjectPublicId(projectId) {
     this._config.projectPublicId = projectId;
   }
   async save() {
-    await fs2.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
-    await fs2.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/flakinessSession.ts
-import fs3 from "fs/promises";
-import os2 from "os";
-import path3 from "path";
-
-// src/serverapi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-function createServerAPI(endpoint, options) {
-  endpoint += "/api/";
-  const fetcher = options?.auth ? (url, init) => fetch(url, {
-    ...init,
-    headers: {
-      ...init.headers,
-      "Authorization": `Bearer ${options.auth}`
-    }
-  }) : fetch;
-  if (options?.retries)
-    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
-  return TypedHTTP.createClient(endpoint, fetcher);
-}
-
-// src/flakinessSession.ts
-var CONFIG_DIR = (() => {
-  const configDir = process.platform === "darwin" ? path3.join(os2.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path3.join(os2.homedir(), "AppData", "Roaming", "flakiness") : path3.join(os2.homedir(), ".config", "flakiness");
-  return configDir;
-})();
-var CONFIG_PATH = path3.join(CONFIG_DIR, "config.json");
-var FlakinessSession = class _FlakinessSession {
-  constructor(_config) {
-    this._config = _config;
-    this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
-  }
-  static async loadOrDie() {
-    const session = await _FlakinessSession.load();
-    if (!session)
-      throw new Error(`Please login first with 'npx flakiness login'`);
-    return session;
-  }
-  static async load() {
-    const data = await fs3.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
-    if (!data)
-      return void 0;
-    const json = JSON.parse(data);
-    return new _FlakinessSession(json);
-  }
-  static async remove() {
-    await fs3.unlink(CONFIG_PATH).catch((e) => void 0);
-  }
-  api;
-  endpoint() {
-    return this._config.endpoint;
-  }
-  path() {
-    return CONFIG_PATH;
-  }
-  sessionToken() {
-    return this._config.token;
-  }
-  async save() {
-    await fs3.mkdir(CONFIG_DIR, { recursive: true });
-    await fs3.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+    await fs4.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
+    await fs4.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
   }
 };
 
@@ -456,8 +565,8 @@ 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 fs5 from "fs";
+import path3 from "path";
 import { z } from "zod/v4";
 
 // src/localGit.ts
@@ -512,7 +621,7 @@ var ReportInfo = class {
   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);
+    const report = await fs5.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
     if (!report) {
       this.report = void 0;
       this.commits = [];
@@ -522,7 +631,7 @@ var ReportInfo = class {
     if (JSON.stringify(report) === JSON.stringify(this.report))
       return;
     this.report = report;
-    this.commits = await listLocalCommits(path4.dirname(this._options.reportPath), report.commitId, 100);
+    this.commits = await listLocalCommits(path3.dirname(this._options.reportPath), report.commitId, 100);
     const attachmentsDir = this._options.attachmentsFolder;
     const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
     if (missingAttachments.length) {
@@ -556,7 +665,7 @@ var localReportRouter = {
         const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs4.promises.readFile(idx.path);
+        const buffer = await fs5.promises.readFile(idx.path);
         return TypedHTTP2.ok(buffer, idx.contentType);
       }
     }),
@@ -635,194 +744,34 @@ var LocalReportServer = class _LocalReportServer {
   }
 };
 
-// src/cli/cmd-show-report.ts
-async function cmdShowReport(reportFolder) {
-  const reportPath = path5.join(reportFolder, "report.json");
-  const session = await FlakinessSession.load();
-  const config = await FlakinessConfig.load();
+// src/showReport.ts
+async function showReport(reportFolder) {
+  const reportPath = path4.join(reportFolder, "report.json");
+  const config = await FlakinessProjectConfig.load();
   const projectPublicId = config.projectPublicId();
-  const project = projectPublicId && session ? await session.api.project.getProject.GET({ projectPublicId }).catch((e) => void 0) : void 0;
-  const endpoint = session?.endpoint() ?? "https://flakiness.io";
+  const reportViewerEndpoint = config.reportViewerEndpoint();
   const server = await LocalReportServer.create({
-    endpoint,
+    endpoint: reportViewerEndpoint,
     port: 9373,
     reportPath,
     attachmentsFolder: reportFolder
   });
-  const reportEndpoint = project ? `${endpoint}/localreport/${project.org.orgSlug}/${project.projectSlug}?port=${server.port()}&token=${server.authToken()}` : `${endpoint}/localreport?port=${server.port()}&token=${server.authToken()}`;
+  const url = new URL(reportViewerEndpoint);
+  url.searchParams.set("port", String(server.port()));
+  url.searchParams.set("token", server.authToken());
+  if (projectPublicId)
+    url.searchParams.set("ppid", projectPublicId);
   console.log(chalk.cyan(`
-  Serving Flakiness report at ${reportEndpoint}
+  Serving Flakiness report at ${url.toString()}
   Press Ctrl+C to quit.`));
-  await open(reportEndpoint);
+  await open(url.toString());
   await new Promise(() => {
   });
 }
 
-// src/createTestStepSnippets.ts
-import { codeFrameColumns } from "@babel/code-frame";
-import fs5 from "fs";
-function createTestStepSnippets(filepathToSteps) {
-  for (const [filepath, steps] of filepathToSteps) {
-    let source;
-    try {
-      source = fs5.readFileSync(filepath, "utf-8");
-    } catch (e) {
-      continue;
-    }
-    const lines = source.split("\n").length;
-    const highlighted = codeFrameColumns(source, { start: { line: lines, column: 1 } }, { highlightCode: true, linesAbove: lines, linesBelow: 0 });
-    const highlightedLines = highlighted.split("\n");
-    const lineWithArrow = highlightedLines[highlightedLines.length - 1];
-    for (const step of steps) {
-      if (!step.location)
-        continue;
-      if (step.location.line < 2 || step.location.line >= lines)
-        continue;
-      const snippetLines = highlightedLines.slice(step.location.line - 2, step.location.line + 1);
-      const index = lineWithArrow.indexOf("^");
-      const shiftedArrow = lineWithArrow.slice(0, index) + " ".repeat(step.location.column - 1) + lineWithArrow.slice(index);
-      snippetLines.splice(2, 0, shiftedArrow);
-      step.snippet = snippetLines.join("\n");
-    }
-  }
-}
-
-// src/reportUploader.ts
-import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
-import assert2 from "assert";
-import fs6 from "fs";
-import { URL } from "url";
-var ReportUploader = class _ReportUploader {
-  static optionsFromEnv(overrides) {
-    const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
-    if (!flakinessAccessToken)
-      return void 0;
-    const flakinessEndpoint = overrides?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
-    return { flakinessAccessToken, flakinessEndpoint };
-  }
-  static async upload(options) {
-    const uploaderOptions = _ReportUploader.optionsFromEnv(options);
-    if (!uploaderOptions) {
-      if (process.env.CI)
-        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
-      return void 0;
-    }
-    const uploader = new _ReportUploader(uploaderOptions);
-    const upload = uploader.createUpload(options.report, options.attachments);
-    const uploadResult = await upload.upload();
-    if (!uploadResult.success) {
-      options.log?.(`[flakiness.io] X Failed to upload to ${uploaderOptions.flakinessEndpoint}: ${uploadResult.message}`);
-      return { errorMessage: uploadResult.message };
-    }
-    options.log?.(`[flakiness.io] \u2713 Report uploaded ${uploadResult.message ?? ""}`);
-    if (uploadResult.reportUrl)
-      options.log?.(`[flakiness.io] ${uploadResult.reportUrl}`);
-  }
-  _options;
-  constructor(options) {
-    this._options = options;
-  }
-  createUpload(report, attachments) {
-    const upload = new ReportUpload(this._options, report, attachments);
-    return upload;
-  }
-};
-var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
-var ReportUpload = class {
-  _report;
-  _attachments;
-  _options;
-  _api;
-  constructor(options, report, attachments) {
-    this._options = options;
-    this._report = report;
-    this._attachments = attachments;
-    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF, auth: this._options.flakinessAccessToken });
-  }
-  async upload(options) {
-    const response = await this._api.run.startUpload.POST({
-      attachmentIds: this._attachments.map((attachment) => attachment.id)
-    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ result: void 0, error: e }));
-    if (response?.error || !response.result)
-      return { success: false, message: `flakiness.io returned error: ${response.error.message}` };
-    await Promise.all([
-      this._uploadReport(JSON.stringify(this._report), response.result.report_upload_url, options?.syncCompression ?? false),
-      ...this._attachments.map((attachment) => {
-        const uploadURL = response.result.attachment_upload_urls[attachment.id];
-        if (!uploadURL)
-          throw new Error("Internal error: missing upload URL for attachment!");
-        return this._uploadAttachment(attachment, uploadURL, options?.syncCompression ?? false);
-      })
-    ]);
-    const response2 = await this._api.run.completeUpload.POST({
-      upload_token: response.result.upload_token
-    }).then((result) => ({ result, error: void 0 })).catch((e) => ({ error: e, result: void 0 }));
-    const url = response2?.result?.report_url ? new URL(response2?.result.report_url, this._options.flakinessEndpoint).toString() : void 0;
-    return { success: true, reportUrl: url };
-  }
-  async _uploadReport(data, uploadUrl, syncCompression) {
-    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
-    const headers = {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(compressed) + "",
-      "Content-Encoding": "br"
-    };
-    await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = httpUtils.createRequest({
-        url: uploadUrl,
-        headers,
-        method: "put"
-      });
-      request.write(compressed);
-      request.end();
-      await responseDataPromise;
-    }, HTTP_BACKOFF);
-  }
-  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
-    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
-    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
-    if (!compressable && attachment.path) {
-      const attachmentPath = attachment.path;
-      await retryWithBackoff(async () => {
-        const { request, responseDataPromise } = httpUtils.createRequest({
-          url: uploadUrl,
-          headers: {
-            "Content-Type": attachment.contentType,
-            "Content-Length": (await fs6.promises.stat(attachmentPath)).size + ""
-          },
-          method: "put"
-        });
-        fs6.createReadStream(attachmentPath).pipe(request);
-        await responseDataPromise;
-      }, HTTP_BACKOFF);
-      return;
-    }
-    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)
-      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
-    const headers = {
-      "Content-Type": attachment.contentType,
-      "Content-Length": Buffer.byteLength(buffer) + "",
-      "Content-Encoding": encoding
-    };
-    await retryWithBackoff(async () => {
-      const { request, responseDataPromise } = httpUtils.createRequest({
-        url: uploadUrl,
-        headers,
-        method: "put"
-      });
-      request.write(buffer);
-      request.end();
-      await responseDataPromise;
-    }, HTTP_BACKOFF);
-  }
-};
-
 // src/systemUtilizationSampler.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import os3 from "os";
+import os2 from "os";
 function getAvailableMemMacOS() {
   const lines = spawnSync2("vm_stat", { encoding: "utf8" }).stdout.trim().split("\n");
   const pageSize = parseInt(lines[0].match(/page size of (\d+) bytes/)[1], 10);
@@ -843,7 +792,7 @@ function getAvailableMemMacOS() {
 function getSystemUtilization() {
   let idleTicks = 0;
   let totalTicks = 0;
-  for (const cpu of os3.cpus()) {
+  for (const cpu of os2.cpus()) {
     totalTicks += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq + cpu.times.idle;
     idleTicks += cpu.times.idle;
   }
@@ -851,14 +800,14 @@ function getSystemUtilization() {
     idleTicks,
     totalTicks,
     timestamp: Date.now(),
-    freeBytes: os3.platform() === "darwin" ? getAvailableMemMacOS() : os3.freemem()
+    freeBytes: os2.platform() === "darwin" ? getAvailableMemMacOS() : os2.freemem()
   };
 }
 function toFKUtilization(sample, previous) {
   const idleTicks = sample.idleTicks - previous.idleTicks;
   const totalTicks = sample.totalTicks - previous.totalTicks;
   const cpuUtilization = Math.floor((1 - idleTicks / totalTicks) * 1e4) / 100;
-  const memoryUtilization = Math.floor((1 - sample.freeBytes / os3.totalmem()) * 1e4) / 100;
+  const memoryUtilization = Math.floor((1 - sample.freeBytes / os2.totalmem()) * 1e4) / 100;
   return {
     cpuUtilization,
     memoryUtilization,
@@ -873,7 +822,7 @@ var SystemUtilizationSampler = class {
     this.result = {
       samples: [],
       startTimestamp: this._lastSample.timestamp,
-      totalMemoryBytes: os3.totalmem()
+      totalMemoryBytes: os2.totalmem()
     };
     this._timer = setTimeout(this._addSample.bind(this), 50);
   }
@@ -894,7 +843,7 @@ var err = (txt) => console.error(chalk2.red(`[flakiness.io] ${txt}`));
 var FlakinessReporter = class {
   constructor(_options = {}) {
     this._options = _options;
-    this._outputFolder = path6.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
+    this._outputFolder = path5.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
   }
   _config;
   _rootSuite;
@@ -997,7 +946,7 @@ var FlakinessReporter = class {
       location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
     };
     if (pwStep.location) {
-      const resolvedPath = path6.resolve(pwStep.location.file);
+      const resolvedPath = path5.resolve(pwStep.location.file);
       this._filepathToSteps.set(resolvedPath, step);
     }
     if (pwStep.error)
@@ -1046,10 +995,10 @@ var FlakinessReporter = class {
     const environmentsMap = createEnvironments(this._config.projects);
     if (this._options.collectBrowserVersions) {
       try {
-        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"));
+        let playwrightPath = fs6.realpathSync(process.argv[1]);
+        while (path5.basename(playwrightPath) !== "test")
+          playwrightPath = path5.dirname(playwrightPath);
+        const module = await import(path5.join(playwrightPath, "index.js"));
         for (const [project, env] of environmentsMap) {
           const { browserName = "chromium", channel, headless } = project.use;
           let browserType;
@@ -1114,10 +1063,10 @@ var FlakinessReporter = class {
     const openMode = this._options.open ?? "on-failure";
     const shouldOpen = process.stdin.isTTY && !process.env.CI && (openMode === "always" || openMode === "on-failure" && this._result?.status === "failed");
     if (shouldOpen) {
-      await cmdShowReport(this._outputFolder);
+      await showReport(this._outputFolder);
     } else {
-      const defaultOutputFolder = path6.join(process.cwd(), "flakiness-report");
-      const folder = defaultOutputFolder === this._outputFolder ? "" : path6.relative(process.cwd(), this._outputFolder);
+      const defaultOutputFolder = path5.join(process.cwd(), "flakiness-report");
+      const folder = defaultOutputFolder === this._outputFolder ? "" : path5.relative(process.cwd(), this._outputFolder);
       console.log(`
 To open last Flakiness report, install Flakiness CLI tool and run: