@flakiness/sdk 0.150.1 → 0.151.0

package/lib/normalizeReport.js

@@ -1,113 +0,0 @@
-import stableObjectHash from "stable-hash";
-class Multimap {
-  _map = /* @__PURE__ */ new Map();
-  set(key, value) {
-    const set = this._map.get(key) ?? /* @__PURE__ */ new Set();
-    this._map.set(key, set);
-    set.add(value);
-  }
-  getAll(key) {
-    return Array.from(this._map.get(key) ?? []);
-  }
-}
-function normalizeReport(report) {
-  const gEnvs = /* @__PURE__ */ new Map();
-  const gSuites = /* @__PURE__ */ new Map();
-  const gTests = new Multimap();
-  const gSuiteIds = /* @__PURE__ */ new Map();
-  const gTestIds = /* @__PURE__ */ new Map();
-  const gEnvIds = /* @__PURE__ */ new Map();
-  const gSuiteChildren = new Multimap();
-  const gSuiteTests = new Multimap();
-  for (const env of report.environments) {
-    const envId = computeEnvId(env);
-    gEnvs.set(envId, env);
-    gEnvIds.set(env, envId);
-  }
-  const usedEnvIds = /* @__PURE__ */ new Set();
-  function visitTests(tests, suiteId) {
-    for (const test of tests ?? []) {
-      const testId = computeTestId(test, suiteId);
-      gTests.set(testId, test);
-      gTestIds.set(test, testId);
-      gSuiteTests.set(suiteId, test);
-      for (const attempt of test.attempts) {
-        const env = report.environments[attempt.environmentIdx];
-        const envId = gEnvIds.get(env);
-        usedEnvIds.add(envId);
-      }
-    }
-  }
-  function visitSuite(suite, parentSuiteId) {
-    const suiteId = computeSuiteId(suite, parentSuiteId);
-    gSuites.set(suiteId, suite);
-    gSuiteIds.set(suite, suiteId);
-    for (const childSuite of suite.suites ?? []) {
-      visitSuite(childSuite, suiteId);
-      gSuiteChildren.set(suiteId, childSuite);
-    }
-    visitTests(suite.tests ?? [], suiteId);
-  }
-  function transformTests(tests) {
-    const testIds = new Set(tests.map((test) => gTestIds.get(test)));
-    return [...testIds].map((testId) => {
-      const tests2 = gTests.getAll(testId);
-      const tags = tests2.map((test) => test.tags ?? []).flat();
-      return {
-        location: tests2[0].location,
-        title: tests2[0].title,
-        tags: tags.length ? tags : void 0,
-        attempts: tests2.map((t) => t.attempts).flat().map((attempt) => ({
-          ...attempt,
-          environmentIdx: envIdToIndex.get(gEnvIds.get(report.environments[attempt.environmentIdx]))
-        }))
-      };
-    });
-  }
-  function transformSuites(suites) {
-    const suiteIds = new Set(suites.map((suite) => gSuiteIds.get(suite)));
-    return [...suiteIds].map((suiteId) => {
-      const suite = gSuites.get(suiteId);
-      return {
-        location: suite.location,
-        title: suite.title,
-        type: suite.type,
-        suites: transformSuites(gSuiteChildren.getAll(suiteId)),
-        tests: transformTests(gSuiteTests.getAll(suiteId))
-      };
-    });
-  }
-  visitTests(report.tests ?? [], "suiteless");
-  for (const suite of report.suites)
-    visitSuite(suite);
-  const newEnvironments = [...usedEnvIds];
-  const envIdToIndex = new Map(newEnvironments.map((envId, index) => [envId, index]));
-  return {
-    ...report,
-    environments: newEnvironments.map((envId) => gEnvs.get(envId)),
-    suites: transformSuites(report.suites),
-    tests: transformTests(report.tests ?? [])
-  };
-}
-function computeEnvId(env) {
-  return stableObjectHash(env);
-}
-function computeSuiteId(suite, parentSuiteId) {
-  return stableObjectHash({
-    parentSuiteId: parentSuiteId ?? "",
-    type: suite.type,
-    file: suite.location?.file ?? "",
-    title: suite.title
-  });
-}
-function computeTestId(test, suiteId) {
-  return stableObjectHash({
-    suiteId,
-    file: test.location?.file ?? "",
-    title: test.title
-  });
-}
-export {
-  normalizeReport
-};
-//# sourceMappingURL=normalizeReport.js.map

package/lib/reportUtils.js

