Merge pull request #217 from LambdaTest/stage

sushobhit-lt · web-flow · commit 5ae8489d1ca4 · 2025-02-08T15:41:19.000+05:30
[Dot-4568] Release PR for version 4.0.21
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.0.20",
+  "version": "4.0.21",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"
diff --git a/src/commander/commander.ts b/src/commander/commander.ts
@@ -5,6 +5,9 @@ import capture from './capture.js'
 import upload from './upload.js'
 import { version } from '../../package.json'
 import { uploadFigma, uploadWebFigmaCommand  } from './uploadFigma.js'
+import startServer from './server.js';
+import stopServer from './stopServer.js'
+import ping from './ping.js'
 
 const program = new Command();
 
@@ -18,11 +21,14 @@ program
     .addCommand(configWeb)
     .addCommand(configStatic)
     .addCommand(upload)
+    .addCommand(startServer)
+    .addCommand(stopServer)
+    .addCommand(ping)
     .addCommand(configFigma)
     .addCommand(uploadFigma)
     .addCommand(configWebFigma)
     .addCommand(uploadWebFigmaCommand)
 
-    
+
 
 export default program;
diff --git a/src/commander/ping.ts b/src/commander/ping.ts
@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import chalk from 'chalk'
+
+function getSmartUIServerAddress() {
+    const serverAddress = process.env.SMARTUI_SERVER_ADDRESS || 'http://localhost:49152';
+    return serverAddress;
+}
+
+const command = new Command();
+
+command
+    .name('exec:ping')
+    .description('Ping the SmartUI server to check if it is running')
+    .action(async function(this: Command) {
+        try {
+            console.log(chalk.yellow("Pinging server..."));
+            const serverAddress = getSmartUIServerAddress();
+            console.log(chalk.yellow(`Pinging server at ${serverAddress} from terminal...`));
+
+            // Send GET request to the /ping endpoint
+            const response = await axios.get(`${serverAddress}/ping`, { timeout: 15000 });
+
+            // Log the response from the server
+            if (response.status === 200) {
+                console.log(chalk.green('SmartUI Server is running'));
+                console.log(chalk.green(`Response: ${JSON.stringify(response.data)}`)); // Log response data if needed
+            } else {
+                console.log(chalk.red('Failed to reach the server'));
+            }
+        } catch (error: any) {
+            // Handle any errors during the HTTP request
+            if (error.code === 'ECONNABORTED') {
+                console.error(chalk.red('Error: SmartUI server did not respond in 15 seconds'));
+            } else {
+                console.error(chalk.red('SmartUI server is not running'));
+            }
+        }
+    });
+
+export default command;
diff --git a/src/commander/server.ts b/src/commander/server.ts
@@ -0,0 +1,64 @@
+import { Command } from 'commander';
+import { Context } from '../types.js';
+import { color, Listr, ListrDefaultRendererLogLevels } from 'listr2';
+import startServer from '../tasks/startServer.js';
+import auth from '../tasks/auth.js';
+import ctxInit from '../lib/ctx.js';
+import getGitInfo from '../tasks/getGitInfo.js';
+import createBuild from '../tasks/createBuild.js';
+import snapshotQueue from '../lib/snapshotQueue.js';
+import { startPolling, startPingPolling } from '../lib/utils.js';
+
+const command = new Command();
+
+command
+    .name('exec:start')
+    .description('Start SmartUI server')
+    .option('-P, --port <number>', 'Port number for the server')
+    .option('--fetch-results [filename]', 'Fetch results and optionally specify an output file, e.g., <filename>.json')
+    .option('--buildName <string>', 'Specify the build name')
+    .action(async function(this: Command) {
+        const options = command.optsWithGlobals();
+        if (options.buildName === '') {
+            console.log(`Error: The '--buildName' option cannot be an empty string.`);
+            process.exit(1);
+        }
+        let ctx: Context = ctxInit(command.optsWithGlobals());
+        ctx.snapshotQueue = new snapshotQueue(ctx);
+        ctx.totalSnapshots = 0
+        ctx.isStartExec = true
+
+        let tasks = new Listr<Context>(
+            [
+                auth(ctx),
+                startServer(ctx),
+                getGitInfo(ctx),
+                createBuild(ctx),
+
+            ],
+            {
+                rendererOptions: {
+                    icon: {
+                        [ListrDefaultRendererLogLevels.OUTPUT]: `→`
+                    },
+                    color: {
+                        [ListrDefaultRendererLogLevels.OUTPUT]: color.gray
+                    }
+                }
+            }
+        );
+
+        try {
+            await tasks.run(ctx);
+            startPingPolling(ctx);
+            if (ctx.options.fetchResults) {
+                startPolling(ctx);
+            }
+            
+    
+        } catch (error) {
+            console.error('Error during server execution:', error);
+        }
+    });
+
+export default command;
diff --git a/src/commander/stopServer.ts b/src/commander/stopServer.ts
@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import axios from 'axios'; // Import axios for HTTP requests
+import chalk from 'chalk'
+
+const command = new Command();
+
+function getSmartUIServerAddress() {
+    const serverAddress = process.env.SMARTUI_SERVER_ADDRESS || 'http://localhost:49152';
+    return serverAddress;
+}
+
+command
+    .name('exec:stop')
+    .description('Stop the SmartUI server')
+    .action(async function(this: Command) {
+        try {
+            const serverAddress = getSmartUIServerAddress();
+            console.log(chalk.yellow(`Stopping server at ${serverAddress} from terminal...`));
+
+            // Send POST request to the /stop endpoint with the correct headers
+            const response = await axios.post(`${serverAddress}/stop`, { timeout: 15000 }, {
+                headers: {
+                    'Content-Type': 'application/json' // Ensure the correct Content-Type header
+                }
+            });
+
+            // Log the response from the server
+            if (response.status === 200) {
+                console.log(chalk.green('Server stopped successfully'));
+                console.log(chalk.green(`Response: ${JSON.stringify(response.data)}`)); // Log response data if needed
+            } else {
+                console.log(chalk.red('Failed to stop server'));
+            }
+        } catch (error: any) {
+            // Handle any errors during the HTTP request
+            if (error.code === 'ECONNABORTED') {
+                console.error(chalk.red('Error: SmartUI server did not respond in 15 seconds'));
+            } else {
+                console.error(chalk.red('Error while stopping server'));
+            }
+        }
+    });
+
+export default command;
diff --git a/src/lib/ctx.ts b/src/lib/ctx.ts
@@ -126,6 +126,7 @@ export default (options: Record<string, string>): Context => {
             fetchResultsFileName: fetchResultsFileObj,
         },
         cliVersion: version,
