@flakiness/sdk 0.95.0 → 0.97.0

package/lib/flakinessSession.js

@@ -3,247 +3,26 @@ import fs from "fs/promises";
 import os from "os";
 import path 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(path2, input, options) {
-      const method = path2.at(-1);
-      const url = new URL(path2.slice(0, path2.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(path2 = []) {
-      return new Proxy(() => {
-      }, {
-        get(target, prop) {
-          if (typeof prop === "symbol")
-            return void 0;
-          if (prop === "prepare")
-            return (input, options) => buildUrl(path2, input, options);
-          const newPath = [...path2, prop];
-          return createProxy(newPath);
-        },
-        apply(target, thisArg, args) {
-          const options = buildUrl(path2, 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
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
 
 // src/utils.ts
+import { FlakinessReport } from "@flakiness/report";
 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;
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
 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);
+        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));
@@ -261,6 +40,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));
@@ -342,6 +122,12 @@ var FlakinessSession = class _FlakinessSession {
     this._config = _config;
     this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
   }
+  static async loadOrDie() {
+    const session = await _FlakinessSession.load();
+    if (!session)
+      throw new Error(`Please login first with 'npx flakiness login'`);
+    return session;
+  }
   static async load() {
     const data = await fs.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
     if (!data)

package/lib/junit.js

@@ -6,17 +6,11 @@ import fs2 from "fs";
 import path from "path";
 
 // src/utils.ts
+import { FlakinessReport } from "@flakiness/report";
 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");
@@ -32,6 +26,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);
@@ -43,9 +41,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));
@@ -63,6 +61,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/localGit.js

@@ -0,0 +1,43 @@
+// src/localGit.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function listLocalCommits(gitRoot, head, count) {
+  const FIELD_SEPARATOR = "|~|";
+  const RECORD_SEPARATOR = "\0";
+  const prettyFormat = [
+    "%H",
+    // %H:  Full commit hash
+    "%at",
+    // %at: Author date as a Unix timestamp (seconds since epoch)
+    "%an",
+    // %an: Author name
+    "%s"
+    // %s:  Subject (the first line of the commit message)
+  ].join(FIELD_SEPARATOR);
+  const command = `git log ${head} -n ${count} --pretty=format:"${prettyFormat}" -z`;
+  try {
+    const { stdout } = await execAsync(command, { cwd: gitRoot });
+    if (!stdout) {
+      return [];
+    }
+    return stdout.trim().split(RECORD_SEPARATOR).filter((record) => record).map((record) => {
+      const [commitId, timestampStr, author, message] = record.split(FIELD_SEPARATOR);
+      return {
+        commitId,
+        timestamp: parseInt(timestampStr, 10) * 1e3,
+        // Convert timestamp from seconds to milliseconds
+        author,
+        message,
+        walkIndex: 0
+      };
+    });
+  } catch (error) {
+    console.error(`Failed to list commits for repository at ${gitRoot}:`, error);
+    throw error;
+  }
+}
+export {
+  listLocalCommits
+};
+//# sourceMappingURL=localGit.js.map

package/lib/localReportApi.js

@@ -0,0 +1,40 @@
+// src/localReportApi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+import fs from "fs";
+import { z } from "zod/v4";
+var t = TypedHTTP.Router.create();
+var localReportRouter = {
+  ping: t.get({
+    handler: async () => {
+      return "pong";
+    }
+  }),
+  lastCommits: t.get({
+    handler: async ({ ctx }) => {
+      return ctx.commits;
+    }
+  }),
+  report: {
+    attachment: t.rawMethod("GET", {
+      input: z.object({
+        attachmentId: z.string().min(1).max(100).transform((id) => id)
+      }),
+      handler: async ({ ctx, input }) => {
+        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        if (!idx)
+          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
+        const buffer = await fs.promises.readFile(idx.path);
+        return TypedHTTP.ok(buffer, idx.contentType);
+      }
+    }),
+    json: t.get({
+      handler: async ({ ctx }) => {
+        return ctx.report;
+      }
+    })
+  }
+};
+export {
+  localReportRouter
+};
+//# sourceMappingURL=localReportApi.js.map