flakiness 0.158.0 → 0.160.0

package/README.md

@@ -65,7 +65,6 @@ flakiness upload ./report.json --endpoint https://custom.flakiness.io
 **Options:**
 - `-t, --access-token <token>` — Read-write access token (env: `FLAKINESS_ACCESS_TOKEN`)
 - `-e, --endpoint <url>` — Service endpoint (env: `FLAKINESS_ENDPOINT`)
-- `--attachments-dir <dir>` — Directory containing attachments (defaults to report directory)
 
 ### Download Reports
 

package/lib/cli/cli.js

@@ -813,6 +813,11 @@ var TypedHTTP;
     ...TypedHTTP2.StatusCodes.ClientErrors,
     ...TypedHTTP2.StatusCodes.ServerErrors
   };
+  function assert3(value, code, message) {
+    if (!value)
+      throw HttpError.withCode(code, message);
+  }
+  TypedHTTP2.assert = assert3;
   class HttpError extends Error {
     constructor(status, message) {
       super(message);
@@ -901,8 +906,8 @@ var TypedHTTP;
   }
   TypedHTTP2.Router = Router;
   function createClient(base, fetchCallback) {
-    function buildUrl(method, path8, input, options) {
-      const url = new URL(path8.join("/"), base);
+    function buildUrl(method, path7, input, options) {
+      const url = new URL(path7.join("/"), base);
       const signal = options?.signal;
       let body = void 0;
       if (method === "GET" && input)
@@ -917,8 +922,8 @@ var TypedHTTP;
         signal
       };
     }
-    function fetcher(method, path8, input, methodOptions) {
-      const options = buildUrl(method, path8, input, methodOptions);
+    function fetcher(method, path7, input, methodOptions) {
+      const options = buildUrl(method, path7, input, methodOptions);
       return fetchCallback(options.url, {
         method: options.method,
         body: options.body,
@@ -941,17 +946,17 @@ var TypedHTTP;
         }
       });
     }
-    function createProxy(path8 = []) {
+    function createProxy(path7 = []) {
       return new Proxy({}, {
         get(target, prop) {
           if (typeof prop === "symbol")
             return void 0;
           if (allHttpMethods.includes(prop)) {
-            const f = fetcher.bind(null, prop, path8);
-            f.prepare = buildUrl.bind(null, prop, path8);
+            const f = fetcher.bind(null, prop, path7);
+            f.prepare = buildUrl.bind(null, prop, path7);
             return f;
           }
-          const newPath = [...path8, prop];
+          const newPath = [...path7, prop];
           return createProxy(newPath);
         }
       });
@@ -964,14 +969,15 @@ var TypedHTTP;
 // src/cli/cli.ts
 import assert2 from "assert";
 import { Command, Option } from "commander";
-import fs7 from "fs";
+import debug2 from "debug";
+import fs6 from "fs";
 import ora from "ora";
-import path7 from "path";
+import path6 from "path";
 
 // ../package.json
 var package_default = {
   name: "flakiness",
-  version: "0.158.0",
+  version: "0.160.0",
   type: "module",
   private: true,
   scripts: {
@@ -990,10 +996,10 @@ var package_default = {
   license: "Fair Source 100",
   devDependencies: {
     "@flakiness/playwright": "^0.154.0",
-    "@playwright/test": "^1.57.0",
+    "@playwright/test": "catalog:",
     "@types/node": "^22.19.3",
     esbuild: "^0.27.2",
-    glob: "^10.5.0",
+    glob: "catalog:",
     kubik: "^0.24.0",
     tsx: "^4.21.0",
     typescript: "^5.9.3"
@@ -1001,157 +1007,13 @@ var package_default = {
 };
 
 // src/flakinessSession.ts
-import fs2 from "fs/promises";
+import fs from "fs/promises";
 import os from "os";
-import path2 from "path";
-
-// src/utils.ts
-import { ReportUtils } from "@flakiness/sdk";
-import crypto from "crypto";
-import fs from "fs";
-import http from "http";
-import https from "https";
 import path from "path";
-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", (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);
-  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");
-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,
-            type: "file"
-          });
-        }
-      }
-    }
-  });
-  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;
-}
 
 // src/serverapi.ts
