flakiness 0.148.0 → 0.149.0

package/lib/cli/cli.js

@@ -738,16 +738,16 @@ var Ranges;
 
 // src/cli/cli.ts
 import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
-import assert3 from "assert";
+import assert2 from "assert";
 import { Command, Option } from "commander";
-import fs8 from "fs";
+import fs7 from "fs";
 import ora from "ora";
-import path8 from "path";
+import path7 from "path";
 
 // ../package.json
 var package_default = {
   name: "flakiness",
-  version: "0.148.0",
+  version: "0.149.0",
   private: true,
   scripts: {
     minor: "./version.mjs minor",
@@ -790,7 +790,7 @@ var package_default = {
 
 // src/flakinessSession.ts
 import fs2 from "fs/promises";
-import os2 from "os";
+import os from "os";
 import path2 from "path";
 
 // src/serverapi.ts
@@ -798,23 +798,11 @@ import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
 
 // src/utils.ts
 import { ReportUtils } from "@flakiness/sdk";
-import assert from "assert";
-import { spawnSync } from "child_process";
 import crypto from "crypto";
 import fs from "fs";
 import http from "http";
 import https from "https";
-import os from "os";
-import path, { posix as posixPath, win32 as win32Path } from "path";
-async function existsAsync(aPath) {
-  return fs.promises.stat(aPath).then(() => true).catch((e) => false);
-}
-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()])
-  );
-}
+import path from "path";
 function sha1File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash("sha1");
@@ -918,96 +906,6 @@ var httpUtils;
   httpUtils2.postJSON = postJSON;
 })(httpUtils || (httpUtils = {}));
 var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
-function stripAnsi(str) {
-  return str.replace(ansiRegex, "");
-}
-async function saveReportAndAttachments(report, attachments, outputFolder) {
-  const reportPath = path.join(outputFolder, "report.json");
-  const attachmentsFolder = path.join(outputFolder, "attachments");
-  await fs.promises.rm(outputFolder, { recursive: true, force: true });
-  await fs.promises.mkdir(outputFolder, { recursive: true });
-  await fs.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
-  if (attachments.length)
-    await fs.promises.mkdir(attachmentsFolder);
-  const movedAttachments = [];
-  for (const attachment of attachments) {
-    const attachmentPath = path.join(attachmentsFolder, attachment.id);
-    if (attachment.path)
-      await fs.promises.cp(attachment.path, attachmentPath);
-    else if (attachment.body)
-      await fs.promises.writeFile(attachmentPath, attachment.body);
-    movedAttachments.push({
-      contentType: attachment.contentType,
-      id: attachment.id,
-      path: attachmentPath
-    });
-  }
-  return movedAttachments;
-}
-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 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 osLinuxInfo() {
-  const arch = shell(`uname`, [`-m`]);
-  const osReleaseMap = readLinuxOSRelease();
-  const name = osReleaseMap.get("name") ?? shell(`uname`);
-  const version = osReleaseMap.get("version_id");
-  return { name, arch, version };
-}
-function osDarwinInfo() {
-  const name = "macos";
-  const arch = shell(`uname`, [`-m`]);
-  const version = shell(`sw_vers`, [`-productVersion`]);
-  return { name, arch, version };
-}
-function osWinInfo() {
-  const name = "win";
-  const arch = process.arch;
-  const version = os.release();
-  return { name, arch, version };
-}
-function getOSInfo() {
-  if (process.platform === "darwin")
-    return osDarwinInfo();
-  if (process.platform === "win32")
-    return osWinInfo();
-  return osLinuxInfo();
-}
-function inferRunUrl() {
-  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID)
-    return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
-  return void 0;
-}
-function parseStringDate(dateString) {
-  return +new Date(dateString);
-}
-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();
-}
 async function resolveAttachmentPaths(report, attachmentsDir) {
   const attachmentFiles = await listFilesRecursively(attachmentsDir);
   const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
@@ -1023,7 +921,8 @@ async function resolveAttachmentPaths(report, attachmentsDir) {
           attachmentIdToPath.set(attachment.id, {
             contentType: attachment.contentType,
             id: attachment.id,
-            path: attachmentPath
+            path: attachmentPath,
+            type: "file"
           });
         }
       }
