@flakiness/sdk 0.150.1 → 0.151.0

package/lib/index.js

@@ -1,18 +1,1196 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
 import { FlakinessReport } from "@flakiness/flakiness-report";
-import { CIUtils } from "./ciUtils.js";
-import { GitWorktree } from "./gitWorktree.js";
-import * as ReportUtils from "./reportUtils.js";
-import { SystemUtilizationSampler } from "./systemUtilizationSampler.js";
-import { showReport } from "./showReport.js";
-import { uploadReport } from "./uploadReport.js";
-import { writeReport } from "./writeReport.js";
-import { FlakinessProjectConfig } from "./flakinessProjectConfig.js";
+
+// src/ciUtils.ts
+var CIUtils;
+((CIUtils2) => {
+  function runUrl() {
+    return githubActions() ?? azure() ?? process.env.CI_JOB_URL ?? process.env.BUILD_URL;
+  }
+  CIUtils2.runUrl = runUrl;
+})(CIUtils || (CIUtils = {}));
+function githubActions() {
+  const serverUrl = process.env.GITHUB_SERVER_URL || "https://github.com";
+  const repo = process.env.GITHUB_REPOSITORY;
+  const runId = process.env.GITHUB_RUN_ID;
+  if (!repo || !runId) return void 0;
+  try {
+    const url = new URL(`${serverUrl}/${repo}/actions/runs/${runId}`);
+    const attempt = process.env.GITHUB_RUN_ATTEMPT;
+    if (attempt) url.searchParams.set("attempt", attempt);
+    url.searchParams.set("check_suite_focus", "true");
+    return url.toString();
+  } catch (error) {
+    return void 0;
+  }
+}
+function azure() {
+  const collectionUri = process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI;
+  const project = process.env.SYSTEM_TEAMPROJECT;
+  const buildId = process.env.BUILD_BUILDID;
+  if (!collectionUri || !project || !buildId)
+    return void 0;
+  try {
+    const baseUrl = collectionUri.endsWith("/") ? collectionUri : `${collectionUri}/`;
+    const url = new URL(`${baseUrl}${project}/_build/results`);
+    url.searchParams.set("buildId", buildId);
+    return url.toString();
+  } catch (error) {
+    return void 0;
+  }
+}
+
+// src/gitWorktree.ts
+import assert from "assert";
+import { exec } from "child_process";
+import debug from "debug";
+import { posix as posixPath, win32 as win32Path } from "path";
+import { promisify } from "util";
+
+// src/_internalUtils.ts
+import { spawnSync } from "child_process";
+import crypto from "crypto";
+import fs from "fs";
+import util from "util";
+import zlib from "zlib";
+var asyncBrotliCompress = util.promisify(zlib.brotliCompress);
+async function compressTextAsync(text) {
+  return asyncBrotliCompress(text, {
+    chunkSize: 32 * 1024,
+    params: {
+      [zlib.constants.BROTLI_PARAM_QUALITY]: 6,
+      [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT
+    }
+  });
+}
+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();
+}
+function shell(command, args, options) {
+  try {
+    const result = spawnSync(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+}
+function sha1Text(data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
+function sha1File(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve2(hash.digest("hex"));
+    });
+    stream.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function randomUUIDBase62() {
+  const BASE62_CHARSET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  let num = BigInt("0x" + crypto.randomUUID().replace(/-/g, ""));
+  if (num === 0n)
+    return BASE62_CHARSET[0];
+  const chars = [];
+  while (num > 0n) {
+    const remainder = Number(num % 62n);
+    num /= 62n;
+    chars.push(BASE62_CHARSET[remainder]);
+  }
+  return chars.reverse().join("");
+}
+
+// src/gitWorktree.ts
+var log = debug("fk:git");
+var execAsync = promisify(exec);
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+function toPosixAbsolutePath(absolutePath) {
+  if (IS_WIN32_PATH.test(absolutePath)) {
+    absolutePath = absolutePath.split(win32Path.sep).join(posixPath.sep);
+  }
+  if (IS_ALMOST_POSIX_PATH.test(absolutePath))
+    return "/" + absolutePath[0] + absolutePath.substring(2);
+  return absolutePath;
+}
+function toNativeAbsolutePath(posix) {
+  if (process.platform !== "win32")
+    return posix;
+  assert(posix.startsWith("/"), "The path must be absolute");
+  const m = posix.match(/^\/([a-zA-Z])(\/.*)?$/);
+  assert(m, `Invalid POSIX path: ${posix}`);
+  const drive = m[1];
+  const rest = (m[2] ?? "").split(posixPath.sep).join(win32Path.sep);
+  return drive.toUpperCase() + ":" + rest;
+}
+var GitWorktree = class _GitWorktree {
+  constructor(_gitRoot) {
+    this._gitRoot = _gitRoot;
+    this._posixGitRoot = toPosixAbsolutePath(this._gitRoot);
+  }
+  /**
+   * Creates a GitWorktree instance from any path inside a git repository.
+   *
+   * @param {string} somePathInsideGitRepo - Any path (file or directory) within a git repository.
+   *   Can be absolute or relative. The function will locate the git root directory.
+   *
+   * @returns {GitWorktree} A new GitWorktree instance bound to the discovered git root.
+   *
+   * @throws {Error} Throws if the path is not inside a git repository or if git commands fail.
+   *
+   * @example
+   * ```typescript
+   * const worktree = GitWorktree.create('./src/my-test.ts');
+   * const gitRoot = worktree.rootPath();
+   * ```
+   */
+  static create(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 new _GitWorktree(root);
+  }
+  _posixGitRoot;
+  /**
+   * Returns the native absolute path of the git repository root directory.
+   *
+   * @returns {string} Native absolute path to the git root. Format matches the current platform
+   *   (Windows or POSIX).
+   *
+   * @example
+   * ```typescript
+   * const root = worktree.rootPath();
+   * // On Windows: 'D:\project'
+   * // On Unix: '/project'
+   * ```
+   */
+  rootPath() {
+    return this._gitRoot;
+  }
+  /**
+   * Returns the commit ID (SHA-1 hash) of the current HEAD commit.
+   *
+   * @returns {FlakinessReport.CommitId} Full 40-character commit hash of the HEAD commit.
+   *
+   * @throws {Error} Throws if git command fails or repository is in an invalid state.
+   *
+   * @example
+   * ```typescript
+   * const commitId = worktree.headCommitId();
+   * // Returns: 'a1b2c3d4e5f6...' (40-character SHA-1)
+   * ```
+   */
+  headCommitId() {
+    const sha = shell(`git`, ["rev-parse", "HEAD"], {
+      cwd: this._gitRoot,
+      encoding: "utf-8"
+    });
+    assert(sha, `FAILED: git rev-parse HEAD @ ${this._gitRoot}`);
+    return sha.trim();
+  }
+  /**
+   * Converts a native absolute path to a git-relative POSIX path.
+   *
+   * Takes any absolute path (Windows or POSIX format) and converts it to a POSIX path
+   * relative to the git repository root. This is essential for Flakiness reports where
+   * all file paths must be git-relative and use POSIX separators.
+   *
+   * @param {string} absolutePath - Native absolute path to convert. Can be in Windows format
+   *   (e.g., `D:\project\src\test.ts`) or POSIX format (e.g., `/project/src/test.ts`).
+   *
+   * @returns {FlakinessReport.GitFilePath} POSIX path relative to git root (e.g., `src/test.ts`).
+   *   Returns an empty string if the path is the git root itself.
+   *
+   * @example
+   * ```typescript
+   * const gitPath = worktree.gitPath('/Users/project/src/test.ts');
+   * // Returns: 'src/test.ts'
+   * ```
+   */
+  gitPath(absolutePath) {
+    return posixPath.relative(this._posixGitRoot, toPosixAbsolutePath(absolutePath));
+  }
+  /**
+   * Converts a git-relative POSIX path to a native absolute path.
+   *
+   * Takes a POSIX path relative to the git root and converts it to the native absolute path
+   * format for the current platform (Windows or POSIX). This is the inverse of `gitPath()`.
+   *
+   * @param {FlakinessReport.GitFilePath} relativePath - POSIX path relative to git root
+   *   (e.g., `src/test.ts`).
+   *
+   * @returns {string} Native absolute path. On Windows, returns Windows format (e.g., `D:\project\src\test.ts`).
+   *   On POSIX systems, returns POSIX format (e.g., `/project/src/test.ts`).
+   *
+   * @example
+   * ```typescript
+   * const absolutePath = worktree.absolutePath('src/test.ts');
+   * // On Windows: 'D:\project\src\test.ts'
+   * // On Unix: '/project/src/test.ts'
+   * ```
+   */
+  absolutePath(relativePath) {
+    return toNativeAbsolutePath(posixPath.join(this._posixGitRoot, relativePath));
+  }
+  /**
+   * Lists recent commits from the repository.
+   *
+   * Retrieves commit information including commit ID, timestamp, author, message, and parent commits.
+   * Note: CI environments often have shallow checkouts with limited history, which may affect
+   * the number of commits returned.
+   *
+   * @param {number} count - Maximum number of commits to retrieve, starting from HEAD.
+   *
+   * @returns {Promise<GitCommit[]>} Promise that resolves to an array of commit objects, ordered
+   *   from most recent to oldest. Each commit includes:
+   *   - `commitId` - Full commit hash
+   *   - `timestamp` - Commit timestamp in milliseconds since Unix epoch
+   *   - `message` - Commit message (subject line)
+   *   - `author` - Author name
+   *   - `parents` - Array of parent commit IDs
+   *
+   * @example
+   * ```typescript
+   * const commits = await worktree.listCommits(10);
+   * console.log(`Latest commit: ${commits[0].message}`);
+   * ```
+   */
+  async listCommits(count) {
+    return await listCommits(this._gitRoot, "HEAD", count);
+  }
+};
+async function listCommits(gitRoot, head, count) {
+  const FIELD_SEPARATOR = "|~|";
+  const RECORD_SEPARATOR = "\0";
+  const prettyFormat = [
+    "%H",
+    // Full commit hash
+    "%ct",
+    // Commit timestamp (Unix seconds)
+    "%an",
+    // Author name
+    "%s",
+    // Subject line
+    "%P"
+    // Parent hashes (space-separated)
+  ].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, parentsStr] = record.split(FIELD_SEPARATOR);
+      const parents = parentsStr ? parentsStr.split(" ").filter((p) => p) : [];
+      return {
+        commitId,
+        timestamp: parseInt(timestampStr, 10) * 1e3,
+        author,
+        message,
+        parents,
+        walkIndex: 0
+      };
+    });
+  } catch (error) {
+    log(`Failed to list commits for repository at ${gitRoot}:`, error);
+    return [];
+  }
+}
+
+// src/reportUtils.ts
+var reportUtils_exports = {};
+__export(reportUtils_exports, {
+  createDataAttachment: () => createDataAttachment,
+  createEnvironment: () => createEnvironment,
+  createFileAttachment: () => createFileAttachment,
+  createTestStepSnippetsInplace: () => createTestStepSnippetsInplace,
+  normalizeReport: () => normalizeReport,
+  stripAnsi: () => stripAnsi,
+  visitTests: () => visitTests
+});
+
+// src/createEnvironment.ts
+import fs2 from "fs";
+import os from "os";
+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 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 createEnvironment(options) {
+  const osInfo = getOSInfo();
+  return {
+    name: options.name,
+    systemData: {
+      osArch: osInfo.arch,
+      osName: osInfo.name,
+      osVersion: osInfo.version
+    },
+    userSuppliedData: {
+      ...extractEnvConfiguration(),
+      ...options.userSuppliedData ?? {}
+    },
+    opaqueData: options.opaqueData
+  };
+}
+
+// src/createTestStepSnippets.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import fs3 from "fs";
+
+// src/visitTests.ts
+function visitTests(report, testVisitor) {
+  function visitSuite(suite, parents) {
+    parents.push(suite);
+    for (const test of suite.tests ?? [])
+      testVisitor(test, parents);
+    for (const childSuite of suite.suites ?? [])
+      visitSuite(childSuite, parents);
+    parents.pop();
+  }
+  for (const test of report.tests ?? [])
+    testVisitor(test, []);
+  for (const suite of report.suites)
+    visitSuite(suite, []);
+}
+
+// src/createTestStepSnippets.ts
+function createTestStepSnippetsInplace(worktree, report) {
+  const allSteps = /* @__PURE__ */ new Map();
+  visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const step of attempt.steps ?? []) {
+        if (!step.location)
+          continue;
+        let fileSteps = allSteps.get(step.location.file);
+        if (!fileSteps) {
+          fileSteps = /* @__PURE__ */ new Set();
+          allSteps.set(step.location.file, fileSteps);
+        }
+        fileSteps.add(step);
+      }
+    }
+  });
+  for (const [gitFilePath, steps] of allSteps) {
+    let source;
+    try {
+      source = fs3.readFileSync(worktree.absolutePath(gitFilePath), "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/normalizeReport.ts
+import stableObjectHash from "stable-hash";
+var Multimap = class {
+  _map = /* @__PURE__ */ new Map();
+  set(key, value) {
+    const set = this._map.get(key) ?? /* @__PURE__ */ new Set();
+    this._map.set(key, set);
+    set.add(value);
+  }
+  getAll(key) {
+    return Array.from(this._map.get(key) ?? []);
+  }
+};
+function normalizeReport(report) {
+  const gEnvs = /* @__PURE__ */ new Map();
+  const gSuites = /* @__PURE__ */ new Map();
+  const gTests = new Multimap();
+  const gSuiteIds = /* @__PURE__ */ new Map();
+  const gTestIds = /* @__PURE__ */ new Map();
+  const gEnvIds = /* @__PURE__ */ new Map();
+  const gSuiteChildren = new Multimap();
+  const gSuiteTests = new Multimap();
+  for (const env of report.environments) {
+    const envId = computeEnvId(env);
+    gEnvs.set(envId, env);
+    gEnvIds.set(env, envId);
+  }
+  const usedEnvIds = /* @__PURE__ */ new Set();
+  function visitTests2(tests, suiteId) {
+    for (const test of tests ?? []) {
+      const testId = computeTestId(test, suiteId);
+      gTests.set(testId, test);
+      gTestIds.set(test, testId);
+      gSuiteTests.set(suiteId, test);
+      for (const attempt of test.attempts) {
+        const env = report.environments[attempt.environmentIdx];
+        const envId = gEnvIds.get(env);
+        usedEnvIds.add(envId);
+      }
+    }
+  }
+  function visitSuite(suite, parentSuiteId) {
+    const suiteId = computeSuiteId(suite, parentSuiteId);
+    gSuites.set(suiteId, suite);
+    gSuiteIds.set(suite, suiteId);
+    for (const childSuite of suite.suites ?? []) {
+      visitSuite(childSuite, suiteId);
+      gSuiteChildren.set(suiteId, childSuite);
+    }
+    visitTests2(suite.tests ?? [], suiteId);
+  }
+  function transformTests(tests) {
+    const testIds = new Set(tests.map((test) => gTestIds.get(test)));
+    return [...testIds].map((testId) => {
+      const tests2 = gTests.getAll(testId);
+      const tags = tests2.map((test) => test.tags ?? []).flat();
+      return {
+        location: tests2[0].location,
+        title: tests2[0].title,
+        tags: tags.length ? tags : void 0,
+        attempts: tests2.map((t) => t.attempts).flat().map((attempt) => ({
+          ...attempt,
+          environmentIdx: envIdToIndex.get(gEnvIds.get(report.environments[attempt.environmentIdx]))
+        }))
+      };
+    });
+  }
+  function transformSuites(suites) {
+    const suiteIds = new Set(suites.map((suite) => gSuiteIds.get(suite)));
+    return [...suiteIds].map((suiteId) => {
+      const suite = gSuites.get(suiteId);
+      return {
+        location: suite.location,
+        title: suite.title,
+        type: suite.type,
+        suites: transformSuites(gSuiteChildren.getAll(suiteId)),
+        tests: transformTests(gSuiteTests.getAll(suiteId))
+      };
+    });
+  }
+  visitTests2(report.tests ?? [], "suiteless");
+  for (const suite of report.suites)
+    visitSuite(suite);
+  const newEnvironments = [...usedEnvIds];
+  const envIdToIndex = new Map(newEnvironments.map((envId, index) => [envId, index]));
+  return {
+    ...report,
+    environments: newEnvironments.map((envId) => gEnvs.get(envId)),
+    suites: transformSuites(report.suites),
+    tests: transformTests(report.tests ?? [])
+  };
+}
+function computeEnvId(env) {
+  return stableObjectHash(env);
+}
+function computeSuiteId(suite, parentSuiteId) {
+  return stableObjectHash({
+    parentSuiteId: parentSuiteId ?? "",
+    type: suite.type,
+    file: suite.location?.file ?? "",
+    title: suite.title
+  });
+}
+function computeTestId(test, suiteId) {
+  return stableObjectHash({
+    suiteId,
+    file: test.location?.file ?? "",
+    title: test.title
+  });
+}
+
+// src/stripAnsi.ts
+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, "");
+}
+
+// src/uploadReport.ts
+import assert2 from "assert";
+import fs4 from "fs";
+import { URL as URL2 } from "url";
+async function createFileAttachment(contentType, filePath) {
+  return {
+    type: "file",
+    contentType,
+    id: await sha1File(filePath),
+    path: filePath
+  };
+}
+async function createDataAttachment(contentType, data) {
+  return {
+    type: "buffer",
+    contentType,
+    id: sha1Text(data),
+    body: data
+  };
+}
+async function uploadReport(report, attachments, options) {
+  const flakinessAccessToken = options?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
+  const flakinessEndpoint = options?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
+  const logger = options?.logger ?? console;
+  if (!flakinessAccessToken) {
+    const reason = "No FLAKINESS_ACCESS_TOKEN found";
+    if (process.env.CI)
+      logger.warn(`[flakiness.io] \u26A0 Skipping upload: ${reason}`);
+    return { status: "skipped", reason };
+  }
+  try {
+    const upload = new ReportUpload(report, attachments, { flakinessAccessToken, flakinessEndpoint });
+    const uploadResult = await upload.upload();
+    if (!uploadResult.success) {
+      const errorMessage = uploadResult.message || "Unknown upload error";
+      logger.error(`[flakiness.io] \u2715 Failed to upload: ${errorMessage}`);
+      if (options?.throwOnFailure)
+        throw new Error(`Flakiness upload failed: ${errorMessage}`);
+      return { status: "failed", error: errorMessage };
+    }
+    logger.log(`[flakiness.io] \u2713 Uploaded to ${uploadResult.reportUrl}`);
+    return { status: "success", reportUrl: uploadResult.reportUrl };
+  } catch (e) {
+    const errorMessage = e.message || String(e);
+    logger.error(`[flakiness.io] \u2715 Unexpected error during upload: ${errorMessage}`);
+    if (options?.throwOnFailure)
+      throw e;
+    return { status: "failed", error: errorMessage };
+  }
+}
+var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
+var ReportUpload = class {
+  _report;
+  _attachments;
+  _options;
+  constructor(report, attachments, options) {
+    this._options = options;
+    this._report = report;
+    this._attachments = attachments;
+  }
+  async _api(pathname, token, body) {
+    const url = new URL2(this._options.flakinessEndpoint);
+    url.pathname = pathname;
+    return await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    }).then(async (response) => !response.ok ? {
+      result: void 0,
+      error: response.status + " " + url.href + " " + await response.text()
+    } : {
+      result: await response.json(),
+      error: void 0
+    }).catch((error) => ({
+      result: void 0,
+      error
+    }));
+  }
+  async upload() {
+    const response = await this._api("/api/upload/start", this._options.flakinessAccessToken);
+    if (response?.error || !response.result)
+      return { success: false, message: response.error };
+    const webUrl = new URL2(response.result.webUrl, this._options.flakinessEndpoint).toString();
+    const attachmentsPresignedUrls = await this._api("/api/upload/attachments", response.result.uploadToken, {
+      attachmentIds: this._attachments.map((a) => a.id)
+    });
+    if (attachmentsPresignedUrls?.error || !attachmentsPresignedUrls.result)
+      return { success: false, message: attachmentsPresignedUrls.error };
+    const attachments = new Map(attachmentsPresignedUrls.result.map((a) => [a.attachmentId, a.presignedUrl]));
+    await Promise.all([
+      this._uploadReport(JSON.stringify(this._report), response.result.presignedReportUrl),
+      ...this._attachments.map((attachment) => {
+        const uploadURL = attachments.get(attachment.id);
+        if (!uploadURL)
+          throw new Error("Internal error: missing upload URL for attachment!");
+        return this._uploadAttachment(attachment, uploadURL);
+      })
+    ]);
+    await this._api("/api/upload/finish", response.result.uploadToken);
+    return { success: true, reportUrl: webUrl };
+  }
+  async _uploadReport(data, uploadUrl) {
+    const compressed = await compressTextAsync(data);
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(compressed) + "",
+      "Content-Encoding": "br"
+    };
+    await retryWithBackoff(async () => {
+      const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers,
+        body: Buffer.from(compressed)
+      });
+      if (!response.ok) {
+        throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
+      }
+      await response.arrayBuffer();
+    }, HTTP_BACKOFF);
+  }
+  async _uploadAttachment(attachment, uploadUrl) {
+    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
+    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
+    if (!compressable && attachment.type === "file") {
+      await retryWithBackoff(async () => {
+        const fileBuffer = await fs4.promises.readFile(attachment.path);
+        const response = await fetch(uploadUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": attachment.contentType,
+            "Content-Length": fileBuffer.length + ""
+          },
+          body: new Uint8Array(fileBuffer)
+        });
+        if (!response.ok) {
+          throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
+        }
+        await response.arrayBuffer();
+      }, HTTP_BACKOFF);
+      return;
+    }
+    let buffer = attachment.type === "buffer" ? attachment.body : await fs4.promises.readFile(attachment.path);
+    assert2(buffer);
+    const encoding = compressable ? "br" : void 0;
+    if (compressable)
+      buffer = await compressTextAsync(buffer);
+    const headers = {
+      "Content-Type": attachment.contentType,
+      "Content-Length": Buffer.byteLength(buffer) + ""
+    };
+    if (encoding) {
+      headers["Content-Encoding"] = encoding;
+    }
+    await retryWithBackoff(async () => {
+      const response = await fetch(uploadUrl, {
+        method: "PUT",
+        headers,
+        body: new Uint8Array(buffer)
+      });
+      if (!response.ok) {
+        throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
+      }
+      await response.arrayBuffer();
+    }, 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 {
+  /**
+   * The accumulated system utilization data.
+   *
+   * This object is populated as samples are collected and can be directly included in
+   * Flakiness reports. It contains:
+   * - `samples` - Array of utilization samples with CPU/memory percentages and durations
+   * - `startTimestamp` - Timestamp when sampling began
+   * - `totalMemoryBytes` - Total system memory in bytes
+   */
+  result;
+  _lastSample = getSystemUtilization();
+  _timer;
+  /**
+   * Creates a new SystemUtilizationSampler and starts sampling immediately.
+   *
+   * The first sample is collected after 50ms, and subsequent samples are collected
+   * every 1000ms. Call `dispose()` to stop sampling and clean up resources.
+   */
+  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);
+  }
+  /**
+   * Stops sampling and cleans up resources.
+   *
+   * Call this method when you're done collecting utilization data to stop the sampling
+   * timer and prevent memory leaks. The `result` object remains accessible after disposal.
+   */
+  dispose() {
+    clearTimeout(this._timer);
+  }
+};
+
+// src/showReport.ts
+import chalk from "chalk";
+import open from "open";
+
+// src/flakinessProjectConfig.ts
+import fs5 from "fs";
+import path from "path";
+function createConfigPath(dir) {
+  return path.join(dir, ".flakiness", "config.json");
+}
+var gConfigPath;
+function ensureConfigPath() {
+  if (!gConfigPath)
+    gConfigPath = computeConfigPath();
+  return gConfigPath;
+}
+function computeConfigPath() {
+  for (let p = process.cwd(); p !== path.resolve(p, ".."); p = path.resolve(p, "..")) {
+    const configPath = createConfigPath(p);
+    if (fs5.existsSync(configPath))
+      return configPath;
+  }
+  try {
+    const worktree = GitWorktree.create(process.cwd());
+    return createConfigPath(worktree.rootPath());
+  } catch (e) {
+    return createConfigPath(process.cwd());
+  }
+}
+var FlakinessProjectConfig = class _FlakinessProjectConfig {
+  constructor(_configPath, _config) {
+    this._configPath = _configPath;
+    this._config = _config;
+  }
+  /**
+   * Loads the Flakiness project configuration from disk.
+   *
+   * Searches for an existing `.flakiness/config.json` file starting from the current working
+   * directory and walking up the directory tree. If no config exists, it determines the
+   * appropriate location (git root or current directory) for future saves.
+   *
+   * @returns {Promise<FlakinessProjectConfig>} Promise that resolves to a FlakinessProjectConfig
+   *   instance. If no config file exists, returns an instance with default/empty values.
+   *
+   * @example
+   * ```typescript
+   * const config = await FlakinessProjectConfig.load();
+   * const projectId = config.projectPublicId();
+   * ```
+   */
+  static async load() {
+    const configPath = ensureConfigPath();
+    const data = await fs5.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const json = data ? JSON.parse(data) : {};
+    return new _FlakinessProjectConfig(configPath, json);
+  }
+  /**
+   * Creates a new empty Flakiness project configuration.
+   *
+   * Creates a configuration instance with no values set. Use this when you want to build
+   * a configuration from scratch. Call `save()` to persist it to disk.
+   *
+   * @returns {FlakinessProjectConfig} A new empty configuration instance.
+   *
+   * @example
+   * ```typescript
+   * const config = FlakinessProjectConfig.createEmpty();
+   * config.setProjectPublicId('my-project-id');
+   * await config.save();
+   * ```
+   */
+  static createEmpty() {
+    return new _FlakinessProjectConfig(ensureConfigPath(), {});
+  }
+  /**
+   * Returns the absolute path to the configuration file.
+   *
+   * @returns {string} Absolute path to `.flakiness/config.json`.
+   */
+  path() {
+    return this._configPath;
+  }
+  /**
+   * Returns the project's public ID, if configured.
+   *
+   * The project public ID is used to associate reports with a specific Flakiness.io project.
+   *
+   * @returns {string | undefined} Project public ID, or `undefined` if not set.
+   */
+  projectPublicId() {
+    return this._config.projectPublicId;
+  }
+  /**
+   * Returns the report viewer URL, either custom or default.
+   *
+   * @returns {string} Custom report viewer URL if configured, otherwise the default
+   *   `https://report.flakiness.io`.
+   */
+  reportViewerUrl() {
+    return this._config.customReportViewerUrl ?? "https://report.flakiness.io";
+  }
+  /**
+   * Sets or clears the custom report viewer URL.
+   *
+   * @param {string | undefined} url - Custom report viewer URL to use, or `undefined` to
+   *   clear and use the default URL.
+   */
+  setCustomReportViewerUrl(url) {
+    if (url)
+      this._config.customReportViewerUrl = url;
+    else
+      delete this._config.customReportViewerUrl;
+  }
+  /**
+   * Sets the project's public ID.
+   *
+   * @param {string | undefined} projectId - Project public ID to set, or `undefined` to clear.
+   */
+  setProjectPublicId(projectId) {
+    this._config.projectPublicId = projectId;
+  }
+  /**
+   * Saves the configuration to disk.
+   *
+   * Writes the current configuration values to `.flakiness/config.json`. Creates the
+   * `.flakiness` directory if it doesn't exist.
+   *
+   * @returns {Promise<void>} Promise that resolves when the file has been written.
+   *
+   * @throws {Error} Throws if unable to create directories or write the file.
+   *
+   * @example
+   * ```typescript
+   * const config = await FlakinessProjectConfig.load();
+   * config.setProjectPublicId('my-project');
+   * await config.save();
+   * ```
+   */
+  async save() {
+    await fs5.promises.mkdir(path.dirname(this._configPath), { recursive: true });
+    await fs5.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
+  }
+};
+
+// src/staticServer.ts
+import debug2 from "debug";
+import * as fs6 from "fs";
+import * as http from "http";
+import * as path2 from "path";
+var log2 = debug2("fk:static_server");
+var StaticServer = class {
+  _server;
+  _absoluteFolderPath;
+  _pathPrefix;
+  _cors;
+  _mimeTypes = {
+    ".html": "text/html",
+    ".js": "text/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".txt": "text/plain"
+  };
+  constructor(pathPrefix, folderPath, cors) {
+    this._pathPrefix = "/" + pathPrefix.replace(/^\//, "").replace(/\/$/, "");
+    this._absoluteFolderPath = path2.resolve(folderPath);
+    this._cors = cors;
+    this._server = http.createServer((req, res) => this._handleRequest(req, res));
+  }
+  port() {
+    const address = this._server.address();
+    if (!address)
+      return void 0;
+    return address.port;
+  }
+  address() {
+    const address = this._server.address();
+    if (!address)
+      return void 0;
+    const displayHost = address.address.includes(":") ? `[${address.address}]` : address.address;
+    return `http://${displayHost}:${address.port}${this._pathPrefix}`;
+  }
+  async _startServer(port, host) {
+    let okListener;
+    let errListener;
+    const result = new Promise((resolve2, reject) => {
+      okListener = resolve2;
+      errListener = reject;
+    }).finally(() => {
+      this._server.removeListener("listening", okListener);
+      this._server.removeListener("error", errListener);
+    });
+    this._server.once("listening", okListener);
+    this._server.once("error", errListener);
+    this._server.listen(port, host);
+    await result;
+    log2('Serving "%s" on "%s"', this._absoluteFolderPath, this.address());
+  }
+  async start(port, host = "127.0.0.1") {
+    if (port === 0) {
+      await this._startServer(port, host);
+      return this.address();
+    }
+    for (let i = 0; i < 20; ++i) {
+      const err = await this._startServer(port, host).then(() => void 0).catch((e) => e);
+      if (!err)
+        return this.address();
+      if (err.code !== "EADDRINUSE")
+        throw err;
+      log2("Port %d is busy (EADDRINUSE). Trying next port...", port);
+      port = port + 1;
+      if (port > 65535)
+        port = 4e3;
+    }
+    log2("All sequential ports busy. Falling back to random port.");
+    await this._startServer(0, host);
+    return this.address();
+  }
+  stop() {
+    return new Promise((resolve2, reject) => {
+      this._server.close((err) => {
+        if (err) {
+          log2("Error stopping server: %o", err);
+          reject(err);
+        } else {
+          log2("Server stopped.");
+          resolve2();
+        }
+      });
+    });
+  }
+  _errorResponse(req, res, code, text) {
+    res.writeHead(code, { "Content-Type": "text/plain" });
+    res.end(text);
+    log2(`[${code}] ${req.method} ${req.url}`);
+  }
+  _handleRequest(req, res) {
+    const { url, method } = req;
+    if (this._cors) {
+      res.setHeader("Access-Control-Allow-Headers", "*");
+      res.setHeader("Access-Control-Allow-Origin", this._cors);
+      res.setHeader("Access-Control-Allow-Methods", "*");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+    }
+    if (method !== "GET") {
+      this._errorResponse(req, res, 405, "Method Not Allowed");
+      return;
+    }
+    req.on("aborted", () => log2(`ABORTED ${req.method} ${req.url}`));
+    res.on("close", () => {
+      if (!res.headersSent) log2(`CLOSED BEFORE SEND ${req.method} ${req.url}`);
+    });
+    if (!url || !url.startsWith(this._pathPrefix)) {
+      this._errorResponse(req, res, 404, "Not Found");
+      return;
+    }
+    const relativePath = url.slice(this._pathPrefix.length);
+    const safeSuffix = path2.normalize(decodeURIComponent(relativePath)).replace(/^(\.\.[\/\\])+/, "");
+    const filePath = path2.join(this._absoluteFolderPath, safeSuffix);
+    if (!filePath.startsWith(this._absoluteFolderPath)) {
+      this._errorResponse(req, res, 403, "Forbidden");
+      return;
+    }
+    fs6.stat(filePath, (err, stats) => {
+      if (err || !stats.isFile()) {
+        this._errorResponse(req, res, 404, "File Not Found");
+        return;
+      }
+      const ext = path2.extname(filePath).toLowerCase();
+      const contentType = this._mimeTypes[ext] || "application/octet-stream";
+      res.writeHead(200, { "Content-Type": contentType });
+      log2(`[200] ${req.method} ${req.url} -> ${filePath}`);
+      const readStream = fs6.createReadStream(filePath);
+      readStream.pipe(res);
+      readStream.on("error", (err2) => {
+        log2("Stream error: %o", err2);
+        res.end();
+      });
+    });
+  }
+};
+
+// src/showReport.ts
+async function showReport(reportFolder) {
+  const config = await FlakinessProjectConfig.load();
+  const projectPublicId = config.projectPublicId();
+  const reportViewerEndpoint = config.reportViewerUrl();
+  const token = randomUUIDBase62();
+  const server = new StaticServer(token, reportFolder, reportViewerEndpoint);
+  await server.start(9373, "127.0.0.1");
+  const url = new URL(reportViewerEndpoint);
+  url.searchParams.set("port", String(server.port()));
+  url.searchParams.set("token", token);
+  if (projectPublicId)
+    url.searchParams.set("ppid", projectPublicId);
+  console.log(chalk.cyan(`
+  Serving Flakiness report at ${url.toString()}
+  Press Ctrl+C to quit.`));
+  await open(url.toString());
+  await new Promise(() => {
+  });
+}
+
+// src/writeReport.ts
+import fs7 from "fs";
+import path3 from "path";
+async function writeReport(report, attachments, outputFolder) {
+  const reportPath = path3.join(outputFolder, "report.json");
+  const attachmentsFolder = path3.join(outputFolder, "attachments");
+  await fs7.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs7.promises.mkdir(outputFolder, { recursive: true });
+  await fs7.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  if (attachments.length)
+    await fs7.promises.mkdir(attachmentsFolder);
+  const movedAttachments = [];
+  for (const attachment of attachments) {
+    const attachmentPath = path3.join(attachmentsFolder, attachment.id);
+    if (attachment.type === "file")
+      await fs7.promises.cp(attachment.path, attachmentPath);
+    else if (attachment.type === "buffer")
+      await fs7.promises.writeFile(attachmentPath, attachment.body);
+    movedAttachments.push({
+      type: "file",
+      contentType: attachment.contentType,
+      id: attachment.id,
+      path: attachmentPath
+    });
+  }
+  return movedAttachments;
+}
 export {
   CIUtils,
   FlakinessProjectConfig,
   FlakinessReport,
   GitWorktree,
-  ReportUtils,
+  reportUtils_exports as ReportUtils,
   SystemUtilizationSampler,
   showReport,
   uploadReport,