flakiness 0.0.0 → 0.147.0

package/lib/cli/cmd-upload-playwright-json.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+
+// src/cli/cmd-upload-playwright-json.ts
+import { ReportUploader } from "@flakiness/sdk";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/playwrightJSONReport.ts
+import { FlakinessReport as FK, ReportUtils as ReportUtils2 } from "@flakiness/sdk";
+import debug from "debug";
+import { posix as posixPath2 } from "path";
+
+// 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()])
+  );
+}
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    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);
+    });
+  });
+}
+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);
+  return hash.digest("hex");
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, 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 httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    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));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+function stripAnsi(str) {
+  return str.replace(ansiRegex, "");
+}
+function shell(command, args, options) {
+  try {
+    const result = spawnSync(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      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();
+}
+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/playwrightJSONReport.ts
+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: FK.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: ReportUtils2.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 = path2.resolve(relativePath);
+  if (!await fs2.access(fullPath, fs2.constants.F_OK).then(() => true).catch(() => false)) {
+    console.error(`Error: path ${fullPath} is not accessible`);
+    process.exit(1);
+  }
+  const text = await fs2.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 ?? ""}`);
+  }
+}
+export {
+  cmdUploadPlaywrightJson
+};
+//# sourceMappingURL=cmd-upload-playwright-json.js.map

package/lib/cli/cmd-upload.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+// src/cli/cmd-upload.ts
+import { ReportUploader } from "@flakiness/sdk";
+import chalk from "chalk";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import path, { posix as posixPath, win32 as win32Path } from "path";
+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 httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    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));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+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();
+  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 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;
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/cli/cmd-upload.ts
+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 ReportUploader({
+    flakinessAccessToken: options.accessToken,
+    flakinessEndpoint: options.endpoint
+  });
+  for (const relativePath of relativePaths) {
+    const fullPath = path2.resolve(relativePath);
+    if (!await fs2.access(fullPath, fs2.constants.F_OK).then(() => true).catch(() => false)) {
+      err(`Path ${fullPath} is not accessible!`);
+      process.exit(1);
+    }
+    const text = await fs2.readFile(fullPath, "utf-8");
+    const report = JSON.parse(text);
+    const attachmentsDir = options.attachmentsDir ?? path2.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 ?? ""}`);
+    }
+  }
+}
+export {
+  cmdUpload
+};
+//# sourceMappingURL=cmd-upload.js.map