@mablhq/mabl-cli 1.61.8 → 2.0.3

package/execution/runAppiumServer.js

@@ -0,0 +1,133 @@
+const appium = require('appium');
+
+
+
+
+
+
+
+const APPIUM_SERVER_READY = 'APPIUM_SERVER_READY';
+const APPIUM_SERVER_SHUTDOWN = 'APPIUM_SERVER_SHUTDOWN';
+const APPIUM_SERVER_LOG = 'APPIUM_SERVER_LOG';
+const APPIUM_SERVER_PARENT_ALIVE = 'APPIUM_SERVER_PARENT_ALIVE';
+const APPIUM_SERVER_CHECK_IN = 'APPIUM_SERVER_CHECK_IN';
+
+
+const CHECK_IN_FAIL_LIMIT_MILLIS = 15_000;
+
+const CHECK_IN_INTERVAL_MILLIS = 5_000;
+
+
+const appiumConfig = JSON.parse(process.argv[2]);
+
+if (appiumConfig.androidHome) {
+  process.env.ANDROID_HOME = appiumConfig.androidHome;
+  delete appiumConfig.androidHome;
+}
+
+
+
+appiumConfig.allowInsecure = ['chromedriver_autodownload'];
+
+let server;
+let shutdownCalled = false;
+let lastKnownCheckInTime = Date.now();
+let intervalCheckIn;
+
+appium
+  .main({...appiumConfig, logHandler: logHandlerFunc})
+  .then((serverInstance) => {
+    server = serverInstance;
+    process.send({type: APPIUM_SERVER_READY});
+    lastKnownCheckInTime = Date.now();
+    intervalCheckIn = global.setInterval(
+      checkInOnParent,
+      CHECK_IN_INTERVAL_MILLIS,
+    );
+  })
+  .catch((error) => {
+    
+    throw error;
+  });
+process.on('message', (message) => {
+  switch (message) {
+        case APPIUM_SERVER_PARENT_ALIVE:
+      lastKnownCheckInTime = Date.now();
+      break;
+    case APPIUM_SERVER_SHUTDOWN:
+      shutdownCalled = true;
+      server.close().catch((error) => {
+        
+        throw error;
+      });
+      break;
+    default:
+      console.log('unsupported message', message);
+  }
+});
+
+
+function logHandlerFunc(logLevel, log) {
+  process.send({
+    type: APPIUM_SERVER_LOG,
+    payload: {
+      logLevel,
+      log,
+    },
+  });
+}
+
+
+const originalExit = process.exit;
+
+
+
+process.exit = (code) => {
+  if (shutdownCalled) {
+    global.clearInterval(intervalCheckIn);
+    
+    
+    originalExit();
+    process.kill();
+  }
+  if (code && code > 0) {
+    const stack = new Error().stack;
+    process.send({
+      type: APPIUM_SERVER_LOG,
+      payload: {
+        logLevel: 'error',
+        log: `process.exit() call prevented - ${stack}`,
+      },
+    });
+    return;
+  }
+};
+
+process.on('disconnect', () => {
+  console.log(
+    '[runAppiumServer.js] lost connection to parent process, terminating',
+  );
+  originalExit();
+  process.kill();
+});
+
+
+function checkInOnParent() {
+  try {
+    process.send({type: APPIUM_SERVER_CHECK_IN});
+    const currentTime = Date.now();
+    const timeSinceLastCheckIn = currentTime - lastKnownCheckInTime;
+    if (timeSinceLastCheckIn > CHECK_IN_FAIL_LIMIT_MILLIS) {
+      console.log(
+        '[runAppiumServer.js] parent process has gone dark, terminating',
+      );
+      global.clearInterval(intervalCheckIn);
+      originalExit();
+      process.kill();
+    }
+    lastKnownCheckInTime = currentTime;
+  } catch (error) {
+    console.error('Could not run checkin function', error);
+  }
+  return;
+}

package/http/MablHttpAgent.js

