@flakiness/sdk 0.147.0 → 0.148.0

package/lib/showReport.js

@@ -1,7 +1,7 @@
 // src/showReport.ts
+import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
 import chalk from "chalk";
 import open from "open";
-import path3 from "path";
 
 // src/flakinessProjectConfig.ts
 import fs from "fs";
@@ -93,8 +93,14 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
   projectPublicId() {
     return this._config.projectPublicId;
   }
-  reportViewerEndpoint() {
-    return this._config.customReportViewerEndpoint ?? "https://report.flakiness.io";
+  reportViewerUrl() {
+    return this._config.customReportViewerUrl ?? "https://report.flakiness.io";
+  }
+  setCustomReportViewerUrl(url) {
+    if (url)
+      this._config.customReportViewerUrl = url;
+    else
+      delete this._config.customReportViewerUrl;
   }
   setProjectPublicId(projectId) {
     this._config.projectPublicId = projectId;
@@ -105,369 +111,163 @@ var FlakinessProjectConfig = class _FlakinessProjectConfig {
   }
 };
 
-// src/localReportServer.ts
-import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
-import { randomUUIDBase62 } from "@flakiness/shared/node/nodeutils.js";
-import { createTypedHttpExpressMiddleware } from "@flakiness/shared/node/typedHttpExpress.js";
-import bodyParser from "body-parser";
-import compression from "compression";
-import debug2 from "debug";
-import express from "express";
-import "express-async-errors";
-import http from "http";
-
-// src/localReportApi.ts
-import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-import fs2 from "fs";
-import path2 from "path";
-import { z } from "zod/v4";
-
-// src/localGit.ts
-import { exec } from "child_process";
+// src/staticServer.ts
 import debug from "debug";
-import { promisify } from "util";
-var log = debug("fk:git");
-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)
-    "%P"
-    // %P:  Parent hashes (space-separated)
-  ].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, parentsStr] = record.split(FIELD_SEPARATOR);
-      const parents = parentsStr ? parentsStr.split(" ").filter((p) => p) : [];
-      return {
-        commitId,
-        timestamp: parseInt(timestampStr, 10) * 1e3,
-        author,
-        message,
-        parents,
-        walkIndex: 0
-      };
-    });
-  } catch (error) {
-    log(`Failed to list commits for repository at ${gitRoot}:`, error);
-    return [];
-  }
-}
-
-// src/reportUtils.ts
-import { Multimap } from "@flakiness/shared/common/multimap.js";
-import { xxHash, xxHashObject } from "@flakiness/shared/common/utils.js";
-var ReportUtils;
-((ReportUtils2) => {
-  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, []);
-  }
-  ReportUtils2.visitTests = visitTests;
-  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 visitTests2(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);
-      }
-      visitTests2(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((t2) => t2.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))
-        };
-      });
-    }
-    visitTests2(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 ?? [])
-    };
+import * as fs2 from "fs";
+import * as http from "http";
+import * as path2 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 = path2.resolve(folderPath);
+    this._cors = cors;
+    this._server = http.createServer((req, res) => this._handleRequest(req, res));
   }
