@flakiness/sdk 0.95.0 → 0.96.0

package/lib/cli/cmd-convert.js

@@ -12,19 +12,13 @@ import fs2 from "fs";
 import path from "path";
 
 // src/utils.ts
+import { FlakinessReport } from "@flakiness/report";
 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 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;
 function sha1File(filePath) {
   return new Promise((resolve, reject) => {
     const hash = crypto.createHash("sha1");
@@ -40,6 +34,10 @@ function sha1File(filePath) {
     });
   });
 }
+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);
@@ -51,9 +49,9 @@ async function retryWithBackoff(job, backoff = []) {
       return await job();
     } catch (e) {
       if (e instanceof AggregateError)
-        console.error(`[flakiness.io err]`, e.errors[0].message);
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
       else if (e instanceof Error)
-        console.error(`[flakiness.io err]`, e.message);
+        console.error(`[flakiness.io err]`, errorText(e));
       else
         console.error(`[flakiness.io err]`, e);
       await new Promise((x) => setTimeout(x, timeout));
@@ -71,6 +69,7 @@ var httpUtils;
       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));

package/lib/cli/cmd-download.js

@@ -1,476 +1,26 @@
 // src/cli/cmd-download.ts
-import fs3 from "fs";
-import path3 from "path";
-
-// src/flakinessLink.ts
-import fs from "fs/promises";
+import fs from "fs";
 import path from "path";
