fixed merge conflicts

Nick-1234531 · Nick-1234531 · commit 6430da9a365e · 2025-08-26T13:40:45.000+05:30
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,4 @@
 node_modules
 dist
 .idea
+*.tgz
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@lambdatest/smartui-cli",
-  "version": "4.1.20",
+  "version": "4.1.25",
   "description": "A command line interface (CLI) to run SmartUI tests on LambdaTest",
   "files": [
     "dist/**/*"
diff --git a/src/commander/capture.ts b/src/commander/capture.ts
@@ -20,6 +20,7 @@ command
     .option('-F, --force', 'forcefully apply the specified parallel instances per browser')
     .option('--fetch-results [filename]', 'Fetch results and optionally specify an output file, e.g., <filename>.json')
     .option('--buildName <string>', 'Specify the build name')
+    .option('--scheduled <string>', 'Specify the schedule ID')
     .option('--userName <string>', 'Specify the LT username')
     .option('--accessKey <string>', 'Specify the LT accesskey')
     .action(async function(file, _, command) {
@@ -38,7 +39,6 @@ command
         try {
             ctx.webStaticConfig = JSON.parse(fs.readFileSync(file, 'utf8'));
             if (!validateWebStaticConfig(ctx.webStaticConfig)){
-
                 ctx.log.debug(JSON.stringify(validateWebStaticConfig.errors, null, 2));
                 // Iterate and add warning for "additionalProperties"
                 validateWebStaticConfig.errors?.forEach(error => {
@@ -58,6 +58,7 @@ command
             }
         } catch (error: any) {
             ctx.log.error(`Invalid Web Static Config; ${error.message}`);
+            process.exitCode = 1;
             return;
         }
         //Print Config here in debug mode
@@ -88,6 +89,7 @@ command
         } catch (error) {
             console.log('\nRefer docs: https://www.lambdatest.com/support/docs/smart-visual-regression-testing/');
             process.exitCode = 1;
+            throw new Error();
         }
 
     })
diff --git a/src/commander/commander.ts b/src/commander/commander.ts
@@ -9,6 +9,7 @@ import startServer from './server.js';
 import stopServer from './stopServer.js'
 import ping from './ping.js'
 import merge from './merge.js'
+import pingTest from './pingTest.js'
 
 const program = new Command();
 
@@ -36,6 +37,7 @@ program
     .addCommand(configAppFigma)
     .addCommand(uploadWebFigmaCommand)
     .addCommand(uploadAppFigmaCommand)
+    .addCommand(pingTest)
 
 
 
diff --git a/src/commander/ping.ts b/src/commander/ping.ts
@@ -34,6 +34,8 @@ command
                 console.error(chalk.red('Error: SmartUI server did not respond in 15 seconds'));
             } else {
                 console.error(chalk.red('SmartUI server is not running'));
+                console.error(chalk.red(`Error: ${error?.code}`));  
+                console.error(error);            
             }
         }
     });
