@flakiness/sdk 0.147.0 → 0.148.0

package/lib/index.js

@@ -5,65 +5,14 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import chalk from "chalk";
 import fs6 from "fs";
-import open from "open";
 import path3 from "path";
+import { FlakinessReport } from "@flakiness/flakiness-report";
 
-// src/flakinessProjectConfig.ts
-import fs from "fs";
-import path from "path";
-
-// src/git.ts
-import assert from "assert";
-
-// src/pathutils.ts
-var pathutils_exports = {};
-__export(pathutils_exports, {
-  gitFilePath: () => gitFilePath,
-  normalizePath: () => normalizePath
-});
-import { posix as posixPath, win32 as win32Path } from "path";
-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);
-}
-
-// src/utils.ts
+// src/createEnvironment.ts
 import { spawnSync } from "child_process";
-var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
-function errorText(error) {
-  return FLAKINESS_DBG ? error.stack : error.message;
-}
-async function retryWithBackoff(job, backoff = []) {
-  for (const timeout of backoff) {
-    try {
-      return await job();
-    } catch (e) {
-      if (e instanceof AggregateError)
-        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
-      else if (e instanceof Error)
-        console.error(`[flakiness.io err]`, errorText(e));
-      else
-        console.error(`[flakiness.io err]`, e);
-      await new Promise((x) => setTimeout(x, timeout));
-    }
-  }
-  return await job();
-}
-var 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, "");
-}
+import fs from "fs";
+import os from "os";
 function shell(command, args, options) {
   try {
     const result = spawnSync(command, args, { encoding: "utf-8", ...options });
@@ -76,141 +25,69 @@ function shell(command, args, options) {
     return void 0;
   }
 }
-
-// src/git.ts
-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 readLinuxOSRelease() {
+  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("=");
+    if (value.startsWith('"') && value.endsWith('"'))
+      value = value.substring(1, value.length - 1);
+    return [key, value];
+  }));
 }
-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);
+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 };
 }
-
-// src/flakinessProjectConfig.ts
-function createConfigPath(dir) {
-  return path.join(dir, ".flakiness", "config.json");
+function osDarwinInfo() {
+  const name = "macos";
+  const arch = shell(`uname`, [`-m`]);
+  const version = shell(`sw_vers`, [`-productVersion`]);
+  return { name, arch, version };
 }
-var gConfigPath;
-function ensureConfigPath() {
-  if (!gConfigPath)
-    gConfigPath = computeConfigPath();
-  return gConfigPath;
+function osWinInfo() {
+  const name = "win";
+  const arch = process.arch;
+  const version = os.release();
+  return { name, arch, version };
 }
-function computeConfigPath() {
-  for (let p = process.cwd(); p !== path.resolve(p, ".."); p = path.resolve(p, "..")) {
-    const configPath = createConfigPath(p);
-    if (fs.existsSync(configPath))
-      return configPath;
-  }
-  try {
-    const gitRoot = computeGitRoot(process.cwd());
-    return createConfigPath(gitRoot);
-  } catch (e) {
-    return createConfigPath(process.cwd());
-  }
+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
+  };
 }
-var FlakinessProjectConfig = class _FlakinessProjectConfig {
-  constructor(_configPath, _config) {
-    this._configPath = _configPath;
-    this._config = _config;
-  }
-  static async load() {
-    const configPath = ensureConfigPath();
-    const data = await fs.promises.readFile(configPath, "utf-8").catch((e) => void 0);
-    const json = data ? JSON.parse(data) : {};
-    return new _FlakinessProjectConfig(configPath, json);
-  }
-  static createEmpty() {
-    return new _FlakinessProjectConfig(ensureConfigPath(), {});
-  }
-  path() {
-    return this._configPath;
-  }
-  projectPublicId() {
-    return this._config.projectPublicId;
-  }
-  reportViewerEndpoint() {
-    return this._config.customReportViewerEndpoint ?? "https://report.flakiness.io";
-  }
-  setProjectPublicId(projectId) {
-    this._config.projectPublicId = projectId;
-  }
-  async save() {
-    await fs.promises.mkdir(path.dirname(this._configPath), { recursive: true });
-    await fs.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/localReportServer.ts
-import { TypedHTTP as TypedHTTP2 } 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 debug2 from "debug";
-import express from "express";
-import "express-async-errors";
-import http from "http";
 
-// src/localReportApi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+// src/createTestStepSnippets.ts
+import { codeFrameColumns } from "@babel/code-frame";
 import fs2 from "fs";
-import path2 from "path";
-import { z } from "zod/v4";
-
-// src/localGit.ts
-import { exec } from "child_process";
-import debug from "debug";
-import { promisify } from "util";
-var log = debug("fk:git");
-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)
-    "%P"
-    // %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 [];
-  }
-}
+import { posix as posixPath } from "path";
 
 // src/reportUtils.ts
 import { Multimap } from "@flakiness/shared/common/multimap.js";