-
-// src/utils.ts
-import assert from "assert";
-import { spawnSync } from "child_process";
-import http from "http";
-import https from "https";
-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 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 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 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;
-}
-
-// src/flakinessLink.ts
-var GIT_ROOT = computeGitRoot(process.cwd());
-var CONFIG_DIR = path.join(GIT_ROOT, ".flakiness");
-var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
-var FlakinessLink = class _FlakinessLink {
-  constructor(_config) {
-    this._config = _config;
-  }
-  static async load() {
-    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 _FlakinessLink(json);
-  }
-  static async remove() {
-    await fs.unlink(CONFIG_PATH).catch((e) => void 0);
-  }
-  path() {
-    return CONFIG_PATH;
-  }
-  projectId() {
-    return this._config.projectId;
-  }
-  async save() {
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-    await fs.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/flakinessSession.ts
-import fs2 from "fs/promises";
-import os from "os";
-import path2 from "path";
-
-// ../server/lib/common/typedHttp.js
-var TypedHTTP;
-((TypedHTTP2) => {
-  TypedHTTP2.StatusCodes = {
-    Informational: {
-      CONTINUE: 100,
-      SWITCHING_PROTOCOLS: 101,
-      PROCESSING: 102,
-      EARLY_HINTS: 103
-    },
-    Success: {
-      OK: 200,
-      CREATED: 201,
-      ACCEPTED: 202,
-      NON_AUTHORITATIVE_INFORMATION: 203,
-      NO_CONTENT: 204,
-      RESET_CONTENT: 205,
-      PARTIAL_CONTENT: 206,
-      MULTI_STATUS: 207
-    },
-    Redirection: {
-      MULTIPLE_CHOICES: 300,
-      MOVED_PERMANENTLY: 301,
-      MOVED_TEMPORARILY: 302,
-      SEE_OTHER: 303,
-      NOT_MODIFIED: 304,
-      USE_PROXY: 305,
-      TEMPORARY_REDIRECT: 307,
-      PERMANENT_REDIRECT: 308
-    },
-    ClientErrors: {
-      BAD_REQUEST: 400,
-      UNAUTHORIZED: 401,
-      PAYMENT_REQUIRED: 402,
-      FORBIDDEN: 403,
-      NOT_FOUND: 404,
-      METHOD_NOT_ALLOWED: 405,
-      NOT_ACCEPTABLE: 406,
-      PROXY_AUTHENTICATION_REQUIRED: 407,
-      REQUEST_TIMEOUT: 408,
-      CONFLICT: 409,
-      GONE: 410,
-      LENGTH_REQUIRED: 411,
-      PRECONDITION_FAILED: 412,
-      REQUEST_TOO_LONG: 413,
-      REQUEST_URI_TOO_LONG: 414,
-      UNSUPPORTED_MEDIA_TYPE: 415,
-      REQUESTED_RANGE_NOT_SATISFIABLE: 416,
-      EXPECTATION_FAILED: 417,
-      IM_A_TEAPOT: 418,
-      INSUFFICIENT_SPACE_ON_RESOURCE: 419,
-      METHOD_FAILURE: 420,
-      MISDIRECTED_REQUEST: 421,
-      UNPROCESSABLE_ENTITY: 422,
-      LOCKED: 423,
-      FAILED_DEPENDENCY: 424,
-      UPGRADE_REQUIRED: 426,
-      PRECONDITION_REQUIRED: 428,
-      TOO_MANY_REQUESTS: 429,
-      REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-      UNAVAILABLE_FOR_LEGAL_REASONS: 451
-    },
-    ServerErrors: {
-      INTERNAL_SERVER_ERROR: 500,
-      NOT_IMPLEMENTED: 501,
-      BAD_GATEWAY: 502,
-      SERVICE_UNAVAILABLE: 503,
-      GATEWAY_TIMEOUT: 504,
-      HTTP_VERSION_NOT_SUPPORTED: 505,
-      INSUFFICIENT_STORAGE: 507,
-      NETWORK_AUTHENTICATION_REQUIRED: 511
-    }
-  };
-  const AllErrorCodes = {
-    ...TypedHTTP2.StatusCodes.ClientErrors,
-    ...TypedHTTP2.StatusCodes.ServerErrors
-  };
-  class HttpError extends Error {
-    constructor(status, message) {
-      super(message);
-      this.status = status;
-    }
-    static withCode(code, message) {
-      const statusCode = AllErrorCodes[code];
-      const defaultMessage = code.split("_").map((word) => word.charAt(0) + word.slice(1).toLowerCase()).join(" ");
-      return new HttpError(statusCode, message ?? defaultMessage);
-    }
-  }
-  TypedHTTP2.HttpError = HttpError;
-  function isInformationalResponse(response) {
-    return response.status >= 100 && response.status < 200;
-  }
-  TypedHTTP2.isInformationalResponse = isInformationalResponse;
-  function isSuccessResponse(response) {
-    return response.status >= 200 && response.status < 300;
-  }
-  TypedHTTP2.isSuccessResponse = isSuccessResponse;
-  function isRedirectResponse(response) {
-    return response.status >= 300 && response.status < 400;
-  }
-  TypedHTTP2.isRedirectResponse = isRedirectResponse;
-  function isErrorResponse(response) {
-    return response.status >= 400 && response.status < 600;
-  }
-  TypedHTTP2.isErrorResponse = isErrorResponse;
-  function info(status) {
-    return { status };
-  }
-  TypedHTTP2.info = info;
-  function ok(data, status) {
-    return {
-      status: status ?? TypedHTTP2.StatusCodes.Success.OK,
-      data
-    };
-  }
-  TypedHTTP2.ok = ok;
-  function redirect(url, status = 302) {
-    return { status, url };
-  }
-  TypedHTTP2.redirect = redirect;
-  function error(message, status = TypedHTTP2.StatusCodes.ServerErrors.INTERNAL_SERVER_ERROR) {
-    return { status, message };
-  }
-  TypedHTTP2.error = error;
-  class Router {
-    constructor(_resolveContext) {
-      this._resolveContext = _resolveContext;
-    }
-    static create() {
-      return new Router(async (e) => e.ctx);
-    }
-    rawMethod(method, route) {
-      return {
-        [method]: {
-          method,
-          input: route.input,
-          etag: route.etag,
-          resolveContext: this._resolveContext,
-          handler: route.handler
-        }
-      };
-    }
-    get(route) {
-      return this.rawMethod("GET", {
-        ...route,
-        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
-      });
-    }
-    post(route) {
-      return this.rawMethod("POST", {
-        ...route,
-        handler: (...args) => Promise.resolve(route.handler(...args)).then((result) => TypedHTTP2.ok(result))
-      });
-    }
-    use(resolveContext) {
-      return new Router(async (options) => {
-        const m = await this._resolveContext(options);
-        return resolveContext({ ...options, ctx: m });
-      });
-    }
-  }
-  TypedHTTP2.Router = Router;
-  function createClient(base, fetchCallback) {
-    function buildUrl(path4, input, options) {
-      const method = path4.at(-1);
-      const url = new URL(path4.slice(0, path4.length - 1).join("/"), base);
-      const signal = options?.signal;
-      let body = void 0;
-      if (method === "GET" && input)
-        url.searchParams.set("input", JSON.stringify(input));
-      else if (method !== "GET" && input)
-        body = JSON.stringify(input);
-      return {
-        url,
-        method,
-        headers: body ? { "Content-Type": "application/json" } : void 0,
-        body,
-        signal
-      };
-    }
-    function createProxy(path4 = []) {
-      return new Proxy(() => {
-      }, {
-        get(target, prop) {
-          if (typeof prop === "symbol")
-            return void 0;
-          if (prop === "prepare")
-            return (input, options) => buildUrl(path4, input, options);
-          const newPath = [...path4, prop];
-          return createProxy(newPath);
-        },
-        apply(target, thisArg, args) {
-          const options = buildUrl(path4, args[0], args[1]);
-          return fetchCallback(options.url, {
-            method: options.method,
-            body: options.body,
-            headers: options.headers,
-            signal: options.signal
-          }).then(async (response) => {
-            if (response.status >= 200 && response.status < 300) {
-              if (response.headers.get("content-type")?.includes("application/json")) {
-                const text = await response.text();
-                return text.length ? JSON.parse(text) : void 0;
-              }
-              return await response.blob();
-            }
-            if (response.status >= 400 && response.status < 600) {
-              const text = await response.text();
-              if (text)
-                throw new Error(`HTTP request failed with status ${response.status}: ${text}`);
-              else
-                throw new Error(`HTTP request failed with status ${response.status}`);
-            }
-          });
-        }
-      });
-    }
-    return createProxy();
-  }
-  TypedHTTP2.createClient = createClient;
-})(TypedHTTP || (TypedHTTP = {}));
-
-// src/serverapi.ts
-function createServerAPI(endpoint, options) {
-  endpoint += "/api/";
-  const fetcher = options?.auth ? (url, init) => fetch(url, {
-    ...init,
-    headers: {
-      ...init.headers,
-      "Authorization": `Bearer ${options.auth}`
-    }
-  }) : fetch;
-  if (options?.retries)
-    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
-  return TypedHTTP.createClient(endpoint, fetcher);
-}
-
-// src/flakinessSession.ts
-var CONFIG_DIR2 = (() => {
-  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");
-  return configDir;
-})();
-var CONFIG_PATH2 = path2.join(CONFIG_DIR2, "config.json");
-var FlakinessSession = class _FlakinessSession {
-  constructor(_config) {
-    this._config = _config;
-    this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
-  }
-  static async load() {
-    const data = await fs2.readFile(CONFIG_PATH2, "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_PATH2).catch((e) => void 0);
-  }
-  api;
-  endpoint() {
-    return this._config.endpoint;
-  }
-  path() {
-    return CONFIG_PATH2;
-  }
-  sessionToken() {
-    return this._config.token;
-  }
-  async save() {
-    await fs2.mkdir(CONFIG_DIR2, { recursive: true });
-    await fs2.writeFile(CONFIG_PATH2, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/cli/cmd-download.ts
-async function cmdDownload(runId) {
-  const session = await FlakinessSession.load();
-  if (!session) {
-    console.log(`Please login first`);
-    process.exit(1);
-  }
-  const link = await FlakinessLink.load();
-  if (!link) {
-    console.log(`Please run 'npx flakiness link' to link to the project`);
-    process.exit(1);
-  }
-  const project = await session.api.project.getProject.GET({ projectPublicId: link.projectId() });
+async function cmdDownload(session, project, runId) {
   const urls = await session.api.run.downloadURLs.GET({
     orgSlug: project.org.orgSlug,
     projectSlug: project.projectSlug,
     runId
   });
   const rootDir = `fkrun-${runId}`;
-  if (fs3.existsSync(rootDir)) {
+  if (fs.existsSync(rootDir)) {
     console.log(`Directory ${rootDir} already exists!`);
     return;
   }
-  const attachmentsDir = path3.join(rootDir, "attachments");
-  await fs3.promises.mkdir(rootDir, { recursive: true });
+  const attachmentsDir = path.join(rootDir, "attachments");
+  await fs.promises.mkdir(rootDir, { recursive: true });
   if (urls.attachmentURLs.length)
-    await fs3.promises.mkdir(attachmentsDir, { recursive: true });
+    await fs.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 fs3.promises.writeFile(path3.join(rootDir, "report.json"), reportContent);
+  await fs.promises.writeFile(path.join(rootDir, "report.json"), reportContent);
   const attachmentDownloader = async () => {
     while (urls.attachmentURLs.length) {
       const url = urls.attachmentURLs.pop();
@@ -478,8 +28,8 @@ async function cmdDownload(runId) {
       if (!response2.ok)
         throw new Error(`HTTP error ${response2.status} for attachment URL: ${url}`);
       const fileBuffer = Buffer.from(await response2.arrayBuffer());
-      const filename = path3.basename(new URL(url).pathname);
-      await fs3.promises.writeFile(path3.join(attachmentsDir, filename), fileBuffer);
+      const filename = path.basename(new URL(url).pathname);
+      await fs.promises.writeFile(path.join(attachmentsDir, filename), fileBuffer);
     }
   };
   const workerPromises = [];