@percy/client 1.32.12-beta.1 → 1.32.12-beta.2

package/dist/proxy.js

@@ -86,13 +86,17 @@ export function href(options) {
 }
 ;
 
-// Returns the proxy URL for a set of request options
-export function getProxy(options) {
-  let proxyUrl = options.protocol === 'https:' && (process.env.https_proxy || process.env.HTTPS_PROXY) || process.env.http_proxy || process.env.HTTP_PROXY;
-  let shouldProxy = !!proxyUrl && !hostnameMatches(stripQuotesAndSpaces(process.env.no_proxy || process.env.NO_PROXY), href(options));
-  if (proxyUrl && typeof proxyUrl === 'string') {
-    proxyUrl = stripQuotesAndSpaces(proxyUrl);
+// Returns the proxy URL for a set of request options. An explicit `override` proxy URL is
+// used as-is, without consulting the proxy env vars or NO_PROXY; the caller owns bypassing.
+export function getProxy(options, override) {
+  let envProxyUrl = options.protocol === 'https:' && (process.env.https_proxy || process.env.HTTPS_PROXY) || process.env.http_proxy || process.env.HTTP_PROXY;
+  let shouldProxy = !!override || !!envProxyUrl && !hostnameMatches(stripQuotesAndSpaces(process.env.no_proxy || process.env.NO_PROXY), href(options));
+
+  // only env values may carry stray quotes/spaces; an explicit override is used verbatim
+  if (envProxyUrl && typeof envProxyUrl === 'string') {
+    envProxyUrl = stripQuotesAndSpaces(envProxyUrl);
   }
+  let proxyUrl = override || envProxyUrl;
   if (shouldProxy) {
     proxyUrl = new URL(proxyUrl);
     let isHttps = proxyUrl.protocol === 'https:';
@@ -120,11 +124,20 @@ export class ProxyHttpAgent extends http.Agent {
   httpsAgent = new https.Agent({
     keepAlive: true
   });
+
+  // an optional `proxy` URL takes precedence over the proxy env vars
+  constructor({
+    proxy,
+    ...options
+  } = {}) {
+    super(options);
+    this.proxy = proxy;
+  }
   addRequest(request, options) {
     var _request$outputData;
-    let proxy = getProxy(options);
+    let proxy = getProxy(options, this.proxy);
     if (!proxy) return super.addRequest(request, options);
-    logger('client:proxy').debug(`Proxying request: ${options.href}`);
+    logger('client:proxy').debug(`Proxying request: ${href(options)}`);
 
     // modify the request for proxying
     request.path = href(options);
@@ -157,15 +170,20 @@ export class ProxyHttpAgent extends http.Agent {
 
 // Proxified https agent
 export class ProxyHttpsAgent extends https.Agent {
-  constructor(options) {
+  // an optional `proxy` URL takes precedence over the proxy env vars
+  constructor({
+    proxy,
+    ...options
+  } = {}) {
     // default keep-alive
     super({
       keepAlive: true,
       ...options
     });
+    this.proxy = proxy;
   }
   createConnection(options, callback) {
-    let proxy = getProxy(options);
+    let proxy = getProxy(options, this.proxy);
     if (!proxy) return super.createConnection(options, callback);
     logger('client:proxy').debug(`Proxying request: ${href(options)}`);
 
@@ -180,8 +198,13 @@ export class ProxyHttpsAgent extends https.Agent {
 
     // start the proxy connection and setup listeners
     let socket = proxy.connect();
+
+    // destroying the socket re-emits 'error' and 'close'; only the first failure counts
+    let failed = false;
     let handleError = err => {
       var _err$message, _err$message2;
+      if (failed) return;
+      failed = true;
       socket.destroy(err);
       logger('client:proxy').error(`Proxying request ${href(options)} failed: ${err}`);
 
@@ -194,6 +217,12 @@ export class ProxyHttpsAgent extends https.Agent {
       callback(err);
     };
     let handleClose = () => handleError(new Error('Connection closed while sending request to upstream proxy'));
+
+    // a request's `timeout` only starts once it has a socket, which is handed over after the
+    // CONNECT reply; bound the handshake itself so a silent proxy cannot hang the request
+    let handleTimeout = () => handleError(Object.assign(new Error(`Request to ${href(options)} timed out after ${options.timeout}ms waiting for the proxy`), {
+      code: 'ETIMEDOUT'
+    }));
     let buffer = '';
     let handleData = data => {
       var _buffer$match;
@@ -205,11 +234,16 @@ export class ProxyHttpsAgent extends https.Agent {
       if (((_buffer$match = buffer.match(STATUS_REG)) === null || _buffer$match === void 0 ? void 0 : _buffer$match[1]) !== '200') {
         return handleError(new Error('Error establishing proxy connection. ' + `Response from server was: ${buffer}`));
       }
+
+      // the tunnel is established; its later close (e.g. keep-alive teardown) is not a failure
+      socket.off('error', handleError).off('close', handleClose).off('timeout', handleTimeout);
+      socket.setTimeout(0);
       options.socket = socket;
       options.servername = options.hostname;
       // callback not passed in so not to be added as a listener
       callback(null, super.createConnection(options));
     };
+    if (options.timeout) socket.setTimeout(options.timeout, handleTimeout);
 
     // send and handle the connect message
     socket.on('error', handleError).on('close', handleClose).on('data', handleData).write(connectMessage);
@@ -222,6 +256,7 @@ export function proxyAgentFor(url, options) {
     hostname
   } = new URL(url);
   let cachekey = `${protocol}//${hostname}`;
+  if (options !== null && options !== void 0 && options.proxy) cachekey += ` via ${options.proxy}`;
 
   // If we already have a cached agent, return it
   if (cache.has(cachekey)) {
@@ -231,8 +266,8 @@ export function proxyAgentFor(url, options) {
     let agent;
     const pacUrl = process.env.PERCY_PAC_FILE_URL;
 
-    // If PAC URL is provided, use PAC proxy
-    if (pacUrl) {
+    // If PAC URL is provided, use PAC proxy (an explicit proxy takes precedence)
+    if (pacUrl && !(options !== null && options !== void 0 && options.proxy)) {
       logger('client:proxy').info(`Using PAC file from: ${pacUrl}`);
       agent = createPacAgent(pacUrl, options);
     } else {

package/dist/utils.js

@@ -116,7 +116,8 @@ const RETRY_ERROR_CODES = ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH'
 // and any received error details. Server 500 errors are retried up to 5 times at 50ms intervals by
 // default, and 404 errors may also be optionally retried. If a callback is provided, it is called
 // with the parsed response body and response details. If the callback returns a value, that value
-// will be returned in the final resolved promise instead of the response body.
+// will be returned in the final resolved promise instead of the response body. A `proxy` URL
+// routes the request through that proxy regardless of the proxy env vars.
 export async function request(url, options = {}, callback) {
   // accept `request(url, callback)`
   if (typeof options === 'function') [options, callback] = [{}, options];
@@ -129,6 +130,7 @@ export async function request(url, options = {}, callback) {
     retryNotFound,
     interval,
     noProxy,
+    proxy,
     buffer,
     meta = {},
     ...requestOptions
@@ -163,7 +165,9 @@ export async function request(url, options = {}, callback) {
 
   // combine request options
   Object.assign(requestOptions, {
-    agent: requestOptions.agent || !noProxy && proxyAgentFor(url) || null,
+    agent: requestOptions.agent || proxy && proxyAgentFor(url, {
+      proxy
+    }) || !noProxy && proxyAgentFor(url) || null,
     path: pathname + search + hash,
     protocol,
     hostname,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/client",
-  "version": "1.32.12-beta.1",
+  "version": "1.32.12-beta.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,11 +33,11 @@
     "test:coverage": "yarn test --coverage"
   },
   "dependencies": {
-    "@percy/config": "1.32.12-beta.1",
-    "@percy/env": "1.32.12-beta.1",
-    "@percy/logger": "1.32.12-beta.1",
+    "@percy/config": "1.32.12-beta.2",
+    "@percy/env": "1.32.12-beta.2",
+    "@percy/logger": "1.32.12-beta.2",
     "pac-proxy-agent": "^7.0.2",
     "pako": "^2.1.0"
   },
-  "gitHead": "80a7983e35606c049956af87c5f74646cb2333fa"
+  "gitHead": "35e95e257d7f09d763698765e429dbae0ce7d5e9"
 }