@@ -279,7 +156,7 @@ var ReportUtils;
           location: tests2[0].location,
           title: tests2[0].title,
           tags: tags.length ? tags : void 0,
-          attempts: tests2.map((t2) => t2.attempts).flat().map((attempt) => ({
+          attempts: tests2.map((t) => t.attempts).flat().map((attempt) => ({
             ...attempt,
             environmentIdx: envIdToIndex.get(gEnvIds.get(report.environments[attempt.environmentIdx]))
           }))
@@ -332,254 +209,7 @@ var ReportUtils;
   }
 })(ReportUtils || (ReportUtils = {}));
 
-// src/localReportApi.ts
-var ReportInfo = class {
-  constructor(_options) {
-    this._options = _options;
-  }
-  report;
-  attachmentIdToPath = /* @__PURE__ */ new Map();
-  commits = [];
-  async refresh() {
-    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
-    if (!report) {
-      this.report = void 0;
-      this.commits = [];
-      this.attachmentIdToPath = /* @__PURE__ */ new Map();
-      return;
-    }
-    if (JSON.stringify(report) === JSON.stringify(this.report))
-      return;
-    this.report = report;
-    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
-    const attachmentsDir = this._options.attachmentsFolder;
-    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
-    if (missingAttachments.length) {
-      const first = missingAttachments.slice(0, 3);
-      for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
-        console.warn(`Missing attachment with id ${missingAttachments[i]}`);
-      if (missingAttachments.length > 3)
-        console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
-    }
-    this.attachmentIdToPath = attachmentIdToPath;
-  }
-};
-var t = TypedHTTP.Router.create();
-var localReportRouter = {
-  ping: t.get({
-    handler: async () => {
-      return "pong";
-    }
-  }),
-  lastCommits: t.get({
-    handler: async ({ ctx }) => {
-      return ctx.reportInfo.commits;
-    }
-  }),
-  report: {
-    attachment: t.rawMethod("GET", {
-      input: z.object({
-        attachmentId: z.string().min(1).max(100).transform((id) => id)
-      }),
-      handler: async ({ ctx, input }) => {
-        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
-        if (!idx)
-          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs2.promises.readFile(idx.path);
-        return TypedHTTP.ok(buffer, idx.contentType);
-      }
-    }),
-    json: t.get({
-      handler: async ({ ctx }) => {
-        await ctx.reportInfo.refresh();
-        return ctx.reportInfo.report;
-      }
-    })
-  }
-};
-async function resolveAttachmentPaths(report, attachmentsDir) {
-  const attachmentFiles = await listFilesRecursively(attachmentsDir);
-  const filenameToPath = new Map(attachmentFiles.map((file) => [path2.basename(file), file]));
-  const attachmentIdToPath = /* @__PURE__ */ new Map();
-  const missingAttachments = /* @__PURE__ */ new Set();
-  ReportUtils.visitTests(report, (test) => {
-    for (const attempt of test.attempts) {
-      for (const attachment of attempt.attachments ?? []) {
-        const attachmentPath = filenameToPath.get(attachment.id);
-        if (!attachmentPath) {
-          missingAttachments.add(attachment.id);
-        } else {
-          attachmentIdToPath.set(attachment.id, {
-            contentType: attachment.contentType,
-            id: attachment.id,
-            path: attachmentPath
-          });
-        }
-      }
-    }
-  });
-  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
-}
-async function listFilesRecursively(dir, result = []) {
-  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    if (entry.isDirectory())
-      await listFilesRecursively(fullPath, result);
-    else
-      result.push(fullPath);
-  }
-  return result;
-}
-
-// src/localReportServer.ts
-var logHTTPServer = debug2("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 TypedHTTP2.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();
-    });
-    const reportInfo = new ReportInfo(options);
-    app.use("/" + authToken, createTypedHttpExpressMiddleware({
-      router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ reportInfo })
-    }));
-    app.use((err, req, res, next) => {
-      if (err instanceof TypedHTTP2.HttpError)
-        return res.status(err.status).send({ error: err.message });
-      logHTTPServer(err);
-      res.status(500).send({ error: "Internal Server Error" });
-    });
-    const server = http.createServer(app);
-    server.on("error", (err) => {
-      if (err.code === "ECONNRESET") {
-        logHTTPServer("Client connection reset. Ignoring.");
-        return;
-      }
-      throw err;
-    });
-    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/index.ts
-import { FlakinessReport } from "@flakiness/flakiness-report";
-
-// src/createEnvironment.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import fs3 from "fs";
-import os from "os";
-function shell2(command, args, options) {
-  try {
-    const result = spawnSync2(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 readLinuxOSRelease() {
-  const osReleaseText = fs3.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 = shell2(`uname`, [`-m`]);
-  const osReleaseMap = readLinuxOSRelease();
-  const name = osReleaseMap.get("name") ?? shell2(`uname`);
-  const version = osReleaseMap.get("version_id");
-  return { name, arch, version };
-}
-function osDarwinInfo() {
-  const name = "macos";
-  const arch = shell2(`uname`, [`-m`]);
-  const version = shell2(`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 fs4 from "fs";
-import { posix as posixPath2 } from "path";
 function createTestStepSnippetsInplace(report, gitRoot) {
   const allSteps = /* @__PURE__ */ new Map();
   ReportUtils.visitTests(report, (test) => {
@@ -599,7 +229,7 @@ function createTestStepSnippetsInplace(report, gitRoot) {
   for (const [gitFilePath2, steps] of allSteps) {
     let source;
     try {
-      source = fs4.readFileSync(posixPath2.join(gitRoot, gitFilePath2), "utf-8");
+      source = fs2.readFileSync(posixPath.join(gitRoot, gitFilePath2), "utf-8");
     } catch (e) {
       continue;
     }
@@ -621,34 +251,180 @@ function createTestStepSnippetsInplace(report, gitRoot) {
   }
 }
 
+// src/flakinessProjectConfig.ts
+import fs3 from "fs";
+import path from "path";
+
+// src/git.ts
+import assert from "assert";
+
+// src/pathutils.ts
+var pathutils_exports = {};
+__export(pathutils_exports, {
+  gitFilePath: () => gitFilePath,
+  normalizePath: () => normalizePath
+});
+import { posix as posixPath2, win32 as win32Path } from "path";
+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(posixPath2.sep);
+  }
+  if (IS_ALMOST_POSIX_PATH.test(aPath))
+    return "/" + aPath[0] + aPath.substring(2);
+  return aPath;
+}
+function gitFilePath(gitRoot, absolutePath) {
+  return posixPath2.relative(gitRoot, absolutePath);
+}
+
+// src/utils.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var 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 shell2(command, args, options) {
+  try {
+    const result = spawnSync2(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;
+  }
+}
+
+// src/git.ts
+function gitCommitInfo(gitRepo) {
+  const sha = shell2(`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 = shell2(`git`, ["rev-parse", "--show-toplevel"], {
+    cwd: somePathInsideGitRepo,
+    encoding: "utf-8"
+  });
+  assert(root, `FAILED: git rev-parse --show-toplevel HEAD @ ${somePathInsideGitRepo}`);
+  return normalizePath(root);
+}
+
+// src/flakinessProjectConfig.ts
+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 (fs3.existsSync(configPath))
+      return configPath;
+  }
+  try {
+    const gitRoot = computeGitRoot(process.cwd());
+    return createConfigPath(gitRoot);
+  } catch (e) {
+    return createConfigPath(process.cwd());
+  }
+}
+var FlakinessProjectConfig = class _FlakinessProjectConfig {
+  constructor(_configPath, _config) {
+    this._configPath = _configPath;
+    this._config = _config;
+  }
+  static async load() {
+    const configPath = ensureConfigPath();
+    const data = await fs3.promises.readFile(configPath, "utf-8").catch((e) => void 0);
+    const json = data ? JSON.parse(data) : {};
+    return new _FlakinessProjectConfig(configPath, json);
+  }
+  static createEmpty() {
+    return new _FlakinessProjectConfig(ensureConfigPath(), {});
+  }
+  path() {
+    return this._configPath;
+  }
+  projectPublicId() {
+    return this._config.projectPublicId;
+  }
+  reportViewerUrl() {
+    return this._config.customReportViewerUrl ?? "https://report.flakiness.io";
+  }
+  setCustomReportViewerUrl(url) {
+    if (url)
+      this._config.customReportViewerUrl = url;
+    else
+      delete this._config.customReportViewerUrl;
+  }
+  setProjectPublicId(projectId) {
+    this._config.projectPublicId = projectId;
+  }
+  async save() {
+    await fs3.promises.mkdir(path.dirname(this._configPath), { recursive: true });
+    await fs3.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
+  }
+};
+
 // src/reportUploader.ts
 import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
 import assert2 from "assert";
 import crypto from "crypto";
-import fs5 from "fs";
+import fs4 from "fs";
 import { URL as URL2 } from "url";
 
 // src/httpUtils.ts
-import http2 from "http";
+import http from "http";
 import https from "https";
 var FLAKINESS_DBG2 = !!process.env.FLAKINESS_DBG;
 var httpUtils;
 ((httpUtils2) => {
   function createRequest({ url, method = "get", headers = {} }) {
-    let resolve;
+    let resolve2;
     let reject;
     const responseDataPromise = new Promise((a, b) => {
-      resolve = a;
+      resolve2 = a;
       reject = b;
     });
-    const protocol = url.startsWith("https") ? https : http2;
+    const protocol = url.startsWith("https") ? https : http;
     headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
     const request = protocol.request(url, { method, headers }, (res) => {
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
       res.on("end", () => {
         if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
-          resolve(Buffer.concat(chunks));
+          resolve2(Buffer.concat(chunks));
         else
           reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
       });
@@ -697,14 +473,14 @@ var httpUtils;
 
 // src/reportUploader.ts
 function sha1File(filePath) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const hash = crypto.createHash("sha1");
-    const stream = fs5.createReadStream(filePath);
+    const stream = fs4.createReadStream(filePath);
     stream.on("data", (chunk) => {
       hash.update(chunk);
     });
     stream.on("end", () => {
-      resolve(hash.digest("hex"));
+      resolve2(hash.digest("hex"));
     });
     stream.on("error", (err) => {
       reject(err);
@@ -845,16 +621,16 @@ var ReportUpload = class {
           url: uploadUrl,
           headers: {
             "Content-Type": attachment.contentType,
-            "Content-Length": (await fs5.promises.stat(attachmentPath)).size + ""
+            "Content-Length": (await fs4.promises.stat(attachmentPath)).size + ""
           },
           method: "put"
         });
-        fs5.createReadStream(attachmentPath).pipe(request);
+        fs4.createReadStream(attachmentPath).pipe(request);
         await responseDataPromise;
       }, HTTP_BACKOFF);
       return;
     }
-    let buffer = attachment.body ? attachment.body : attachment.path ? await fs5.promises.readFile(attachment.path) : void 0;
+    let buffer = attachment.body ? attachment.body : attachment.path ? await fs4.promises.readFile(attachment.path) : void 0;
     assert2(buffer);
     const encoding = compressable ? "br" : void 0;
     if (compressable)
@@ -877,6 +653,178 @@ var ReportUpload = class {
   }
 };
 
+// src/showReport.ts
+import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
+import chalk from "chalk";
+import open from "open";
+
+// src/staticServer.ts
+import debug from "debug";
+import * as fs5 from "fs";
+import * as http2 from "http";
+import * as path2 from "path";
+var log = debug("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 = http2.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;
+    log('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;
+      log("Port %d is busy (EADDRINUSE). Trying next port...", port);
+      port = port + 1;
+      if (port > 65535)
+        port = 4e3;
+    }
+    log("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) {
+          log("Error stopping server: %o", err);
+          reject(err);
+        } else {
+          log("Server stopped.");
+          resolve2();
+        }
+      });
+    });
+  }
+  _errorResponse(req, res, code, text) {
+    res.writeHead(code, { "Content-Type": "text/plain" });
+    res.end(text);
+    log(`[${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", () => log(`ABORTED ${req.method} ${req.url}`));
+    res.on("close", () => {
+      if (!res.headersSent) log(`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;
+    }
+    fs5.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 });
+      log(`[200] ${req.method} ${req.url} -> ${filePath}`);
+      const readStream = fs5.createReadStream(filePath);
+      readStream.pipe(res);
+      readStream.on("error", (err2) => {
+        log("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/systemUtilizationSampler.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import os2 from "os";
@@ -951,29 +899,6 @@ function inferRunUrl() {
     return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
   return void 0;
 }
-async function showReport(reportFolder) {
-  const reportPath = path3.join(reportFolder, "report.json");
-  const config = await FlakinessProjectConfig.load();
-  const projectPublicId = config.projectPublicId();
-  const reportViewerEndpoint = config.reportViewerEndpoint();
-  const server = await LocalReportServer.create({
-    endpoint: reportViewerEndpoint,
-    port: 9373,
-    reportPath,
-    attachmentsFolder: reportFolder
-  });
-  const url = new URL(reportViewerEndpoint);
-  url.searchParams.set("port", String(server.port()));
-  url.searchParams.set("token", server.authToken());
-  if (projectPublicId)
-    url.searchParams.set("ppid", projectPublicId);
-  console.log(chalk.cyan(`
-  Serving Flakiness report at ${url.toString()}
-  Press Ctrl+C to quit.`));
-  await open(url.toString());
-  await new Promise(() => {
-  });
-}
 async function saveReport(report, attachments, outputFolder) {
   const reportPath = path3.join(outputFolder, "report.json");
   const attachmentsFolder = path3.join(outputFolder, "attachments");