@flakiness/sdk 0.147.0 → 0.149.0

package/lib/staticServer.js

@@ -0,0 +1,149 @@
+// src/staticServer.ts
+import debug from "debug";
+import * as fs from "fs";
+import * as http from "http";
+import * as path from "path";
+var log = debug("fk:static_server");
+var StaticServer = class {
+  _server;
+  _absoluteFolderPath;
+  _pathPrefix;
+  _cors;
+  _mimeTypes = {
+    ".html": "text/html",
+    ".js": "text/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".txt": "text/plain"
+  };
+  constructor(pathPrefix, folderPath, cors) {
+    this._pathPrefix = "/" + pathPrefix.replace(/^\//, "").replace(/\/$/, "");
+    this._absoluteFolderPath = 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((resolve2, reject) => {
+      okListener = resolve2;
+      errListener = reject;
+    }).finally(() => {
+      this._server.removeListener("listening", okListener);
+      this._server.removeListener("error", errListener);
+    });
+    this._server.once("listening", okListener);
+    this._server.once("error", errListener);
+    this._server.listen(port, host);
+    await result;
+    log('Serving "%s" on "%s"', this._absoluteFolderPath, this.address());
+  }
+  async start(port, host = "127.0.0.1") {
+    if (port === 0) {
+      await this._startServer(port, host);
+      return this.address();
+    }
+    for (let i = 0; i < 20; ++i) {
+      const err = await this._startServer(port, host).then(() => void 0).catch((e) => e);
+      if (!err)
+        return this.address();
+      if (err.code !== "EADDRINUSE")
+        throw err;
+      log("Port %d is busy (EADDRINUSE). Trying next port...", port);
+      port = port + 1;
+      if (port > 65535)
+        port = 4e3;
+    }
+    log("All sequential ports busy. Falling back to random port.");
+    await this._startServer(0, host);
+    return this.address();
+  }
+  stop() {
+    return new Promise((resolve2, reject) => {
+      this._server.close((err) => {
+        if (err) {
+          log("Error stopping server: %o", err);
+          reject(err);
+        } else {
+          log("Server stopped.");
+          resolve2();
+        }
+      });
+    });
+  }
+  _errorResponse(req, res, code, text) {
+    res.writeHead(code, { "Content-Type": "text/plain" });
+    res.end(text);
+    log(`[${code}] ${req.method} ${req.url}`);
+  }
+  _handleRequest(req, res) {
+    const { url, method } = req;
+    if (this._cors) {
+      res.setHeader("Access-Control-Allow-Headers", "*");
+      res.setHeader("Access-Control-Allow-Origin", this._cors);
+      res.setHeader("Access-Control-Allow-Methods", "*");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+    }
+    if (method !== "GET") {
+      this._errorResponse(req, res, 405, "Method Not Allowed");
+      return;
+    }
+    req.on("aborted", () => log(`ABORTED ${req.method} ${req.url}`));
+    res.on("close", () => {
+      if (!res.headersSent) log(`CLOSED BEFORE SEND ${req.method} ${req.url}`);
+    });
+    if (!url || !url.startsWith(this._pathPrefix)) {
+      this._errorResponse(req, res, 404, "Not Found");
+      return;
+    }
+    const relativePath = url.slice(this._pathPrefix.length);
+    const safeSuffix = 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

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

package/lib/systemUtilizationSampler.js

@@ -44,9 +44,24 @@ function toFKUtilization(sample, previous) {
   };
 }
 var SystemUtilizationSampler = class {
+  /**
+   * 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: [],
@@ -61,6 +76,12 @@ var SystemUtilizationSampler = class {
     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);
   }

package/lib/{reportUploader.js → uploadReport.js}

@@ -1,15 +1,25 @@
-// src/reportUploader.ts
-import { compressTextAsync, compressTextSync } from "@flakiness/shared/node/compression.js";
+// src/uploadReport.ts
 import assert from "assert";
-import crypto from "crypto";
-import fs from "fs";
+import fs2 from "fs";
 import { URL } from "url";
 
-// src/httpUtils.ts
+// src/_internalUtils.ts
+import crypto from "crypto";
+import fs from "fs";
 import http from "http";
 import https from "https";
-
-// src/utils.ts
+import util from "util";
+import zlib from "zlib";
+var asyncBrotliCompress = util.promisify(zlib.brotliCompress);
+async function compressTextAsync(text) {
+  return asyncBrotliCompress(text, {
+    chunkSize: 32 * 1024,
+    params: {
+      [zlib.constants.BROTLI_PARAM_QUALITY]: 6,
+      [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT
+    }
+  });
+}
 var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
 function errorText(error) {
   return FLAKINESS_DBG ? error.stack : error.message;
@@ -30,10 +40,6 @@ async function retryWithBackoff(job, backoff = []) {
   }
   return await job();
 }
-var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
-
-// src/httpUtils.ts
-var FLAKINESS_DBG2 = !!process.env.FLAKINESS_DBG;
 var httpUtils;
 ((httpUtils2) => {
   function createRequest({ url, method = "get", headers = {} }) {
@@ -96,8 +102,11 @@ var httpUtils;
   }
   httpUtils2.postJSON = postJSON;
 })(httpUtils || (httpUtils = {}));
-
-// src/reportUploader.ts
+function sha1Text(data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
 function sha1File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash("sha1");
@@ -113,64 +122,60 @@ function sha1File(filePath) {
     });
   });
 }
+
+// src/uploadReport.ts
 async function createFileAttachment(contentType, filePath) {
   return {
+    type: "file",
     contentType,
     id: await sha1File(filePath),
     path: filePath
   };
 }
 async function createDataAttachment(contentType, data) {
-  const hash = crypto.createHash("sha1");
-  hash.update(data);
-  const id = hash.digest("hex");
   return {
+    type: "buffer",
     contentType,
-    id,
+    id: sha1Text(data),
     body: data
   };
 }
-var ReportUploader = class _ReportUploader {
-  static optionsFromEnv(overrides) {
-    const flakinessAccessToken = overrides?.flakinessAccessToken ?? process.env["FLAKINESS_ACCESS_TOKEN"];
-    if (!flakinessAccessToken)
-      return void 0;
-    const flakinessEndpoint = overrides?.flakinessEndpoint ?? process.env["FLAKINESS_ENDPOINT"] ?? "https://flakiness.io";
-    return { flakinessAccessToken, flakinessEndpoint };
+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 };
   }
-  static async upload(options) {
-    const uploaderOptions = _ReportUploader.optionsFromEnv(options);
-    if (!uploaderOptions) {
-      if (process.env.CI)
-        options.log?.(`[flakiness.io] Uploading skipped since no FLAKINESS_ACCESS_TOKEN is specified`);
-      return void 0;
-    }
-    const uploader = new _ReportUploader(uploaderOptions);
-    const upload = uploader.createUpload(options.report, options.attachments);
+  try {
+    const upload = new ReportUpload(report, attachments, { flakinessAccessToken, flakinessEndpoint });
     const uploadResult = await upload.upload();
     if (!uploadResult.success) {
-      options.log?.(`[flakiness.io] X Failed to upload to ${uploaderOptions.flakinessEndpoint}: ${uploadResult.message}`);
-      return { errorMessage: uploadResult.message };
+      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 };
     }
-    options.log?.(`[flakiness.io] \u2713 Report uploaded ${uploadResult.message ?? ""}`);
-    if (uploadResult.reportUrl)
-      options.log?.(`[flakiness.io] ${uploadResult.reportUrl}`);
+    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 };
   }
-  _options;
-  constructor(options) {
-    this._options = options;
-  }
-  createUpload(report, attachments) {
-    const upload = new ReportUpload(this._options, report, attachments);
-    return upload;
-  }
-};
+}
 var HTTP_BACKOFF = [100, 500, 1e3, 1e3, 1e3, 1e3];
 var ReportUpload = class {
   _report;
   _attachments;
   _options;
-  constructor(options, report, attachments) {
+  constructor(report, attachments, options) {
     this._options = options;
     this._report = report;
     this._attachments = attachments;
@@ -196,7 +201,7 @@ var ReportUpload = class {
       error
     }));
   }
-  async upload(options) {
+  async upload() {
     const response = await this._api("/api/upload/start", this._options.flakinessAccessToken);
     if (response?.error || !response.result)
       return { success: false, message: response.error };
@@ -208,19 +213,19 @@ var ReportUpload = class {
       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, options?.syncCompression ?? false),
+      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, options?.syncCompression ?? false);
+        return this._uploadAttachment(attachment, uploadURL);
       })
     ]);
     await this._api("/api/upload/finish", response.result.uploadToken);
     return { success: true, reportUrl: webUrl };
   }
-  async _uploadReport(data, uploadUrl, syncCompression) {
-    const compressed = syncCompression ? compressTextSync(data) : await compressTextAsync(data);
+  async _uploadReport(data, uploadUrl) {
+    const compressed = await compressTextAsync(data);
     const headers = {
       "Content-Type": "application/json",
       "Content-Length": Buffer.byteLength(compressed) + "",
@@ -237,30 +242,29 @@ var ReportUpload = class {
       await responseDataPromise;
     }, HTTP_BACKOFF);
   }
-  async _uploadAttachment(attachment, uploadUrl, syncCompression) {
+  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.path) {
-      const attachmentPath = attachment.path;
+    if (!compressable && attachment.type === "file") {
       await retryWithBackoff(async () => {
         const { request, responseDataPromise } = httpUtils.createRequest({
           url: uploadUrl,
           headers: {
             "Content-Type": attachment.contentType,
-            "Content-Length": (await fs.promises.stat(attachmentPath)).size + ""
+            "Content-Length": (await fs2.promises.stat(attachment.path)).size + ""
           },
           method: "put"
         });
-        fs.createReadStream(attachmentPath).pipe(request);
+        fs2.createReadStream(attachment.path).pipe(request);
         await responseDataPromise;
       }, HTTP_BACKOFF);
       return;
     }
-    let buffer = attachment.body ? attachment.body : attachment.path ? await fs.promises.readFile(attachment.path) : void 0;
+    let buffer = attachment.type === "buffer" ? attachment.body : await fs2.promises.readFile(attachment.path);
     assert(buffer);
     const encoding = compressable ? "br" : void 0;
     if (compressable)
-      buffer = syncCompression ? compressTextSync(buffer) : await compressTextAsync(buffer);
+      buffer = await compressTextAsync(buffer);
     const headers = {
       "Content-Type": attachment.contentType,
       "Content-Length": Buffer.byteLength(buffer) + "",
@@ -279,8 +283,8 @@ var ReportUpload = class {
   }
 };
 export {
-  ReportUploader,
   createDataAttachment,
-  createFileAttachment
+  createFileAttachment,
+  uploadReport
 };
-//# sourceMappingURL=reportUploader.js.map
+//# sourceMappingURL=uploadReport.js.map

package/lib/visitTests.js

@@ -0,0 +1,19 @@
+// src/visitTests.ts
+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

@@ -0,0 +1,31 @@
+// src/writeReport.ts
+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

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@flakiness/sdk",
-  "version": "0.147.0",
+  "version": "0.149.0",
   "private": false,
   "exports": {
-    "./localReportApi": {
-      "types": "./types/src/localReportApi.d.ts"
-    },
     ".": {
       "types": "./types/src/index.d.ts",
       "import": "./lib/index.js",
       "require": "./lib/index.js"
     },
     "./browser": {
-      "types": "./types/src/browser/index.d.ts",
-      "import": "./lib/browser/index.js",
-      "require": "./lib/browser/index.js"
+      "types": "./types/src/browser.d.ts",
+      "import": "./lib/browser.js",
+      "require": "./lib/browser.js"
     }
   },
   "type": "module",
@@ -25,22 +22,14 @@
   "author": "Degu Labs, Inc",
   "license": "Fair Source 100",
   "devDependencies": {
-    "@playwright/test": "^1.57.0",
-    "@types/babel__code-frame": "^7.0.6",
-    "@types/compression": "^1.8.1",
-    "@types/express": "^4.17.20"
+    "@types/babel__code-frame": "^7.0.6"
   },
   "dependencies": {
     "@babel/code-frame": "^7.26.2",
     "@flakiness/flakiness-report": "^0.16.0",
-    "@flakiness/shared": "0.147.0",
-    "body-parser": "^1.20.3",
     "chalk": "^5.6.2",
-    "compression": "^1.8.1",
     "debug": "^4.3.7",
-    "express": "^4.21.2",
-    "express-async-errors": "^3.1.1",
     "open": "^10.2.0",
-    "zod": "^3.25.23"
+    "stable-hash": "^0.0.6"
   }
 }