@lambdatest/smartui-cli 1.0.3 → 2.0.1

package/dist/index.cjs

@@ -0,0 +1,689 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var which = require('which');
+var listr2 = require('listr2');
+var chalk = require('chalk');
+var path2 = require('path');
+var fastify = require('fastify');
+var fs = require('fs');
+var winston = require('winston');
+var FormData = require('form-data');
+var axios = require('axios');
+var child_process = require('child_process');
+var spawn = require('cross-spawn');
+var playwright = require('playwright');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var which__default = /*#__PURE__*/_interopDefault(which);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fastify__default = /*#__PURE__*/_interopDefault(fastify);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var FormData__default = /*#__PURE__*/_interopDefault(FormData);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var spawn__default = /*#__PURE__*/_interopDefault(spawn);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var server_default = (ctx) => __async(void 0, null, function* () {
+  const server = fastify__default.default({ logger: false, bodyLimit: 1e7 });
+  const opts = {};
+  const SMARTUI_DOM = fs.readFileSync(path2__default.default.resolve(__dirname, "dom-serializer.js"), "utf-8");
+  server.get("/healthcheck", opts, (_, reply) => {
+    reply.code(200).send({ cliVersion: ctx.cliVersion });
+  });
+  server.get("/domserializer", opts, (request, reply) => {
+    reply.code(200).send({ data: { dom: SMARTUI_DOM } });
+  });
+  server.post("/snapshot", opts, (request, reply) => __async(void 0, null, function* () {
+    let { snapshot, testType } = request.body;
+    snapshot.dom = Buffer.from(snapshot.dom).toString("base64");
+    try {
+      yield ctx.client.uploadSnapshot(ctx.build.id, snapshot, testType, ctx.log);
+    } catch (error) {
+      reply.code(500).send({ error: { message: error.message } });
+    }
+    reply.code(200).send({ data: { message: "success" } });
+  }));
+  yield server.listen({ port: 8080 });
+  let { address, port } = server.addresses()[0];
+  process.env.SMARTUI_SERVER_ADDRESS = `http://${address}:${port}`;
+  return server;
+});
+
+// src/lib/env.ts
+var env_default = () => {
+  const {
+    PROJECT_TOKEN = "",
+    SMARTUI_CLIENT_API_URL = "https://api.lambdatest.com/visualui/1.0",
+    SMARTUI_LOG_LEVEL,
+    SMARTUI_DEBUG
+  } = process.env;
+  return {
+    PROJECT_TOKEN,
+    SMARTUI_CLIENT_API_URL,
+    SMARTUI_LOG_LEVEL,
+    SMARTUI_DEBUG
+  };
+};
+
+// src/lib/logger.ts
+var logContext = {};
+function updateLogContext(newContext) {
+  logContext = __spreadValues(__spreadValues({}, logContext), newContext);
+}
+var logLevel = () => {
+  let env = env_default();
+  let debug = env.SMARTUI_DEBUG === "true" ? "debug" : void 0;
+  return debug || env.SMARTUI_LOG_LEVEL || "info";
+};
+var logger = winston.createLogger({
+  level: logLevel(),
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.printf((info) => {
+      let contextString;
+      if (logContext && Object.keys(logContext).length) {
+        contextString = Object.values(logContext).join(" | ");
+      }
+      let message = `[${contextString}:${info.level}] `;
+      message += info.message === "object" ? JSON.stringify(info.message) : info.message;
+      return message;
+    })
+  ),
+  transports: [new winston.transports.File({ filename: "smartui.log" })]
+});
+var logger_default = logger;
+
+// src/tasks/startServer.ts
+var startServer_default = (ctx) => {
+  return {
+    title: `Setting up SmartUI server`,
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      var _a;
+      updateLogContext({ task: "startServer" });
+      try {
+        ctx2.server = yield server_default(ctx2);
+        task.output = chalk__default.default.gray(`listening on port ${(_a = ctx2.server.addresses()[0]) == null ? void 0 : _a.port}`);
+        task.title = "SmartUI started";
+      } catch (error) {
+        if (error.code === "EADDRINUSE") {
+          task.output = chalk__default.default.gray(`port 8080 is already in use`);
+        }
+        throw new Error("SmartUI server setup failed");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+var auth_default = (ctx) => {
+  return {
+    title: `Authenticating with SmartUI`,
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      updateLogContext({ task: "auth" });
+      try {
+        yield ctx2.client.auth(ctx2.log);
+        task.output = chalk__default.default.gray(`using project token '******#${ctx2.env.PROJECT_TOKEN.split("#").pop()}'`);
+        task.title = "Authenticated with SmartUI";
+      } catch (error) {
+        ctx2.log.debug(error.message);
+        throw new Error("Authentication failed");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+var DEFAULT_WEB_STATIC_CONFIG = [
+  {
+    "name": "lambdatest-home-page",
+    "url": "https://www.lambdatest.com",
+    "waitForTimeout": 1e3
+  },
+  {
+    "name": "example-page",
+    "url": "https://example.com/"
+  }
+];
+var DEFAULT_WEB_CONFIG = {
+  web: {
+    browsers: [
+      "chrome",
+      "firefox",
+      "safari",
+      "edge"
+    ],
+    viewports: [
+      [1920, 1080],
+      [1366, 768],
+      [360, 640]
+    ]
+  }
+};
+function createWebConfig(filepath) {
+  filepath = filepath || "smartui-web.json";
+  let filetype = path2__default.default.extname(filepath);
+  if (filetype != ".json") {
+    console.log("Error: Config file must have .json extension");
+    return;
+  }
+  if (fs__default.default.existsSync(filepath)) {
+    console.log(`Error: SmartUI Web Config already exists: ${filepath}`);
+    console.log(`To create a new file, please specify the file name like: 'smartui config:create-web webConfig.json'`);
+    return;
+  }
+  fs__default.default.mkdirSync(path2__default.default.dirname(filepath), { recursive: true });
+  fs__default.default.writeFileSync(filepath, JSON.stringify(DEFAULT_WEB_CONFIG, null, 2) + "\n");
+  console.log(`Created SmartUI Web Config: ${filepath}`);
+}
+function createWebStaticConfig(filepath) {
+  filepath = filepath || "url.json";
+  let filetype = path2__default.default.extname(filepath);
+  if (filetype != ".json") {
+    console.log("Error: Config file must have .json extension");
+    return;
+  }
+  if (fs__default.default.existsSync(filepath)) {
+    console.log(`Error: web-static config already exists: ${filepath}`);
+    console.log(`To create a new file, please specify the file name like: 'smartui config:create-web links.json'`);
+    return;
+  }
+  fs__default.default.mkdirSync(path2__default.default.dirname(filepath), { recursive: true });
+  fs__default.default.writeFileSync(filepath, JSON.stringify(DEFAULT_WEB_STATIC_CONFIG, null, 2) + "\n");
+  console.log(`Created web-static config: ${filepath}`);
+}
+
+// package.json
+var version = "2.0.1";
+function delDir(dir) {
+  if (fs__default.default.existsSync(dir)) {
+    fs__default.default.rmSync(dir, { recursive: true });
+  }
+}
+
+// src/lib/httpClient.ts
+var httpClient = class {
+  constructor({ SMARTUI_CLIENT_API_URL, PROJECT_TOKEN }) {
+    this.axiosInstance = axios__default.default.create({
+      baseURL: SMARTUI_CLIENT_API_URL,
+      headers: { "projectToken": PROJECT_TOKEN }
+    });
+  }
+  request(config, log) {
+    return __async(this, null, function* () {
+      log.debug(`http request: ${JSON.stringify(config)}`);
+      return this.axiosInstance.request(config).then((resp) => {
+        log.debug(`http response: ${JSON.stringify({
+          status: resp.status,
+          headers: resp.headers,
+          body: resp.data
+        })}`);
+        return resp.data;
+      }).catch((error) => {
+        if (error.response) {
+          throw new Error(JSON.stringify(error.response.data));
+        }
+        if (error.request) {
+          throw new Error(error.toJSON().message);
+        }
+        throw new Error(error.message);
+      });
+    });
+  }
+  auth(log) {
+    return this.request({
+      url: "/token/verify",
+      method: "GET"
+    }, log);
+  }
+  createBuild({ branch, commitId, commitAuthor, commitMessage, githubURL }, config, log) {
+    return this.request({
+      url: "/build",
+      method: "POST",
+      data: {
+        git: {
+          branch,
+          commitId,
+          commitAuthor,
+          commitMessage,
+          githubURL
+        },
+        config: {
+          browsers: config.browsers,
+          resolutions: config.viewports
+        }
+      }
+    }, log);
+  }
+  finalizeBuild(buildId, log) {
+    return this.request({
+      url: "/build",
+      method: "DELETE",
+      params: {
+        buildId
+      }
+    }, log);
+  }
+  uploadSnapshot(buildId, snapshot, testType, log) {
+    return this.request({
+      url: `/builds/${buildId}/snapshot`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: {
+        snapshot,
+        test: {
+          type: testType,
+          source: "cli"
+        }
+      }
+    }, log);
+  }
+  uploadScreenshot({ id: buildId, name: buildName, baseline }, ssPath, ssName, browserName, viewport, completed) {
+    const file = fs__default.default.readFileSync(ssPath);
+    const form = new FormData__default.default();
+    form.append("screenshots", file, { filename: `${ssName}.png`, contentType: "image/png" });
+    form.append("browser", browserName);
+    form.append("resolution", viewport);
+    form.append("buildId", buildId);
+    form.append("buildName", buildName);
+    form.append("screenshotName", ssName);
+    form.append("baseline", baseline.toString());
+    form.append("completed", completed.toString());
+    return this.axiosInstance.request({
+      url: `/screenshot`,
+      method: "POST",
+      headers: form.getHeaders(),
+      data: form
+    }).then(() => {
+      if (completed)
+        delDir("screenshots");
+    }).catch((error) => {
+      if (error.response) {
+        throw new Error(JSON.stringify(error.response.data));
+      }
+      if (error.request) {
+        throw new Error(error.toJSON().message);
+      }
+      throw new Error(error.message);
+    });
+  }
+};
+var ctx_default = (options) => {
+  let env = env_default();
+  let viewports = [];
+  let webConfig = DEFAULT_WEB_CONFIG;
+  try {
+    if (options.config) {
+      webConfig = JSON.parse(fs__default.default.readFileSync(options.config, "utf-8"));
+    }
+    for (let viewport of webConfig.web.viewports) {
+      viewports.push({ width: viewport[0], height: viewport[1] });
+    }
+  } catch (error) {
+    throw new Error(error.message);
+  }
+  return {
+    env,
+    log: logger_default,
+    client: new httpClient(env),
+    config: {
+      browsers: webConfig.web.browsers,
+      viewports
+    },
+    staticConfig: [],
+    git: {
+      branch: "",
+      commitId: "",
+      commitAuthor: "",
+      commitMessage: "",
+      githubURL: ""
+    },
+    build: {
+      id: "",
+      name: "",
+      baseline: false,
+      url: "",
+      projectId: ""
+    },
+    args: {},
+    cliVersion: version
+  };
+};
+function executeCommand(command3) {
+  let dst = process.cwd();
+  try {
+    return child_process.execSync(command3, {
+      cwd: dst,
+      stdio: ["ignore"],
+      encoding: "utf-8"
+    });
+  } catch (error) {
+    throw new Error(error.message);
+  }
+}
+function isGitRepo() {
+  try {
+    executeCommand("git status");
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+var git_default = () => {
+  const splitCharacter = "<##>";
+  const prettyFormat = ["%h", "%H", "%s", "%f", "%b", "%at", "%ct", "%an", "%ae", "%cn", "%ce", "%N", ""];
+  const command3 = 'git log -1 --pretty=format:"' + prettyFormat.join(splitCharacter) + '" && git rev-parse --abbrev-ref HEAD && git tag --contains HEAD';
+  let res = executeCommand(command3).split(splitCharacter);
+  var branchAndTags = res[res.length - 1].split("\n").filter((n) => n);
+  var branch = branchAndTags[0];
+  branchAndTags.slice(1);
+  return {
+    branch,
+    commitId: res[0] || "",
+    commitMessage: res[2] || "",
+    commitAuthor: res[7] || ""
+  };
+};
+var getGitInfo_default = (ctx) => {
+  return {
+    title: `Fetching git repo details`,
+    skip: (ctx2) => {
+      return !isGitRepo() ? "[SKIPPED] Fetching git repo details; not a git repo" : "";
+    },
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      try {
+        ctx2.git = git_default();
+        task.output = chalk__default.default.gray(`branch: ${ctx2.git.branch}, commit: ${ctx2.git.commitId}, author: ${ctx2.git.commitAuthor}`);
+        task.title = "Fetched git information";
+      } catch (error) {
+        task.output = chalk__default.default.gray(`${error.message}`);
+        throw new Error("Error fetching git repo details");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+var createBuild_default = (ctx) => {
+  return {
+    title: `Creating SmartUI build`,
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      updateLogContext({ task: "createBuild" });
+      try {
+        let resp = yield ctx2.client.createBuild(ctx2.git, ctx2.config, ctx2.log);
+        ctx2.build = {
+          id: resp.data.buildId,
+          name: resp.data.buildName,
+          url: resp.buildURL,
+          baseline: resp.data.baseline || false,
+          projectId: resp.data.projectId
+        };
+        task.output = chalk__default.default.gray(`build id: ${resp.data.buildId}`);
+        task.title = "SmartUI build created";
+      } catch (error) {
+        task.output = chalk__default.default.gray(JSON.parse(error.message).message);
+        throw new Error("SmartUI build creation failed");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+var exec_default = (ctx) => {
+  var _a;
+  return {
+    title: `Executing '${(_a = ctx.args.execCommand) == null ? void 0 : _a.join(" ")}'`,
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      updateLogContext({ task: "exec" });
+      return new Promise((resolve, reject) => {
+        var _a2, _b, _c;
+        const childProcess = spawn__default.default(ctx2.args.execCommand[0], (_a2 = ctx2.args.execCommand) == null ? void 0 : _a2.slice(1));
+        let totalOutput = "";
+        const output = listr2.createWritable((chunk) => {
+          totalOutput += chunk;
+          task.output = chalk__default.default.gray(totalOutput);
+        });
+        (_b = childProcess.stdout) == null ? void 0 : _b.pipe(output);
+        (_c = childProcess.stderr) == null ? void 0 : _c.pipe(output);
+        childProcess.on("error", (error) => {
+          var _a3;
+          task.output = chalk__default.default.gray(`error: ${error.message}`);
+          throw new Error(`Execution of '${(_a3 = ctx2.args.execCommand) == null ? void 0 : _a3.join(" ")}' failed`);
+        });
+        childProcess.on("close", (code, signal) => __async(void 0, null, function* () {
+          var _a3;
+          if (code !== null) {
+            task.title = `Execution of '${(_a3 = ctx2.args.execCommand) == null ? void 0 : _a3.join(" ")}' completed; exited with code ${code}`;
+          } else if (signal !== null) {
+            throw new Error(`Child process killed with signal ${signal}`);
+          }
+          resolve();
+        }));
+      });
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+var finalizeBuild_default = (ctx, waitTime) => {
+  return {
+    title: `Finalizing build`,
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      try {
+        if (waitTime > 0) {
+          yield new Promise((resolve) => setTimeout(resolve, waitTime));
+          yield ctx2.client.finalizeBuild(ctx2.build.id, ctx2.log);
+        }
+        task.output = chalk__default.default.gray(`build url: ${ctx2.build.url}`);
+        task.title = "Finalized build";
+      } catch (error) {
+        throw new Error("Finalize build error");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+
+// src/commander/exec.ts
+var command = new commander.Command();
+command.name("exec").description("Run test commands around SmartUI").argument("<command...>", "Command supplied for running tests").action(function(execCommand, _, command3) {
+  return __async(this, null, function* () {
+    var _a;
+    let ctx = ctx_default(command3.optsWithGlobals());
+    if (!which__default.default.sync(execCommand[0], { nothrow: true })) {
+      console.log(`Error: Command not found "${execCommand[0]}"`);
+      return;
+    }
+    ctx.args.execCommand = execCommand;
+    let tasks = new listr2.Listr(
+      [
+        auth_default(),
+        startServer_default(),
+        getGitInfo_default(),
+        createBuild_default(),
+        exec_default(ctx),
+        finalizeBuild_default(ctx, 3e4)
+      ],
+      {
+        rendererOptions: {
+          icon: {
+            [listr2.ListrDefaultRendererLogLevels.OUTPUT]: `\u2192`
+          },
+          color: {
+            [listr2.ListrDefaultRendererLogLevels.OUTPUT]: listr2.color.gray
+          }
+        }
+      }
+    );
+    try {
+      yield tasks.run(ctx);
+    } catch (error) {
+      console.log("\nRefer docs: https://www.lambdatest.com/support/docs/smart-visual-regression-testing/");
+    } finally {
+      yield (_a = ctx.server) == null ? void 0 : _a.close();
+    }
+  });
+});
+var exec_default2 = command;
+var configWeb = new commander.Command();
+var configStatic = new commander.Command();
+configWeb.name("config:create-web").description("Create SmartUI Web config file").argument("[filepath]", "Optional config filepath").action(function(filepath, options) {
+  return __async(this, null, function* () {
+    createWebConfig(filepath);
+  });
+});
+configStatic.name("config:web-static").description("Create Web Static config file").argument("[filepath]", "Optional config filepath").action(function(filepath, options) {
+  return __async(this, null, function* () {
+    createWebStaticConfig(filepath);
+  });
+});
+var BROWSER_CHROME = "chrome";
+var BROWSER_SAFARI = "safari";
+var BROWSER_FIREFOX = "firefox";
+var BROWSER_EDGE = "edge";
+var EDGE_CHANNEL = "msedge";
+function captureScreenshots(ctx, screenshots) {
+  return __async(this, null, function* () {
+    var _a;
+    delDir("screenshots");
+    let totalBrowsers = ctx.config.browsers.length;
+    let totalViewports = ctx.config.viewports.length;
+    let totalScreenshots = screenshots.length;
+    for (let i = 0; i < totalBrowsers; i++) {
+      let browserName = (_a = ctx.config.browsers[i]) == null ? void 0 : _a.toLowerCase();
+      let browser;
+      let launchOptions = { headless: true };
+      switch (browserName) {
+        case BROWSER_CHROME:
+          browser = yield playwright.chromium.launch(launchOptions);
+          break;
+        case BROWSER_SAFARI:
+          browser = yield playwright.webkit.launch(launchOptions);
+          break;
+        case BROWSER_FIREFOX:
+          browser = yield playwright.firefox.launch(launchOptions);
+          break;
+        case BROWSER_EDGE:
+          launchOptions.channel = EDGE_CHANNEL;
+          browser = yield playwright.chromium.launch(launchOptions);
+          break;
+      }
+      const context = yield browser.newContext();
+      for (let j = 0; j < totalScreenshots; j++) {
+        let screenshot = screenshots[j];
+        let screenshotId = screenshot.name.toLowerCase().replace(/\s/g, "-");
+        const page = yield context.newPage();
+        yield page.goto(screenshot.url);
+        yield page.waitForTimeout(screenshot.waitForTimeout || 0);
+        for (let k = 0; k < totalViewports; k++) {
+          let { width, height } = ctx.config.viewports[k];
+          let ssName = `${browserName}-${width}x${height}-${screenshotId}.png`;
+          let ssPath = `screenshots/${screenshotId}/${ssName}.png`;
+          yield page.setViewportSize({ width, height });
+          yield page.screenshot({ path: ssPath, fullPage: true });
+          let completed = i == totalBrowsers - 1 && j == totalScreenshots - 1 && k == totalViewports - 1 ? true : false;
+          ctx.client.uploadScreenshot(ctx.build, ssPath, screenshot.name, browserName, `${width}x${height}`, completed);
+        }
+        yield page.close();
+      }
+      yield browser.close();
+    }
+    return totalBrowsers * totalViewports * totalScreenshots;
+  });
+}
+var captureScreenshots_default = (ctx) => {
+  return {
+    title: "Capturing screenshots",
+    task: (ctx2, task) => __async(void 0, null, function* () {
+      try {
+        let { staticConfig: screenshots } = ctx2;
+        let totalScreenshots = yield captureScreenshots(ctx2, screenshots);
+        task.title = "Screenshots captured successfully";
+        task.output = chalk__default.default.gray(`total screenshots: ${totalScreenshots}`);
+      } catch (error) {
+        console.error(error);
+        throw new Error("Capturing screenshots failed");
+      }
+    }),
+    rendererOptions: { persistentOutput: true }
+  };
+};
+
+// src/commander/capture.ts
+var command2 = new commander.Command();
+command2.name("capture").description("Capture screenshots of static sites").argument("<file>", "Web static config file").action(function(file, _, command3) {
+  return __async(this, null, function* () {
+    let ctx = ctx_default(command3.optsWithGlobals());
+    let tasks = new listr2.Listr(
+      [
+        auth_default(),
+        getGitInfo_default(),
+        createBuild_default(),
+        captureScreenshots_default(),
+        finalizeBuild_default(ctx, 0)
+      ],
+      {
+        rendererOptions: {
+          icon: {
+            [listr2.ListrDefaultRendererLogLevels.OUTPUT]: `\u2192`
+          },
+          color: {
+            [listr2.ListrDefaultRendererLogLevels.OUTPUT]: listr2.color.gray
+          }
+        }
+      }
+    );
+    try {
+      if (!fs__default.default.existsSync(file)) {
+        console.log(`Error: Config file ${file} not found.`);
+        return;
+      }
+      ctx.staticConfig = JSON.parse(fs__default.default.readFileSync(file, "utf8"));
+      yield tasks.run(ctx);
+    } catch (error) {
+      console.log("\nRefer docs: https://www.lambdatest.com/support/docs/smart-visual-regression-testing/");
+    }
+  });
+});
+var capture_default = command2;
+
+// src/commander/commander.ts
+var program = new commander.Command();
+program.name("smartui").description("CLI to help you run your SmartUI tests on LambdaTest platform").version(`v${version}`).option("-c --config <filepath>", "Config file path").addCommand(exec_default2).addCommand(capture_default).addCommand(configWeb).addCommand(configStatic);
+var commander_default = program;
+
+// src/index.ts
+commander_default.parse();