@@ -1,19 +0,0 @@
-import { createEnvironment } from "./createEnvironment.js";
-import { createTestStepSnippetsInplace } from "./createTestStepSnippets.js";
-import { normalizeReport } from "./normalizeReport.js";
-import { stripAnsi } from "./stripAnsi.js";
-import {
-  createDataAttachment,
-  createFileAttachment
-} from "./uploadReport.js";
-import { visitTests } from "./visitTests.js";
-export {
-  createDataAttachment,
-  createEnvironment,
-  createFileAttachment,
-  createTestStepSnippetsInplace,
-  normalizeReport,
-  stripAnsi,
-  visitTests
-};
-//# sourceMappingURL=reportUtils.js.map

package/lib/reportUtilsBrowser.js

@@ -1,9 +0,0 @@
-import { normalizeReport } from "./normalizeReport.js";
-import { stripAnsi } from "./stripAnsi.js";
-import { visitTests } from "./visitTests.js";
-export {
-  normalizeReport,
-  stripAnsi,
-  visitTests
-};
-//# sourceMappingURL=reportUtilsBrowser.js.map

package/lib/showReport.js

@@ -1,28 +0,0 @@
-import chalk from "chalk";
-import open from "open";
-import { randomUUIDBase62 } from "./_internalUtils.js";
-import { FlakinessProjectConfig } from "./flakinessProjectConfig.js";
-import { StaticServer } from "./staticServer.js";
-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(() => {
-  });
-}
-export {
-  showReport
-};
-//# sourceMappingURL=showReport.js.map

package/lib/staticServer.js

@@ -1,148 +0,0 @@
-import debug from "debug";
-import * as fs from "fs";
-import * as http from "http";
-import * as path from "path";
-const log = debug("fk:static_server");
-class StaticServer {
-  _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 = path.resolve(folderPath);
-    this._cors = cors;
-    this._server = http.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((resolve, reject) => {
-      okListener = resolve;
-      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((resolve, reject) => {
-      this._server.close((err) => {
-        if (err) {
-          log("Error stopping server: %o", err);
-          reject(err);
-        } else {
-          log("Server stopped.");
-          resolve();
-        }
-      });
-    });
-  }
-  _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 = path.normalize(decodeURIComponent(relativePath)).replace(/^(\.\.[\/\\])+/, "");
-    const filePath = path.join(this._absoluteFolderPath, safeSuffix);
-    if (!filePath.startsWith(this._absoluteFolderPath)) {
-      this._errorResponse(req, res, 403, "Forbidden");
-      return;
-    }
-    fs.stat(filePath, (err, stats) => {
-      if (err || !stats.isFile()) {
-        this._errorResponse(req, res, 404, "File Not Found");
-        return;
-      }
-      const ext = path.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 = fs.createReadStream(filePath);
-      readStream.pipe(res);
-      readStream.on("error", (err2) => {
-        log("Stream error: %o", err2);
-        res.end();
-      });
-    });
-  }
-}
-export {
-  StaticServer
-};
-//# sourceMappingURL=staticServer.js.map

package/lib/stripAnsi.js

@@ -1,8 +0,0 @@
-const 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, "");
-}
-export {
-  stripAnsi
-};
-//# sourceMappingURL=stripAnsi.js.map

package/lib/systemUtilizationSampler.js

@@ -1,91 +0,0 @@
-import { spawnSync } from "child_process";
-import os from "os";
-function getAvailableMemMacOS() {
-  const lines = spawnSync("vm_stat", { encoding: "utf8" }).stdout.trim().split("\n");
-  const pageSize = parseInt(lines[0].match(/page size of (\d+) bytes/)[1], 10);
-  if (isNaN(pageSize)) {
-    console.warn("[flakiness.io] Error detecting macos page size");
-    return 0;
-  }
-  let totalFree = 0;
-  for (const line of lines) {
-    if (/Pages (free|inactive|speculative):/.test(line)) {
-      const match = line.match(/\d+/);
-      if (match)
-        totalFree += parseInt(match[0], 10);
-    }
-  }
-  return totalFree * pageSize;
-}
-function getSystemUtilization() {
-  let idleTicks = 0;
-  let totalTicks = 0;
-  for (const cpu of os.cpus()) {
-    totalTicks += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq + cpu.times.idle;
-    idleTicks += cpu.times.idle;
-  }
-  return {
-    idleTicks,
-    totalTicks,
-    timestamp: Date.now(),
-    freeBytes: os.platform() === "darwin" ? getAvailableMemMacOS() : os.freemem()
-  };
-}
-function toFKUtilization(sample, previous) {
-  const idleTicks = sample.idleTicks - previous.idleTicks;
-  const totalTicks = sample.totalTicks - previous.totalTicks;
-  const cpuUtilization = Math.floor((1 - idleTicks / totalTicks) * 1e4) / 100;
-  const memoryUtilization = Math.floor((1 - sample.freeBytes / os.totalmem()) * 1e4) / 100;
-  return {
-    cpuUtilization,
-    memoryUtilization,
-    dts: sample.timestamp - previous.timestamp
-  };
-}
-class SystemUtilizationSampler {
-  /**
-   * The accumulated system utilization data.
-   *
-   * This object is populated as samples are collected and can be directly included in
-   * Flakiness reports. It contains:
-   * - `samples` - Array of utilization samples with CPU/memory percentages and durations
-   * - `startTimestamp` - Timestamp when sampling began
-   * - `totalMemoryBytes` - Total system memory in bytes
-   */
-  result;
-  _lastSample = getSystemUtilization();
-  _timer;
-  /**
-   * Creates a new SystemUtilizationSampler and starts sampling immediately.
-   *
-   * The first sample is collected after 50ms, and subsequent samples are collected
-   * every 1000ms. Call `dispose()` to stop sampling and clean up resources.
-   */
-  constructor() {
-    this.result = {
-      samples: [],
-      startTimestamp: this._lastSample.timestamp,
-      totalMemoryBytes: os.totalmem()
-    };
-    this._timer = setTimeout(this._addSample.bind(this), 50);
-  }
-  _addSample() {
-    const sample = getSystemUtilization();
-    this.result.samples.push(toFKUtilization(sample, this._lastSample));
-    this._lastSample = sample;
-    this._timer = setTimeout(this._addSample.bind(this), 1e3);
-  }
-  /**
-   * Stops sampling and cleans up resources.
-   *
-   * Call this method when you're done collecting utilization data to stop the sampling
-   * timer and prevent memory leaks. The `result` object remains accessible after disposal.
-   */
-  dispose() {
-    clearTimeout(this._timer);
-  }
-}
-export {
-  SystemUtilizationSampler
-};
-//# sourceMappingURL=systemUtilizationSampler.js.map