diff --git a/src/commander/pingTest.ts b/src/commander/pingTest.ts
@@ -0,0 +1,88 @@
+import { Command } from 'commander';
+import * as http from 'http';
+import * as https from 'https';
+import chalk from 'chalk'
+
+function getSmartUIServerAddress() {
+    const serverAddress = process.env.SMARTUI_SERVER_ADDRESS || 'http://localhost:49152';
+    return serverAddress;
+}
+
+function makeHttpRequest(url: string, timeout: number): Promise<{ status: number; data: any }> {
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(url);
+        const isHttps = urlObj.protocol === 'https:';
+        const client = isHttps ? https : http;
+        
+        const req = client.request(url, { timeout }, (res) => {
+            let data = '';
+            
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            
+            res.on('end', () => {
+                let parsedData;
+                try {
+                    parsedData = JSON.parse(data);
+                } catch {
+                    parsedData = data;
+                }
+                
+                resolve({
+                    status: res.statusCode || 0,
+                    data: parsedData
+                });
+            });
+        });
+        
+        req.on('error', (error) => {
+            console.error(error)
+            reject(error);
+        });
+        
+        req.on('timeout', () => {
+            req.destroy();
+            const timeoutError = new Error('Request timeout');
+            (timeoutError as any).code = 'ECONNABORTED';
+            reject(timeoutError);
+        });
+        
+        req.end();
+    });
+}
+
+const command = new Command();
+
+command
+    .name('exec:pingTest')
+    .description('Ping the SmartUI server to check if it is running using default http client')
+    .action(async function(this: Command) {
+        try {
+            console.log(chalk.yellow("Pinging server using default http client..."));
+            const serverAddress = getSmartUIServerAddress();
+            console.log(chalk.yellow(`Pinging server at ${serverAddress} from terminal using default http client...`));
+
+            // Send GET request to the /ping endpoint
+            const response = await makeHttpRequest(`${serverAddress}/ping`, 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'));
+                console.error(chalk.red(`Error: ${error?.code}`));  
+                console.error(error);
+            }
+        }
+    });
+
+export default command;
diff --git a/src/lib/ctx.ts b/src/lib/ctx.ts
@@ -24,6 +24,7 @@ export default (options: Record<string, string>): Context => {
     let fetchResultsFileObj: string;
     let buildNameObj: string;
     let allowDuplicateSnapshotNames: boolean = false;
+    let useLambdaInternal: boolean = false;
     try {
         if (options.config) {
             config = JSON.parse(fs.readFileSync(options.config, 'utf-8'));
@@ -73,7 +74,7 @@ export default (options: Record<string, string>): Context => {
         }
     } catch (error: any) {
         console.log(`[smartui] Error: ${error.message}`);
-        process.exit();
+        process.exit(1);
     }
 
     if (config.web) {
@@ -96,6 +97,9 @@ export default (options: Record<string, string>): Context => {
     if (config.allowDuplicateSnapshotNames) {
         allowDuplicateSnapshotNames = true;
     }
+    if (config.useLambdaInternal) {
+        useLambdaInternal = true;
+    }
 
     return {
         env: env,
@@ -122,6 +126,7 @@ export default (options: Record<string, string>): Context => {
             userAgent: config.userAgent || '',
             requestHeaders: config.requestHeaders || {},
             allowDuplicateSnapshotNames: allowDuplicateSnapshotNames,
+            useLambdaInternal: useLambdaInternal,
         },
         uploadFilePath: '',
         webStaticConfig: [],
diff --git a/src/lib/httpClient.ts b/src/lib/httpClient.ts
@@ -92,10 +92,10 @@ export default class httpClient {
 
     async request(config: AxiosRequestConfig, log: Logger): Promise<Record<string, any>> {
         log.debug(`http request: ${config.method} ${config.url}`);
-        if (config && config.data && !config.data.name && !config.data.snapshot) {
+        if (config && config.data && !config.data.skipLogging && !config.data.name && !config.data.snapshot) {
             log.debug(config.data);
         }
-        if (config && config.data && config.data.snapshotUuid) {
+        if (config && config.data && !config.data.skipLogging && config.data.snapshotUuid) {
             log.debug(config.data);
         }
         return this.axiosInstance.request(config)
@@ -497,6 +497,38 @@ export default class httpClient {
         }, ctx.log)
     }
 
+    sendDomToLSRS(ctx: Context, snapshot: ProcessedSnapshot, snapshotUuid: string) {
+        return this.request({
+            url: `/upload/dom`,
+            method: 'POST',
+            data: {
+                buildId: ctx.build.id,
+                snapshotName: snapshot.name,
+                snapshotUuid: snapshotUuid,
+                domContent: snapshot,
+                skipLogging: true
+            }
+        }, ctx.log);
+    }
+
+    sendDomToLSRSForCaps(ctx: Context, snapshot: ProcessedSnapshot, snapshotUuid: string, capsBuildId: string, capsProjectToken: string) {
+        return this.request({
+            url: `/upload/dom`,
+            method: 'POST',
+            headers: { 
+                'Content-Type': 'application/json',
+                projectToken: capsProjectToken !== '' ? capsProjectToken : this.projectToken
+            },
+            data: {
+                buildId: capsBuildId,
+                snapshotName: snapshot.name,
+                snapshotUuid: snapshotUuid,
+                domContent: snapshot,
+                skipLogging: true
+            }
+        }, ctx.log);
+    }
+
     uploadLogs(ctx: Context, uploadURL: string) {
         const fileStream = fs.createReadStream(constants.LOG_FILE_PATH);
         const { size } = fs.statSync(constants.LOG_FILE_PATH);
@@ -514,6 +546,20 @@ export default class httpClient {
         }, ctx.log)
     }
 
+    sendCliLogsToLSRS(ctx: Context) {
+        const logContent = fs.readFileSync(constants.LOG_FILE_PATH, 'utf-8');
+
+        return this.request({
+            url: `/upload/logs`,
+            method: 'POST',
+            data: {
+                buildId: ctx.build.id,
+                logContent: logContent,
+                skipLogging: true
+            }
+        }, ctx.log);
+    }
+
     uploadSnapshotToS3(ctx: Context, uploadURL: string, snapshot: Snapshot) {
         return this.request({
             url: uploadURL,
diff --git a/src/lib/schemaValidation.ts b/src/lib/schemaValidation.ts
@@ -262,6 +262,10 @@ const ConfigSchema = {
         allowDuplicateSnapshotNames: {
             type: "boolean",
             errorMessage: "Invalid config; allowDuplicateSnapshotNames must be true/false"
+        },
+        useLambdaInternal: {
+            type: "boolean",
+            errorMessage: "Invalid config; useLambdaInternal must be true/false"
         }
     },
     anyOf: [
diff --git a/src/lib/snapshotQueue.ts b/src/lib/snapshotQueue.ts
@@ -5,6 +5,7 @@ import processSnapshot, {prepareSnapshot} from "./processSnapshot.js"
 import { v4 as uuidv4 } from 'uuid';
 import { startPolling, stopTunnelHelper, calculateVariantCountFromSnapshot } from "./utils.js";
 
+const uploadDomToS3ViaEnv = process.env.USE_LAMBDA_INTERNAL || false;
 export default class Queue {
     private snapshots: Array<Snapshot> = [];
     private processedSnapshots: Array<Record<string, any>> = [];
@@ -347,10 +348,16 @@ export default class Queue {
                         this.ctx.log.info(`Using cached buildId: ${capsBuildId}`);
                         if (useKafkaFlowCaps) {
                             const snapshotUuid = uuidv4();
-                            const presignedResponse = await this.ctx.client.getS3PresignedURLForSnapshotUploadCaps(this.ctx, processedSnapshot.name, snapshotUuid, capsBuildId, capsProjectToken);
-                            const uploadUrl = presignedResponse.data.url;
-
-                            await this.ctx.client.uploadSnapshotToS3Caps(this.ctx, uploadUrl, processedSnapshot, capsProjectToken)
+                            let uploadDomToS3 = this.ctx.config.useLambdaInternal || uploadDomToS3ViaEnv;
+                            if (!uploadDomToS3) {
+                                this.ctx.log.debug(`Uploading dom to S3 for snapshot using presigned URL for CAPS`);
+                                const presignedResponse = await this.ctx.client.getS3PresignedURLForSnapshotUploadCaps(this.ctx, processedSnapshot.name, snapshotUuid, capsBuildId, capsProjectToken);
+                                const uploadUrl = presignedResponse.data.url;
+                                await this.ctx.client.uploadSnapshotToS3Caps(this.ctx, uploadUrl, processedSnapshot, capsProjectToken)
+                            } else {
+                                this.ctx.log.debug(`Uploading dom to S3 for snapshot using LSRS`);
+                                await this.ctx.client.sendDomToLSRSForCaps(this.ctx, processedSnapshot, snapshotUuid, capsBuildId, capsProjectToken);
+                            }
                             await this.ctx.client.processSnapshotCaps(this.ctx, processedSnapshot, snapshotUuid, capsBuildId, capsProjectToken, discoveryErrors);
                         } else {
                             await this.ctx.client.uploadSnapshotForCaps(this.ctx, processedSnapshot, capsBuildId, capsProjectToken, discoveryErrors);
@@ -386,15 +393,22 @@ export default class Queue {
                         }
                         if (this.ctx.build && this.ctx.build.useKafkaFlow) {
                             let snapshotUuid = uuidv4();
-                            
+                            let snapshotUploadResponse
                             if (snapshot?.options?.contextId && this.ctx.contextToSnapshotMap?.has(snapshot.options.contextId)) {
-                               snapshotUuid = snapshot.options.contextId;
-                            }
-                            
-                            const presignedResponse = await this.ctx.client.getS3PresignedURLForSnapshotUpload(this.ctx, processedSnapshot.name, snapshotUuid);
-                            const uploadUrl = presignedResponse.data.url;
+                                snapshotUuid = snapshot.options.contextId;
+                             }
+                             let uploadDomToS3 = this.ctx.config.useLambdaInternal || uploadDomToS3ViaEnv;
+                             if (!uploadDomToS3) {
+                                this.ctx.log.debug(`Uploading dom to S3 for snapshot using presigned URL`);
+                                const presignedResponse = await this.ctx.client.getS3PresignedURLForSnapshotUpload(this.ctx, processedSnapshot.name, snapshotUuid);
+                                const uploadUrl = presignedResponse.data.url;
+                                snapshotUploadResponse = await this.ctx.client.uploadSnapshotToS3(this.ctx, uploadUrl, processedSnapshot);
+                             } else {
+                                this.ctx.log.debug(`Uploading dom to S3 for snapshot using LSRS`);
+                                snapshotUploadResponse = await this.ctx.client.sendDomToLSRS(this.ctx, processedSnapshot, snapshotUuid);
+                             }
+
 
-                            let snapshotUploadResponse = await this.ctx.client.uploadSnapshotToS3(this.ctx, uploadUrl, processedSnapshot);
                             if (!snapshotUploadResponse || Object.keys(snapshotUploadResponse).length === 0) {
                                 this.ctx.log.debug(`snapshot failed; Unable to upload dom to S3`);
                                 this.processedSnapshots.push({ name: snapshot?.name, error: `snapshot failed; Unable to upload dom to S3` });
diff --git a/src/tasks/finalizeBuild.ts b/src/tasks/finalizeBuild.ts
@@ -7,6 +7,7 @@ import { unlinkSync } from 'fs';
 import constants from '../lib/constants.js';
 import fs from 'fs';
 
+const uploadDomToS3ViaEnv = process.env.USE_LAMBDA_INTERNAL || false;
 export default (ctx: Context): ListrTask<Context, ListrRendererFactory, ListrRendererFactory>  =>  {
     return {
         title: `Finalizing build`,
@@ -76,9 +77,15 @@ export default (ctx: Context): ListrTask<Context, ListrRendererFactory, ListrRen
                 await ctx.server?.close();
                 ctx.log.debug(`Closed server`);
                 if (ctx.isSnapshotCaptured) {
-                    ctx.log.debug(`Log file to be uploaded`)
-                    let resp = await ctx.client.getS3PreSignedURL(ctx);
-                    await ctx.client.uploadLogs(ctx, resp.data.url);
+                    let uploadCLILogsToS3 = ctx.config.useLambdaInternal || uploadDomToS3ViaEnv;
+                    if (!uploadCLILogsToS3) {
+                        ctx.log.debug(`Log file to be uploaded`)
+                        let resp = await ctx.client.getS3PreSignedURL(ctx);
+                        await ctx.client.uploadLogs(ctx, resp.data.url);
+                    } else {
+                        ctx.log.debug(`Log file to be uploaded via LSRS`)
+                        let resp = ctx.client.sendCliLogsToLSRS(ctx);
+                    }
                 }
             } catch (error: any) {
                 ctx.log.debug(error);
diff --git a/src/types.ts b/src/types.ts
@@ -37,6 +37,7 @@ export interface Context {
         userAgent?: string;
         requestHeaders?: Array<Record<string, string>>;
         allowDuplicateSnapshotNames?: boolean;
+        useLambdaInternal?: boolean;
     };
     uploadFilePath: string;
     webStaticConfig: WebStaticConfig;

-Original file line number
+Diff line change
@@ @@ -1,3 +1,4 @@ @@
 node_modules
 dist
 .idea
 +*.tgz
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.1.20",`
	`3`	`+ "version": "4.1.25",`
`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
`@@ -34,6 +34,8 @@ command`
`34`	`34`	`console.error(chalk.red('Error: SmartUI server did not respond in 15 seconds'));`
`35`	`35`	`} else {`
`36`	`36`	`console.error(chalk.red('SmartUI server is not running'));`
	`37`	+ console.error(chalk.red(`Error: ${error?.code}`));
	`38`	`+ console.error(error);`
`37`	`39`	`}`
`38`	`40`	`}`
`39`	`41`	`});`