@@ -1042,65 +941,6 @@ async function listFilesRecursively(dir, result = []) {
   }
   return result;
 }
-function computeGitRoot(somePathInsideGitRepo) {
-  const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
-    cwd: somePathInsideGitRepo,
-    encoding: "utf-8"
-  });
-  assert(root, `FAILED: git rev-parse --show-toplevel HEAD @ ${somePathInsideGitRepo}`);
-  return normalizePath(root);
-}
-var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
-var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
-function normalizePath(aPath) {
-  if (IS_WIN32_PATH.test(aPath)) {
-    aPath = aPath.split(win32Path.sep).join(posixPath.sep);
-  }
-  if (IS_ALMOST_POSIX_PATH.test(aPath))
-    return "/" + aPath[0] + aPath.substring(2);
-  return aPath;
-}
-function gitFilePath(gitRoot, absolutePath) {
-  return posixPath.relative(gitRoot, absolutePath);
-}
-function parseDurationMS(value) {
-  if (isNaN(value))
-    throw new Error("Duration cannot be NaN");
-  if (value < 0)
-    throw new Error(`Duration cannot be less than 0, found ${value}`);
-  return value | 0;
-}
-function createEnvironments(projects) {
-  const envConfiguration = extractEnvConfiguration();
-  const osInfo = getOSInfo();
-  let uniqueNames = /* @__PURE__ */ new Set();
-  const result = /* @__PURE__ */ new Map();
-  for (const project of projects) {
-    let defaultName = project.name;
-    if (!defaultName.trim())
-      defaultName = "anonymous";
-    let name = defaultName;
-    for (let i = 2; uniqueNames.has(name); ++i)
-      name = `${defaultName}-${i}`;
-    uniqueNames.add(defaultName);
-    result.set(project, {
-      name,
-      systemData: {
-        osArch: osInfo.arch,
-        osName: osInfo.name,
-        osVersion: osInfo.version
-      },
-      userSuppliedData: {
-        ...envConfiguration,
-        ...project.metadata
-      },
-      opaqueData: {
-        project
-      }
-    });
-  }
-  return result;
-}
 
 // src/serverapi.ts
 function createServerAPI(endpoint, options) {
@@ -1119,7 +959,7 @@ function createServerAPI(endpoint, options) {
 
 // src/flakinessSession.ts
 var CONFIG_DIR = (() => {
-  const configDir = process.platform === "darwin" ? path2.join(os2.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path2.join(os2.homedir(), "AppData", "Roaming", "flakiness") : path2.join(os2.homedir(), ".config", "flakiness");
+  const configDir = process.platform === "darwin" ? path2.join(os.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path2.join(os.homedir(), "AppData", "Roaming", "flakiness") : path2.join(os.homedir(), ".config", "flakiness");
   return configDir;
 })();
 var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
@@ -1161,13 +1001,14 @@ var FlakinessSession = class _FlakinessSession {
 };
 
 // src/cli/cmd-convert.ts
+import { GitWorktree, writeReport } from "@flakiness/sdk";
 import fs4 from "fs/promises";
 import path4 from "path";
 
 // src/junit.ts
 import { ReportUtils as ReportUtils2 } from "@flakiness/sdk";
 import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
-import assert2 from "assert";
+import assert from "assert";
 import fs3 from "fs";
 import path3 from "path";
 function getProperties(element) {
@@ -1217,13 +1058,15 @@ async function parseAttachment(value) {
     return {
       contentType: "image/png",
       path: absolutePath,
-      id
+      id,
+      type: "file"
     };
   }
   return {
     contentType: "text/plain",
     id: sha1Buffer(value),
-    body: Buffer.from(value)
+    body: Buffer.from(value),
+    type: "buffer"
   };
 }
 async function traverseJUnitReport(context, node) {
@@ -1264,7 +1107,7 @@ async function traverseJUnitReport(context, node) {
       currentEnvIndex = report.environments.push(currentEnv) - 1;
     }
   } else if (element.name === "testcase") {
-    assert2(currentSuite);
+    assert(currentSuite);
     const file = element.attributes["file"];
     const name = element.attributes["name"];
     const line = parseInt(element.attributes["line"], 10);
@@ -1284,7 +1127,7 @@ async function traverseJUnitReport(context, node) {
           id: attachment.id,
           contentType: attachment.contentType,
           //TODO: better default names for attachments?
-          name: attachment.path ? path3.basename(attachment.path) : `attachment`
+          name: attachment.type === "file" ? path3.basename(attachment.path) : `attachment`
         });
       } else {
         annotations.push({
@@ -1389,7 +1232,8 @@ async function cmdConvert(junitPath, options) {
     commitId = options.commitId;
   } else {
     try {
-      commitId = gitCommitInfo(process.cwd());
+      const worktree = GitWorktree.create(process.cwd());
+      commitId = worktree.headCommitId();
     } catch (e) {
       console.error("Failed to get git commit info. Please provide --commit-id option.");
       process.exit(1);
@@ -1401,7 +1245,7 @@ async function cmdConvert(junitPath, options) {
     runStartTimestamp: Date.now(),
     runDuration: 0
   });
-  await saveReportAndAttachments(report, attachments, options.outputDir);
+  await writeReport(report, attachments, options.outputDir);
   console.log(`\u2713 Saved to ${options.outputDir}`);
 }
 async function findXmlFiles(dir, result = []) {
@@ -1481,7 +1325,7 @@ var KNOWN_CLIENT_IDS = {
 
 // src/cli/cmd-login.ts
 import open from "open";
-import os3 from "os";
+import os2 from "os";
 
 // src/cli/cmd-logout.ts
 async function cmdLogout() {
@@ -1501,7 +1345,7 @@ async function cmdLogin(endpoint = DEFAULT_FLAKINESS_ENDPOINT) {
   const api = createServerAPI(endpoint);
   const data = await api.deviceauth.createRequest.POST({
     clientId: KNOWN_CLIENT_IDS.OFFICIAL_CLI,
-    name: os3.hostname()
+    name: os2.hostname()
   });
   await open(new URL(data.verificationUrl, endpoint).href);
   console.log(`Please navigate to ${new URL(data.verificationUrl, endpoint)}`);
@@ -1566,246 +1410,31 @@ async function cmdUnlink() {
   await config.save();
 }
 
-// src/cli/cmd-upload-playwright-json.ts
-import { ReportUploader } from "@flakiness/sdk";
-import fs6 from "fs/promises";
-import path6 from "path";
-
-// src/playwrightJSONReport.ts
-import { FlakinessReport as FK2, ReportUtils as ReportUtils3 } from "@flakiness/sdk";
-import debug from "debug";
-import { posix as posixPath2 } from "path";
-var dlog = debug("flakiness:json-report");
-var PlaywrightJSONReport;
-((PlaywrightJSONReport2) => {
-  function collectMetadata(somePathInsideProject = process.cwd()) {
-    const commitId = gitCommitInfo(somePathInsideProject);
-    const osInfo = getOSInfo();
-    const metadata = {
-      gitRoot: computeGitRoot(somePathInsideProject),
-      commitId,
-      osName: osInfo.name,
-      arch: osInfo.arch,
-      osVersion: osInfo.version,
-      runURL: inferRunUrl()
-    };
-    dlog(`metadata directory: ${somePathInsideProject}`);
-    dlog(`metadata: ${JSON.stringify(metadata)}`);
-    dlog(`commit info: ${JSON.stringify(commitId)}`);
-    dlog(`os info: ${JSON.stringify(osInfo)}`);
-    return metadata;
-  }
-  PlaywrightJSONReport2.collectMetadata = collectMetadata;
-  async function parse(metadata, jsonReport, options) {
-    const context = {
-      projectId2environmentIdx: /* @__PURE__ */ new Map(),
-      testBaseDir: normalizePath(jsonReport.config.rootDir),
-      gitRoot: metadata.gitRoot,
-      attachments: /* @__PURE__ */ new Map(),
-      unaccessibleAttachmentPaths: [],
-      extractAttachments: options.extractAttachments
-    };
-    const configPath = jsonReport.config.configFile ? gitFilePath(context.gitRoot, normalizePath(jsonReport.config.configFile)) : void 0;
-    const report = {
-      category: FK2.CATEGORY_PLAYWRIGHT,
-      commitId: metadata.commitId,
-      configPath,
-      url: metadata.runURL,
-      environments: [],
-      suites: [],
-      opaqueData: jsonReport.config,
-      unattributedErrors: jsonReport.errors.map((error) => parseJSONError(context, error)),
-      // The report.stats is a releatively new addition to Playwright's JSONReport,
-      // so we have to polyfill with some reasonable values when it's missing.
-      duration: jsonReport.stats?.duration && jsonReport.stats?.duration > 0 ? parseDurationMS(jsonReport.stats.duration) : 0,
-      startTimestamp: jsonReport.stats && jsonReport.stats.startTime ? parseStringDate(jsonReport.stats.startTime) : Date.now()
-    };
-    report.environments = [...createEnvironments(jsonReport.config.projects).values()];
-    for (let envIdx = 0; envIdx < report.environments.length; ++envIdx)
-      context.projectId2environmentIdx.set(jsonReport.config.projects[envIdx].id, envIdx);
-    report.suites = await Promise.all(jsonReport.suites.map((suite) => parseJSONSuite(context, suite)));
-    return {
-      report: ReportUtils3.normalizeReport(report),
-      attachments: [...context.attachments.values()],
-      unaccessibleAttachmentPaths: context.unaccessibleAttachmentPaths
-    };
-  }
-  PlaywrightJSONReport2.parse = parse;
-})(PlaywrightJSONReport || (PlaywrightJSONReport = {}));
-async function parseJSONSuite(context, jsonSuite) {
-  let type = "suite";
-  if (jsonSuite.column === 0 && jsonSuite.line === 0)
-    type = "file";
-  else if (!jsonSuite.title)
-    type = "anonymous suite";
-  const suite = {
-    type,
-    title: jsonSuite.title,
-    location: {
-      file: gitFilePath(context.gitRoot, normalizePath(jsonSuite.file)),
-      line: jsonSuite.line,
-      column: jsonSuite.column
-    }
-  };
-  if (jsonSuite.suites && jsonSuite.suites.length)
-    suite.suites = await Promise.all(jsonSuite.suites.map((suite2) => parseJSONSuite(context, suite2)));
-  if (jsonSuite.specs && jsonSuite.specs.length)
-    suite.tests = await Promise.all(jsonSuite.specs.map((spec) => parseJSONSpec(context, spec)));
-  return suite;
-}
-async function parseJSONSpec(context, jsonSpec) {
-  const test = {
-    title: jsonSpec.title,
-    tags: jsonSpec.tags,
-    location: {
-      file: gitFilePath(context.gitRoot, normalizePath(posixPath2.join(context.testBaseDir, normalizePath(jsonSpec.file)))),
-      line: jsonSpec.line,
-      column: jsonSpec.column
-    },
-    attempts: []
-  };
-  for (const jsonTest of jsonSpec.tests) {
-    const environmentIdx = context.projectId2environmentIdx.get(jsonTest.projectId);
-    if (environmentIdx === void 0)
-      throw new Error("Inconsistent report - no project for a test found!");
-    const testResults = jsonTest.results.filter((result) => result.status !== void 0);
-    if (!testResults.length)
-      continue;
-    test.attempts.push(...await Promise.all(testResults.map((jsonTestResult) => parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult))));
-  }
-  return test;
-}
-function createLocation(context, location) {
-  return {
-    file: gitFilePath(context.gitRoot, normalizePath(location.file)),
-    line: location.line,
-    column: location.column
-  };
-}
-async function parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult) {
-  const attachments = [];
-  const attempt = {
-    timeout: parseDurationMS(jsonTest.timeout),
-    annotations: jsonTest.annotations.map((annotation) => ({
-      type: annotation.type,
-      description: annotation.description,
-      location: annotation.location ? createLocation(context, annotation.location) : void 0
-    })),
-    environmentIdx,
-    expectedStatus: jsonTest.expectedStatus,
-    parallelIndex: jsonTestResult.parallelIndex,
-    status: jsonTestResult.status,
-    errors: jsonTestResult.errors && jsonTestResult.errors.length ? jsonTestResult.errors.map((error) => parseJSONError(context, error)) : void 0,
-    stdout: jsonTestResult.stdout && jsonTestResult.stdout.length ? jsonTestResult.stdout : void 0,
-    stderr: jsonTestResult.stderr && jsonTestResult.stderr.length ? jsonTestResult.stderr : void 0,
-    steps: jsonTestResult.steps ? jsonTestResult.steps.map((jsonTestStep) => parseJSONTestStep(context, jsonTestStep)) : void 0,
-    startTimestamp: parseStringDate(jsonTestResult.startTime),
-    duration: jsonTestResult.duration && jsonTestResult.duration > 0 ? parseDurationMS(jsonTestResult.duration) : 0,
-    attachments
-  };
-  if (context.extractAttachments) {
-    await Promise.all((jsonTestResult.attachments ?? []).map(async (jsonAttachment) => {
-      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
-        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
-        return;
-      }
-      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
-      context.attachments.set(id, {
-        contentType: jsonAttachment.contentType,
-        id,
-        body: jsonAttachment.body ? Buffer.from(jsonAttachment.body) : void 0,
-        path: jsonAttachment.path
-      });
-      attachments.push({
-        id,
-        name: jsonAttachment.name,
-        contentType: jsonAttachment.contentType
-      });
-    }));
-  }
-  return attempt;
-}
-function parseJSONTestStep(context, jsonStep) {
-  const step = {
-    // NOTE: jsonStep.duration was -1 in some playwright versions
-    duration: parseDurationMS(Math.max(jsonStep.duration, 0)),
-    title: jsonStep.title
-  };
-  if (jsonStep.error)
-    step.error = parseJSONError(context, jsonStep.error);
-  if (jsonStep.steps)
-    step.steps = jsonStep.steps.map((childJSONStep) => parseJSONTestStep(context, childJSONStep));
-  return step;
-}
-function parseJSONError(context, error) {
-  return {
-    location: error.location ? createLocation(context, error.location) : void 0,
-    message: error.message ? stripAnsi(error.message).split("\n")[0] : void 0,
-    stack: error.stack,
-    value: error.value
-  };
-}
-
-// src/cli/cmd-upload-playwright-json.ts
-async function cmdUploadPlaywrightJson(relativePath, options) {
-  const fullPath = path6.resolve(relativePath);
-  if (!await fs6.access(fullPath, fs6.constants.F_OK).then(() => true).catch(() => false)) {
-    console.error(`Error: path ${fullPath} is not accessible`);
-    process.exit(1);
-  }
-  const text = await fs6.readFile(fullPath, "utf-8");
-  const playwrightJson = JSON.parse(text);
-  const { attachments, report, unaccessibleAttachmentPaths } = await PlaywrightJSONReport.parse(PlaywrightJSONReport.collectMetadata(), playwrightJson, {
-    extractAttachments: true
-  });
-  for (const unaccessibleAttachment of unaccessibleAttachmentPaths)
-    console.warn(`WARN: cannot access attachment ${unaccessibleAttachment}`);
-  const uploader = new ReportUploader({
-    flakinessAccessToken: options.accessToken,
-    flakinessEndpoint: options.endpoint
-  });
-  const upload = uploader.createUpload(report, attachments);
-  const uploadResult = await upload.upload();
-  if (!uploadResult.success) {
-    console.log(`[flakiness.io] X Failed to upload to ${options.endpoint}: ${uploadResult.message}`);
-  } else {
-    console.log(`[flakiness.io] \u2713 Report uploaded ${uploadResult.reportUrl ?? uploadResult.message ?? ""}`);
-  }
-}
-
 // src/cli/cmd-upload.ts
-import { ReportUploader as ReportUploader2 } from "@flakiness/sdk";
+import { uploadReport } from "@flakiness/sdk";
 import chalk from "chalk";
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 var warn = (txt) => console.warn(chalk.yellow(`[flakiness.io] WARN: ${txt}`));
 var err = (txt) => console.error(chalk.red(`[flakiness.io] Error: ${txt}`));
-var log = (txt) => console.log(`[flakiness.io] ${txt}`);
 async function cmdUpload(relativePaths, options) {
-  const uploader = new ReportUploader2({
-    flakinessAccessToken: options.accessToken,
-    flakinessEndpoint: options.endpoint
-  });
   for (const relativePath of relativePaths) {
-    const fullPath = path7.resolve(relativePath);
-    if (!await fs7.access(fullPath, fs7.constants.F_OK).then(() => true).catch(() => false)) {
+    const fullPath = path6.resolve(relativePath);
+    if (!await fs6.access(fullPath, fs6.constants.F_OK).then(() => true).catch(() => false)) {
       err(`Path ${fullPath} is not accessible!`);
       process.exit(1);
     }
-    const text = await fs7.readFile(fullPath, "utf-8");
+    const text = await fs6.readFile(fullPath, "utf-8");
     const report = JSON.parse(text);
-    const attachmentsDir = options.attachmentsDir ?? path7.dirname(fullPath);
+    const attachmentsDir = options.attachmentsDir ?? path6.dirname(fullPath);
     const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
     if (missingAttachments.length) {
       warn(`Missing ${missingAttachments.length} attachments`);
     }
-    const upload = uploader.createUpload(report, Array.from(attachmentIdToPath.values()));
-    const uploadResult = await upload.upload();
-    if (!uploadResult.success) {
-      err(`Failed to upload to ${options.endpoint}: ${uploadResult.message}`);
-    } else {
-      log(`\u2713 Uploaded ${uploadResult.reportUrl ?? uploadResult.message ?? ""}`);
-    }
+    await uploadReport(report, Array.from(attachmentIdToPath.values()), {
+      flakinessAccessToken: options.accessToken,
+      flakinessEndpoint: options.endpoint
+    });
   }
 }
 
@@ -1853,15 +1482,12 @@ async function ensureAccessToken(options) {
       }
     }
   }
-  assert3(accessToken, `Please either pass FLAKINESS_ACCESS_TOKEN or run login + link`);
+  assert2(accessToken, `Please either pass FLAKINESS_ACCESS_TOKEN or run login + link`);
   return {
     ...options,
     accessToken
   };
 }
-program.command("upload-playwright-json", { hidden: true }).description("Upload Playwright Test JSON report to the flakiness.io service").argument("<relative-path-to-json>", "Path to the Playwright JSON report file").addOption(optAccessToken).addOption(optEndpoint).action(async (relativePath, options) => runCommand(async () => {
-  await cmdUploadPlaywrightJson(relativePath, await ensureAccessToken(options));
-}));
 program.command("login").description("Login to the Flakiness.io service").addOption(optEndpoint).action(async (options) => runCommand(async () => {
   await cmdLogin(options.endpoint);
 }));
@@ -1938,7 +1564,7 @@ program.command("download").description("Download run").addOption(optSince).addO
     });
     console.log(`Found ${Ranges.cardinality(runIds)} reports uploaded since ${options.since}`);
   }
-  const alreadyExisting = fs8.readdirSync(process.cwd());
+  const alreadyExisting = fs7.readdirSync(process.cwd());
   const downloadedRuns = alreadyExisting.filter((entry) => entry.startsWith("fkrun-")).map((run) => parseInt(run.substring(`fkrun-`.length), 10)).filter((runId) => !isNaN(runId));
   console.log(`Found ${downloadedRuns.length} locally downloaded reports`);
   const toBeDownloaded = Ranges.subtract(runIds, Ranges.fromList(downloadedRuns));
@@ -1967,7 +1593,7 @@ program.command("upload").description("Upload Flakiness report to the flakiness.
   });
 });
 program.command("show").description("Show flakiness report").argument("[relative-path]", "Path to the Flakiness report file or folder that contains `report.json`. (default: flakiness-report)").action(async (arg) => runCommand(async () => {
-  const dir = path8.resolve(arg ?? "flakiness-report");
+  const dir = path7.resolve(arg ?? "flakiness-report");
   await showReport(dir);
 }));
 program.command("convert-junit").description("Convert JUnit XML report(s) to Flakiness report format").argument("<junit-root-dir-path>", "Path to JUnit XML file or directory containing XML files").option("--env-name <name>", "Environment name for the report", "junit").option("--commit-id <id>", "Git commit ID (auto-detected if not provided)").option("--output-dir <dir>", "Output directory for the report", "flakiness-report").action(async (junitPath, options) => {