package/lib/uploadReport.js

@@ -1,175 +0,0 @@
-import assert from "assert";
-import fs from "fs";
-import { URL } from "url";
-import { compressTextAsync, retryWithBackoff, sha1File, sha1Text } from "./_internalUtils.js";
-async function createFileAttachment(contentType, filePath) {
-  return {
-    type: "file",
-    contentType,
-    id: await sha1File(filePath),
-    path: filePath
-  };
-}
-async function createDataAttachment(contentType, data) {
-  return {
-    type: "buffer",
-    contentType,
-    id: sha1Text(data),
-    body: data
-  };
-}
-async function uploadReport(report, attachments, options) {
-  const flakinessAccessToken = options?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
-  const flakinessEndpoint = options?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
-  const logger = options?.logger ?? console;
-  if (!flakinessAccessToken) {
-    const reason = "No FLAKINESS_ACCESS_TOKEN found";
-    if (process.env.CI)
-      logger.warn(`[flakiness.io] \u26A0 Skipping upload: ${reason}`);
-    return { status: "skipped", reason };
-  }
-  try {
-    const upload = new ReportUpload(report, attachments, { flakinessAccessToken, flakinessEndpoint });
-    const uploadResult = await upload.upload();
-    if (!uploadResult.success) {
-      const errorMessage = uploadResult.message || "Unknown upload error";
-      logger.error(`[flakiness.io] \u2715 Failed to upload: ${errorMessage}`);
-      if (options?.throwOnFailure)
-        throw new Error(`Flakiness upload failed: ${errorMessage}`);
-      return { status: "failed", error: errorMessage };
-    }
-    logger.log(`[flakiness.io] \u2713 Uploaded to ${uploadResult.reportUrl}`);
-    return { status: "success", reportUrl: uploadResult.reportUrl };
-  } catch (e) {
-    const errorMessage = e.message || String(e);
-    logger.error(`[flakiness.io] \u2715 Unexpected error during upload: ${errorMessage}`);
-    if (options?.throwOnFailure)
-      throw e;
-    return { status: "failed", error: errorMessage };
-  }
-}
-const HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
-class ReportUpload {
-  _report;
-  _attachments;
-  _options;
-  constructor(report, attachments, options) {
-    this._options = options;
-    this._report = report;
-    this._attachments = attachments;
-  }
-  async _api(pathname, token, body) {
-    const url = new URL(this._options.flakinessEndpoint);
-    url.pathname = pathname;
-    return await fetch(url, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: body ? JSON.stringify(body) : void 0
-    }).then(async (response) => !response.ok ? {
-      result: void 0,
-      error: response.status + " " + url.href + " " + await response.text()
-    } : {
-      result: await response.json(),
-      error: void 0
-    }).catch((error) => ({
-      result: void 0,
-      error
-    }));
-  }
-  async upload() {
-    const response = await this._api("/api/upload/start", this._options.flakinessAccessToken);
-    if (response?.error || !response.result)
-      return { success: false, message: response.error };
-    const webUrl = new URL(response.result.webUrl, this._options.flakinessEndpoint).toString();
-    const attachmentsPresignedUrls = await this._api("/api/upload/attachments", response.result.uploadToken, {
-      attachmentIds: this._attachments.map((a) => a.id)
-    });
-    if (attachmentsPresignedUrls?.error || !attachmentsPresignedUrls.result)
-      return { success: false, message: attachmentsPresignedUrls.error };
-    const attachments = new Map(attachmentsPresignedUrls.result.map((a) => [a.attachmentId, a.presignedUrl]));
-    await Promise.all([
-      this._uploadReport(JSON.stringify(this._report), response.result.presignedReportUrl),
-      ...this._attachments.map((attachment) => {
-        const uploadURL = attachments.get(attachment.id);
-        if (!uploadURL)
-          throw new Error("Internal error: missing upload URL for attachment!");
-        return this._uploadAttachment(attachment, uploadURL);
-      })
-    ]);
-    await this._api("/api/upload/finish", response.result.uploadToken);
-    return { success: true, reportUrl: webUrl };
-  }
-  async _uploadReport(data, uploadUrl) {
-    const compressed = await compressTextAsync(data);
-    const headers = {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(compressed) + "",
-      "Content-Encoding": "br"
-    };
-    await retryWithBackoff(async () => {
-      const response = await fetch(uploadUrl, {
-        method: "PUT",
-        headers,
-        body: Buffer.from(compressed)
-      });
-      if (!response.ok) {
-        throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
-      }
-      await response.arrayBuffer();
-    }, HTTP_BACKOFF);
-  }
-  async _uploadAttachment(attachment, uploadUrl) {
-    const mimeType = attachment.contentType.toLocaleLowerCase().trim();
-    const compressable = mimeType.startsWith("text/") || mimeType.endsWith("+json") || mimeType.endsWith("+text") || mimeType.endsWith("+xml");
-    if (!compressable && attachment.type === "file") {
-      await retryWithBackoff(async () => {
-        const fileBuffer = await fs.promises.readFile(attachment.path);
-        const response = await fetch(uploadUrl, {
-          method: "PUT",
-          headers: {
-            "Content-Type": attachment.contentType,
-            "Content-Length": fileBuffer.length + ""
-          },
-          body: new Uint8Array(fileBuffer)
-        });
-        if (!response.ok) {
-          throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
-        }
-        await response.arrayBuffer();
-      }, HTTP_BACKOFF);
-      return;
-    }
-    let buffer = attachment.type === "buffer" ? attachment.body : await fs.promises.readFile(attachment.path);
-    assert(buffer);
-    const encoding = compressable ? "br" : void 0;
-    if (compressable)
-      buffer = await compressTextAsync(buffer);
-    const headers = {
-      "Content-Type": attachment.contentType,
-      "Content-Length": Buffer.byteLength(buffer) + ""
-    };
-    if (encoding) {
-      headers["Content-Encoding"] = encoding;
-    }
-    await retryWithBackoff(async () => {
-      const response = await fetch(uploadUrl, {
-        method: "PUT",
-        headers,
-        body: new Uint8Array(buffer)
-      });
-      if (!response.ok) {
-        throw new Error(`Request to ${uploadUrl} failed with ${response.status}`);
-      }
-      await response.arrayBuffer();
-    }, HTTP_BACKOFF);
-  }
-}
-export {
-  createDataAttachment,
-  createFileAttachment,
-  uploadReport
-};
-//# sourceMappingURL=uploadReport.js.map

package/lib/visitTests.js

@@ -1,18 +0,0 @@
-function visitTests(report, testVisitor) {
-  function visitSuite(suite, parents) {
-    parents.push(suite);
-    for (const test of suite.tests ?? [])
-      testVisitor(test, parents);
-    for (const childSuite of suite.suites ?? [])
-      visitSuite(childSuite, parents);
-    parents.pop();
-  }
-  for (const test of report.tests ?? [])
-    testVisitor(test, []);
-  for (const suite of report.suites)
-    visitSuite(suite, []);
-}
-export {
-  visitTests
-};
-//# sourceMappingURL=visitTests.js.map

package/lib/writeReport.js

@@ -1,30 +0,0 @@
-import fs from "fs";
-import path from "path";
-async function writeReport(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.type === "file")
-      await fs.promises.cp(attachment.path, attachmentPath);
-    else if (attachment.type === "buffer")
-      await fs.promises.writeFile(attachmentPath, attachment.body);
-    movedAttachments.push({
-      type: "file",
-      contentType: attachment.contentType,
-      id: attachment.id,
-      path: attachmentPath
-    });
-  }
-  return movedAttachments;
-}
-export {
-  writeReport
-};
-//# sourceMappingURL=writeReport.js.map