-        totalSnapshots: -1
+        totalSnapshots: -1,
+        isStartExec: false
     }
 }
diff --git a/src/lib/env.ts b/src/lib/env.ts
@@ -18,6 +18,8 @@ export default (): Env => {
         BASELINE_BRANCH,
         CURRENT_BRANCH,
         PROJECT_NAME,
+        SMARTUI_API_PROXY,
+        SMARTUI_API_SKIP_CERTIFICATES
     } = process.env
         
     return {
@@ -36,6 +38,8 @@ export default (): Env => {
         CURRENT_BRANCH,
         LT_SDK_DEBUG: LT_SDK_DEBUG === 'true',
         SMARTUI_DO_NOT_USE_CAPTURED_COOKIES: SMARTUI_DO_NOT_USE_CAPTURED_COOKIES === 'true',
-        PROJECT_NAME
+        PROJECT_NAME,
+        SMARTUI_API_PROXY,
+        SMARTUI_API_SKIP_CERTIFICATES: SMARTUI_API_SKIP_CERTIFICATES === 'true'
     }
 }
diff --git a/src/lib/httpClient.ts b/src/lib/httpClient.ts
@@ -5,6 +5,7 @@ import { Env, Snapshot, ProcessedSnapshot, Git, Build, Context } from '../types.
 import constants from './constants.js';
 import type { Logger } from 'winston'
 import pkgJSON from './../../package.json'
