@lambdatest/smartui-cli 4.1.41 → 4.1.42

package/dist/index.cjs

@@ -112,7 +112,7 @@ var __async = (__this, __arguments, generator) => {
 
 // node_modules/.pnpm/find-free-port@2.0.0/node_modules/find-free-port/index.js
 var require_find_free_port = __commonJS({
-  "node_modules/.pnpm/find-free-port@2.0.0/node_modules/find-free-port/index.js"(exports, module) {
+  "node_modules/.pnpm/find-free-port@2.0.0/node_modules/find-free-port/index.js"(exports$1, module) {
     var net = __require("net");
     function findFreePort(beg, ...rest) {
       const p = rest.slice(0, rest.length - 1), cb = rest[rest.length - 1];
@@ -870,6 +870,14 @@ var ConfigSchema = {
         uniqueItems: "Invalid config; duplicates in requestHeaders"
       }
     },
+    dedicatedProxyURL: {
+      type: "string",
+      errorMessage: "Invalid config; dedicatedProxyURL must be a string"
+    },
+    geolocation: {
+      type: "string",
+      errorMessage: "Invalid config; geolocation must be a string like 'lat,lon'"
+    },
     allowDuplicateSnapshotNames: {
       type: "boolean",
       errorMessage: "Invalid config; allowDuplicateSnapshotNames must be true/false"
@@ -946,6 +954,9 @@ var WebStaticConfigSchema = {
       execute: {
         type: "object",
         properties: {
+          beforeNavigation: {
+            type: "string"
+          },
           afterNavigation: {
             type: "string"
           },
@@ -1878,7 +1889,7 @@ function startPollingForTunnel(ctx, build_id, baseline, projectToken, buildName)
 function stopTunnelHelper(ctx) {
   return __async(this, null, function* () {
     ctx.log.debug("stop-tunnel:: Stopping the tunnel now");
-    const tunnelRunningStatus = yield tunnelInstance.isRunning();
+    const tunnelRunningStatus = yield tunnelInstance == null ? void 0 : tunnelInstance.isRunning();
     ctx.log.debug("stop-tunnel:: Running status of tunnel before stopping ? " + tunnelRunningStatus);
     const status = yield tunnelInstance.stop();
     ctx.log.debug("stop-tunnel:: Tunnel is Stopped ? " + status);
@@ -2573,7 +2584,10 @@ var server_default = (ctx) => __async(void 0, null, function* () {
             lastExternalResponse = externalResponse;
             if (externalResponse.statusCode === 200) {
               replyCode = 200;
-              replyBody = externalResponse.data;
+              replyBody = {
+                data: externalResponse.data,
+                error: externalResponse.error.message
+              };
               return reply.code(replyCode).send(replyBody);
             } else if (externalResponse.statusCode === 202) {
               replyBody = externalResponse.data;
@@ -2585,22 +2599,15 @@ var server_default = (ctx) => __async(void 0, null, function* () {
             } else {
               ctx.log.debug(`Unexpected response from external API: ${JSON.stringify(externalResponse)}`);
               replyCode = 500;
-              replyBody = {
-                error: {
-                  message: `Unexpected response from external API: ${externalResponse.statusCode}`,
-                  externalApiStatus: externalResponse.statusCode
-                }
-              };
-              return reply.code(replyCode).send(replyBody);
+              return reply.code(replyCode).send(externalResponse);
             }
             ctx.log.debug(`timeoutDuration: ${timeoutDuration}`);
             ctx.log.debug(`Time passed: ${Date.now() - startTime}`);
             if (Date.now() - startTime > timeoutDuration) {
               replyCode = 202;
               replyBody = {
-                data: {
-                  message: "Request timed out-> Snapshot still processing"
-                }
+                error: "Request timed out, Snapshot still processing",
+                data: lastExternalResponse.data
               };
               return reply.code(replyCode).send(replyBody);
             }
@@ -2791,7 +2798,7 @@ var authExec_default = (ctx) => {
 };
 
 // package.json
-var version = "4.1.41";
+var version = "4.1.42";
 var package_default = {
   name: "@lambdatest/smartui-cli",
   version,
@@ -2879,10 +2886,15 @@ var httpClient = class {
     }
     const axiosConfig = {
       baseURL: SMARTUI_CLIENT_API_URL,
-      proxy: proxyUrl ? {
+      proxy: proxyUrl ? __spreadValues({
         host: proxyUrl.hostname,
         port: proxyUrl.port ? Number(proxyUrl.port) : 80
-      } : false
+      }, proxyUrl.username && proxyUrl.password ? {
+        auth: {
+          username: proxyUrl.username,
+          password: proxyUrl.password
+        }
+      } : {}) : false
     };
     if (SMARTUI_API_SKIP_CERTIFICATES) {
       axiosConfig.httpsAgent = new https__namespace.default.Agent({
@@ -2987,12 +2999,20 @@ var httpClient = class {
         }
       }, log2);
       if (response && response.projectToken) {
+        let orgId = 0;
+        let userId = 0;
         this.projectToken = response.projectToken;
         env.PROJECT_TOKEN = response.projectToken;
         if (response.message && response.message.includes("Project created successfully")) {
           result = 2;
         }
-        return result;
+        if (response.orgId) {
+          orgId = response.orgId;
+        }
+        if (response.userId) {
+          userId = response.userId;
+        }
+        return { authResult: result, orgId, userId };
       } else {
         throw new Error("Authentication failed, project token not received");
       }
@@ -3483,6 +3503,20 @@ var httpClient = class {
       }
     }, ctx.log);
   }
+  getGeolocationProxy(geoLocation, log2) {
+    return __async(this, null, function* () {
+      try {
+        const resp = yield this.request({
+          url: "/geolocation",
+          method: "GET",
+          params: { geoLocation }
+        }, log2);
+        return resp;
+      } catch (error) {
+        this.handleHttpError(error, log2);
+      }
+    });
+  }
   uploadPdf(ctx, form, buildName) {
     return __async(this, null, function* () {
       form.append("projectToken", this.projectToken);
@@ -3682,6 +3716,8 @@ var ctx_default = (options) => {
       ignoreHTTPSErrors: (_i = config.ignoreHTTPSErrors) != null ? _i : false,
       skipBuildCreation: (_j = config.skipBuildCreation) != null ? _j : false,
       tunnel: tunnelObj,
+      dedicatedProxyURL: config.dedicatedProxyURL || "",
+      geolocation: config.geolocation || "",
       userAgent: config.userAgent || "",
       requestHeaders: config.requestHeaders || {},
       allowDuplicateSnapshotNames,
@@ -5746,7 +5782,7 @@ var auth_default = (ctx) => {
     task: (ctx2, task) => __async(void 0, null, function* () {
       updateLogContext({ task: "auth" });
       try {
-        const authResult = yield ctx2.client.auth(ctx2.log, ctx2.env);
+        const { authResult, orgId, userId } = yield ctx2.client.auth(ctx2.log, ctx2.env);
         if (authResult === 2) {
           task.output = chalk__default.default.gray(`New project '${ctx2.env.PROJECT_NAME}' created successfully`);
         } else if (authResult === 0) {
@@ -5754,6 +5790,8 @@ var auth_default = (ctx) => {
         } else if (authResult === 1) {
           task.output = chalk__default.default.gray(`Using existing project '${ctx2.env.PROJECT_NAME}'`);
         }
+        ctx2.orgId = orgId;
+        ctx2.userId = userId;
         task.title = "Authenticated with SmartUI";
       } catch (error) {
         ctx2.log.debug(error);
@@ -5803,6 +5841,7 @@ function captureScreenshotsForConfig(ctx, browsers, urlConfig, browserName, rend
   return __async(this, null, function* () {
     ctx.log.debug(`*** urlConfig  ${JSON.stringify(urlConfig)}`);
     let { name, url, waitForTimeout, execute, pageEvent, userAgent } = urlConfig;
+    let beforeNavigationScript = execute == null ? void 0 : execute.beforeNavigation;
     let afterNavigationScript = execute == null ? void 0 : execute.afterNavigation;
     let beforeSnapshotScript = execute == null ? void 0 : execute.beforeSnapshot;
     let waitUntilEvent = pageEvent || process.env.SMARTUI_PAGE_WAIT_UNTIL_EVENT || "load";
@@ -5813,6 +5852,69 @@ function captureScreenshotsForConfig(ctx, browsers, urlConfig, browserName, rend
     let contextOptions = {
       ignoreHTTPSErrors: ctx.config.ignoreHTTPSErrors
     };
+    try {
+      if (ctx.config.tunnel && ctx.config.tunnel.tunnelName) {
+        if (ctx.tunnelDetails && ctx.tunnelDetails.tunnelPort != -1 && ctx.tunnelDetails.tunnelHost) {
+          const tunnelServer = `http://${ctx.tunnelDetails.tunnelHost}:${ctx.tunnelDetails.tunnelPort}`;
+          ctx.log.info(`URL Capture :: Using tunnel address: ${tunnelServer}`);
+          contextOptions.proxy = { server: tunnelServer };
+        } else {
+          let tunnelResp = yield ctx.client.getTunnelDetails(ctx, ctx.log);
+          ctx.log.debug(`Tunnel Response: ${JSON.stringify(tunnelResp)}`);
+          if (tunnelResp && tunnelResp.data && tunnelResp.data.host && tunnelResp.data.port) {
+            ctx.tunnelDetails = {
+              tunnelHost: tunnelResp.data.host,
+              tunnelPort: tunnelResp.data.port,
+              tunnelName: tunnelResp.data.tunnel_name
+            };
+            const tunnelServer = `http://${ctx.tunnelDetails.tunnelHost}:${ctx.tunnelDetails.tunnelPort}`;
+            ctx.log.info(`URL Capture :: Using tunnel address: ${tunnelServer}`);
+            contextOptions.proxy = { server: tunnelServer };
+          } else if (tunnelResp && tunnelResp.error) {
+            if (tunnelResp.error.message) {
+              ctx.log.warn(`Error while fetching tunnel details: ${tunnelResp.error.message}`);
+            }
+          }
+        }
+      } else if (ctx.config.geolocation && ctx.config.geolocation !== "") {
+        if (ctx.geolocationData && ctx.geolocationData.proxy && ctx.geolocationData.username && ctx.geolocationData.password && ctx.geolocationData.geoCode === ctx.config.geolocation) {
+          ctx.log.info(`URL Capture :: Using cached geolocation proxy for ${ctx.config.geolocation}`);
+          contextOptions.proxy = {
+            server: ctx.geolocationData.proxy,
+            username: ctx.geolocationData.username,
+            password: ctx.geolocationData.password
+          };
+        } else {
+          const geoResp = yield ctx.client.getGeolocationProxy(ctx.config.geolocation, ctx.log);
+          ctx.log.debug(`Geolocation proxy response: ${JSON.stringify(geoResp)}`);
+          if (geoResp && geoResp.data && geoResp.data.proxy && geoResp.data.username && geoResp.data.password) {
+            ctx.log.info(`URL Capture :: Using geolocation proxy for ${ctx.config.geolocation}`);
+            ctx.geolocationData = {
+              proxy: geoResp.data.proxy,
+              username: geoResp.data.username,
+              password: geoResp.data.password,
+              geoCode: ctx.config.geolocation
+            };
+            contextOptions.proxy = {
+              server: geoResp.data.proxy,
+              username: geoResp.data.username,
+              password: geoResp.data.password
+            };
+          } else {
+            ctx.log.warn(`Geolocation proxy not available for '${ctx.config.geolocation}', falling back if dedicatedProxyURL present`);
+            if (ctx.config.dedicatedProxyURL && ctx.config.dedicatedProxyURL !== "") {
+              ctx.log.info(`URL Capture :: Using dedicated proxy: ${ctx.config.dedicatedProxyURL}`);
+              contextOptions.proxy = { server: ctx.config.dedicatedProxyURL };
+            }
+          }
+        }
+      } else if (ctx.config.dedicatedProxyURL && ctx.config.dedicatedProxyURL !== "") {
+        ctx.log.info(`URL Capture :: Using dedicated proxy: ${ctx.config.dedicatedProxyURL}`);
+        contextOptions.proxy = { server: ctx.config.dedicatedProxyURL };
+      }
+    } catch (e) {
+      ctx.log.debug(`Failed resolving tunnel/proxy details: ${e}`);
+    }
     let page;
     if (browserName == constants_default.CHROME)
       contextOptions.userAgent = constants_default.CHROME_USER_AGENT;
@@ -5834,6 +5936,15 @@ function captureScreenshotsForConfig(ctx, browsers, urlConfig, browserName, rend
       const browser = browsers[browserName];
       context = yield browser == null ? void 0 : browser.newContext(contextOptions);
       page = yield context == null ? void 0 : context.newPage();
+      if (beforeNavigationScript && beforeNavigationScript !== "") {
+        const wrappedScript = new Function("page", `
+                return (async () => {
+                    ${beforeNavigationScript}
+                })();
+            `);
+        ctx.log.debug(`Executing before navigation script: ${wrappedScript}`);
+        yield wrappedScript(page);
+      }
       const headersObject = {};
       if (ctx.config.requestHeaders && Array.isArray(ctx.config.requestHeaders)) {
         ctx.config.requestHeaders.forEach((headerObj) => {
@@ -5849,6 +5960,11 @@ function captureScreenshotsForConfig(ctx, browsers, urlConfig, browserName, rend
           });
         });
       }
+      if (ctx.config.basicAuthorization) {
+        ctx.log.debug(`Adding basic authorization to the headers for root url`);
+        let token = Buffer.from(`${ctx.config.basicAuthorization.username}:${ctx.config.basicAuthorization.password}`).toString("base64");
+        headersObject["Authorization"] = `Basic ${token}`;
+      }
       ctx.log.debug(`Combined headers: ${JSON.stringify(headersObject)}`);
       if (Object.keys(headersObject).length > 0) {
         yield page.setExtraHTTPHeaders(headersObject);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.1.41",
+  "version": "4.1.42",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"