@flakiness/sdk 0.145.0 → 0.146.0

package/lib/cli/cmd-convert.js

@@ -1,421 +0,0 @@
-#!/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/report";
-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/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 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.dedupeSuitesTestsEnvironments(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

@@ -1,42 +0,0 @@
-// 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

@@ -1,207 +0,0 @@
-// src/flakinessConfig.ts
-import fs from "fs";
-import path2 from "path";
-
-// src/utils.ts
-import { ReportUtils } from "@flakiness/report";
-import assert from "assert";
-import { spawnSync } from "child_process";
-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");
-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 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/flakinessConfig.ts
-function createConfigPath(dir) {
-  return path2.join(dir, ".flakiness", "config.json");
-}
-var gConfigPath;
-function ensureConfigPath() {
-  if (!gConfigPath)
-    gConfigPath = computeConfigPath();
-  return gConfigPath;
-}
-function computeConfigPath() {
-  for (let p = process.cwd(); p !== path2.resolve(p, ".."); p = path2.resolve(p, "..")) {
-    const configPath = createConfigPath(p);
-    if (fs.existsSync(configPath))
-      return configPath;
-  }
-  try {
-    const gitRoot = computeGitRoot(process.cwd());
-    return createConfigPath(gitRoot);
-  } catch (e) {
-    return createConfigPath(process.cwd());
-  }
-}
-var FlakinessConfig = class _FlakinessConfig {
-  constructor(_configPath, _config) {
-    this._configPath = _configPath;
-    this._config = _config;
-  }
-  static async load() {
-    const configPath = ensureConfigPath();
-    const data = await fs.promises.readFile(configPath, "utf-8").catch((e) => void 0);
-    const json = data ? JSON.parse(data) : {};
-    return new _FlakinessConfig(configPath, json);
-  }
-  static async projectOrDie(session) {
-    const config = await _FlakinessConfig.load();
-    const projectPublicId = config.projectPublicId();
-    if (!projectPublicId)
-      throw new Error(`Please link to flakiness project with 'npx flakiness link'`);
-    const project = await session.api.project.getProject.GET({ projectPublicId }).catch((e) => void 0);
-    if (!project)
-      throw new Error(`Failed to fetch linked project; please re-link with 'npx flakiness link'`);
-    return project;
-  }
-  static createEmpty() {
-    return new _FlakinessConfig(ensureConfigPath(), {});
-  }
-  path() {
-    return this._configPath;
-  }
-  projectPublicId() {
-    return this._config.projectPublicId;
-  }
-  setProjectPublicId(projectId) {
-    this._config.projectPublicId = projectId;
-  }
-  async save() {
-    await fs.promises.mkdir(path2.dirname(this._configPath), { recursive: true });
-    await fs.promises.writeFile(this._configPath, JSON.stringify(this._config, null, 2));
-  }
-};
-
-// src/cli/cmd-link.ts
-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 = FlakinessConfig.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