@flakiness/sdk 0.95.0 → 0.97.0

package/lib/playwright-test.js

@@ -1,283 +1,31 @@
 // 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";
+import chalk2 from "chalk";
+import fs8 from "fs";
+import path5 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/cli/cmd-show-report.ts
+import chalk from "chalk";
+import open from "open";
+import path4 from "path";
 
-// 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/flakinessConfig.ts
+import fs2 from "fs";
+import path2 from "path";
 
 // src/utils.ts
+import { FlakinessReport } from "@flakiness/report";
 import assert from "assert";
 import { spawnSync } from "child_process";
 import crypto from "crypto";
-import fs2 from "fs";
+import fs 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;
+import path, { posix as posixPath, win32 as win32Path } from "path";
 async function existsAsync(aPath) {
-  return fs2.promises.stat(aPath).then(() => true).catch((e) => false);
+  return fs.promises.stat(aPath).then(() => true).catch((e) => false);
 }
 function extractEnvConfiguration() {
   const ENV_PREFIX = "FK_ENV_";
@@ -288,18 +36,22 @@ function extractEnvConfiguration() {
 function sha1File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash("sha1");
-    const stream = fs2.createReadStream(filePath);
+    const stream = fs.createReadStream(filePath);
     stream.on("data", (chunk) => {
       hash.update(chunk);
     });
     stream.on("end", () => {
       resolve(hash.digest("hex"));
     });
-    stream.on("error", (err) => {
-      reject(err);
+    stream.on("error", (err2) => {
+      reject(err2);
     });
   });
 }
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
 function sha1Buffer(data) {
   const hash = crypto.createHash("sha1");
   hash.update(data);
@@ -311,9 +63,9 @@ async function retryWithBackoff(job, backoff = []) {
       return await job();
     } catch (e) {
       if (e instanceof AggregateError)
-        console.error(`[flakiness.io err]`, e.errors[0].message);
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
       else if (e instanceof Error)
-        console.error(`[flakiness.io err]`, e.message);
+        console.error(`[flakiness.io err]`, errorText(e));
       else
         console.error(`[flakiness.io err]`, e);
       await new Promise((x) => setTimeout(x, timeout));
@@ -331,6 +83,7 @@ var httpUtils;
       reject = b;
     });
     const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
     const request = protocol.request(url, { method, headers }, (res) => {
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
@@ -390,18 +143,16 @@ 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);
+    console.error(e);
     return void 0;
   }
 }
 function readLinuxOSRelease() {
-  const osReleaseText = fs2.readFileSync("/etc/os-release", "utf-8");
+  const osReleaseText = fs.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("=");
@@ -449,6 +200,40 @@ function gitCommitInfo(gitRepo) {
   assert(sha, `FAILED: git rev-parse HEAD @ ${gitRepo}`);
   return sha.trim();
 }
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Set();
+  FlakinessReport.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.add(attachment.id);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
 function computeGitRoot(somePathInsideGitRepo) {
   const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
     cwd: somePathInsideGitRepo,
@@ -509,7 +294,75 @@ function createEnvironments(projects) {
   return result;
 }
 
+// src/flakinessConfig.ts
+function createConfigPath(dir) {
+  return path2.join(dir, ".flakiness", "config.json");
+}
+var gConfigPath;
+function ensureConfigPath() {
+  if (!gConfigPath)
+    gConfigPath = computeConfigPath();
+  return gConfigPath;
+}
+function computeConfigPath() {
+  for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
+    const configPath = createConfigPath(p);
+    if (fs2.existsSync(configPath))
+      return configPath;
+  }
+  try {
+    const gitRoot = computeGitRoot(process.cwd());
+    return createConfigPath(gitRoot);
+  } catch (e) {
+    return createConfigPath(process.cwd());
+  }
+}
+var FlakinessConfig = class _FlakinessConfig {
+  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 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;
+  }
+  static createEmpty() {
+    return new _FlakinessConfig(ensureConfigPath(), {});
+  }
+  path() {
+    return this._configPath;
+  }
+  projectPublicId() {
+    return this._config.projectPublicId;
+  }
+  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, {
@@ -524,7 +377,277 @@ function createServerAPI(endpoint, options) {
   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));
+  }
+};
+
+// src/localReportServer.ts
+import { TypedHTTP as TypedHTTP3 } from "@flakiness/shared/common/typedHttp.js";
+import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
+import { createTypedHttpExpressMiddleware } from "@flakiness/shared/node/typedHttpExpress.js";
+import bodyParser from "body-parser";
+import compression from "compression";
+import debug from "debug";
+import express from "express";
+import "express-async-errors";
+import fs5 from "fs";
+import http2 from "http";
+
+// src/localGit.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function listLocalCommits(gitRoot, head, count) {
+  const FIELD_SEPARATOR = "|~|";
+  const RECORD_SEPARATOR = "\0";
+  const prettyFormat = [
+    "%H",
+    // %H:  Full commit hash
+    "%at",
+    // %at: Author date as a Unix timestamp (seconds since epoch)
+    "%an",
+    // %an: Author name
+    "%s"
+    // %s:  Subject (the first line of the commit message)
+  ].join(FIELD_SEPARATOR);
+  const command = `git log ${head} -n ${count} --pretty=format:"${prettyFormat}" -z`;
+  try {
+    const { stdout } = await execAsync(command, { cwd: gitRoot });
+    if (!stdout) {
+      return [];
+    }
+    return stdout.trim().split(RECORD_SEPARATOR).filter((record) => record).map((record) => {
+      const [commitId, timestampStr, author, message] = record.split(FIELD_SEPARATOR);
+      return {
+        commitId,
+        timestamp: parseInt(timestampStr, 10) * 1e3,
+        // Convert timestamp from seconds to milliseconds
+        author,
+        message,
+        walkIndex: 0
+      };
+    });
+  } catch (error) {
+    console.error(`Failed to list commits for repository at ${gitRoot}:`, error);
+    throw error;
+  }
+}
+
+// src/localReportApi.ts
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
+import fs4 from "fs";
+import { z } from "zod/v4";
+var t = TypedHTTP2.Router.create();
+var localReportRouter = {
+  ping: t.get({
+    handler: async () => {
+      return "pong";
+    }
+  }),
+  lastCommits: t.get({
+    handler: async ({ ctx }) => {
+      return ctx.commits;
+    }
+  }),
+  report: {
+    attachment: t.rawMethod("GET", {
+      input: z.object({
+        attachmentId: z.string().min(1).max(100).transform((id) => id)
+      }),
+      handler: async ({ ctx, input }) => {
+        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        if (!idx)
+          throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
+        const buffer = await fs4.promises.readFile(idx.path);
+        return TypedHTTP2.ok(buffer, idx.contentType);
+      }
+    }),
+    json: t.get({
+      handler: async ({ ctx }) => {
+        return ctx.report;
+      }
+    })
+  }
+};
+
+// src/localReportServer.ts
+var logHTTPServer = debug("fk:http");
+var LocalReportServer = class _LocalReportServer {
+  constructor(_server, _port, _authToken) {
+    this._server = _server;
+    this._port = _port;
+    this._authToken = _authToken;
+  }
+  static async create(options) {
+    const app = express();
+    app.set("etag", false);
+    const authToken = randomUUIDBase62();
+    app.use(compression());
+    app.use(bodyParser.json({ limit: 256 * 1024 }));
+    app.use((req, res, next) => {
+      if (!req.path.startsWith("/" + authToken))
+        throw TypedHTTP3.HttpError.withCode("UNAUTHORIZED");
+      res.setHeader("Access-Control-Allow-Headers", "*");
+      res.setHeader("Access-Control-Allow-Origin", options.endpoint);
+      res.setHeader("Access-Control-Allow-Methods", "*");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      req.on("aborted", () => logHTTPServer(`REQ ABORTED ${req.method} ${req.originalUrl}`));
+      res.on("close", () => {
+        if (!res.headersSent)
+          logHTTPServer(`RES CLOSED BEFORE SEND ${req.method} ${req.originalUrl}`);
+      });
+      next();
+    });
+    app.use("/" + authToken, createTypedHttpExpressMiddleware({
+      router: localReportRouter,
+      createRootContext: async ({ req, res, input }) => {
+        const report = JSON.parse(await fs5.promises.readFile(options.reportPath, "utf-8"));
+        const attachmentsDir = options.attachmentsFolder;
+        const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
+        if (missingAttachments.length) {
+          const first = missingAttachments.slice(0, 3);
+          for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
+            console.warn(`Missing attachment with id ${missingAttachments[i]}`);
+          if (missingAttachments.length > 3)
+            console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
+        }
+        return {
+          report,
+          commits: await listLocalCommits(process.cwd(), report.commitId, 100),
+          attachmentIdToPath
+        };
+      }
+    }));
+    app.use((err2, req, res, next) => {
+      if (err2 instanceof TypedHTTP3.HttpError)
+        return res.status(err2.status).send({ error: err2.message });
+      logHTTPServer(err2);
+      res.status(500).send({ error: "Internal Server Error" });
+    });
+    const server = http2.createServer(app);
+    server.on("error", (err2) => {
+      if (err2.code === "ECONNRESET") {
+        logHTTPServer("Client connection reset. Ignoring.");
+        return;
+      }
+      throw err2;
+    });
+    const port = await new Promise((resolve) => server.listen(options.port, () => {
+      resolve(server.address().port);
+    }));
+    return new _LocalReportServer(server, port, authToken);
+  }
+  authToken() {
+    return this._authToken;
+  }
+  port() {
+    return this._port;
+  }
+  async dispose() {
+    await new Promise((x) => this._server.close(x));
+  }
+};
+
+// src/cli/cmd-show-report.ts
+async function cmdShowReport(reportFolder) {
+  const reportPath = path4.join(reportFolder, "report.json");
+  const session = await FlakinessSession.load();
+  const config = await FlakinessConfig.load();
+  const projectPublicId = config.projectPublicId();
+  const project = projectPublicId && session ? await session.api.project.getProject.GET({ projectPublicId }) : void 0;
+  const endpoint = session?.endpoint() ?? "https://flakiness.io";
+  const server = await LocalReportServer.create({
+    endpoint,
+    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()}`;
+  console.log(chalk.cyan(`
+  Serving Flakiness report at ${reportEndpoint}
+  Press Ctrl+C to quit.`));
+  await open(reportEndpoint);
+  await new Promise(() => {
+  });
+}
+
+// src/createTestStepSnippets.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import fs6 from "fs";
+function createTestStepSnippets(filepathToSteps) {
+  for (const [filepath, steps] of filepathToSteps) {
+    let source;
+    try {
+      source = fs6.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 fs7 from "fs";
+import { URL } from "url";
 var ReportUploader = class _ReportUploader {
   static optionsFromEnv(overrides) {
     const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
@@ -536,7 +659,8 @@ var ReportUploader = class _ReportUploader {
   static async upload(options) {
     const uploaderOptions = _ReportUploader.optionsFromEnv(options);
     if (!uploaderOptions) {
-      options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
+      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);
@@ -569,11 +693,10 @@ var ReportUpload = class {
     this._options = options;
     this._report = report;
     this._attachments = attachments;
-    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF });
+    this._api = createServerAPI(this._options.flakinessEndpoint, { retries: HTTP_BACKOFF, auth: this._options.flakinessAccessToken });
   }
   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)
@@ -584,17 +707,17 @@ var ReportUpload = class {
         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);
+        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;
+    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 ? brotliCompressSync2(data) : await brotliCompressAsync(data);
+    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
     const headers = {
       "Content-Type": "application/json",
       "Content-Length": Buffer.byteLength(compressed) + "",
@@ -611,11 +734,34 @@ var ReportUpload = class {
       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;
+  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 fs7.promises.stat(attachmentPath)).size + ""
+          },
+          method: "put"
+        });
+        fs7.createReadStream(attachmentPath).pipe(request);
+        await responseDataPromise;
+      }, HTTP_BACKOFF);
+      return;
+    }
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs7.promises.readFile(attachment.path) : void 0;
+    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": bytesLength + ""
+      "Content-Length": Buffer.byteLength(buffer) + "",
+      "Content-Encoding": encoding
     };
     await retryWithBackoff(async () => {
       const { request, responseDataPromise } = httpUtils.createRequest({
@@ -623,13 +769,8 @@ var ReportUpload = class {
         headers,
         method: "put"
       });
-      if (attachment.path) {
-        fs3.createReadStream(attachment.path).pipe(request);
-      } else {
-        if (attachment.body)
-          request.write(attachment.body);
-        request.end();
-      }
+      request.write(buffer);
+      request.end();
       await responseDataPromise;
     }, HTTP_BACKOFF);
   }
@@ -637,7 +778,7 @@ var ReportUpload = class {
 
 // src/systemUtilizationSampler.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import os2 from "os";
+import os3 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);
@@ -658,7 +799,7 @@ function getAvailableMemMacOS() {
 function getSystemUtilization() {
   let idleTicks = 0;
   let totalTicks = 0;
-  for (const cpu of os2.cpus()) {
+  for (const cpu of os3.cpus()) {
     totalTicks += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq + cpu.times.idle;
     idleTicks += cpu.times.idle;
   }
@@ -666,14 +807,14 @@ function getSystemUtilization() {
     idleTicks,
     totalTicks,
     timestamp: Date.now(),
-    freeBytes: os2.platform() === "darwin" ? getAvailableMemMacOS() : os2.freemem()
+    freeBytes: os3.platform() === "darwin" ? getAvailableMemMacOS() : os3.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;
+  const memoryUtilization = Math.floor((1 - sample.freeBytes / os3.totalmem()) * 1e4) / 100;
   return {
     cpuUtilization,
     memoryUtilization,
@@ -688,7 +829,7 @@ var SystemUtilizationSampler = class {
     this.result = {
       samples: [],
       startTimestamp: this._lastSample.timestamp,
-      totalMemoryBytes: os2.totalmem()
+      totalMemoryBytes: os3.totalmem()
     };
     this._timer = setTimeout(this._addSample.bind(this), 50);
   }
@@ -704,9 +845,12 @@ var SystemUtilizationSampler = class {
 };
 
 // src/playwright-test.ts
+var warn = (txt) => console.warn(chalk2.yellow(`[flakiness.io] ${txt}`));
+var err = (txt) => console.error(chalk2.red(`[flakiness.io] ${txt}`));
 var FlakinessReporter = class {
   constructor(_options = {}) {
     this._options = _options;
+    this._outputFolder = path5.join(process.cwd(), this._options.outputFolder ?? process.env.FLAKINESS_OUTPUT_DIR ?? "flakiness-report");
   }
   _config;
   _rootSuite;
@@ -714,6 +858,10 @@ var FlakinessReporter = class {
   _unattributedErrors = [];
   _filepathToSteps = new Multimap();
   _systemUtilizationSampler = new SystemUtilizationSampler();
+  _report;
+  _attachments = [];
+  _outputFolder;
+  _result;
   printsToStdio() {
     return false;
   }
@@ -805,7 +953,7 @@ var FlakinessReporter = class {
       location: pwStep.location ? this._createLocation(context, pwStep.location) : void 0
     };
     if (pwStep.location) {
-      const resolvedPath = path.resolve(pwStep.location.file);
+      const resolvedPath = path5.resolve(pwStep.location.file);
       this._filepathToSteps.set(resolvedPath, step);
     }
     if (pwStep.error)
@@ -834,19 +982,12 @@ var FlakinessReporter = class {
     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?`);
+      warn(`Failed to fetch commit info - is this a git repo?`);
+      err(`Report is NOT generated.`);
       return;
     }
     const gitRoot = normalizePath(computeGitRoot(this._config.rootDir));
