@flakiness/sdk 0.95.0

package/lib/utils.js

@@ -0,0 +1,323 @@
+// src/utils.ts
+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 { posix as posixPath, win32 as win32Path } from "path";
+import util from "util";
+import zlib from "zlib";
+var gzipAsync = util.promisify(zlib.gzip);
+var gunzipAsync = util.promisify(zlib.gunzip);
+var gunzipSync = zlib.gunzipSync;
+var brotliCompressAsync = util.promisify(zlib.brotliCompress);
+var brotliCompressSync = zlib.brotliCompressSync;
+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);
+    });
+  });
+}
+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]`, e.errors[0].message);
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, e.message);
+      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;
+    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) {
+      console.log(result);
+      console.log(options);
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.log(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 getCallerLocation(gitRoot, offset = 0) {
+  const err = new Error();
+  const stack = err.stack?.split("\n");
+  const caller = stack?.[2 + offset]?.trim();
+  const match = caller?.match(/\((.*):(\d+):(\d+)\)$/);
+  if (!match)
+    return void 0;
+  const [, filePath, line, column] = match;
+  return {
+    file: gitFilePath(gitRoot, normalizePath(filePath)),
+    line: Number(line),
+    column: Number(column)
+  };
+}
+function parseStackLocations() {
+  const err = new Error();
+  const stack = err.stack?.split("\n").slice(2);
+  if (!stack)
+    return [];
+  const result = [];
+  for (const caller of stack) {
+    const match = caller.trim().match(/\((.*):(\d+):(\d+)\)$/);
+    if (!match)
+      continue;
+    const [, file, line, column] = match;
+    result.push({ file, line, column });
+  }
+  return result;
+}
+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 createEnvironment(options) {
+  const osInfo = getOSInfo();
+  return {
+    name: options.name,
+    systemData: {
+      osArch: osInfo.arch,
+      osName: osInfo.name,
+      osVersion: osInfo.version
+    },
+    userSuppliedData: {
+      ...extractEnvConfiguration(),
+      ...options.userSuppliedData ?? {}
+    }
+  };
+}
+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;
+}
+export {
+  brotliCompressAsync,
+  brotliCompressSync,
+  computeGitRoot,
+  createEnvironment,
+  createEnvironments,
+  existsAsync,
+  extractEnvConfiguration,
+  getCallerLocation,
+  getOSInfo,
+  gitCommitInfo,
+  gitFilePath,
+  gunzipAsync,
+  gunzipSync,
+  gzipAsync,
+  httpUtils,
+  inferRunUrl,
+  normalizePath,
+  parseDurationMS,
+  parseStackLocations,
+  parseStringDate,
+  retryWithBackoff,
+  sha1Buffer,
+  sha1File,
+  shell,
+  stripAnsi
+};
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@flakiness/sdk",
+  "version": "0.95.0",
+  "private": false,
+  "bin": {
+    "flakiness": "./lib/cli/cli.js"
+  },
+  "exports": {
+    "./uploader": {
+      "import": "./lib/reportUploader.js",
+      "require": "./lib/reportUploader.js",
+      "types": "./types/src/reportUploader.d.ts"
+    },
+    "./utils": {
+      "import": "./lib/utils.js",
+      "require": "./lib/utils.js",
+      "types": "./types/src/utils.d.ts"
+    },
+    "./playwright": {
+      "import": "./lib/playwrightJSONReport.js",
+      "require": "./lib/playwrightJSONReport.js",
+      "types": "./types/src/playwrightJSONReport.d.ts"
+    },
+    "./junit": {
+      "import": "./lib/junit.js",
+      "require": "./lib/junit.js",
+      "types": "./types/src/junit.d.ts"
+    },
+    "./playwright-test": {
+      "import": "./lib/playwright-test.js",
+      "require": "./lib/playwright-test.js",
+      "types": "./types/src/playwright-test.d.ts"
+    }
+  },
+  "type": "module",
+  "description": "",
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Degu Labs, Inc",
+  "license": "Fair Source 100",
+  "devDependencies": {
+    "@playwright/test": "^1.54.0",
+    "@flakiness/server": "0.95.0",
+    "@types/babel__code-frame": "^7.0.6"
+  },
+  "dependencies": {
+    "@babel/code-frame": "^7.26.2",
+    "@flakiness/shared": "0.95.0",
+    "@flakiness/report": "0.95.0",
+    "@rgrove/parse-xml": "^4.2.0",
+    "commander": "^13.1.0",
+    "debug": "^4.3.7",
+    "zod": "^3.25.23"
+  }
+}