-  ReportUtils2.normalizeReport = normalizeReport;
-  function computeEnvId(env) {
-    return xxHashObject(env);
-  }
-  function computeSuiteId(suite, parentSuiteId) {
-    return xxHash([
-      parentSuiteId ?? "",
-      suite.type,
-      suite.location?.file ?? "",
-      suite.title
-    ]);
-  }
-  function computeTestId(test, suiteId) {
-    return xxHash([
-      suiteId,
-      test.location?.file ?? "",
-      test.title
-    ]);
+  port() {
+    const address = this._server.address();
+    if (!address)
+      return void 0;
+    return address.port;
   }
-})(ReportUtils || (ReportUtils = {}));
-
-// src/localReportApi.ts
-var ReportInfo = class {
-  constructor(_options) {
-    this._options = _options;
+  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}`;
   }
-  report;
-  attachmentIdToPath = /* @__PURE__ */ new Map();
-  commits = [];
-  async refresh() {
-    const report = await fs2.promises.readFile(this._options.reportPath, "utf-8").then((x) => JSON.parse(x)).catch((e) => void 0);
-    if (!report) {
-      this.report = void 0;
-      this.commits = [];
-      this.attachmentIdToPath = /* @__PURE__ */ new Map();
-      return;
-    }
-    if (JSON.stringify(report) === JSON.stringify(this.report))
-      return;
-    this.report = report;
-    this.commits = await listLocalCommits(path2.dirname(this._options.reportPath), report.commitId, 100);
-    const attachmentsDir = this._options.attachmentsFolder;
-    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
-    if (missingAttachments.length) {
-      const first = missingAttachments.slice(0, 3);
-      for (let i = 0; i < 3 && i < missingAttachments.length; ++i)
-        console.warn(`Missing attachment with id ${missingAttachments[i]}`);
-      if (missingAttachments.length > 3)
-        console.warn(`...and ${missingAttachments.length - 3} more missing attachments.`);
-    }
-    this.attachmentIdToPath = attachmentIdToPath;
+  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());
   }
-};
-var t = TypedHTTP.Router.create();
-var localReportRouter = {
-  ping: t.get({
-    handler: async () => {
-      return "pong";
+  async start(port, host = "127.0.0.1") {
+    if (port === 0) {
+      await this._startServer(port, host);
+      return this.address();
     }
-  }),
-  lastCommits: t.get({
-    handler: async ({ ctx }) => {
-      return ctx.reportInfo.commits;
+    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;
     }
-  }),
-  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.reportInfo.attachmentIdToPath.get(input.attachmentId);
-        if (!idx)
-          throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs2.promises.readFile(idx.path);
-        return TypedHTTP.ok(buffer, idx.contentType);
-      }
-    }),
-    json: t.get({
-      handler: async ({ ctx }) => {
-        await ctx.reportInfo.refresh();
-        return ctx.reportInfo.report;
-      }
-    })
+    log("All sequential ports busy. Falling back to random port.");
+    await this._startServer(0, host);
+    return this.address();
   }
-};
-async function resolveAttachmentPaths(report, attachmentsDir) {
-  const attachmentFiles = await listFilesRecursively(attachmentsDir);
-  const filenameToPath = new Map(attachmentFiles.map((file) => [path2.basename(file), file]));
-  const attachmentIdToPath = /* @__PURE__ */ new Map();
-  const missingAttachments = /* @__PURE__ */ new Set();
-  ReportUtils.visitTests(report, (test) => {
-    for (const attempt of test.attempts) {
-      for (const attachment of attempt.attachments ?? []) {
-        const attachmentPath = filenameToPath.get(attachment.id);
-        if (!attachmentPath) {
-          missingAttachments.add(attachment.id);
+  stop() {
+    return new Promise((resolve2, reject) => {
+      this._server.close((err) => {
+        if (err) {
+          log("Error stopping server: %o", err);
+          reject(err);
         } else {
-          attachmentIdToPath.set(attachment.id, {
-            contentType: attachment.contentType,
-            id: attachment.id,
-            path: attachmentPath
-          });
+          log("Server stopped.");
+          resolve2();
         }
-      }
-    }
-  });
-  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
-}
-async function listFilesRecursively(dir, result = []) {
-  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    if (entry.isDirectory())
-      await listFilesRecursively(fullPath, result);
-    else
-      result.push(fullPath);
+      });
+    });
   }
-  return result;
-}
-
-// src/localReportServer.ts
-var logHTTPServer = debug2("fk:http");
-var LocalReportServer = class _LocalReportServer {
-  constructor(_server, _port, _authToken) {
-    this._server = _server;
-    this._port = _port;
-    this._authToken = _authToken;
+  _errorResponse(req, res, code, text) {
+    res.writeHead(code, { "Content-Type": "text/plain" });
+    res.end(text);
+    log(`[${code}] ${req.method} ${req.url}`);
   }
-  static async create(options) {
-    const app = express();
-    app.set("etag", false);
-    const authToken = randomUUIDBase62();
-    app.use(compression());
-    app.use(bodyParser.json({ limit: 256 * 1024 }));
-    app.use((req, res, next) => {
-      if (!req.path.startsWith("/" + authToken))
-        throw TypedHTTP2.HttpError.withCode("UNAUTHORIZED");
+  _handleRequest(req, res) {
+    const { url, method } = req;
+    if (this._cors) {
       res.setHeader("Access-Control-Allow-Headers", "*");
-      res.setHeader("Access-Control-Allow-Origin", options.endpoint);
+      res.setHeader("Access-Control-Allow-Origin", this._cors);
       res.setHeader("Access-Control-Allow-Methods", "*");
       if (req.method === "OPTIONS") {
         res.writeHead(204);
         res.end();
         return;
       }
-      req.on("aborted", () => logHTTPServer(`REQ ABORTED ${req.method} ${req.originalUrl}`));
-      res.on("close", () => {
-        if (!res.headersSent) logHTTPServer(`RES CLOSED BEFORE SEND ${req.method} ${req.originalUrl}`);
-      });
-      next();
-    });
-    const reportInfo = new ReportInfo(options);
-    app.use("/" + authToken, createTypedHttpExpressMiddleware({
-      router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ reportInfo })
-    }));
-    app.use((err, req, res, next) => {
-      if (err instanceof TypedHTTP2.HttpError)
-        return res.status(err.status).send({ error: err.message });
-      logHTTPServer(err);
-      res.status(500).send({ error: "Internal Server Error" });
+    }
+    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}`);
     });