@@ -861,10 +1002,10 @@ var FlakinessReporter = class {
     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"));
+        let playwrightPath = fs8.realpathSync(process.argv[1]);
+        while (path5.basename(playwrightPath) !== "test")
+          playwrightPath = path5.dirname(playwrightPath);
+        const module = await import(path5.join(playwrightPath, "index.js"));
         for (const [project, env] of environmentsMap) {
           const { browserName = "chromium", channel, headless } = project.use;
           let browserType;
@@ -888,7 +1029,7 @@ var FlakinessReporter = class {
           env.userSuppliedData["browser"] = (channel ?? browserName).toLowerCase().trim() + " " + version;
         }
       } catch (e) {
-        console.error("[flakiness.io] failed to resolve browser version", e);
+        err(`Failed to resolve browser version: ${e}`);
       }
     }
     const environments = [...environmentsMap.values()];
@@ -911,15 +1052,52 @@ var FlakinessReporter = class {
     });
     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,
+      warn(`cannot access attachment ${unaccessibleAttachment}`);
+    this._report = report;
+    const reportPath = path5.join(this._outputFolder, "report.json");
+    const attachmentsFolder = path5.join(this._outputFolder, "attachments");
+    await fs8.promises.rm(this._outputFolder, { recursive: true, force: true });
+    await fs8.promises.mkdir(this._outputFolder, { recursive: true });
+    await fs8.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+    if (context.attachments.size)
+      await fs8.promises.mkdir(attachmentsFolder);
+    for (const attachment of context.attachments.values()) {
+      const attachmentPath = path5.join(attachmentsFolder, attachment.id);
+      if (attachment.path)
+        await fs8.promises.cp(attachment.path, attachmentPath);
+      else if (attachment.body)
+        await fs8.promises.writeFile(attachmentPath, attachment.body);
+      this._attachments.push({
+        contentType: attachment.contentType,
+        id: attachment.id,
+        path: attachmentPath
+      });
+    }
+    this._result = result;
+  }
+  async onExit() {
+    if (!this._report)
+      return;
+    await ReportUploader.upload({
+      report: this._report,
+      attachments: this._attachments,
+      flakinessAccessToken: this._options.token,
+      flakinessEndpoint: this._options.endpoint,
       log: console.log
     });
-    if (uploadError)
-      return { status: "failed" };
+    const openMode = this._options.open ?? "on-failure";
+    const shouldOpen = openMode === "always" || openMode === "on-failure" && this._result?.status === "failed";
+    if (shouldOpen) {
+      await cmdShowReport(this._outputFolder);
+    } else {
+      const defaultOutputFolder = path5.join(process.cwd(), "flakiness-report");
+      const folder = defaultOutputFolder === this._outputFolder ? "" : path5.relative(process.cwd(), this._outputFolder);
+      console.log(`
+To open last Flakiness report run:
+
+  ${chalk2.cyan(`npx flakiness show-report ${folder}`)}
+      `);
+    }
   }
 };
 function toSTDIOEntry(data) {