flakiness 0.0.0 → 0.147.0

package/lib/cli/cmd-convert.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+// src/cli/cmd-convert.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/junit.ts
+import { ReportUtils as ReportUtils2 } from "@flakiness/sdk";
+import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
+import assert2 from "assert";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+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 path, { posix as posixPath, win32 as win32Path } from "path";
+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);
+    });
+  });
+}
+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);
+  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]`, 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 saveReportAndAttachments(report, attachments, outputFolder) {
+  const reportPath = path.join(outputFolder, "report.json");
+  const attachmentsFolder = path.join(outputFolder, "attachments");
+  await fs.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs.promises.mkdir(outputFolder, { recursive: true });
+  await fs.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  if (attachments.length)
+    await fs.promises.mkdir(attachmentsFolder);
+  const movedAttachments = [];
+  for (const attachment of attachments) {
+    const attachmentPath = path.join(attachmentsFolder, attachment.id);
+    if (attachment.path)
+      await fs.promises.cp(attachment.path, attachmentPath);
+    else if (attachment.body)
+      await fs.promises.writeFile(attachmentPath, attachment.body);
+    movedAttachments.push({
+      contentType: attachment.contentType,
+      id: attachment.id,
+      path: attachmentPath
+    });
+  }
+  return movedAttachments;
+}
+function shell(command, args, options) {
+  try {
+    const result = spawnSync(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+}
+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();
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// src/junit.ts
+function getProperties(element) {
+  const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
+  if (!propertiesNodes.length)
+    return [];
+  const result = [];
+  for (const propertiesNode of propertiesNodes) {
+    const properties = propertiesNode.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "property");
+    for (const property of properties) {
+      const name = property.attributes["name"];
+      const innerText = property.children.find((node) => node instanceof XmlText);
+      const value = property.attributes["value"] ?? innerText?.text ?? "";
+      result.push([name, value]);
+    }
+  }
+  return result;
+}
+function extractErrors(testcase) {
+  const xmlErrors = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === "error" || element.name === "failure");
+  if (!xmlErrors.length)
+    return void 0;
+  const errors = [];
+  for (const xmlErr of xmlErrors) {
+    const message = [xmlErr.attributes["type"], xmlErr.attributes["message"]].filter((x) => !!x).join(" ");
+    const xmlStackNodes = xmlErr.children.filter((child) => child instanceof XmlText);
+    const stack = xmlStackNodes ? xmlStackNodes.map((node) => node.text).join("\n") : void 0;
+    errors.push({
+      message,
+      stack
+    });
+  }
+  return errors;
+}
+function extractStdout(testcase, stdio) {
+  const xmlStdio = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === stdio);
+  if (!xmlStdio.length)
+    return void 0;
+  return xmlStdio.map((node) => node.children.filter((node2) => node2 instanceof XmlText)).flat().map((txtNode) => ({
+    text: txtNode.text
+  }));
+}
+async function parseAttachment(value) {
+  let absolutePath = path2.resolve(process.cwd(), value);
+  if (fs2.existsSync(absolutePath)) {
+    const id = await sha1File(absolutePath);
+    return {
+      contentType: "image/png",
+      path: absolutePath,
+      id
+    };
+  }
+  return {
+    contentType: "text/plain",
+    id: sha1Buffer(value),
+    body: Buffer.from(value)
+  };
+}
+async function traverseJUnitReport(context, node) {
+  const element = node;
+  if (!(element instanceof XmlElement))
+    return;
+  let { currentEnv, currentEnvIndex, currentSuite, report, currentTimeMs, attachments } = context;
+  if (element.attributes["timestamp"])
+    currentTimeMs = new Date(element.attributes["timestamp"]).getTime();
+  if (element.name === "testsuite") {
+    const file = element.attributes["file"];
+    const line = parseInt(element.attributes["line"], 10);
+    const name = element.attributes["name"];
+    const newSuite = {
+      title: name ?? file,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      type: name ? "suite" : file ? "file" : "anonymous suite",
+      suites: [],
+      tests: []
+    };
+    if (currentSuite) {
+      currentSuite.suites ??= [];
+      currentSuite.suites.push(newSuite);
+    } else {
+      report.suites.push(newSuite);
+    }
+    currentSuite = newSuite;
+    const userSuppliedData = getProperties(element);
+    if (userSuppliedData.length) {
+      currentEnv = structuredClone(currentEnv);
+      currentEnv.userSuppliedData ??= {};
+      for (const [key, value] of userSuppliedData)
+        currentEnv.userSuppliedData[key] = value;
+      currentEnvIndex = report.environments.push(currentEnv) - 1;
+    }
+  } else if (element.name === "testcase") {
+    assert2(currentSuite);
+    const file = element.attributes["file"];
+    const name = element.attributes["name"];
+    const line = parseInt(element.attributes["line"], 10);
+    const timeMs = parseFloat(element.attributes["time"]) * 1e3;
+    const startTimestamp = currentTimeMs;
+    const duration = timeMs;
+    currentTimeMs += timeMs;
+    const annotations = [];
+    const attachments2 = [];
+    for (const [key, value] of getProperties(element)) {
+      if (key.toLowerCase().startsWith("attachment")) {
+        if (context.ignoreAttachments)
+          continue;
+        const attachment = await parseAttachment(value);
+        context.attachments.set(attachment.id, attachment);
+        attachments2.push({
+          id: attachment.id,
+          contentType: attachment.contentType,
+          //TODO: better default names for attachments?
+          name: attachment.path ? path2.basename(attachment.path) : `attachment`
+        });
+      } else {
+        annotations.push({
+          type: key,
+          description: value.length ? value : void 0
+        });
+      }
+    }
+    const childElements = element.children.filter((child) => child instanceof XmlElement);
+    const xmlSkippedAnnotation = childElements.find((child) => child.name === "skipped");
+    if (xmlSkippedAnnotation)
+      annotations.push({ type: "skipped", description: xmlSkippedAnnotation.attributes["message"] });
+    const expectedStatus = xmlSkippedAnnotation ? "skipped" : "passed";
+    const errors = extractErrors(element);
+    const test = {
+      title: name,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      attempts: [{
+        environmentIdx: currentEnvIndex,
+        expectedStatus,
+        annotations,
+        attachments: attachments2,
+        startTimestamp,
+        duration,
+        status: xmlSkippedAnnotation ? "skipped" : errors ? "failed" : "passed",
+        errors,
+        stdout: extractStdout(element, "system-out"),
+        stderr: extractStdout(element, "system-err")
+      }]
+    };
+    currentSuite.tests ??= [];
+    currentSuite.tests.push(test);
+  }
+  context = { ...context, currentEnv, currentEnvIndex, currentSuite, currentTimeMs };
+  for (const child of element.children)
+    await traverseJUnitReport(context, child);
+}
+async function parseJUnit(xmls, options) {
+  const report = {
+    category: "junit",
+    commitId: options.commitId,
+    duration: options.runDuration,
+    startTimestamp: options.runStartTimestamp,
+    url: options.runUrl,
+    environments: [options.defaultEnv],
+    suites: [],
+    unattributedErrors: []
+  };
+  const context = {
+    currentEnv: options.defaultEnv,
+    currentEnvIndex: 0,
+    currentTimeMs: 0,
+    report,
+    currentSuite: void 0,
+    attachments: /* @__PURE__ */ new Map(),
+    ignoreAttachments: !!options.ignoreAttachments
+  };
+  for (const xml of xmls) {
+    const doc = parseXml(xml);
+    for (const element of doc.children)
+      await traverseJUnitReport(context, element);
+  }
+  return {
+    report: ReportUtils2.normalizeReport(report),
+    attachments: Array.from(context.attachments.values())
+  };
+}
+
+// src/cli/cmd-convert.ts
+async function cmdConvert(junitPath, options) {
+  const fullPath = path3.resolve(junitPath);
+  if (!await fs3.access(fullPath, fs3.constants.F_OK).then(() => true).catch(() => false)) {
+    console.error(`Error: path ${fullPath} is not accessible`);
+    process.exit(1);
+  }
+  const stat = await fs3.stat(fullPath);
+  let xmlContents = [];
+  if (stat.isFile()) {
+    const xmlContent = await fs3.readFile(fullPath, "utf-8");
+    xmlContents.push(xmlContent);
+  } else if (stat.isDirectory()) {
+    const xmlFiles = await findXmlFiles(fullPath);
+    if (xmlFiles.length === 0) {
+      console.error(`Error: No XML files found in directory ${fullPath}`);
+      process.exit(1);
+    }
+    console.log(`Found ${xmlFiles.length} XML files`);
+    for (const xmlFile of xmlFiles) {
+      const xmlContent = await fs3.readFile(xmlFile, "utf-8");
+      xmlContents.push(xmlContent);
+    }
+  } else {
+    console.error(`Error: ${fullPath} is neither a file nor a directory`);
+    process.exit(1);
+  }
+  let commitId;
+  if (options.commitId) {
+    commitId = options.commitId;
+  } else {
+    try {
+      commitId = gitCommitInfo(process.cwd());
+    } catch (e) {
+      console.error("Failed to get git commit info. Please provide --commit-id option.");
+      process.exit(1);
+    }
+  }
+  const { report, attachments } = await parseJUnit(xmlContents, {
+    commitId,
+    defaultEnv: { name: options.envName },
+    runStartTimestamp: Date.now(),
+    runDuration: 0
+  });
+  await saveReportAndAttachments(report, attachments, options.outputDir);
+  console.log(`\u2713 Saved to ${options.outputDir}`);
+}
+async function findXmlFiles(dir, result = []) {
+  const entries = await fs3.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".xml"))
+      result.push(fullPath);
+    else if (entry.isDirectory())
+      await findXmlFiles(fullPath, result);
+  }
+  return result;
+}
+export {
+  cmdConvert
+};
+//# sourceMappingURL=cmd-convert.js.map

package/lib/cli/cmd-download.js

@@ -0,0 +1,42 @@
+// src/cli/cmd-download.ts
+import fs from "fs";
+import path from "path";
+async function cmdDownload(session, project, runId, rootDir) {
+  if (fs.existsSync(rootDir)) {
+    console.log(`Directory ${rootDir} already exists!`);
+    return;
+  }
+  const urls = await session.api.run.downloadURLs.GET({
+    orgSlug: project.org.orgSlug,
+    projectSlug: project.projectSlug,
+    runId
+  });
+  const attachmentsDir = path.join(rootDir, "attachments");
+  await fs.promises.mkdir(rootDir, { recursive: true });
+  if (urls.attachmentURLs.length)
+    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 fs.promises.writeFile(path.join(rootDir, "report.json"), reportContent);
+  const attachmentDownloader = async () => {
+    while (urls.attachmentURLs.length) {
+      const url = urls.attachmentURLs.pop();
+      const response2 = await fetch(url);
+      if (!response2.ok)
+        throw new Error(`HTTP error ${response2.status} for attachment URL: ${url}`);
+      const fileBuffer = Buffer.from(await response2.arrayBuffer());
+      const filename = path.basename(new URL(url).pathname);
+      await fs.promises.writeFile(path.join(attachmentsDir, filename), fileBuffer);
+    }
+  };
+  const workerPromises = [];
+  for (let i = 0; i < 4; ++i)
+    workerPromises.push(attachmentDownloader());
+  await Promise.all(workerPromises);
+}
+export {
+  cmdDownload
+};
+//# sourceMappingURL=cmd-download.js.map

package/lib/cli/cmd-link.js

@@ -0,0 +1,21 @@
+// src/cli/cmd-link.ts
+import { FlakinessProjectConfig } from "@flakiness/sdk";
+async function cmdLink(session, slug) {
+  const [orgSlug, projectSlug] = slug.split("/");
+  const project = await session.api.project.findProject.GET({
+    orgSlug,
+    projectSlug
+  });
+  if (!project) {
+    console.log(`Failed to find project ${slug}`);
+    process.exit(1);
+  }
+  const config = FlakinessProjectConfig.createEmpty();
+  config.setProjectPublicId(project.projectPublicId);
+  await config.save();
+  console.log(`\u2713 Linked to ${session.endpoint()}/${project.org.orgSlug}/${project.projectSlug}`);
+}
+export {
+  cmdLink
+};
+//# sourceMappingURL=cmd-link.js.map

package/lib/cli/cmd-login.js

@@ -0,0 +1,223 @@
+// ../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/flakinessSession.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/sdk";
+import http from "http";
+import https from "https";
+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");
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+
+// 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_DIR = (() => {
+  const configDir = process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "flakiness") : path.join(os.homedir(), ".config", "flakiness");
+  return configDir;
+})();
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var FlakinessSession = class _FlakinessSession {
+  constructor(_config) {
+    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)
+      return void 0;
+    const json = JSON.parse(data);
+    return new _FlakinessSession(json);
+  }
+  static async remove() {
+    await fs.unlink(CONFIG_PATH).catch((e) => void 0);
+  }
+  api;
+  endpoint() {
+    return this._config.endpoint;
+  }
+  path() {
+    return CONFIG_PATH;
+  }
+  sessionToken() {
+    return this._config.token;
+  }
+  async save() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+  }
+};
+
+// src/cli/cmd-logout.ts
+async function cmdLogout() {
+  const session = await FlakinessSession.load();
+  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 }).catch((e) => void 0);
+  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;
+}
+export {
+  DEFAULT_FLAKINESS_ENDPOINT,
+  cmdLogin
+};
+//# sourceMappingURL=cmd-login.js.map