initial commit for tunnel support in smartUI

Author: parthlambdatest

src/lib/ctx.ts

@@ -98,7 +98,9 @@ export default (options: Record<string, string>): Context => {
             delayedUpload: config.delayedUpload ?? false,
             useGlobalCache: config.useGlobalCache ?? false,
             ignoreHTTPSErrors: config.ignoreHTTPSErrors ?? false,
-            skipBuildCreation: config.skipBuildCreation ?? false
+            skipBuildCreation: config.skipBuildCreation ?? false,
+            tunnel: config.tunnel ?? false,
+            tunnelName: config.tunnelName || ''
         },
         uploadFilePath: '',
         webStaticConfig: [],
@@ -116,6 +118,11 @@ export default (options: Record<string, string>): Context => {
             url: ''
         },
         args: {},
+        tunnelDetails: {
+            tunnelPort: -1,
+            tunnelHost: '',
+            tunnelName: ''
+        },
         options: {
             parallel: parallelObj,
             force: options.force ? true : false,

src/lib/httpClient.ts

@@ -169,6 +169,17 @@ export default class httpClient {
         }, log);
     }
 
+    getTunnelDetails(tunnelName: string, log: Logger) {
+        return this.request({
+            url: '/tunnel',
+            method: 'POST',
+            data: { 
+                tunnelName: tunnelName
+            }
+        }, log)
+    }
+    
+
     ping(buildId: string, log: Logger) {
         return this.request({
             url: '/build/ping',

src/lib/processSnapshot.ts

@@ -306,7 +306,15 @@ export default async function processSnapshot(snapshot: Snapshot, ctx: Context):
         }
     }
 
-        // process for every viewport
+    if (ctx.config.tunnel) {
+        if (ctx.tunnelDetails && ctx.tunnelDetails.tunnelPort != -1 && ctx.tunnelDetails.tunnelHost != '') {
+            const tunnelAddress = `http://${ctx.tunnelDetails.tunnelHost}:${ctx.tunnelDetails.tunnelPort}`;
+            processedOptions.tunnelAddress = tunnelAddress;
+            ctx.log.debug(`Tunnel address added to processedOptions: ${tunnelAddress}`);
+        }
+    }
+
+    // process for every viewport
     let navigated: boolean = false;
     let previousDeviceType: string | null = null;
 
@@ -354,7 +362,19 @@ export default async function processSnapshot(snapshot: Snapshot, ctx: Context):
                 ctx.log.debug(`Navigated to ${snapshot.url}`);
             } catch (error: any) {
                 ctx.log.debug(`Navigation to discovery page failed; ${error}`)
-                throw new Error(error.message)
+                if (error && error.name && error.name === 'TimeoutError') {
+                    ctx.log.debug(`Payload uploaded tough navigation to discovery page failed; ${error}`)
+                    return {
+                        processedSnapshot: {
+                            name: snapshot.name,
+                            url: snapshot.url,
+                            dom: Buffer.from(snapshot.dom.html).toString('base64'),
+                            resources: cache,
+                            options: processedOptions
+                        },
+                        warnings: [...optionWarnings, ...snapshot.dom.warnings]
+                    };
+                }
             }
 
         }

src/lib/schemaValidation.ts

@@ -173,6 +173,14 @@ const ConfigSchema = {
             type: "boolean",
             errorMessage: "Invalid config; skipBuildCreation must be true/false"
         },
+        tunnel: {
+            type: "boolean",
+            errorMessage: "Invalid config; tunnel must be true/false"
+        },
+        tunnelName: {
+            type: "string",
+            errorMessage: "Invalid config; tunnelName must be string"
+        },
     },
     anyOf: [
         { required: ["web"] },

src/tasks/createBuildExec.ts

@@ -25,6 +25,27 @@ export default (ctx: Context): ListrTask<Context, ListrRendererFactory, ListrRen
                     task.output = chalk.gray(`Empty PROJECT_TOKEN and PROJECT_NAME. Skipping Creation of Build!`)
                     task.title = 'Skipped SmartUI build creation'
                 }
+
+                if (ctx.config.tunnel) {
+                    let tunnelResp = await ctx.client.getTunnelDetails(ctx.config.tunnelName, ctx.log);
+                    ctx.log.debug(`Tunnel Response: ${JSON.stringify(tunnelResp)}`)
+                    if (tunnelResp && tunnelResp.data && tunnelResp.data.host && tunnelResp.data.port && tunnelResp.data.tunnel_name) {
+                        ctx.tunnelDetails = {
+                            tunnelHost: tunnelResp.data.host,
+                            tunnelPort: tunnelResp.data.port,
+                            tunnelName: tunnelResp.data.tunnel_name
+                        }
+                        ctx.log.debug(`Tunnel Details: ${JSON.stringify(ctx.tunnelDetails)}`)
+                    } else if (tunnelResp && tunnelResp.error) {
+                        if (tunnelResp.error.message) {
+                            if (tunnelResp.error.code && tunnelResp.error.code === 400) {
+                                ctx.log.info(chalk.yellow(tunnelResp.error.message))
+                            } else {
+                                ctx.log.info(chalk.yellow(`Error while fetch tunnel details; Either tunnel is not running or tunnel parameters are different`))
+                            }
+                        }
+                    }
+                }
             } catch (error: any) {
                 ctx.log.debug(error);
                 task.output = chalk.gray(error.message);

src/types.ts

@@ -32,6 +32,8 @@ export interface Context {
         figma?: FigmaWebConfig;
         ignoreHTTPSErrors : boolean;
         skipBuildCreation?: boolean;
+        tunnel?: boolean;
+        tunnelName?: string;
     };
     uploadFilePath: string;
     webStaticConfig: WebStaticConfig;
@@ -40,6 +42,11 @@ export interface Context {
     args: {
         execCommand?: Array<string>
     }
+    tunnelDetails: {
+        tunnelPort: number;
+        tunnelHost: string;
+        tunnelName: string;
+    }
     options: {
         parallel?: number,
         force?: boolean,