@flakiness/sdk 0.129.4 → 0.131.0

package/lib/cli/cmd-link.js

@@ -249,13 +249,88 @@ var FlakinessSession = class _FlakinessSession {
   }
 };
 
-// src/cli/cmd-link.ts
-async function cmdLink(slug) {
+// ../server/lib/common/knownClientIds.js
+var KNOWN_CLIENT_IDS = {
+  OFFICIAL_WEB: "flakiness-io-official-cli",
+  OFFICIAL_CLI: "flakiness-io-official-website"
+};
+
+// src/cli/cmd-login.ts
+import open from "open";
+import os2 from "os";
+
+// src/cli/cmd-logout.ts
+async function cmdLogout() {
   const session = await FlakinessSession.load();
-  if (!session) {
-    console.log(`Please login first`);
+  if (!session)
+    return;
+  const currentSession = await session.api.user.currentSession.GET().catch((e) => void 0);
+  if (currentSession)
+    await session.api.user.logoutSession.POST({ sessionId: currentSession.sessionPublicId });
+  await FlakinessSession.remove();
+}
+
+// src/cli/cmd-login.ts
+var DEFAULT_FLAKINESS_ENDPOINT = "https://flakiness.io";
+async function cmdLogin(endpoint = DEFAULT_FLAKINESS_ENDPOINT) {
+  await cmdLogout();
+  const api = createServerAPI(endpoint);
+  const data = await api.deviceauth.createRequest.POST({
+    clientId: KNOWN_CLIENT_IDS.OFFICIAL_CLI,
+    name: os2.hostname()
+  });
+  await open(new URL(data.verificationUrl, endpoint).href);
+  console.log(`Please navigate to ${new URL(data.verificationUrl, endpoint)}`);
+  let token;
+  while (Date.now() < data.deadline) {
+    await new Promise((x) => setTimeout(x, 2e3));
+    const result = await api.deviceauth.getToken.GET({ deviceCode: data.deviceCode }).catch((e) => void 0);
+    if (!result) {
+      console.error(`Authorization request was rejected.`);
+      process.exit(1);
+    }
+    token = result.token;
+    if (token)
+      break;
+  }
+  if (!token) {
+    console.log(`Failed to login.`);
     process.exit(1);
   }
+  const session = new FlakinessSession({
+    endpoint,
+    token
+  });
+  try {
+    const user = await session.api.user.whoami.GET();
+    await session.save();
+    console.log(`\u2713 Logged in as ${user.userName} (${user.userLogin})`);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`x Failed to login:`, message);
+  }
+  return session;
+}
+
+// src/cli/cmd-link.ts
+async function cmdLink(slugOrUrl) {
+  let slug = slugOrUrl;
+  let endpoint = DEFAULT_FLAKINESS_ENDPOINT;
+  if (slugOrUrl.startsWith("http://") || slugOrUrl.startsWith("https://")) {
+    const url = URL.parse(slugOrUrl);
+    if (!url) {
+      console.error(`Invalid URL: ${slugOrUrl}`);
+      process.exit(1);
+    }
+    slug = url.pathname.substring(1);
+    endpoint = url.origin;
+  } else if (slugOrUrl.startsWith("flakiness.io/")) {
+    endpoint = "https://flakiness.io";
+    slug = slugOrUrl.substring("flakiness.io/".length);
+  }
+  let session = await FlakinessSession.load();
+  if (!session || session.endpoint() !== endpoint)
+    session = await cmdLogin(endpoint);
   const [orgSlug, projectSlug] = slug.split("/");
   const project = await session.api.project.findProject.GET({
     orgSlug,

package/lib/cli/cmd-login.js

@@ -176,7 +176,8 @@ async function cmdLogout() {
 }
 
 // src/cli/cmd-login.ts
-async function cmdLogin(endpoint) {
+var DEFAULT_FLAKINESS_ENDPOINT = "https://flakiness.io";
+async function cmdLogin(endpoint = DEFAULT_FLAKINESS_ENDPOINT) {
   await cmdLogout();
   const api = createServerAPI(endpoint);
   const data = await api.deviceauth.createRequest.POST({
@@ -190,8 +191,8 @@ async function cmdLogin(endpoint) {
     await new Promise((x) => setTimeout(x, 2e3));
     const result = await api.deviceauth.getToken.GET({ deviceCode: data.deviceCode }).catch((e) => void 0);
     if (!result) {
-      console.log(`Authorization request was rejected.`);
-      return;
+      console.error(`Authorization request was rejected.`);
+      process.exit(1);
     }
     token = result.token;
     if (token)
@@ -213,8 +214,10 @@ async function cmdLogin(endpoint) {
     const message = e instanceof Error ? e.message : String(e);
     console.error(`x Failed to login:`, message);
   }
+  return session;
 }
 export {
+  DEFAULT_FLAKINESS_ENDPOINT,
   cmdLogin
 };
 //# sourceMappingURL=cmd-login.js.map

package/lib/cli/cmd-show-report.js

@@ -1,7 +1,7 @@
 // src/cli/cmd-show-report.ts
 import chalk from "chalk";
 import open from "open";
-import path4 from "path";
+import path5 from "path";
 
 // src/flakinessConfig.ts
 import fs2 from "fs";
@@ -298,9 +298,14 @@ import compression from "compression";
 import debug from "debug";
 import express from "express";
 import "express-async-errors";
-import fs5 from "fs";
 import http2 from "http";
 
+// src/localReportApi.ts
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
+import fs4 from "fs";
+import path4 from "path";
+import { z } from "zod/v4";
+
 // src/localGit.ts
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -342,9 +347,37 @@ async function listLocalCommits(gitRoot, head, count) {
 }
 
 // src/localReportApi.ts
-import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
-import fs4 from "fs";
-import { z } from "zod/v4";
+var ReportInfo = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  report;
+  attachmentIdToPath = /* @__PURE__ */ new Map();
+  commits = [];
+  async refresh() {
+    const report = await fs4.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(path4.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;
+  }
+};
 var t = TypedHTTP2.Router.create();
 var localReportRouter = {
   ping: t.get({
@@ -354,7 +387,7 @@ var localReportRouter = {
   }),
   lastCommits: t.get({
     handler: async ({ ctx }) => {
-      return ctx.commits;
+      return ctx.reportInfo.commits;
     }
   }),
   report: {
@@ -363,7 +396,7 @@ var localReportRouter = {
         attachmentId: z.string().min(1).max(100).transform((id) => id)
       }),
       handler: async ({ ctx, input }) => {
-        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP2.HttpError.withCode("NOT_FOUND");
         const buffer = await fs4.promises.readFile(idx.path);
@@ -372,7 +405,8 @@ var localReportRouter = {
     }),
     json: t.get({
       handler: async ({ ctx }) => {
-        return ctx.report;
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
       }
     })
   }
@@ -387,17 +421,6 @@ var LocalReportServer = class _LocalReportServer {
     this._authToken = _authToken;
   }
   static async create(options) {
-    const report = JSON.parse(await fs5.promises.readFile(options.reportPath, "utf-8"));
-    const attachmentsDir = 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.`);
-    }
-    const commits = await listLocalCommits(process.cwd(), report.commitId, 100);
     const app = express();
     app.set("etag", false);
     const authToken = randomUUIDBase62();
@@ -420,9 +443,10 @@ var LocalReportServer = class _LocalReportServer {
       });
       next();
     });
+    const reportInfo = new ReportInfo(options);
     app.use("/" + authToken, createTypedHttpExpressMiddleware({
       router: localReportRouter,
-      createRootContext: async ({ req, res, input }) => ({ report, commits, attachmentIdToPath })
+      createRootContext: async ({ req, res, input }) => ({ reportInfo })
     }));
     app.use((err, req, res, next) => {
       if (err instanceof TypedHTTP3.HttpError)
@@ -456,7 +480,7 @@ var LocalReportServer = class _LocalReportServer {
 
 // src/cli/cmd-show-report.ts
 async function cmdShowReport(reportFolder) {
-  const reportPath = path4.join(reportFolder, "report.json");
+  const reportPath = path5.join(reportFolder, "report.json");
   const session = await FlakinessSession.load();
   const config = await FlakinessConfig.load();
   const projectPublicId = config.projectPublicId();

package/lib/junit.js

@@ -1,5 +1,5 @@
 // src/junit.ts
-import { ReportUtils as ReportUtils2, FlakinessReport as FK } from "@flakiness/report";
+import { ReportUtils as ReportUtils2 } from "@flakiness/report";
 import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
 import assert from "assert";
 import fs2 from "fs";
@@ -191,7 +191,7 @@ async function traverseJUnitReport(context, node) {
         file,
         line,
         column: 1
-      } : FK.NO_LOCATION,
+      } : void 0,
       type: name ? "suite" : file ? "file" : "anonymous suite",
       suites: [],
       tests: []
@@ -253,7 +253,7 @@ async function traverseJUnitReport(context, node) {
         file,
         line,
         column: 1
-      } : FK.NO_LOCATION,
+      } : void 0,
       attempts: [{
         environmentIdx: currentEnvIndex,
         expectedStatus,

package/lib/localReportApi.js

@@ -1,7 +1,207 @@
 // src/localReportApi.ts
 import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
-import fs from "fs";
+import fs2 from "fs";
+import path2 from "path";
 import { z } from "zod/v4";
+
+// 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;
+  }
+}
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/report";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import path, { posix as posixPath, win32 as win32Path } from "path";
+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]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      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;
+    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));
+      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");
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.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);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/localReportApi.ts
+var ReportInfo = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  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;
+  }
+};
 var t = TypedHTTP.Router.create();
 var localReportRouter = {
   ping: t.get({
@@ -11,7 +211,7 @@ var localReportRouter = {
   }),
   lastCommits: t.get({
     handler: async ({ ctx }) => {
-      return ctx.commits;
+      return ctx.reportInfo.commits;
     }
   }),
   report: {
@@ -20,21 +220,23 @@ var localReportRouter = {
         attachmentId: z.string().min(1).max(100).transform((id) => id)
       }),
       handler: async ({ ctx, input }) => {
-        const idx = ctx.attachmentIdToPath.get(input.attachmentId);
+        const idx = ctx.reportInfo.attachmentIdToPath.get(input.attachmentId);
         if (!idx)
           throw TypedHTTP.HttpError.withCode("NOT_FOUND");
-        const buffer = await fs.promises.readFile(idx.path);
+        const buffer = await fs2.promises.readFile(idx.path);
         return TypedHTTP.ok(buffer, idx.contentType);
       }
     }),
     json: t.get({
       handler: async ({ ctx }) => {
-        return ctx.report;
+        await ctx.reportInfo.refresh();
+        return ctx.reportInfo.report;
       }
     })
   }
 };
 export {
+  ReportInfo,
   localReportRouter
 };
 //# sourceMappingURL=localReportApi.js.map