implement node tunnel in cli

Author: parthlambdatest

package.json

@@ -30,6 +30,7 @@
     "@types/cross-spawn": "^6.0.4",
     "@types/node": "^20.8.9",
     "@types/which": "^3.0.2",
+    "@lambdatest/node-tunnel": "^4.0.9",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "axios": "^1.6.0",

src/commander/exec.ts

@@ -63,6 +63,7 @@ command
             await tasks.run(ctx);
         } catch (error) {
             ctx.log.info('\nRefer docs: https://www.lambdatest.com/support/docs/smart-visual-regression-testing/');
+            throw new Error();
         }
     })
 

src/lib/ctx.ts

@@ -1,4 +1,4 @@
-import { Context, Env, WebConfig, MobileConfig, basicAuth } from '../types.js'
+import { Context, Env, WebConfig, MobileConfig, basicAuth, tunnelConfig } from '../types.js'
 import constants from './constants.js'
 import { version } from '../../package.json'
 import { validateConfig } from './schemaValidation.js'
@@ -12,6 +12,7 @@ export default (options: Record<string, string>): Context => {
     let webConfig: WebConfig;
     let mobileConfig: MobileConfig;
     let basicAuthObj: basicAuth
+    let tunnelObj: tunnelConfig
     let config = constants.DEFAULT_CONFIG;
     let port: number;
     let resolutionOff: boolean;
@@ -77,7 +78,10 @@ export default (options: Record<string, string>): Context => {
     }
     if (config.basicAuthorization) {
         basicAuthObj = config.basicAuthorization
-    }   
+    }
+    if (config.tunnel) {
+        tunnelObj = config.tunnel
+    }
 
     return {
         env: env,
@@ -100,7 +104,7 @@ export default (options: Record<string, string>): Context => {
             useGlobalCache: config.useGlobalCache ?? false,
             ignoreHTTPSErrors: config.ignoreHTTPSErrors ?? false,
             skipBuildCreation: config.skipBuildCreation ?? false,
-            tunnel: config.tunnel ?? false,
+            tunnel: tunnelObj,
             tunnelName: config.tunnelName || ''
         },
         uploadFilePath: '',
@@ -143,6 +147,8 @@ export default (options: Record<string, string>): Context => {
         isSnapshotCaptured: false,
         sessionCapabilitiesMap: new Map<string, any[]>(),
         buildToSnapshotCountMap: new Map<string, number>(),
-        fetchResultsForBuild: new Array<string>
+        fetchResultsForBuild: new Array<string>,
+        orgId: 0,
+        userId: 0
     }
 }

src/lib/httpClient.ts

@@ -45,14 +45,17 @@ export default class httpClient {
 
         this.axiosInstance = axios.create(axiosConfig);
 
-
         this.axiosInstance.interceptors.request.use((config) => {
             if (!config.headers['projectToken']) {
                 config.headers['projectToken'] = this.projectToken;
             }
             config.headers['projectName'] = this.projectName;
-            config.headers['username'] = this.username;
-            config.headers['accessKey'] = this.accessKey;
+            if (!config.headers['username'] || config.headers['username'] === '') {
+                config.headers['username'] = this.username;
+            }
+            if (!config.headers['accessKey'] || config.headers['accessKey'] === '') {
+                config.headers['accessKey'] = this.accessKey;
+            }
             return config;
         });
 
@@ -151,6 +154,47 @@ export default class httpClient {
         }
     }
 
+    async authExec(ctx: Context, log: Logger, env: Env): Promise<{ authResult: number, orgId: number, userId: number }> {
+        let authResult = 1;
+        let userName = '';
+        let passWord = '';
+        if (ctx.config.tunnel?.user) {
+            userName = ctx.config.tunnel.user
+        }
+        if (ctx.config.tunnel?.key) {
+            passWord = ctx.config.tunnel.key
+        }
+        if (this.projectToken) {
+            authResult = 0;
+        }
+        const response = await this.request({
+            url: '/token/verify',
+            method: 'GET',
+            headers: {
+                username: userName,
+                accessKey: passWord
+            }
+        }, log);
+        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')) {
+                authResult = 2;
+            }
+            if (response.orgId) {
+                orgId = response.orgId
+            }
+            if (response.userId) {
+                userId = response.userId
+            }
+            return { authResult, orgId, userId };
+        } else {
+            throw new Error('Authentication failed, project token not received');
+        }
+    }
+
     createBuild(git: Git, config: any, log: Logger, buildName: string, isStartExec: boolean) {
         return this.request({
             url: '/build',
@@ -174,12 +218,16 @@ export default class httpClient {
         }, log);
     }
 
-    getTunnelDetails(tunnelName: string, log: Logger) {
+    getTunnelDetails(ctx: Context, log: Logger) {
         return this.request({
             url: '/tunnel',
             method: 'POST',
             data: { 
-                tunnelName: tunnelName
+                tunnelName: ctx.config.tunnel?.tunnelName,
+                orgId: ctx.orgId,
+                userId: ctx.userId,
+                userName: ctx.config.tunnel?.user,
+                password: ctx.config.tunnel?.key
             }
         }, log)
     }

src/lib/schemaValidation.ts

@@ -189,8 +189,59 @@ const ConfigSchema = {
             errorMessage: "Invalid config; skipBuildCreation must be true/false"
         },
         tunnel: {
-            type: "boolean",
-            errorMessage: "Invalid config; tunnel must be true/false"
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    errorMessage: "Invalid config; type is mandatory of type string"
+                },
+                tunnelName: {
+                    type: "string",
+                    errorMessage: "Invalid config; tunnelName should be a string value"
+                },
+                user: {
+                    type: "string",
+                    errorMessage: "Invalid config; user should be a string value"
+                },
+                key: {
+                    type: "string",
+                    errorMessage: "Invalid config; key should be a string value"
+                },
+                port: {
+                    type: "number",
+                    errorMessage: "Invalid config; port should be a string value"
+                },
+                proxyHost: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyHost should be a string value"
+                },
+                proxyPort: {
+                    type: "number",
+                    errorMessage: "Invalid config; proxyPort should be an int value"
+                },
+                proxyUser: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyUser should be a string value"
+                },
+                proxyPass: {
+                    type: "string",
+                    errorMessage: "Invalid config; proxyPass should be a string value"
+                },
+                dir: {
+                    type: "string",
+                    errorMessage: "Invalid config; dir should be a string value"
+                },
+                v: {
+                    type: "boolean",
+                    errorMessage: "Invalid config; v should be a boolean value"
+                },
+                logFile: {
+                    type: "string",
+                    errorMessage: "Invalid config; logFile should be a string value"
+                },
+            },
+            required: ["type"],
+            additionalProperties: false
         },
         tunnelName: {
             type: "string",