Release v4.1.32

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.1.31",
+  "version": "4.1.32",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"
@@ -49,6 +49,9 @@
     "which": "^4.0.0",
     "winston": "^3.10.0"
   },
+  "overrides": {
+    "simple-swizzle": "0.2.2"
+  },
   "devDependencies": {
     "typescript": "^5.3.2"
   }

src/commander/exec.ts

@@ -40,6 +40,7 @@ command
         ctx.args.execCommand = execCommand
         ctx.snapshotQueue = new snapshotQueue(ctx)
         ctx.totalSnapshots = 0
+        ctx.sourceCommand = 'exec'
 
         let tasks = new Listr<Context>(
             [

src/commander/server.ts

@@ -8,6 +8,7 @@ import getGitInfo from '../tasks/getGitInfo.js';
 import createBuildExec from '../tasks/createBuildExec.js';
 import snapshotQueue from '../lib/snapshotQueue.js';
 import { startPolling, startPingPolling } from '../lib/utils.js';
+import startTunnel from '../tasks/startTunnel.js'
 
 const command = new Command();
 
@@ -27,12 +28,14 @@ command
         ctx.snapshotQueue = new snapshotQueue(ctx);
         ctx.totalSnapshots = 0
         ctx.isStartExec = true
-
+        ctx.sourceCommand = 'exec-start'
+
         let tasks = new Listr<Context>(
             [
                 authExec(ctx),
                 startServer(ctx),
                 getGitInfo(ctx),
+                ...(ctx.config.tunnel && ctx.config.tunnel?.type === 'auto' ? [startTunnel(ctx)] : []),
                 createBuildExec(ctx),
 
             ],
@@ -50,15 +53,16 @@ command
 
         try {
             await tasks.run(ctx);
-            if (ctx.build && ctx.build.id) {
+            if (ctx.build && ctx.build.id && !ctx.autoTunnelStarted) {
                 startPingPolling(ctx);
             }
             if (ctx.options.fetchResults && ctx.build && ctx.build.id) {
                 startPolling(ctx, '', false, '')
             }
-    
+
         } catch (error) {
             console.error('Error during server execution:', error);
+            process.exit(1);
         }
     });
 

src/commander/stopServer.ts

@@ -33,8 +33,10 @@ command
             }
         } catch (error: any) {
             // Handle any errors during the HTTP request
-            if (error.code === 'ECONNABORTED') {
+            if (error && error.code === 'ECONNABORTED') {
                 console.error(chalk.red('Error: SmartUI server did not respond in 15 seconds'));
+            } if (error && error.code === 'ECONNREFUSED') {
+                console.error(chalk.red('Error: Looks like smartui cli server is already stopped'));
             } else {
                 console.error(chalk.red('Error while stopping server'));
             }

src/lib/ctx.ts

@@ -39,6 +39,12 @@ export default (options: Record<string, string>): Context => {
                 delete config.web.resolutions;
             }
 
+            if(config.approvalThreshold && config.rejectionThreshold) {
+                if(config.rejectionThreshold <= config.approvalThreshold) {
+                    throw new Error('Invalid config; rejectionThreshold must be greater than approvalThreshold');
+                }
+            }
+
             let validateConfigFn = options.scheduled ? validateConfigForScheduled : validateConfig;
 
             // validate config
@@ -142,6 +148,8 @@ export default (options: Record<string, string>): Context => {
             useLambdaInternal: useLambdaInternal,
             useExtendedViewport: useExtendedViewport,
             loadDomContent: loadDomContent,
+            approvalThreshold: config.approvalThreshold,
+            rejectionThreshold: config.rejectionThreshold,
         },
         uploadFilePath: '',
         webStaticConfig: [],

src/lib/httpClient.ts

@@ -77,7 +77,7 @@ export default class httpClient {
             (response) => response,
             async (error) => {
                 const { config } = error;
-                if (config && config.url === '/screenshot' && config.method === 'post') {
+                if (config && config.url === '/screenshot' && config.method === 'post' && error?.response?.status !== 401) {
                     // Set default retry count and delay if not already defined
                     if (!config.retryCount) {
                         config.retryCount = 0;
@@ -242,11 +242,12 @@ export default class httpClient {
         }, log)
     }
 
-    getScreenshotData(buildId: string, baseline: boolean, log: Logger, projectToken: string) {
+    getScreenshotData(buildId: string, baseline: boolean, log: Logger, projectToken: string, buildName: string) {
+        log.debug(`Fetching screenshot data for buildId: ${buildId}  having  buildName: ${buildName} with baseline: ${baseline}`);
         return this.request({
             url: '/screenshot',
             method: 'GET',
-            params: { buildId, baseline },
+            params: { buildId, baseline, buildName },
             headers: {projectToken: projectToken}
         }, log);
     }
@@ -281,7 +282,7 @@ export default class httpClient {
     }
 
 
-    getSmartUICapabilities(sessionId: string, config: any, git: any, log: Logger) {
+    getSmartUICapabilities(sessionId: string, config: any, git: any, log: Logger, isStartExec: boolean) {
         return this.request({
             url: '/sessions/capabilities',
             method: 'GET',
@@ -290,7 +291,8 @@ export default class httpClient {
             },
             data: {
                 git,
-                config
+                config,
+                isStartExec
             },
             headers: {
                 projectToken: '',
@@ -343,24 +345,33 @@ export default class httpClient {
         }, ctx.log)
     }
 
-    processSnapshot(ctx: Context, snapshot: ProcessedSnapshot, snapshotUuid: string,  discoveryErrors: DiscoveryErrors, variantCount: number, sync: boolean = false) {
+    processSnapshot(ctx: Context, snapshot: ProcessedSnapshot, snapshotUuid: string,  discoveryErrors: DiscoveryErrors, variantCount: number, sync: boolean = false, approvalThreshold: number| undefined, rejectionThreshold: number| undefined) {
+        const requestData: any = {
+            name: snapshot.name,
+            url: snapshot.url,
+            snapshotUuid: snapshotUuid,
+            variantCount: variantCount,
+            test: {
+                type: ctx.testType,
+                source: 'cli'
+            },
+            discoveryErrors: discoveryErrors,
+            doRemoteDiscovery: snapshot.options.doRemoteDiscovery,
+            sync: sync
+        };
+
+        if (approvalThreshold !== undefined) {
+            requestData.approvalThreshold = approvalThreshold;
+        }
+        if (rejectionThreshold !== undefined) {
+            requestData.rejectionThreshold = rejectionThreshold;
+        }
+
         return this.request({
             url: `/build/${ctx.build.id}/snapshot`,
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            data: {
-                name: snapshot.name,
-                url: snapshot.url,
-                snapshotUuid: snapshotUuid,
-                variantCount: variantCount,
-                test: {
-                    type: ctx.testType,
-                    source: 'cli'
-                },
-                doRemoteDiscovery: snapshot.options.doRemoteDiscovery,
-                discoveryErrors: discoveryErrors,
-                sync: sync
-            }
+            data: requestData
         }, ctx.log)
     }
 

src/lib/schemaValidation.ts

@@ -239,6 +239,11 @@ const ConfigSchema = {
                     type: "string",
                     errorMessage: "Invalid config; logFile should be a string value"
                 },
+                environment: {
+                    type: "string",
+                    enum: ["stage", "prod"],
+                    errorMessage: "Invalid config; environment should be a string value either stage or prod"
+                }
             },
             required: ["type"],
             additionalProperties: false
@@ -274,6 +279,18 @@ const ConfigSchema = {
         loadDomContent: {
             type: "boolean",
             errorMessage: "Invalid config; loadDomContent must be true/false"
+        },
+        approvalThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            errorMessage: "Invalid config; approvalThreshold must be a number"
+        },
+        rejectionThreshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 100,
+            errorMessage: "Invalid config; rejectionThreshold must be a number"
         }
     },
     anyOf: [
@@ -537,6 +554,18 @@ const SnapshotSchema: JSONSchemaType<Snapshot> = {
                 useExtendedViewport: {
                     type: "boolean",
                     errorMessage: "Invalid snapshot options; useExtendedViewport must be a boolean"
+                },
+                approvalThreshold: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 100,
+                    errorMessage: "Invalid snapshot options; approvalThreshold must be a number between 0 and 100"
+                },
+                rejectionThreshold: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 100,
+                    errorMessage: "Invalid snapshot options; rejectionThreshold must be a number between 0 and 100"
                 }
             },
             additionalProperties: false

src/lib/server.ts

@@ -4,8 +4,7 @@ import fastify, { FastifyInstance, RouteShorthandOptions } from 'fastify';
 import { readFileSync, truncate } from 'fs'
 import { Context } from '../types.js'
 import { validateSnapshot } from './schemaValidation.js'
-import { pingIntervalId } from './utils.js';
-import { startPolling } from './utils.js';
+import { pingIntervalId, startPollingForTunnel, stopTunnelHelper, isTunnelPolling } from './utils.js';
 
 const uploadDomToS3ViaEnv = process.env.USE_LAMBDA_INTERNAL || false;
 export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMessage, ServerResponse>> => {
@@ -38,6 +37,12 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 		try {
 			let { snapshot, testType } = request.body;
 			if (!validateSnapshot(snapshot)) throw new Error(validateSnapshot.errors[0].message);
+
+			if(snapshot?.options?.approvalThreshold !== undefined && snapshot?.options?.rejectionThreshold !== undefined) {
+				if(snapshot?.options?.rejectionThreshold <= snapshot?.options?.approvalThreshold) {
+					throw new Error(`Invalid snapshot options; rejectionThreshold (${snapshot.options.rejectionThreshold}) must be greater than approvalThreshold (${snapshot.options.approvalThreshold})`);
+				}
+			}
 
 			// Fetch sessionId from snapshot options if present
 			const sessionId = snapshot?.options?.sessionId;
@@ -53,7 +58,7 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 				} else {
 					// If not cached, fetch from API and cache it
 					try {
-						let fetchedCapabilitiesResp = await ctx.client.getSmartUICapabilities(sessionId, ctx.config, ctx.git, ctx.log);
+						let fetchedCapabilitiesResp = await ctx.client.getSmartUICapabilities(sessionId, ctx.config, ctx.git, ctx.log, ctx.isStartExec);
 						capsBuildId = fetchedCapabilitiesResp?.buildId || ''
 						ctx.log.debug(`fetch caps for sessionId: ${sessionId} are ${JSON.stringify(fetchedCapabilitiesResp)}`)
 						if (capsBuildId) {
@@ -106,6 +111,7 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 		let replyCode: number;
 		let replyBody: Record<string, any>;
 		try {
+			ctx.log.info('Received stop command. Finalizing build ...');
 			if(ctx.config.delayedUpload){
 				ctx.log.debug("started after processing because of delayedUpload")
 				ctx.snapshotQueue?.startProcessingfunc()
@@ -118,6 +124,7 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 					}
 				}, 1000);
 			})
+            let buildUrls = `build url: ${ctx.build.url}\n`;
 
 			for (const [sessionId, capabilities] of ctx.sessionCapabilitiesMap.entries()) {
                 try {
@@ -126,9 +133,12 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
                     const totalSnapshots = capabilities?.snapshotCount || 0;
                     const sessionBuildUrl = capabilities?.buildURL || '';
                     const testId = capabilities?.id || '';
-
+					ctx.log.debug(`Capabilities for sessionId ${sessionId}: ${JSON.stringify(capabilities)}`)
                     if (buildId && projectToken) {
                         await ctx.client.finalizeBuildForCapsWithToken(buildId, totalSnapshots, projectToken, ctx.log);
+						if (ctx.autoTunnelStarted) {
+							await startPollingForTunnel(ctx, buildId, false, projectToken, capabilities?.buildName);
+						}
                     }
 
                     if (testId && buildId) {
@@ -151,6 +161,16 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 				}
 			}
 
+
+			//If Tunnel Details are present, start polling for tunnel status 
+			if (ctx.tunnelDetails && ctx.tunnelDetails.tunnelHost != "" && ctx.build?.id) {
+				await startPollingForTunnel(ctx, ctx.build.id, false, '', '');
+			} 
+			//stop the tunnel if it was auto started and no tunnel polling is active
+			if (ctx.autoTunnelStarted && isTunnelPolling === null) {
+                await stopTunnelHelper(ctx);
+            }
+
 			await ctx.browser?.close();
 			if (ctx.server){
 				ctx.server.close();
@@ -168,7 +188,9 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 			replyCode = 500;
 			replyBody = { error: { message: error.message } };
 		}
-
+
+		ctx.log.info('Stop command processed. Tearing down server.');
+
 		// Step 5: Return the response
 		return reply.code(replyCode).send(replyBody);
 	});

src/lib/snapshotQueue.ts

@@ -380,7 +380,7 @@ export default class Queue {
                                     useKafkaFlow: resp.data.useKafkaFlow || false,
                                 }
                             } else {
-                                if (this.ctx.config.tunnel && this.ctx.config.tunnel?.type === 'auto') {
+                                if (this.ctx.autoTunnelStarted) {
                                     await stopTunnelHelper(this.ctx)
                                 }
                                 throw new Error('SmartUI capabilities are missing in env variables or in driver capabilities');
@@ -427,7 +427,9 @@ export default class Queue {
                                 }
                                 this.processNext();
                             } else {
-                                await this.ctx.client.processSnapshot(this.ctx, processedSnapshot, snapshotUuid, discoveryErrors,calculateVariantCountFromSnapshot(processedSnapshot, this.ctx.config),snapshot?.options?.sync);
+                                let approvalThreshold = snapshot?.options?.approvalThreshold || this.ctx.config.approvalThreshold;
+                                let rejectionThreshold = snapshot?.options?.rejectionThreshold || this.ctx.config.rejectionThreshold;
+                                await this.ctx.client.processSnapshot(this.ctx, processedSnapshot, snapshotUuid, discoveryErrors,calculateVariantCountFromSnapshot(processedSnapshot, this.ctx.config),snapshot?.options?.sync, approvalThreshold, rejectionThreshold);
                                 if(snapshot?.options?.contextId && this.ctx.contextToSnapshotMap?.has(snapshot.options.contextId)){
                                     this.ctx.contextToSnapshotMap.set(snapshot.options.contextId, 1);
                                 }

src/lib/uploadAppFigma.ts

@@ -19,6 +19,7 @@ export default async (ctx: Context): Promise<string> => {
       smartIgnore: ctx.config.smartIgnore,
       git: ctx.git,
       platformType: 'app',
+      markBaseline: ctx.options.markBaseline,
     };
 
     const responseData = await ctx.client.processWebFigma(requestBody, ctx.log);

src/lib/uploadWebFigma.ts

@@ -18,6 +18,7 @@ export default async (ctx: Context): Promise<string> => {
       figma: figmaConfig,
       smartIgnore: ctx.config.smartIgnore,
       git: ctx.git,
+      markBaseline: ctx.options.markBaseline,
     };
 
     const responseData = await ctx.client.processWebFigma(requestBody, ctx.log);