-    const server = http.createServer(app);
-    server.on("error", (err) => {
-      if (err.code === "ECONNRESET") {
-        logHTTPServer("Client connection reset. Ignoring.");
+    if (!url || !url.startsWith(this._pathPrefix)) {
+      this._errorResponse(req, res, 404, "Not Found");
+      return;
+    }
+    const relativePath = url.slice(this._pathPrefix.length);
+    const safeSuffix = path2.normalize(decodeURIComponent(relativePath)).replace(/^(\.\.[\/\\])+/, "");
+    const filePath = path2.join(this._absoluteFolderPath, safeSuffix);
+    if (!filePath.startsWith(this._absoluteFolderPath)) {
+      this._errorResponse(req, res, 403, "Forbidden");
+      return;
+    }
+    fs2.stat(filePath, (err, stats) => {
+      if (err || !stats.isFile()) {
+        this._errorResponse(req, res, 404, "File Not Found");
         return;
       }
-      throw err;
+      const ext = path2.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 = fs2.createReadStream(filePath);
+      readStream.pipe(res);
+      readStream.on("error", (err2) => {
+        log("Stream error: %o", err2);
+        res.end();
+      });
     });
-    const port = await new Promise((resolve) => server.listen(options.port, () => {
-      resolve(server.address().port);
-    }));
-    return new _LocalReportServer(server, port, authToken);
-  }
-  authToken() {
-    return this._authToken;
-  }
-  port() {
-    return this._port;
-  }
-  async dispose() {
-    await new Promise((x) => this._server.close(x));
   }
 };
 
 // src/showReport.ts
 async function showReport(reportFolder) {
-  const reportPath = path3.join(reportFolder, "report.json");
   const config = await FlakinessProjectConfig.load();
   const projectPublicId = config.projectPublicId();
-  const reportViewerEndpoint = config.reportViewerEndpoint();
-  const server = await LocalReportServer.create({
-    endpoint: reportViewerEndpoint,
-    port: 9373,
-    reportPath,
-    attachmentsFolder: reportFolder
-  });
+  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", server.authToken());
+  url.searchParams.set("token", token);
   if (projectPublicId)
     url.searchParams.set("ppid", projectPublicId);
   console.log(chalk.cyan(`

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