Refactor nodejs module rewriting for further extension

We want to be able to also inject electron apps, so reorganising
this a little will be useful.

Author: pimterry

overrides/js/prepend-node.js

@@ -0,0 +1,94 @@
+/**
+ * --require'd by node before loading any other modules.
+ * This file sets up a global agent for the http & https modules,
+ * plus tweaks various other HTTP clients that need nudges, so they
+ * all correctly pick up the proxy from the environment.
+ *
+ * Tested against Node 6, 8, 10 and 12.
+*/
+
+const wrapModule = require('./wrap-require');
+
+let httpAlreadyIntercepted = false;
+
+function interceptAllHttp() {
+    if (httpAlreadyIntercepted) return;
+    httpAlreadyIntercepted = true;
+
+    const MAJOR_NODEJS_VERSION = parseInt(process.version.slice(1).split('.')[0], 10);
+
+    if (MAJOR_NODEJS_VERSION >= 10) {
+        // `global-agent` works with Node.js v10 and above.
+        const globalAgent = require('global-agent');
+        globalAgent.bootstrap();
+    } else {
+        // `global-tunnel-ng` works only with Node.js v10 and below.
+        const globalTunnel = require('global-tunnel-ng');
+        globalTunnel.initialize();
+    }
+}
+
+wrapModule('http', interceptAllHttp, true);
+wrapModule('https', interceptAllHttp, true);
+
+wrapModule('axios', function wrapAxios (loadedModule) {
+    // Global agent handles this automatically, if used (i.e. Node >= 10)
+    if (global.GLOBAL_AGENT) return;
+
+    // Disable built-in proxy support, to let global-tunnel take precedence
+    // Supported back to the very first release of Axios
+    loadedModule.defaults.proxy = false;
+});
+
+wrapModule('request', function wrapRequest (loadedModule) {
+    // Global agent handles this automatically, if used (i.e. Node >= 10)
+    if (global.GLOBAL_AGENT) return;
+
+    // Is this Request >= 2.17?
+    // Before then proxy support isn't a problem anyway
+    if (!loadedModule.defaults) return;
+
+    // Have we intercepted this already?
+    if (loadedModule.INTERCEPTED_BY_HTTPTOOLKIT) return;
+
+    const fixedModule = loadedModule.defaults({ proxy: false });
+    fixedModule.INTERCEPTED_BY_HTTPTOOLKIT = true;
+    return fixedModule;
+});
+
+wrapModule('superagent', function wrapSuperagent (loadedModule) {
+    // Global agent handles this automatically, if used (i.e. Node >= 10)
+    if (global.GLOBAL_AGENT) return;
+
+    // Have we intercepted this already?
+    if (loadedModule.INTERCEPTED_BY_HTTPTOOLKIT) return;
+    loadedModule.INTERCEPTED_BY_HTTPTOOLKIT = true;
+
+    // Global tunnel doesn't successfully reconfigure superagent.
+    // To fix it, we forcibly override the agent property on every request.
+    const originalRequestMethod = loadedModule.Request.prototype.request;
+    loadedModule.Request.prototype.request = function () {
+        if (this.url.indexOf('https:') === 0) {
+            this._agent = require('https').globalAgent;
+        } else {
+            this._agent = require('http').globalAgent;
+        }
+        return originalRequestMethod.apply(this, arguments);
+    };
+});
+
+wrapModule('stripe', function wrapStripe (loadedModule) {
+    if (loadedModule.INTERCEPTED_BY_HTTPTOOLKIT) return;
+
+    return Object.assign(
+        function () {
+            const result = loadedModule.apply(this, arguments);
+
+            // Set by global-tunnel in Node < 10 (or global-agent in 11.7+)
+            result.setHttpAgent(require('https').globalAgent);
+            return result;
+        },
+        loadedModule,
+        { INTERCEPTED_BY_HTTPTOOLKIT: true }
+    );
+});

overrides/js/wrap-require.js