+import https from 'https';
 
 export default class httpClient {
     axiosInstance: AxiosInstance;
@@ -13,15 +14,38 @@ export default class httpClient {
     username: string;
     accessKey: string;
 
-    constructor({ SMARTUI_CLIENT_API_URL, PROJECT_TOKEN, PROJECT_NAME, LT_USERNAME, LT_ACCESS_KEY }: Env) {
+    constructor({ SMARTUI_CLIENT_API_URL, PROJECT_TOKEN, PROJECT_NAME, LT_USERNAME, LT_ACCESS_KEY, SMARTUI_API_PROXY, SMARTUI_API_SKIP_CERTIFICATES }: Env) {
         this.projectToken = PROJECT_TOKEN || '';
         this.projectName = PROJECT_NAME || '';
         this.username = LT_USERNAME || '';
         this.accessKey = LT_ACCESS_KEY || '';
 
-        this.axiosInstance = axios.create({
+        let proxyUrl = null;
+        try {
+        // Handle URL with or without protocol
+        const urlStr = SMARTUI_API_PROXY?.startsWith('http') ? 
+            SMARTUI_API_PROXY : `http://${SMARTUI_API_PROXY}`;
+            proxyUrl = SMARTUI_API_PROXY ? new URL(urlStr) : null;
+        } catch (error) {
+            console.error('Invalid proxy URL:', error);
+        }
+        const axiosConfig: any = {
             baseURL: SMARTUI_CLIENT_API_URL,
-        });
+            proxy: proxyUrl ? {
+                host: proxyUrl.hostname,
+                port: proxyUrl.port ? Number(proxyUrl.port) : 80
+            } : false
+        };
+     
+        if (SMARTUI_API_SKIP_CERTIFICATES) {
+            axiosConfig.httpsAgent = new https.Agent({
+                rejectUnauthorized: false
+            });
+        }
+
+        this.axiosInstance = axios.create(axiosConfig);
+
+        
         this.axiosInstance.interceptors.request.use((config) => {
             config.headers['projectToken'] = this.projectToken;
             config.headers['projectName'] = this.projectName;
@@ -84,14 +108,15 @@ export default class httpClient {
         }
     }
     
-    createBuild(git: Git, config: any, log: Logger, buildName: string) {
+    createBuild(git: Git, config: any, log: Logger, buildName: string, isStartExec: boolean) {
         return this.request({
             url: '/build',
             method: 'POST',
             data: {
                 git,
                 config,
-                buildName
+                buildName,
+                isStartExec
             }
         }, log)
     }
@@ -102,7 +127,18 @@ export default class httpClient {
             method: 'GET',
             params: { buildId, baseline }
         }, log);
-    }    
+    }
+    
+    ping(buildId: string, log: Logger) {
+        return this.request({
+            url: '/build/ping',
+            method: 'POST',
+            data: {
+                buildId: buildId
+            }
+        }, log);
+    }
+    
 
     finalizeBuild(buildId: string, totalSnapshots: number, log: Logger) {
         let params: Record<string, string | number> = {buildId};
diff --git a/src/lib/server.ts b/src/lib/server.ts
@@ -4,6 +4,7 @@ import fastify, { FastifyInstance, RouteShorthandOptions } from 'fastify';
 import { readFileSync } from 'fs'
 import { Context } from '../types.js'
 import { validateSnapshot } from './schemaValidation.js'
+import { pingIntervalId } from './utils.js';
 
 export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMessage, ServerResponse>> => {
 	
@@ -48,6 +49,54 @@ export default async (ctx: Context): Promise<FastifyInstance<Server, IncomingMes
 		return reply.code(replyCode).send(replyBody);
 	});
 
+	server.post('/stop', opts, async (_, reply) => {
+		let replyCode: number;
+		let replyBody: Record<string, any>;
+		try {
+			if(ctx.config.delayedUpload){
+				ctx.log.debug("started after processing because of delayedUpload")
+				ctx.snapshotQueue?.startProcessingfunc()
+			}
+			await new Promise((resolve) => {
+				const intervalId = setInterval(() => {
+					if (ctx.snapshotQueue?.isEmpty() && !ctx.snapshotQueue?.isProcessing()) {
+						clearInterval(intervalId);
+						resolve();
+					}
+				}, 1000);
+			})
+			await ctx.client.finalizeBuild(ctx.build.id, ctx.totalSnapshots, ctx.log);
+			await ctx.browser?.close();
+			if (ctx.server){
+				ctx.server.close();
+			}
+			let resp = await ctx.client.getS3PreSignedURL(ctx);
+            await ctx.client.uploadLogs(ctx, resp.data.url);
+
+			if (pingIntervalId !== null) {
+				clearInterval(pingIntervalId);
+				ctx.log.debug('Ping polling stopped immediately.');
+			}
+			replyCode = 200;
+			replyBody = { data: { message: "success", type: "DELETE" } };
+		} catch (error: any) {
+			ctx.log.debug(error);
+			ctx.log.debug(`stop endpoint failed; ${error}`);
+			replyCode = 500;
+			replyBody = { error: { message: error.message } };
+		}
+	
+		// Step 5: Return the response
+		return reply.code(replyCode).send(replyBody);
+	});
+
+	// Add /ping route to check server status
+	server.get('/ping', opts, (_, reply) => {
+		reply.code(200).send({ status: 'Server is running', version: ctx.cliVersion });
+	});
+
+	
+
 	await server.listen({ port: ctx.options.port });
 	// store server's address for SDK
 	let { port } = server.addresses()[0];
diff --git a/src/lib/snapshotQueue.ts b/src/lib/snapshotQueue.ts
@@ -270,6 +270,10 @@ export default class Queue {
                 this.processingSnapshot = snapshot?.name;
                 let drop = false;
 
+                if (this.ctx.isStartExec) {
+                    this.ctx.log.info(`Processing Snapshot: ${snapshot?.name}`);
+                }
+
                 if (!this.ctx.config.delayedUpload && snapshot && snapshot.name && this.snapshotNames.includes(snapshot.name)) {
                     drop = true;
                     this.ctx.log.info(`Skipping duplicate SmartUI snapshot '${snapshot.name}'. To capture duplicate screenshots, please set the 'delayedUpload' configuration as true in your config file.`);
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
diff --git a/src/tasks/createBuild.ts b/src/tasks/createBuild.ts
diff --git a/src/tasks/exec.ts b/src/tasks/exec.ts
diff --git a/src/types.ts b/src/types.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@lambdatest/smartui-cli",`
`3`		`- "version": "4.0.20",`
	`3`	`+ "version": "4.0.21",`
`4`	`4`	`"description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",`
`5`	`5`	`"files": [`
`6`	`6`	`"dist/*/"`
Original file line number	Diff line number	Diff line change
`@@ -126,6 +126,7 @@ export default (options: Record<string, string>): Context => {`
`126`	`126`	`fetchResultsFileName: fetchResultsFileObj,`
`127`	`127`	`},`
`128`	`128`	`cliVersion: version,`
`129`		`- totalSnapshots: -1`
	`129`	`+ totalSnapshots: -1,`
	`130`	`+ isStartExec: false`
`130`	`131`	`}`
`131`	`132`	`}`