@@ -55,11 +55,14 @@ class MablHttpAgent extends agent_base_1.Agent {
             httpsAgent: (_b = httpsAgent !== null && httpsAgent !== void 0 ? httpsAgent : proxyConfig.httpsAgent) !== null && _b !== void 0 ? _b : https.globalAgent,
         };
     }
-    callback(req, opts) {
+    createSocket(req, options, cb) {
         var _a;
         if ((_a = this.maybeGetFirstStringHeader(req, httpUtil_1.USER_AGENT_HEADER)) === null || _a === void 0 ? void 0 : _a.startsWith('PostmanRuntime/')) {
             req.setHeader(httpUtil_1.USER_AGENT_HEADER, httpUtil_1.USER_AGENT);
         }
+        super.createSocket(req, options, cb);
+    }
+    connect(_req, opts) {
         return Promise.resolve(opts.secureEndpoint ? this.httpsAgent : this.httpAgent);
     }
     maybeGetFirstStringHeader(req, name) {

package/http/RequestFilteringHttpAgent.js

@@ -45,17 +45,17 @@ class RequestFilteringHttpAgent extends MablHttpAgent_1.MablHttpAgent {
         const constructorParameters = await MablHttpAgent_1.MablHttpAgent.getConstructorParameters();
         return new RequestFilteringHttpAgent(constructorParameters.httpAgent, constructorParameters.httpsAgent);
     }
-    callback(req, opts) {
+    connect(req, opts) {
         if (isForbiddenHost(opts.host)) {
             return Promise.reject(new RequestSecurityError_1.RequestSecurityError('Request contains forbidden host'));
         }
-        else if (containsForbiddenHeader(opts.headers)) {
+        else if (containsForbiddenHeader(req.getHeaders())) {
             return Promise.reject(new RequestSecurityError_1.RequestSecurityError('Request contains forbidden header'));
         }
         else if (isPrivateAddress(opts.host)) {
             return Promise.reject(new RequestSecurityError_1.RequestSecurityError('Request contains private address'));
         }
-        return super.callback(req, opts);
+        return super.connect(req, opts);
     }
 }
 exports.RequestFilteringHttpAgent = RequestFilteringHttpAgent;

package/http/axiosProxyConfig.js

@@ -23,12 +23,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeGetModifiedAxiosConfigForHttpProxy = exports.proxyUrlToPortConfig = exports.axiosProxyConfig = exports.currentProxyConfig = void 0;
+exports.proxyUrlToPortConfig = exports.axiosProxyConfig = exports.currentProxyConfig = exports.setTestExecutionProxyUrl = void 0;
 const cliConfigProvider_1 = require("../providers/cliConfigProvider");
 const https = __importStar(require("https"));
 const https_proxy_agent_1 = require("https-proxy-agent");
 const hpagent_1 = require("hpagent");
 const httpUtil_1 = require("./httpUtil");
+let testExecutionProxyUrl;
+function setTestExecutionProxyUrl(url) {
+    testExecutionProxyUrl = url;
+}
+exports.setTestExecutionProxyUrl = setTestExecutionProxyUrl;
 async function currentProxyConfig(mode = 'mabl') {
     const httpConfig = (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).http;
     return axiosProxyConfig(mode === 'test' ? httpConfig === null || httpConfig === void 0 ? void 0 : httpConfig.test : httpConfig === null || httpConfig === void 0 ? void 0 : httpConfig.mabl);
@@ -41,15 +46,21 @@ function axiosProxyConfig(httpConfig) {
             [httpUtil_1.USER_AGENT_HEADER]: httpUtil_1.USER_AGENT,
         },
     };
-    if (!httpConfig.sslVerify) {
+    let { proxyType, sslVerify } = httpConfig;
+    if (testExecutionProxyUrl) {
+        sslVerify = false;
+        proxyType = 'current';
+    }
+    if (!sslVerify) {
         config.httpsAgent = new https.Agent({
             rejectUnauthorized: false,
         });
     }
-    if ((_a = httpConfig.proxyHost) === null || _a === void 0 ? void 0 : _a.href) {
-        config.proxy = proxyUrlToPortConfig(httpConfig.proxyHost);
+    if (testExecutionProxyUrl || ((_a = httpConfig.proxyHost) === null || _a === void 0 ? void 0 : _a.href)) {
+        config.proxy = proxyUrlToPortConfig((testExecutionProxyUrl !== null && testExecutionProxyUrl !== void 0 ? testExecutionProxyUrl : httpConfig.proxyHost));
     }
-    return maybeGetModifiedAxiosConfigForHttpProxy(config, httpConfig.sslVerify, httpConfig.proxyType);
+    const result = maybeGetModifiedAxiosConfigForHttpProxy(config, sslVerify, proxyType);
+    return result;
 }
 exports.axiosProxyConfig = axiosProxyConfig;
 function escapeRegexDots(input) {
@@ -87,12 +98,16 @@ function maybeGetModifiedAxiosConfigForHttpProxy(config, sslVerify, proxyType) {
         };
         newConfig.proxy = false;
         const authConfig = config.proxy.auth;
+        let proxyString = 'http://';
+        if (authConfig) {
+            proxyString += `${authConfig.username}:${authConfig.password}@`;
+        }
+        proxyString += `${config.proxy.host}:${config.proxy.port}`;
+        const proxyUrl = new URL(proxyString);
+        const configOptions = {
+            rejectUnauthorized: sslVerify !== false,
+        };
         if (proxyType === 'current') {
-            let proxyString = 'http://';
-            if (authConfig !== undefined) {
-                proxyString += `${authConfig.username}:${authConfig.password}@`;
-            }
-            proxyString += `${config.proxy.host}:${config.proxy.port}`;
             const agentConfig = {
                 keepAlive: true,
                 keepAliveMsecs: 1000,
@@ -102,22 +117,12 @@ function maybeGetModifiedAxiosConfigForHttpProxy(config, sslVerify, proxyType) {
                 rejectUnauthorized: sslVerify !== false,
             };
             newConfig.httpsAgent = new hpagent_1.HttpsProxyAgent(agentConfig);
-            newConfig.httpAgent = new hpagent_1.HttpsProxyAgent(agentConfig);
         }
         else {
-            const configOptions = {
-                host: config.proxy.host,
-                port: config.proxy.port,
-                auth: authConfig
-                    ? `${authConfig.username}:${authConfig.password}`
-                    : undefined,
-                rejectUnauthorized: sslVerify !== false,
-            };
-            newConfig.httpsAgent = new https_proxy_agent_1.HttpsProxyAgent(configOptions);
-            newConfig.httpAgent = new https_proxy_agent_1.HttpsProxyAgent(configOptions);
+            newConfig.httpsAgent = new https_proxy_agent_1.HttpsProxyAgent(proxyUrl, configOptions);
         }
+        newConfig.httpAgent = new https_proxy_agent_1.HttpsProxyAgent(proxyUrl, configOptions);
         return newConfig;
     }
     return config;
 }
-exports.maybeGetModifiedAxiosConfigForHttpProxy = maybeGetModifiedAxiosConfigForHttpProxy;

package/http/httpUtil.js

@@ -27,16 +27,12 @@ function maybeGetSocksAgent(linkServer) {
     if (!linkServer) {
         return;
     }
-    const agentOptions = {
-        host: linkServer.forwarding_host,
-        port: linkServer.forwarding_port,
-        userId: linkServer.workspace_id,
-        password: linkServer.label,
-        tls: {
-            rejectUnauthorized: false,
-        },
-    };
-    return new socks_proxy_agent_1.SocksProxyAgent(agentOptions);
+    const user = linkServer.workspace_id;
+    const password = linkServer.label;
+    const host = linkServer.forwarding_host;
+    const port = linkServer.forwarding_port;
+    const url = new URL(`socks5h://${user}:${password}@${host}:${port}`);
+    return new socks_proxy_agent_1.SocksProxyAgent(url);
 }
 function postProcessHeaders(response) {
     var _a, _b, _c;