@@ -0,0 +1,80 @@
+/**
+ * Intercept calls to require() certain modules, to monkey-patch them.
+ *
+ * This modules intercepts all require calls. For all modules previously
+ * registered via wrapModule, it runs the registered wrapper on the loaded
+ * module before it is returned to the original require() call.
+ */
+
+// Grab the built-in module loader that we're going to intercept
+const mod = require('module');
+const realLoad = mod._load;
+
+const wrappers = {};
+
+// Either false, or a list (initially empty) of modules whose wrapping is being
+// delayed. This is important for modules who require other modules that need
+// wrapping, to avoid issues with circular requires.
+let wrappingBlocked = false;
+
+function fixModule(requestedName, filename, loadedModule) {
+    const wrapper = wrappers[requestedName];
+
+    if (wrapper) {
+        wrappingBlocked = wrapper.shouldBlockWrapping ? [] : false;
+
+        // wrap can either return a replacement, or mutate the module itself.
+        const fixedModule = wrapper.wrap(loadedModule) || loadedModule;
+
+        if (fixedModule !== loadedModule && mod._cache[filename] && mod._cache[filename].exports) {
+            mod._cache[filename].exports = fixedModule;
+        }
+
+        if (wrappingBlocked) {
+            wrappingBlocked.forEach(function (modDetails) {
+                fixModule(modDetails.requestedName, modDetails.filename, modDetails.loadedModule);
+            });
+            wrappingBlocked = false;
+        }
+
+        return fixedModule;
+    } else {
+        return loadedModule;
+    }
+}
+
+// Our hook into require():
+mod._load = function (requestedName, parent, isMain) {
+    const filename = mod._resolveFilename(requestedName, parent, isMain);
+    let loadedModule = realLoad.apply(this, arguments);
+
+    // Should always be set, but check just in case. This also allows
+    // users to disable interception explicitly, if need be.
+    if (!process.env.HTTP_TOOLKIT_ACTIVE) return loadedModule;
+
+    if (wrappingBlocked !== false) {
+        wrappingBlocked.push({
+            requestedName: requestedName,
+            filename: filename,
+            loadedModule: loadedModule
+        });
+    } else {
+        loadedModule = fixModule(requestedName, filename, loadedModule);
+    }
+
+    return loadedModule;
+};
+
+// Register a wrapper for a given name. If shouldBlockWrapping is set, all wrapping
+// of modules require'd during the modules wrapper function will be delayed until
+// after it completes.
+module.exports = function wrapModule(
+    requestedName,
+    wrapperFunction,
+    shouldBlockWrapping
+) {
+    wrappers[requestedName] = {
+        wrap: wrapperFunction,
+        shouldBlockWrapping: shouldBlockWrapping || false
+    };
+};

overrides/path/node

@@ -6,7 +6,7 @@ PATH="${PATH//`dirname "$0"`:/}"
 real_node=`command -v node`
 PATH="`dirname "$0"`:$PATH"
 
-PREPEND_PATH=`dirname "$0"`/prepend.js
+PREPEND_PATH=`dirname "$0"`/../js/prepend-node.js
 
 # Call node with the given arguments, prefixed with our extra logic
 if command -v winpty >/dev/null 2>&1; then

overrides/path/node.bat

@@ -17,4 +17,4 @@ REM Reset PATH, so its visible to node & subprocesses
 set PATH=%ORIGINALPATH%
 
 REM Start Node for real, with an extra arg to inject our logic
-"%REAL_NODE%" -r "%WRAPPER_FOLDER%\prepend.js" %*
+"%REAL_NODE%" -r "%WRAPPER_FOLDER%\..\js\prepend-node.js" %*

overrides/path/prepend.js

@@ -50,7 +50,7 @@ describe('Fresh terminal interceptor', function () {
             // Spawn node, as if it was run inside an intercepted terminal
             const terminalEnvOverrides = getTerminalEnvVars(server.port, httpsConfig, process.env);
             const nodeScript = fork(require.resolve('./terminal-js-test-script'), [], {
-                execArgv: ['-r', require.resolve('../../overrides/path/prepend.js')],
+                execArgv: ['-r', require.resolve('../../overrides/js/prepend-node.js')],
                 env: Object.assign({}, process.env, terminalEnvOverrides)
             });
             await new Promise((resolve, reject) => {