@flakiness/sdk 0.95.0

package/lib/playwright-test.js

@@ -0,0 +1,933 @@
+// src/playwright-test.ts
+import { FlakinessReport as FK } from "@flakiness/report";
+import { Multimap } from "@flakiness/shared/common/multimap.js";
+import fs4 from "fs";
+import path 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 fs3 from "fs";
+import { URL as URL2 } from "url";
+import { brotliCompressSync as brotliCompressSync2 } from "zlib";
+
+// ../server/lib/common/typedHttp.js
+var TypedHTTP;
+((TypedHTTP2) => {
+  TypedHTTP2.StatusCodes = {
+    Informational: {
+      CONTINUE: 100,
+      SWITCHING_PROTOCOLS: 101,
+      PROCESSING: 102,
+      EARLY_HINTS: 103
+    },
+    Success: {
+      OK: 200,
+      CREATED: 201,
+      ACCEPTED: 202,
+      NON_AUTHORITATIVE_INFORMATION: 203,
+      NO_CONTENT: 204,
+      RESET_CONTENT: 205,
+      PARTIAL_CONTENT: 206,
+      MULTI_STATUS: 207
+    },
+    Redirection: {
+      MULTIPLE_CHOICES: 300,
+      MOVED_PERMANENTLY: 301,
+      MOVED_TEMPORARILY: 302,
+      SEE_OTHER: 303,
+      NOT_MODIFIED: 304,
+      USE_PROXY: 305,
+      TEMPORARY_REDIRECT: 307,
+      PERMANENT_REDIRECT: 308
+    },
+    ClientErrors: {
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      PAYMENT_REQUIRED: 402,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      METHOD_NOT_ALLOWED: 405,
+      NOT_ACCEPTABLE: 406,
+      PROXY_AUTHENTICATION_REQUIRED: 407,
+      REQUEST_TIMEOUT: 408,
+      CONFLICT: 409,
+      GONE: 410,
+      LENGTH_REQUIRED: 411,
+      PRECONDITION_FAILED: 412,
+      REQUEST_TOO_LONG: 413,
+      REQUEST_URI_TOO_LONG: 414,
+      UNSUPPORTED_MEDIA_TYPE: 415,
+      REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+      EXPECTATION_FAILED: 417,
+      IM_A_TEAPOT: 418,
+      INSUFFICIENT_SPACE_ON_RESOURCE: 419,
+      METHOD_FAILURE: 420,
+      MISDIRECTED_REQUEST: 421,
+      UNPROCESSABLE_ENTITY: 422,
+      LOCKED: 423,
+      FAILED_DEPENDENCY: 424,
+      UPGRADE_REQUIRED: 426,
+      PRECONDITION_REQUIRED: 428,
+      TOO_MANY_REQUESTS: 429,
+      REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+      UNAVAILABLE_FOR_LEGAL_REASONS: 451
+    },
+    ServerErrors: {
+      INTERNAL_SERVER_ERROR: 500,
+      NOT_IMPLEMENTED: 501,
+      BAD_GATEWAY: 502,
+      SERVICE_UNAVAILABLE: 503,
+      GATEWAY_TIMEOUT: 504,
+      HTTP_VERSION_NOT_SUPPORTED: 505,
+      INSUFFICIENT_STORAGE: 507,
+      NETWORK_AUTHENTICATION_REQUIRED: 511
+    }
+  };
+  const AllErrorCodes = {
+    ...TypedHTTP2.StatusCodes.ClientErrors,
+    ...TypedHTTP2.StatusCodes.ServerErrors
+  };
+  class HttpError extends Error {
+    constructor(status, message) {
+      super(message);
+      this.status = status;
+    }
+    static withCode(code, message) {
+      const statusCode = AllErrorCodes[code];
+      const defaultMessage = code.split("_").map((word) => word.charAt(0) + word.slice(1).toLowerCase()).join(" ");
+      return new HttpError(statusCode, message ?? defaultMessage);
+    }
+  }
+  TypedHTTP2.HttpError = HttpError;
+  function isInformationalResponse(response) {
+    return response.status >= 100 && response.status < 200;
+  }
+  TypedHTTP2.isInformationalResponse = isInformationalResponse;
+  function isSuccessResponse(response) {
+    return response.status >= 200 && response.status < 300;
+  }
+  TypedHTTP2.isSuccessResponse = isSuccessResponse;
+  function isRedirectResponse(response) {
+    return response.status >= 300 && response.status < 400;
+  }
+  TypedHTTP2.isRedirectResponse = isRedirectResponse;
+  function isErrorResponse(response) {
+    return response.status >= 400 && response.status < 600;
+  }
+  TypedHTTP2.isErrorResponse = isErrorResponse;
+  function info(status) {
+    return { status };
+  }
+  TypedHTTP2.info = info;
+  function ok(data, status) {
+    return {
+      status: status ?? TypedHTTP2.StatusCodes.Success.OK,
+      data
+    };
+  }
+  TypedHTTP2.ok = ok;
+  function redirect(url, status = 302) {
+    return { status, url };
+  }
+  TypedHTTP2.redirect = redirect;
+  function error(message, status = TypedHTTP2.StatusCodes.ServerErrors.INTERNAL_SERVER_ERROR) {
+    return { status, message };
+  }
+  TypedHTTP2.error = error;
+  class Router {
+    constructor(_resolveContext) {
+      this._resolveContext = _resolveContext;
+    }
+    static create() {
+      return new Router(async (e) => e.ctx);
+    }
+    rawMethod(method, route) {
+      return {
+        [method]: {
+          method,
+          input: route.input,
+          etag: route.etag,
+          resolveContext: this._resolveContext,
+          handler: route.handler
+        }
+      };
+    }
+    get(route) {
+      return this.rawMethod("GET", {
+        ...route,
+        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
+      });
+    }
+    post(route) {
+      return this.rawMethod("POST", {
+        ...route,
+        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
+      });
+    }
+    use(resolveContext) {
+      return new Router(async (options) => {
+        const m = await this._resolveContext(options);
+        return resolveContext({ ...options, ctx: m });
+      });
+    }
+  }
+  TypedHTTP2.Router = Router;
+  function createClient(base, fetchCallback) {
+    function buildUrl(path2, input, options) {
+      const method = path2.at(-1);
+      const url = new URL(path2.slice(0, path2.length - 1).join("/"), base);
+      const signal = options?.signal;
+      let body = void 0;
+      if (method === "GET" && input)
+        url.searchParams.set("input", JSON.stringify(input));
+      else if (method !== "GET" && input)
+        body = JSON.stringify(input);
+      return {
+        url,
+        method,
+        headers: body ? { "Content-Type": "application/json" } : void 0,
+        body,
+        signal
+      };
+    }
+    function createProxy(path2 = []) {
+      return new Proxy(() => {
+      }, {
+        get(target, prop) {
+          if (typeof prop === "symbol")
+            return void 0;
+          if (prop === "prepare")
+            return (input, options) => buildUrl(path2, input, options);
+          const newPath = [...path2, prop];
+          return createProxy(newPath);
+        },
+        apply(target, thisArg, args) {
+          const options = buildUrl(path2, args[0], args[1]);
+          return fetchCallback(options.url, {
+            method: options.method,
+            body: options.body,
+            headers: options.headers,
+            signal: options.signal
+          }).then(async (response) => {
+            if (response.status >= 200 && response.status < 300) {
+              if (response.headers.get("content-type")?.includes("application/json")) {
+                const text = await response.text();
+                return text.length ? JSON.parse(text) : void 0;
+              }
+              return await response.blob();
+            }
+            if (response.status >= 400 && response.status < 600) {
+              const text = await response.text();
+              if (text)
+                throw new Error(`HTTP request failed with status ${response.status}: ${text}`);
+              else
+                throw new Error(`HTTP request failed with status ${response.status}`);
+            }
+          });
+        }
+      });
+    }
+    return createProxy();
+  }
+  TypedHTTP2.createClient = createClient;
+})(TypedHTTP || (TypedHTTP = {}));
+
+// src/utils.ts
+import assert from "assert";
+import { spawnSync } from "child_process";
+import crypto from "crypto";
+import fs2 from "fs";
+import http from "http";
+import https from "https";
+import os from "os";
+import { posix as posixPath, win32 as win32Path } from "path";
+import util from "util";
+import zlib from "zlib";
+var gzipAsync = util.promisify(zlib.gzip);
+var gunzipAsync = util.promisify(zlib.gunzip);
+var gunzipSync = zlib.gunzipSync;
+var brotliCompressAsync = util.promisify(zlib.brotliCompress);
+var brotliCompressSync = zlib.brotliCompressSync;
+async function existsAsync(aPath) {
+  return fs2.promises.stat(aPath).then(() => true).catch((e) => false);
+}
+function extractEnvConfiguration() {
+  const ENV_PREFIX = "FK_ENV_";
+  return Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith(ENV_PREFIX.toUpperCase())).map(([key, value]) => [key.substring(ENV_PREFIX.length).toLowerCase(), (value ?? "").trim().toLowerCase()])
+  );
+}
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs2.createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+    stream.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function sha1Buffer(data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
+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]`, e.errors[0].message);
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, e.message);
+      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;
+    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");
+function stripAnsi(str) {
+  return str.replace(ansiRegex, "");
+}
+function shell(command, args, options) {
+  try {
+    const result = spawnSync(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      console.log(result);
+      console.log(options);
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.log(e);
+    return void 0;
+  }
+}
+function readLinuxOSRelease() {
+  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("=");
+    if (value.startsWith('"') && value.endsWith('"'))
+      value = value.substring(1, value.length - 1);
+    return [key, value];
+  }));
+}
+function osLinuxInfo() {
+  const arch = shell(`uname`, [`-m`]);
+  const osReleaseMap = readLinuxOSRelease();
+  const name = osReleaseMap.get("name") ?? shell(`uname`);
+  const version = osReleaseMap.get("version_id");
+  return { name, arch, version };
+}
+function osDarwinInfo() {
+  const name = "macos";
+  const arch = shell(`uname`, [`-m`]);
+  const version = shell(`sw_vers`, [`-productVersion`]);
+  return { name, arch, version };
+}
+function osWinInfo() {
+  const name = "win";
+  const arch = process.arch;
+  const version = os.release();
+  return { name, arch, version };
+}
+function getOSInfo() {
+  if (process.platform === "darwin")
+    return osDarwinInfo();
+  if (process.platform === "win32")
+    return osWinInfo();
+  return osLinuxInfo();
+}
+function inferRunUrl() {
+  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID)
+    return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+  return void 0;
+}
+function gitCommitInfo(gitRepo) {
+  const sha = shell(`git`, ["rev-parse", "HEAD"], {
+    cwd: gitRepo,
+    encoding: "utf-8"
+  });
+  assert(sha, `FAILED: git rev-parse HEAD @ ${gitRepo}`);
+  return sha.trim();
+}
+function computeGitRoot(somePathInsideGitRepo) {
+  const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
+    cwd: somePathInsideGitRepo,
+    encoding: "utf-8"
+  });
+  assert(root, `FAILED: git rev-parse --show-toplevel HEAD @ ${somePathInsideGitRepo}`);
+  return normalizePath(root);
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+function normalizePath(aPath) {
+  if (IS_WIN32_PATH.test(aPath)) {
+    aPath = aPath.split(win32Path.sep).join(posixPath.sep);
+  }
+  if (IS_ALMOST_POSIX_PATH.test(aPath))
+    return "/" + aPath[0] + aPath.substring(2);
+  return aPath;
+}
+function gitFilePath(gitRoot, absolutePath) {
+  return posixPath.relative(gitRoot, absolutePath);
+}
+function parseDurationMS(value) {
+  if (isNaN(value))
+    throw new Error("Duration cannot be NaN");
+  if (value < 0)
+    throw new Error(`Duration cannot be less than 0, found ${value}`);
+  return value | 0;
+}
+function createEnvironments(projects) {
+  const envConfiguration = extractEnvConfiguration();
+  const osInfo = getOSInfo();
+  let uniqueNames = /* @__PURE__ */ new Set();
+  const result = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    let defaultName = project.name;
+    if (!defaultName.trim())
+      defaultName = "anonymous";
+    let name = defaultName;
+    for (let i = 2; uniqueNames.has(name); ++i)
+      name = `${defaultName}-${i}`;
+    uniqueNames.add(defaultName);
+    result.set(project, {
+      name,
+      systemData: {
+        osArch: osInfo.arch,
+        osName: osInfo.name,
+        osVersion: osInfo.version
+      },
+      userSuppliedData: {
+        ...envConfiguration,
+        ...project.metadata
+      },
+      opaqueData: {
+        project
+      }
+    });
+  }
+  return result;
+}
+
+// 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) {
+      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 });
+  }
+  async upload(options) {
+    const response = await this._api.run.startUpload.POST({
+      flakinessAccessToken: this._options.flakinessAccessToken,
+      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);
+      })
+    ]);
+    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 ? brotliCompressSync2(data) : await brotliCompressAsync(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) {
+    const bytesLength = attachment.path ? (await fs3.promises.stat(attachment.path)).size : attachment.body ? Buffer.byteLength(attachment.body) : 0;
+    const headers = {
+      "Content-Type": attachment.contentType,
+      "Content-Length": bytesLength + ""
+    };
+    await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = httpUtils.createRequest({
+        url: uploadUrl,
+        headers,
+        method: "put"
+      });
+      if (attachment.path) {
+        fs3.createReadStream(attachment.path).pipe(request);
+      } else {
+        if (attachment.body)
+          request.write(attachment.body);
+        request.end();
+      }
+      await responseDataPromise;
+    }, HTTP_BACKOFF);
+  }
+};
+
+// src/systemUtilizationSampler.ts
+import { spawnSync as spawnSync2 } from "child_process";
+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);
+  if (isNaN(pageSize)) {
+    console.warn("[flakiness.io] Error detecting macos page size");
+    return 0;
+  }
+  let totalFree = 0;
+  for (const line of lines) {
+    if (/Pages (free|inactive|speculative):/.test(line)) {
+      const match = line.match(/\d+/);
+      if (match)
+        totalFree += parseInt(match[0], 10);
+    }
+  }
+  return totalFree * pageSize;
+}
+function getSystemUtilization() {
+  let idleTicks = 0;
+  let totalTicks = 0;
+  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;
+  }
+  return {
+    idleTicks,
+    totalTicks,
+    timestamp: Date.now(),
+    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 / os2.totalmem()) * 1e4) / 100;
+  return {
+    cpuUtilization,
+    memoryUtilization,
+    dts: sample.timestamp - previous.timestamp
+  };
+}
+var SystemUtilizationSampler = class {
+  result;
+  _lastSample = getSystemUtilization();
+  _timer;
+  constructor() {
+    this.result = {
+      samples: [],
+      startTimestamp: this._lastSample.timestamp,
+      totalMemoryBytes: os2.totalmem()
+    };
+    this._timer = setTimeout(this._addSample.bind(this), 50);
+  }
+  _addSample() {
+    const sample = getSystemUtilization();
+    this.result.samples.push(toFKUtilization(sample, this._lastSample));
+    this._lastSample = sample;
+    this._timer = setTimeout(this._addSample.bind(this), 1e3);
+  }
+  dispose() {
+    clearTimeout(this._timer);
+  }
+};
+
+// src/playwright-test.ts
+var FlakinessReporter = class {
+  constructor(_options = {}) {
+    this._options = _options;
+  }
+  _config;
+  _rootSuite;
+  _results = new Multimap();
+  _unattributedErrors = [];
+  _filepathToSteps = new Multimap();
+  _systemUtilizationSampler = new SystemUtilizationSampler();
+  printsToStdio() {
+    return false;
+  }
+  onBegin(config, suite) {
+    this._config = config;
+    this._rootSuite = suite;
+  }
+  onError(error) {
+    this._unattributedErrors.push(error);
+  }
+  onTestBegin(test) {
+  }
+  onTestEnd(test, result) {
+    this._results.set(test, result);
+  }
+  async _toFKSuites(context, pwSuite) {
+    const location = pwSuite.location;
+    if (pwSuite.type === "root" || pwSuite.type === "project" || !location)
+      return (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat();
+    let type = "suite";
+    if (pwSuite.type === "file")
+      type = "file";
+    else if (pwSuite.type === "describe" && !pwSuite.title)
+      type = "anonymous suite";
+    return [{
+      type,
+      title: pwSuite.title,
+      location: this._createLocation(context, location),
+      suites: (await Promise.all(pwSuite.suites.map((suite) => this._toFKSuites(context, suite)))).flat(),
+      tests: await Promise.all(pwSuite.tests.map((test) => this._toFKTest(context, test)))
+    }];
+  }
+  async _toFKTest(context, pwTest) {
+    return {
+      title: pwTest.title,
+      // Playwright Test tags must start with '@' so we cut it off.
+      tags: pwTest.tags.map((tag) => tag.startsWith("@") ? tag.substring(1) : tag),
+      location: this._createLocation(context, pwTest.location),
+      // de-duplication of tests will happen later, so here we will have all attempts.
+      attempts: await Promise.all(this._results.getAll(pwTest).map((result) => this._toFKRunAttempt(context, pwTest, result)))
+    };
+  }
+  async _toFKRunAttempt(context, pwTest, result) {
+    const attachments = [];
+    const attempt = {
+      timeout: parseDurationMS(pwTest.timeout),
+      annotations: pwTest.annotations.map((annotation) => ({
+        type: annotation.type,
+        description: annotation.description,
+        location: annotation.location ? this._createLocation(context, annotation.location) : void 0
+      })),
+      environmentIdx: context.project2environmentIdx.get(pwTest.parent.project()),
+      expectedStatus: pwTest.expectedStatus,
+      parallelIndex: result.parallelIndex,
+      status: result.status,
+      errors: result.errors && result.errors.length ? result.errors.map((error) => this._toFKTestError(context, error)) : void 0,
+      stdout: result.stdout ? result.stdout.map(toSTDIOEntry) : void 0,
+      stderr: result.stderr ? result.stderr.map(toSTDIOEntry) : void 0,
+      steps: result.steps ? result.steps.map((jsonTestStep) => this._toFKTestStep(context, jsonTestStep)) : void 0,
+      startTimestamp: +result.startTime,
+      duration: +result.duration,
+      attachments
+    };
+    await Promise.all((result.attachments ?? []).map(async (jsonAttachment) => {
+      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
+        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
+        return;
+      }
+      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
+      context.attachments.set(id, {
+        contentType: jsonAttachment.contentType,
+        id,
+        body: jsonAttachment.body,
+        path: jsonAttachment.path
+      });
+      attachments.push({
+        id,
+        name: jsonAttachment.name,
+        contentType: jsonAttachment.contentType
+      });
+    }));
+    return attempt;
+  }
+  _toFKTestStep(context, pwStep) {
+    const step = {
+      // NOTE: jsonStep.duration was -1 in some playwright versions
+      duration: parseDurationMS(Math.max(pwStep.duration, 0)),
+      title: pwStep.title,
+      location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
+    };
+    if (pwStep.location) {
+      const resolvedPath = path.resolve(pwStep.location.file);
+      this._filepathToSteps.set(resolvedPath, step);
+    }
+    if (pwStep.error)
+      step.error = this._toFKTestError(context, pwStep.error);
+    if (pwStep.steps)
+      step.steps = pwStep.steps.map((childJSONStep) => this._toFKTestStep(context, childJSONStep));
+    return step;
+  }
+  _createLocation(context, pwLocation) {
+    return {
+      file: gitFilePath(context.gitRoot, normalizePath(pwLocation.file)),
+      line: pwLocation.line,
+      column: pwLocation.column
+    };
+  }
+  _toFKTestError(context, pwError) {
+    return {
+      location: pwError.location ? this._createLocation(context, pwError.location) : void 0,
+      message: stripAnsi(pwError.message ?? "").split("\n")[0],
+      snippet: pwError.snippet,
+      stack: pwError.stack,
+      value: pwError.value
+    };
+  }
+  async onEnd(result) {
+    this._systemUtilizationSampler.dispose();
+    if (!this._config || !this._rootSuite)
+      throw new Error("ERROR: failed to resolve config");
+    const uploadOptions = ReportUploader.optionsFromEnv({
+      flakinessAccessToken: this._options.token,
+      flakinessEndpoint: this._options.endpoint
+    });
+    if (!uploadOptions) {
+      console.log(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
+      return;
+    }
+    let commitId;
+    try {
+      commitId = gitCommitInfo(this._config.rootDir);
+    } catch (e) {
+      console.log(`[flakiness.io] Uploading skipped since failed to get commit info - is this a git repo?`);
+      return;
+    }
+    const gitRoot = normalizePath(computeGitRoot(this._config.rootDir));
+    const configPath = this._config.configFile ? gitFilePath(gitRoot, normalizePath(this._config.configFile)) : void 0;
+    const context = {
+      project2environmentIdx: /* @__PURE__ */ new Map(),
+      testBaseDir: normalizePath(this._config.rootDir),
+      gitRoot,
+      attachments: /* @__PURE__ */ new Map(),
+      unaccessibleAttachmentPaths: []
+    };
+    const environmentsMap = createEnvironments(this._config.projects);
+    if (this._options.collectBrowserVersions) {
+      try {
+        let playwrightPath = fs4.realpathSync(process.argv[1]);
+        while (path.basename(playwrightPath) !== "test")
+          playwrightPath = path.dirname(playwrightPath);
+        const module = await import(path.join(playwrightPath, "index.js"));
+        for (const [project, env] of environmentsMap) {
+          const { browserName = "chromium", channel, headless } = project.use;
+          let browserType;
+          switch (browserName) {
+            case "chromium":
+              browserType = module.default.chromium;
+              break;
+            case "firefox":
+              browserType = module.default.firefox;
+              break;
+            case "webkit":
+              browserType = module.default.webkit;
+              break;
+            default:
+              throw new Error(`Unsupported browser: ${browserName}`);
+          }
+          const browser = await browserType.launch({ channel, headless });
+          const version = browser.version();
+          await browser.close();
+          env.userSuppliedData ??= {};
+          env.userSuppliedData["browser"] = (channel ?? browserName).toLowerCase().trim() + " " + version;
+        }
+      } catch (e) {
+        console.error("[flakiness.io] failed to resolve browser version", e);
+      }
+    }
+    const environments = [...environmentsMap.values()];
+    for (let envIdx = 0; envIdx < environments.length; ++envIdx)
+      context.project2environmentIdx.set(this._config.projects[envIdx], envIdx);
+    const relatedCommitIds = this._options.relatedCommitIds;
+    const report = FK.dedupeSuitesTestsEnvironments({
+      category: "playwright",
+      commitId,
+      relatedCommitIds,
+      systemUtilization: this._systemUtilizationSampler.result,
+      configPath,
+      url: inferRunUrl(),
+      environments,
+      suites: await this._toFKSuites(context, this._rootSuite),
+      opaqueData: this._config,
+      unattributedErrors: this._unattributedErrors.map((e) => this._toFKTestError(context, e)),
+      duration: parseDurationMS(result.duration),
+      startTimestamp: +result.startTime
+    });
+    createTestStepSnippets(this._filepathToSteps);
+    for (const unaccessibleAttachment of context.unaccessibleAttachmentPaths)
+      console.warn(`[flakiness.io] WARN: cannot access attachment ${unaccessibleAttachment}`);
+    const uploadError = await ReportUploader.upload({
+      report,
+      attachments: [...context.attachments.values()],
+      ...uploadOptions,
+      log: console.log
+    });
+    if (uploadError)
+      return { status: "failed" };
+  }
+};
+function toSTDIOEntry(data) {
+  if (Buffer.isBuffer(data))
+    return { buffer: data.toString("base64") };
+  return { text: data };
+}
+export {
+  FlakinessReporter as default
+};
+//# sourceMappingURL=playwright-test.js.map