+import debug from "debug";
+var log = debug("fk:server_api");
 function createServerAPI(endpoint, options) {
   endpoint += "/api/";
   const fetcher = options?.auth ? (url, init) => fetch(url, {
@@ -1165,13 +1027,29 @@ function createServerAPI(endpoint, options) {
     return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
   return TypedHTTP.createClient(endpoint, fetcher);
 }
+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]`, log(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, log(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
 
 // src/flakinessSession.ts
 var CONFIG_DIR = (() => {
-  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");
+  const configDir = process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "flakiness") : path.join(os.homedir(), ".config", "flakiness");
   return configDir;
 })();
-var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 var FlakinessSession = class _FlakinessSession {
   constructor(_config) {
     this._config = _config;
@@ -1184,14 +1062,14 @@ var FlakinessSession = class _FlakinessSession {
     return session2;
   }
   static async load() {
-    const data = await fs2.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
+    const data = await fs.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 fs2.unlink(CONFIG_PATH).catch((e) => void 0);
+    await fs.unlink(CONFIG_PATH).catch((e) => void 0);
   }
   api;
   endpoint() {
@@ -1204,22 +1082,23 @@ var FlakinessSession = class _FlakinessSession {
     return this._config.token;
   }
   async save() {
-    await fs2.mkdir(CONFIG_DIR, { recursive: true });
-    await fs2.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
   }
 };
 
 // src/cli/cmd-convert.ts
 import { GitWorktree, writeReport } from "@flakiness/sdk";
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 
 // src/junit.ts
-import { ReportUtils as ReportUtils2 } from "@flakiness/sdk";
+import { ReportUtils } from "@flakiness/sdk";
 import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
 import assert from "assert";
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import mime from "mime";
+import path2 from "path";
 function getProperties(element) {
   const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
   if (!propertiesNodes.length)
@@ -1261,22 +1140,10 @@ function extractStdout(testcase, stdio) {
   }));
 }
 async function parseAttachment(value) {
-  let absolutePath = path3.resolve(process.cwd(), value);
-  if (fs3.existsSync(absolutePath)) {
-    const id = await sha1File(absolutePath);
-    return {
-      contentType: "image/png",
-      path: absolutePath,
-      id,
-      type: "file"
-    };
-  }
-  return {
-    contentType: "text/plain",
-    id: sha1Buffer(value),
-    body: Buffer.from(value),
-    type: "buffer"
-  };
+  let absolutePath = path2.resolve(process.cwd(), value);
+  if (fs2.existsSync(absolutePath))
+    return ReportUtils.createFileAttachment(mime.getType(absolutePath) ?? "image/png", absolutePath);
+  return ReportUtils.createDataAttachment("text/plain", Buffer.from(value));
 }
 async function traverseJUnitReport(context, node) {
   const element = node;
@@ -1337,7 +1204,7 @@ async function traverseJUnitReport(context, node) {
           id: attachment.id,
           contentType: attachment.contentType,
           //TODO: better default names for attachments?
-          name: attachment.type === "file" ? path3.basename(attachment.path) : `attachment`
+          name: attachment.type === "file" ? path2.basename(attachment.path) : `attachment`
         });
       } else {
         annotations.push({
@@ -1405,22 +1272,22 @@ async function parseJUnit(xmls, options) {
       await traverseJUnitReport(context, element);
   }
   return {
-    report: ReportUtils2.normalizeReport(report),
+    report: ReportUtils.normalizeReport(report),
     attachments: Array.from(context.attachments.values())
   };
 }
 
 // src/cli/cmd-convert.ts
 async function cmdConvert(junitPath, options) {
-  const fullPath = path4.resolve(junitPath);
-  if (!await fs4.access(fullPath, fs4.constants.F_OK).then(() => true).catch(() => false)) {
+  const fullPath = path3.resolve(junitPath);
+  if (!await fs3.access(fullPath, fs3.constants.F_OK).then(() => true).catch(() => false)) {
     console.error(`Error: path ${fullPath} is not accessible`);
     process.exit(1);
   }
-  const stat = await fs4.stat(fullPath);
+  const stat = await fs3.stat(fullPath);
   let xmlContents = [];
   if (stat.isFile()) {
-    const xmlContent = await fs4.readFile(fullPath, "utf-8");
+    const xmlContent = await fs3.readFile(fullPath, "utf-8");
     xmlContents.push(xmlContent);
   } else if (stat.isDirectory()) {
     const xmlFiles = await findXmlFiles(fullPath);
@@ -1430,7 +1297,7 @@ async function cmdConvert(junitPath, options) {
     }
     console.log(`Found ${xmlFiles.length} XML files`);
     for (const xmlFile of xmlFiles) {
-      const xmlContent = await fs4.readFile(xmlFile, "utf-8");
+      const xmlContent = await fs3.readFile(xmlFile, "utf-8");
       xmlContents.push(xmlContent);
     }
   } else {
@@ -1459,9 +1326,9 @@ async function cmdConvert(junitPath, options) {
   console.log(`\u2713 Saved to ${options.outputDir}`);
 }
 async function findXmlFiles(dir, result = []) {
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  const entries = await fs3.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path3.join(dir, entry.name);
     if (entry.isFile() && entry.name.toLowerCase().endsWith(".xml"))
       result.push(fullPath);
     else if (entry.isDirectory())
@@ -1471,10 +1338,10 @@ async function findXmlFiles(dir, result = []) {
 }
 
 // src/cli/cmd-download.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 async function cmdDownload(session2, project, runId, rootDir) {
-  if (fs5.existsSync(rootDir)) {
+  if (fs4.existsSync(rootDir)) {
     console.log(`Directory ${rootDir} already exists!`);
     return;
   }
@@ -1483,15 +1350,15 @@ async function cmdDownload(session2, project, runId, rootDir) {
     projectSlug: project.projectSlug,
     runId
   });
-  const attachmentsDir = path5.join(rootDir, "attachments");
-  await fs5.promises.mkdir(rootDir, { recursive: true });
+  const attachmentsDir = path4.join(rootDir, "attachments");
+  await fs4.promises.mkdir(rootDir, { recursive: true });
   if (urls.attachmentURLs.length)
-    await fs5.promises.mkdir(attachmentsDir, { recursive: true });
+    await fs4.promises.mkdir(attachmentsDir, { recursive: true });
   const response = await fetch(urls.reportURL);
   if (!response.ok)
     throw new Error(`HTTP error ${response.status} for report URL: ${urls.reportURL}`);
   const reportContent = await response.text();
-  await fs5.promises.writeFile(path5.join(rootDir, "report.json"), reportContent);
+  await fs4.promises.writeFile(path4.join(rootDir, "report.json"), reportContent);
   const attachmentDownloader = async () => {
     while (urls.attachmentURLs.length) {
       const url = urls.attachmentURLs.pop();
@@ -1499,8 +1366,8 @@ async function cmdDownload(session2, project, runId, rootDir) {
       if (!response2.ok)
         throw new Error(`HTTP error ${response2.status} for attachment URL: ${url}`);
       const fileBuffer = Buffer.from(await response2.arrayBuffer());
-      const filename = path5.basename(new URL(url).pathname);
-      await fs5.promises.writeFile(path5.join(attachmentsDir, filename), fileBuffer);
+      const filename = path4.basename(new URL(url).pathname);
+      await fs4.promises.writeFile(path4.join(attachmentsDir, filename), fileBuffer);
     }
   };
   const workerPromises = [];
@@ -1621,27 +1488,23 @@ async function cmdUnlink() {
 }
 
 // src/cli/cmd-upload.ts
-import { uploadReport } from "@flakiness/sdk";
+import { readReport, uploadReport } from "@flakiness/sdk";
 import chalk from "chalk";
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 var warn = (txt) => console.warn(chalk.yellow(`[flakiness.io] WARN: ${txt}`));
 var err = (txt) => console.error(chalk.red(`[flakiness.io] Error: ${txt}`));
 async function cmdUpload(relativePaths, options) {
   for (const relativePath of relativePaths) {
-    const fullPath = path6.resolve(relativePath);
-    if (!await fs6.access(fullPath, fs6.constants.F_OK).then(() => true).catch(() => false)) {
+    const fullPath = path5.resolve(relativePath);
+    if (!await fs5.access(fullPath, fs5.constants.F_OK).then(() => true).catch(() => false)) {
       err(`Path ${fullPath} is not accessible!`);
       process.exit(1);
     }
-    const text = await fs6.readFile(fullPath, "utf-8");
-    const report = JSON.parse(text);
-    const attachmentsDir = options.attachmentsDir ?? path6.dirname(fullPath);
-    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
-    if (missingAttachments.length) {
+    const { report, attachments, missingAttachments } = await readReport(path5.dirname(fullPath));
+    if (missingAttachments.length)
       warn(`Missing ${missingAttachments.length} attachments`);
-    }
-    await uploadReport(report, Array.from(attachmentIdToPath.values()), {
+    await uploadReport(report, attachments, {
       flakinessAccessToken: options.accessToken,
       flakinessEndpoint: options.endpoint
     });
@@ -1661,17 +1524,17 @@ async function cmdWhoami() {
 }
 
 // src/cli/cli.ts
+var log2 = debug2("fk:cli");
 var session = await FlakinessSession.load();
 var optAccessToken = new Option("-t, --access-token <token>", "A read-write flakiness.io access token").env("FLAKINESS_ACCESS_TOKEN");
 var optEndpoint = new Option("-e, --endpoint <url>", "An endpoint where the service is deployed").default(session?.endpoint() ?? DEFAULT_FLAKINESS_ENDPOINT).env("FLAKINESS_ENDPOINT");
-var optAttachmentsDir = new Option("--attachments-dir <dir>", "Directory containing attachments to upload. Defaults to the report directory");
 async function runCommand(callback) {
   try {
     await callback();
   } catch (e) {
     if (!(e instanceof Error))
       throw e;
-    console.error(errorText(e));
+    log2(e);
     process.exit(1);
   }
 }
@@ -1775,7 +1638,7 @@ program.command("download").description("Download run").addOption(optSince).addO
     });
     console.log(`Found ${Ranges.cardinality(runIds)} reports uploaded since ${options.since}`);
   }
-  const alreadyExisting = fs7.readdirSync(process.cwd());
+  const alreadyExisting = fs6.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));
@@ -1798,13 +1661,13 @@ program.command("download").description("Download run").addOption(optSince).addO
   await Promise.all(downloaders);
   spinner.stop();
 }));
-program.command("upload").description("Upload Flakiness report to the flakiness.io service").argument("<relative-paths...>", "Paths to the Flakiness report files").addOption(optAccessToken).addOption(optEndpoint).addOption(optAttachmentsDir).action(async (relativePaths, options) => {
+program.command("upload").description("Upload Flakiness report to the flakiness.io service").argument("<relative-paths...>", "Paths to the Flakiness report files").addOption(optAccessToken).addOption(optEndpoint).action(async (relativePaths, options) => {
   await runCommand(async () => {
     await cmdUpload(relativePaths, await ensureAccessToken(options));
   });
 });
 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 = path7.resolve(arg ?? "flakiness-report");
+  const dir = path6.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) => {