@percy/client 1.0.0-beta.7 → 1.0.0-beta.73

package/README.md

@@ -1,51 +1,82 @@
 # @percy/client
 
 Communicate with Percy's API to create builds and snapshots, upload resources, and finalize builds
-and snapshots. Uses `@percy/env` to send environment information with new builds. Can also be used
-to query for a project's builds using a read access token.
+and snapshots. Uses [`@percy/env`](.packages/env) to send environment information with new
+builds. Can also be used to query for a project's builds using a read access token.
 
-## Usage
+- [Usage](#usage)
+- [Create a build](#create-a-build)
+- [Create, upload, and finalize snapshots](#create-upload-and-finalize-snapshots)
+- [Finalize a build](#finalize-a-build)
+- [Query for a build*](#query-for-a-build)
+- [Query for a project's builds*](#query-for-a-projects-builds)
+- [Wait for a build to be finished*](#wait-for-a-build-to-be-finished)
 
-### `new PercyClient([options])`
+## Usage
 
 ``` js
-import PercyClient from '@percy/client';
+import PercyClient from '@percy/client'
 
-// provide a read or write token, defaults to PERCY_TOKEN environment variable
-const client = new PercyClient({ token: 'abcdef123456' })
+const client = new PercyClient(options)
 ```
 
-### Create a build
+#### Options
+
+- `token` — Your project's `PERCY_TOKEN` (**default** `process.env.PERCY_TOKEN`)
+- `clientInfo` — Client info sent to Percy via a user-agent string
+- `environmentInfo` — Environment info also sent with the user-agent string
+
+## Create a build
+
+Creates a percy build. Only one build can be created at a time per instance. During this step,
+various environment information is collected via [`@percy/env`](./packages/env#readme) and
+associated with the new build. If `PERCY_PARALLEL_TOTAL` and `PERCY_PARALLEL_NONCE` are present, a
+build shard is created as part of a parallelized Percy build.
 
 ``` js
 await client.createBuild()
 ```
 
-### Create, upload, and finalize snapshots
+## Create, upload, and finalize snapshots
+
+This method combines the work of creating a snapshot, uploading any missing resources, and finally
+finalizng the snapshot.
 
 ``` js
-await client.sendSnapshot({
-  name,
-  widths,
-  minimumHeight,
-  enableJavaScript,
-  clientInfo,
-  environmentInfo,
-  // `sha` falls back to `content` sha
-  resources: [{ url, sha, content, mimetype, root }]
-})
+await client.sendSnapshot(buildId, snapshotOptions)
 ```
 
-### Finalize a build
+#### Options
+
+- `name` — Snapshot name
+- `widths` — Widths to take screenshots at
+- `minHeight` — Miniumum screenshot height
+- `enableJavaScript` — Enable JavaScript for screenshots
+- `clientInfo` — Additional client info
+- `environmentInfo` — Additional environment info
+- `resources` — Array of snapshot resources
+  - `url` — Resource URL (**required**)
+  - `mimetype` — Resource mimetype (**required**)
+  - `content` — Resource content (**required**)
+  - `sha` — Resource content sha
+  - `root` — Boolean indicating a root resource
+
+## Finalize a build
+
+Finalizes a build. When `all` is true, `all-shards=true` is added as a query param so the
+API finalizes all other parallel build shards associated with the build.
 
 ``` js
-await client.finalizeBuild()
+// finalize a build
+await client.finalizeBuild(buildId)
 
 // finalize all parallel build shards
-await client.finalizeBuild({ all: true })
+await client.finalizeBuild(buildId, { all: true })
 ```
 
-### Query for a build
+## Query for a build
+
+Retrieves build data by id.
 
 **Requires a read access token**
 
@@ -53,19 +84,51 @@ await client.finalizeBuild({ all: true })
 await client.getBuild(buildId)
 ```
 
-### Query for a project's builds
+## Query for a project's builds
+
+Retrieves project builds, optionally filtered. The project slug can be found as part of the
+project's URL. For example, the project slug for `https://percy.io/percy/example` is
+`"percy/example"`.
 
 **Requires a read access token**
 
 ``` js
-await client.getBuilds(projectSlug/*, filters*/)
+// get all builds for a project
+await client.getBuilds(projectSlug)
+
+// get all builds for a project's "master" branch
+await client.getBuilds(projectSlug, { branch: 'master' })
 ```
 
-### Wait for a build to be finished
+#### Filters
+
+- `sha` — A single commit sha
+- `shas` — An array of commit shas
+- `branch` — The name of a branch
+- `state` — The build state (`"pending"`, `"finished"`, etc.)
+
+## Wait for a build to be finished
+
+This method resolves when the build has finished and is no longer pending or processing. By default,
+it will time out if there is no update after 10 minutes.
 
 **Requires a read access token**
 
 ``` js
-await client.waitForBuild({ build: 'build-id' })
-await client.waitForBuild({ project: 'project-slug', commit: '40-char-sha' })
+// wait for a specific project build by commit sha
+await client.waitForBuild({
+  project: 'percy/example',
+  commit: '40-char-sha'
+}, data => {
+  // called whenever data changes
+  console.log(JSON.stringify(data));
+})
 ```
+
+#### Options
+
+- `build` — Build ID (**required** when missing `commit`)
+- `commit` — Commit SHA (**required** when missing `build`)
+- `project` — Project slug (**required** when using `commit`)
+- `timeout` — Timeout in milliseconds to wait with no updates (**default** `10 * 60 * 1000`)
+- `interval` — Interval in miliseconds to check for updates (**default** `1000`)

package/dist/client.js

@@ -3,66 +3,94 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.PercyClient = void 0;
 
 var _env = _interopRequireDefault(require("@percy/env"));
 
-var _git = require("@percy/env/dist/git");
+var _utils = require("@percy/env/dist/utils");
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
 
 var _package = _interopRequireDefault(require("../package.json"));
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
+
+var _request = _interopRequireDefault(require("./request"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-// PercyClient is used to communicate with the Percy API to create and finalize
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Default client API URL can be set with an env var for API development
+const {
+  PERCY_CLIENT_API_URL = 'https://percy.io/api/v1'
+} = process.env; // Validate build ID arguments
+
+function validateBuildId(id) {
+  if (!id) throw new Error('Missing build ID');
+
+  if (!(typeof id === 'string' || typeof id === 'number')) {
+    throw new Error('Invalid build ID');
+  }
+} // Validate project path arguments
+
+
+function validateProjectPath(path) {
+  if (!path) throw new Error('Missing project path');
+
+  if (!/^[^/]+?\/.+/.test(path)) {
+    throw new Error(`Invalid project path. Expected "org/project" but received "${path}"`);
+  }
+} // PercyClient is used to communicate with the Percy API to create and finalize
 // builds and snapshot. Uses @percy/env to collect environment information used
 // during build creation.
+
+
 class PercyClient {
   constructor({
     // read or write token, defaults to PERCY_TOKEN environment variable
     token,
     // initial user agent info
-    clientInfo = '',
-    environmentInfo = '',
-    // versioned percy api url
-    apiUrl = 'https://percy.io/api/v1'
+    clientInfo,
+    environmentInfo,
+    // versioned api url
+    apiUrl = PERCY_CLIENT_API_URL
   } = {}) {
+    _defineProperty(this, "log", (0, _logger.default)('client'));
+
+    _defineProperty(this, "env", new _env.default(process.env));
+
+    _defineProperty(this, "clientInfo", new Set());
+
+    _defineProperty(this, "environmentInfo", new Set());
+
     Object.assign(this, {
       token,
-      apiUrl,
-      httpAgent: (0, _utils.httpAgentFor)(apiUrl),
-      clientInfo: [].concat(clientInfo),
-      environmentInfo: [].concat(environmentInfo),
-      env: new _env.default(process.env),
-      // build info is stored for reference
-      build: {
-        id: null,
-        number: null,
-        url: null
-      }
+      apiUrl
     });
+    this.addClientInfo(clientInfo);
+    this.addEnvironmentInfo(environmentInfo);
   } // Adds additional unique client info.
 
 
   addClientInfo(info) {
-    if (info && this.clientInfo.indexOf(info) === -1) {
-      this.clientInfo.push(info);
+    for (let i of [].concat(info)) {
+      if (i) this.clientInfo.add(i);
     }
   } // Adds additional unique environment info.
 
 
   addEnvironmentInfo(info) {
-    if (info && this.environmentInfo.indexOf(info) === -1) {
-      this.environmentInfo.push(info);
+    for (let i of [].concat(info)) {
+      if (i) this.environmentInfo.add(i);
     }
   } // Stringifies client and environment info.
 
 
   userAgent() {
-    let client = [`Percy/${/\w+$/.exec(this.apiUrl)}`].concat(`${_package.default.name}/${_package.default.version}`, this.clientInfo).filter(Boolean).join(' ');
-    let environment = this.environmentInfo.concat([`node/${process.version}`, this.env.info]).filter(Boolean).join('; ');
-    return `${client} (${environment})`;
+    let client = new Set([`Percy/${/\w+$/.exec(this.apiUrl)}`].concat(`${_package.default.name}/${_package.default.version}`, ...this.clientInfo).filter(Boolean));
+    let environment = new Set([...this.environmentInfo].concat(`node/${process.version}`, this.env.info).filter(Boolean));
+    return `${[...client].join(' ')} (${[...environment].join('; ')})`;
   } // Checks for a Percy token and returns it.
 
 
@@ -84,36 +112,21 @@ class PercyClient {
 
 
   get(path) {
-    return (0, _utils.request)(`${this.apiUrl}/${path}`, {
+    return (0, _request.default)(`${this.apiUrl}/${path}`, {
       method: 'GET',
-      agent: this.httpAgent,
       headers: this.headers()
     });
   } // Performs a POST request to a JSON API endpoint with appropriate headers.
 
 
   post(path, body = {}) {
-    return (0, _utils.request)(`${this.apiUrl}/${path}`, {
+    return (0, _request.default)(`${this.apiUrl}/${path}`, {
       method: 'POST',
-      agent: this.httpAgent,
       body: JSON.stringify(body),
       headers: this.headers({
         'Content-Type': 'application/vnd.api+json'
       })
     });
-  } // Sets build reference data or nullifies it when no data is provided.
-
-
-  setBuildData(data) {
-    var _data$attributes, _data$attributes2;
-
-    return Object.assign(this, {
-      build: {
-        id: data === null || data === void 0 ? void 0 : data.id,
-        number: data === null || data === void 0 ? void 0 : (_data$attributes = data.attributes) === null || _data$attributes === void 0 ? void 0 : _data$attributes['build-number'],
-        url: data === null || data === void 0 ? void 0 : (_data$attributes2 = data.attributes) === null || _data$attributes2 === void 0 ? void 0 : _data$attributes2['web-url']
-      }
-    });
   } // Creates a build with optional build resources. Only one build can be
   // created at a time per instance so snapshots and build finalization can be
   // done more seemlessly without manually tracking build ids
@@ -122,11 +135,8 @@ class PercyClient {
   async createBuild({
     resources = []
   } = {}) {
-    if (this.build.id) {
-      throw new Error('This client instance has not finalized the previous build');
-    }
-
-    let body = await this.post('builds', {
+    this.log.debug('Creating a new build...');
+    return this.post('builds', {
       data: {
         type: 'builds',
         attributes: {
@@ -149,7 +159,7 @@ class PercyClient {
           resources: {
             data: resources.map(r => ({
               type: 'resources',
-              id: r.sha || (0, _utils.sha256hash)(r.content),
+              id: r.sha || (0, _utils2.sha256hash)(r.content),
               attributes: {
                 'resource-url': r.url,
                 'is-root': r.root || null,
@@ -160,34 +170,32 @@ class PercyClient {
         }
       }
     });
-    this.setBuildData(body === null || body === void 0 ? void 0 : body.data);
-    return body;
   } // Finalizes the active build. When `all` is true, `all-shards=true` is
   // added as a query param so the API finalizes all other build shards.
 
 
-  async finalizeBuild({
+  async finalizeBuild(buildId, {
     all = false
   } = {}) {
-    if (!this.build.id) {
-      throw new Error('This client instance has no active build');
-    }
-
+    validateBuildId(buildId);
     let qs = all ? 'all-shards=true' : '';
-    let body = await this.post(`builds/${this.build.id}/finalize?${qs}`);
-    this.setBuildData();
-    return body;
+    this.log.debug(`Finalizing build ${buildId}...`);
+    return this.post(`builds/${buildId}/finalize?${qs}`);
   } // Retrieves build data by id. Requires a read access token.
 
 
   async getBuild(buildId) {
+    validateBuildId(buildId);
+    this.log.debug(`Get build ${buildId}`);
     return this.get(`builds/${buildId}`);
   } // Retrieves project builds optionally filtered. Requires a read access token.
 
 
-  async getBuilds(projectSlug, filters = {}) {
+  async getBuilds(project, filters = {}) {
+    validateProjectPath(project);
     let qs = Object.keys(filters).map(k => Array.isArray(filters[k]) ? filters[k].map(v => `filter[${k}][]=${v}`).join('&') : `filter[${k}]=${filters[k]}`).join('&');
-    return this.get(`projects/${projectSlug}/builds?${qs}`);
+    this.log.debug(`Fetching builds for ${project}`);
+    return this.get(`projects/${project}/builds?${qs}`);
   } // Resolves when the build has finished and is no longer pending or
   // processing. By default, will time out if no update after 10 minutes.
 
@@ -196,49 +204,52 @@ class PercyClient {
     build,
     project,
     commit,
-    progress,
-    timeout = 600000,
+    timeout = 10 * 60 * 1000,
     interval = 1000
-  }) {
+  }, onProgress) {
     if (commit && !project) {
-      throw new Error('Missing project for commit');
+      throw new Error('Missing project path for commit');
     } else if (!commit && !build) {
       throw new Error('Missing build ID or commit SHA');
-    } // get build data by id or project-commit combo
+    } else if (project) {
+      validateProjectPath(project);
+    }
 
+    let sha = commit && ((0, _utils.git)(`rev-parse ${commit}`) || commit);
 
-    let getBuildData = async () => {
-      let sha = commit && ((0, _git.git)(`rev-parse ${commit}`) || commit);
-      let body = build ? await this.getBuild(build) : await this.getBuilds(project, {
-        sha
-      });
-      let data = build ? body === null || body === void 0 ? void 0 : body.data : body === null || body === void 0 ? void 0 : body.data[0];
-      return [data, data === null || data === void 0 ? void 0 : data.attributes.state];
-    }; // recursively poll every second until the build finishes
+    let fetchData = async () => build ? (await this.getBuild(build)).data : (await this.getBuilds(project, {
+      sha
+    })).data[0];
 
+    this.log.debug(`Waiting for build ${build || `${project} (${commit})`}...`); // recursively poll every second until the build finishes
 
     return new Promise((resolve, reject) => async function poll(last, t) {
       try {
-        let [data, state] = await getBuildData();
-        let updated = JSON.stringify(data) !== JSON.stringify(last);
-        let pending = !state || state === 'pending' || state === 'processing'; // new data recieved
+        let data = await fetchData();
+        let state = data === null || data === void 0 ? void 0 : data.attributes.state;
+        let pending = !state || state === 'pending' || state === 'processing';
+        let updated = JSON.stringify(data) !== JSON.stringify(last); // new data received
 
         if (updated) {
           t = Date.now(); // no new data within the timeout
         } else if (Date.now() - t >= timeout) {
           throw new Error('Timeout exceeded without an update');
-        } // call progress after the first update
+        } // call progress every update after the first update
 
 
-        if ((last || pending) && updated && progress) {
-          progress(data);
+        if ((last || pending) && updated) {
+          onProgress === null || onProgress === void 0 ? void 0 : onProgress(data);
         } // not finished, poll again
 
 
         if (pending) {
           return setTimeout(poll, interval, data, t); // build finished
         } else {
-          resolve(data);
+          // ensure progress is called at least once
+          if (!last) onProgress === null || onProgress === void 0 ? void 0 : onProgress(data);
+          resolve({
+            data
+          });
         }
       } catch (err) {
         reject(err);
@@ -249,70 +260,70 @@ class PercyClient {
   // created from `content` if one is not provided.
 
 
-  async uploadResource({
+  async uploadResource(buildId, {
+    url,
     sha,
     filepath,
     content
-  }) {
-    if (!this.build.id) {
-      throw new Error('This client instance has no active build');
-    }
-
+  } = {}) {
+    validateBuildId(buildId);
+    this.log.debug(`Uploading resource: ${url}...`);
     content = filepath ? require('fs').readFileSync(filepath) : content;
-    return this.post(`builds/${this.build.id}/resources`, {
+    return this.post(`builds/${buildId}/resources`, {
       data: {
         type: 'resources',
-        id: sha || (0, _utils.sha256hash)(content),
+        id: sha || (0, _utils2.sha256hash)(content),
         attributes: {
-          'base64-content': (0, _utils.base64encode)(content)
+          'base64-content': (0, _utils2.base64encode)(content)
         }
       }
     });
   } // Uploads resources to the active build concurrently, two at a time.
 
 
-  async uploadResources(resources) {
-    if (!this.build.id) {
-      throw new Error('This client instance has no active build');
-    }
-
-    return (0, _utils.pool)(function* () {
+  async uploadResources(buildId, resources) {
+    validateBuildId(buildId);
+    this.log.debug(`Uploading resources for ${buildId}...`);
+    return (0, _utils2.pool)(function* () {
       for (let resource of resources) {
-        yield this.uploadResource(resource);
+        yield this.uploadResource(buildId, resource);
       }
     }, this, 2);
   } // Creates a snapshot for the active build using the provided attributes.
 
 
-  async createSnapshot({
+  async createSnapshot(buildId, {
     name,
     widths,
-    minimumHeight,
+    minHeight,
     enableJavaScript,
     clientInfo,
     environmentInfo,
     resources = []
   } = {}) {
-    if (!this.build.id) {
-      throw new Error('This client instance has no active build');
-    }
-
+    validateBuildId(buildId);
     this.addClientInfo(clientInfo);
     this.addEnvironmentInfo(environmentInfo);
-    return this.post(`builds/${this.build.id}/snapshots`, {
+
+    if (!this.clientInfo.size || !this.environmentInfo.size) {
+      this.log.warn('Warning: Missing `clientInfo` and/or `environmentInfo` properties');
+    }
+
+    this.log.debug(`Creating snapshot: ${name}...`);
+    return this.post(`builds/${buildId}/snapshots`, {
       data: {
         type: 'snapshots',
         attributes: {
           name: name || null,
           widths: widths || null,
-          'minimum-height': minimumHeight || null,
+          'minimum-height': minHeight || null,
           'enable-javascript': enableJavaScript || null
         },
         relationships: {
           resources: {
             data: resources.map(r => ({
               type: 'resources',
-              id: r.sha || (0, _utils.sha256hash)(r.content),
+              id: r.sha || (0, _utils2.sha256hash)(r.content),
               attributes: {
                 'resource-url': r.url || null,
                 'is-root': r.root || null,
@@ -327,31 +338,34 @@ class PercyClient {
 
 
   async finalizeSnapshot(snapshotId) {
+    if (!snapshotId) throw new Error('Missing snapshot ID');
+    this.log.debug(`Finalizing snapshot ${snapshotId}...`);
     return this.post(`snapshots/${snapshotId}/finalize`);
   } // Convenience method for creating a snapshot for the active build, uploading
   // missing resources for the snapshot, and finalizing the snapshot.
 
 
-  async sendSnapshot(options) {
-    var _data$relationships, _data$relationships$m;
+  async sendSnapshot(buildId, options) {
+    var _snapshot$data$relati, _snapshot$data$relati2;
 
-    let {
-      data
-    } = await this.createSnapshot(options);
-    let missing = (_data$relationships = data.relationships) === null || _data$relationships === void 0 ? void 0 : (_data$relationships$m = _data$relationships['missing-resources']) === null || _data$relationships$m === void 0 ? void 0 : _data$relationships$m.data;
+    let snapshot = await this.createSnapshot(buildId, options);
+    let missing = (_snapshot$data$relati = snapshot.data.relationships) === null || _snapshot$data$relati === void 0 ? void 0 : (_snapshot$data$relati2 = _snapshot$data$relati['missing-resources']) === null || _snapshot$data$relati2 === void 0 ? void 0 : _snapshot$data$relati2.data;
 
-    if (missing === null || missing === void 0 ? void 0 : missing.length) {
+    if (missing !== null && missing !== void 0 && missing.length) {
       let resources = options.resources.reduce((acc, r) => Object.assign(acc, {
         [r.sha]: r
       }), {});
-      await this.uploadResources(missing.map(({
+      await this.uploadResources(buildId, missing.map(({
         id
       }) => resources[id]));
     }
 
-    await this.finalizeSnapshot(data.id);
+    await this.finalizeSnapshot(snapshot.data.id);
+    return snapshot;
   }
 
 }
 
-exports.default = PercyClient;
+exports.PercyClient = PercyClient;
+var _default = PercyClient;
+exports.default = _default;

package/dist/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "PercyClient", {
+  enumerable: true,
+  get: function () {
+    return _client.PercyClient;
+  }
+});
 Object.defineProperty(exports, "default", {
   enumerable: true,
   get: function () {
@@ -10,6 +16,8 @@ Object.defineProperty(exports, "default", {
   }
 });
 
-var _client = _interopRequireDefault(require("./client"));
+var _client = _interopRequireWildcard(require("./client"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/request.js

@@ -0,0 +1,303 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ProxyHttpsAgent = exports.ProxyHttpAgent = void 0;
+exports.getProxy = getProxy;
+exports.href = href;
+exports.port = port;
+exports.proxyAgentFor = proxyAgentFor;
+exports.request = request;
+
+var _net = _interopRequireDefault(require("net"));
+
+var _tls = _interopRequireDefault(require("tls"));
+
+var _http = _interopRequireDefault(require("http"));
+
+var _https = _interopRequireDefault(require("https"));
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const CRLF = '\r\n';
+const STATUS_REG = /^HTTP\/1.[01] (\d*)/;
+const RETRY_ERROR_CODES = ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH', 'EAI_AGAIN']; // Returns the port number of a URL object. Defaults to port 443 for https
+// protocols or port 80 otherwise.
+
+function port(options) {
+  if (options.port) return options.port;
+  return options.protocol === 'https:' ? 443 : 80;
+}
+
+function href(options) {
+  let {
+    protocol,
+    hostname,
+    path,
+    pathname,
+    search,
+    hash
+  } = options;
+  return `${protocol}//${hostname}:${port(options)}` + (path || `${pathname || ''}${search || ''}${hash || ''}`);
+}
+
+;
+
+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 && !(0, _utils.hostnameMatches)(process.env.no_proxy || process.env.NO_PROXY, href(options));
+
+  if (shouldProxy) {
+    proxyUrl = new URL(proxyUrl);
+    let isHttps = proxyUrl.protocol === 'https:';
+
+    if (!isHttps && proxyUrl.protocol !== 'http:') {
+      throw new Error(`Unsupported proxy protocol: ${proxyUrl.protocol}`);
+    }
+
+    let proxy = {
+      isHttps
+    };
+    proxy.auth = !!proxyUrl.username && 'Basic ' + (proxyUrl.password ? Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`) : Buffer.from(proxyUrl.username)).toString('base64');
+    proxy.host = proxyUrl.hostname;
+    proxy.port = port(proxyUrl);
+
+    proxy.connect = () => (isHttps ? _tls.default : _net.default).connect({
+      rejectUnauthorized: options.rejectUnauthorized,
+      host: proxy.host,
+      port: proxy.port
+    });
+
+    return proxy;
+  }
+} // Proxified http agent
+
+
+class ProxyHttpAgent extends _http.default.Agent {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "httpsAgent", new _https.default.Agent({
+      keepAlive: true
+    }));
+  }
+
+  addRequest(request, options) {
+    var _request$outputData;
+
+    let proxy = getProxy(options);
+    if (!proxy) return super.addRequest(request, options);
+    (0, _logger.default)('client:proxy').debug(`Proxying request: ${options.href}`); // modify the request for proxying
+
+    request.path = href(options);
+
+    if (proxy.auth) {
+      request.setHeader('Proxy-Authorization', proxy.auth);
+    } // regenerate headers since we just changed things
+
+
+    delete request._header;
+
+    request._implicitHeader();
+
+    if (((_request$outputData = request.outputData) === null || _request$outputData === void 0 ? void 0 : _request$outputData.length) > 0) {
+      let first = request.outputData[0].data;
+      let endOfHeaders = first.indexOf(CRLF.repeat(2)) + 4;
+      request.outputData[0].data = request._header + first.substring(endOfHeaders);
+    } // coerce the connection to the proxy
+
+
+    options.port = proxy.port;
+    options.host = proxy.host;
+    delete options.path;
+
+    if (proxy.isHttps) {
+      // use the underlying https agent to complete the connection
+      request.agent = this.httpsAgent;
+      return this.httpsAgent.addRequest(request, options);
+    } else {
+      return super.addRequest(request, options);
+    }
+  }
+
+} // Proxified https agent
+
+
+exports.ProxyHttpAgent = ProxyHttpAgent;
+
+class ProxyHttpsAgent extends _https.default.Agent {
+  constructor(options) {
+    // default keep-alive
+    super({
+      keepAlive: true,
+      ...options
+    });
+  }
+
+  createConnection(options, callback) {
+    let proxy = getProxy(options);
+    if (!proxy) return super.createConnection(options, callback);
+    (0, _logger.default)('client:proxy').debug(`Proxying request: ${href(options)}`); // generate proxy connect message
+
+    let host = `${options.hostname}:${port(options)}`;
+    let connectMessage = [`CONNECT ${host} HTTP/1.1`, `Host: ${host}`];
+
+    if (proxy.auth) {
+      connectMessage.push(`Proxy-Authorization: ${proxy.auth}`);
+    }
+
+    connectMessage = connectMessage.join(CRLF);
+    connectMessage += CRLF.repeat(2); // start the proxy connection and setup listeners
+
+    let socket = proxy.connect();
+
+    let handleError = err => {
+      socket.destroy(err);
+      callback(err);
+    };
+
+    let handleClose = () => handleError(new Error('Connection closed while sending request to upstream proxy'));
+
+    let buffer = '';
+
+    let handleData = data => {
+      var _buffer$match;
+
+      buffer += data.toString(); // haven't received end of headers yet, keep buffering
+
+      if (!buffer.includes(CRLF.repeat(2))) return; // stop listening after end of headers
+
+      socket.off('data', handleData);
+
+      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}`));
+      }
+
+      options.socket = socket;
+      options.servername = options.hostname; // callback not passed in so not to be added as a listener
+
+      callback(null, super.createConnection(options));
+    }; // send and handle the connect message
+
+
+    socket.on('error', handleError).on('close', handleClose).on('data', handleData).write(connectMessage);
+  }
+
+}
+
+exports.ProxyHttpsAgent = ProxyHttpsAgent;
+
+function proxyAgentFor(url, options) {
+  let cache = proxyAgentFor.cache || (proxyAgentFor.cache = new Map());
+  let {
+    protocol,
+    hostname
+  } = new URL(url);
+  let cachekey = `${protocol}//${hostname}`;
+
+  if (!cache.has(cachekey)) {
+    cache.set(cachekey, protocol === 'https:' ? new ProxyHttpsAgent(options) : new ProxyHttpAgent(options));
+  }
+
+  return cache.get(cachekey);
+} // Proxified request function that resolves with the response body when the request is successful
+// and rejects when a non-successful response is received. The rejected error contains response data
+// 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.
+
+
+function request(url, options = {}, callback) {
+  // accept `request(url, callback)`
+  if (typeof options === 'function') [options, callback] = [{}, options];
+  let {
+    body,
+    retries,
+    retryNotFound,
+    interval,
+    noProxy,
+    ...requestOptions
+  } = options; // allow bypassing proxied requests entirely
+
+  if (!noProxy) requestOptions.agent || (requestOptions.agent = proxyAgentFor(url)); // parse the requested URL into request options
+
+  let {
+    protocol,
+    hostname,
+    port,
+    pathname,
+    search,
+    hash
+  } = new URL(url);
+  return (0, _utils.retry)((resolve, reject, retry) => {
+    let handleError = error => {
+      if (handleError.handled) return;
+      handleError.handled = true;
+      let shouldRetry = error.response // maybe retry 404s and always retry 500s
+      ? retryNotFound && error.response.status === 404 || error.response.status >= 500 && error.response.status < 600 // retry specific error codes
+      : !!error.code && RETRY_ERROR_CODES.includes(error.code);
+      return shouldRetry ? retry(error) : reject(error);
+    };
+
+    let handleFinished = async (body, res) => {
+      let raw = body; // attempt to parse the body as json
+
+      try {
+        body = JSON.parse(body);
+      } catch (e) {}
+
+      try {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          var _await$callback, _callback;
+
+          // resolve successful statuses after the callback
+          resolve((_await$callback = await ((_callback = callback) === null || _callback === void 0 ? void 0 : _callback(body, res))) !== null && _await$callback !== void 0 ? _await$callback : body);
+        } else {
+          var _body, _body$errors, _body$errors$find;
+
+          // use the first error detail or the status message
+          throw new Error(((_body = body) === null || _body === void 0 ? void 0 : (_body$errors = _body.errors) === null || _body$errors === void 0 ? void 0 : (_body$errors$find = _body$errors.find(e => e.detail)) === null || _body$errors$find === void 0 ? void 0 : _body$errors$find.detail) || `${res.statusCode} ${res.statusMessage || raw}`);
+        }
+      } catch (error) {
+        handleError(Object.assign(error, {
+          response: {
+            status: res.statusCode,
+            body
+          }
+        }));
+      }
+    };
+
+    let handleResponse = res => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => handleFinished(body, res));
+      res.on('error', handleError);
+    };
+
+    let req = (protocol === 'https:' ? _https.default : _http.default).request({ ...requestOptions,
+      path: pathname + search + hash,
+      protocol,
+      hostname,
+      port
+    });
+    req.on('response', handleResponse);
+    req.on('error', handleError);
+    req.end(body);
+  }, {
+    retries,
+    interval
+  });
+}
+
+var _default = request;
+exports.default = _default;

package/dist/utils.js

@@ -3,16 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sha256hash = sha256hash;
 exports.base64encode = base64encode;
+exports.hostnameMatches = hostnameMatches;
 exports.pool = pool;
-exports.httpAgentFor = httpAgentFor;
-exports.request = request;
+exports.retry = retry;
+exports.sha256hash = sha256hash;
 
 var _crypto = _interopRequireDefault(require("crypto"));
 
-var _url = require("url");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Returns a sha256 hash of a string.
@@ -74,17 +72,13 @@ function pool(generator, context, concurrency) {
 function retry(fn, {
   retries = 5,
   interval = 50
-} = {}) {
+}) {
   return new Promise((resolve, reject) => {
-    // run the function, decrement retries
-    let run = () => {
-      fn(resolve, reject, retry);
-      retries--;
-    }; // wait an interval to try again or reject with the error
+    let run = () => fn(resolve, reject, retry); // wait an interval to try again or reject with the error
 
 
     let retry = err => {
-      if (retries) {
+      if (retries-- > 0) {
         setTimeout(run, interval);
       } else {
         reject(err);
@@ -94,83 +88,35 @@ function retry(fn, {
 
     run();
   });
-} // Returns the appropriate http or https module for a given URL.
+} // Returns true if the URL hostname matches any patterns
 
 
-function httpModuleFor(url) {
-  return url.match(/^https:\/\//) ? require('https') : require('http');
-} // Returns the appropriate http or https Agent instance for a given URL.
+function hostnameMatches(patterns, url) {
+  let subject = new URL(url);
+  /* istanbul ignore next: only strings are provided internally by the client proxy; core (which
+   * borrows this util) sometimes provides an array of patterns or undefined */
 
+  patterns = typeof patterns === 'string' ? patterns.split(/[\s,]+/) : [].concat(patterns);
 
-function httpAgentFor(url) {
-  let {
-    Agent
-  } = httpModuleFor(url);
-  return new Agent({
-    keepAlive: true,
-    maxSockets: 5
-  });
-} // Returns a promise that resolves when the request is successful and rejects
-// when a non-successful response is received. The rejected error contains
-// response data and any received error details. Server 500 errors are retried
-// up to 5 times at 50ms intervals.
+  for (let pattern of patterns) {
+    if (pattern === '*') return true;
+    if (!pattern) continue; // parse pattern
 
+    let {
+      groups: rule
+    } = pattern.match(/^(?<hostname>.+?)(?::(?<port>\d+))?$/); // missing a hostname or ports do not match
 
-function request(url, {
-  body,
-  ...options
-}) {
-  let http = httpModuleFor(url);
-  let {
-    protocol,
-    hostname,
-    port,
-    pathname,
-    search
-  } = new _url.URL(url);
-  options = { ...options,
-    protocol,
-    hostname,
-    port,
-    path: pathname + search
-  };
-  return retry((resolve, reject, retry) => {
-    http.request(options).on('response', res => {
-      let status = res.statusCode;
-      let raw = '';
-      res.setEncoding('utf8');
-      res.on('data', chunk => {
-        raw += chunk;
-      });
-      res.on('end', () => {
-        let body = raw; // attempt to parse json responses
-
-        try {
-          body = JSON.parse(raw);
-        } catch (e) {} // success
-
-
-        if (status >= 200 && status < 300) {
-          resolve(body);
-        } else {
-          var _body, _body$errors, _body$errors$;
-
-          // error
-          let err = Object.assign(new Error(), {
-            response: {
-              status,
-              body
-            },
-            message: ((_body = body) === null || _body === void 0 ? void 0 : (_body$errors = _body.errors) === null || _body$errors === void 0 ? void 0 : (_body$errors$ = _body$errors[0]) === null || _body$errors$ === void 0 ? void 0 : _body$errors$.detail) || `${status} ${res.statusMessage || raw}`
-          }); // retry 500s
-
-          if (status >= 500) {
-            retry(err);
-          } else {
-            reject(err);
-          }
-        }
-      });
-    }).on('error', reject).end(body);
-  });
+    if (!rule.hostname || rule.port && rule.port !== subject.port) {
+      continue;
+    } // wildcards are treated the same as leading dots
+
+
+    rule.hostname = rule.hostname.replace(/^\*/, ''); // hostnames are equal or end with a wildcard rule
+
+    if (rule.hostname === subject.hostname || rule.hostname.startsWith('.') && subject.hostname.endsWith(rule.hostname)) {
+      return true;
+    }
+  }
+
+  return false;
 }

package/package.json

@@ -1,28 +1,35 @@
 {
   "name": "@percy/client",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.73",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/client"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "dist/index.js",
   "files": [
-    "dist"
+    "dist",
+    "test/helpers.js"
   ],
+  "engines": {
+    "node": ">=12"
+  },
   "scripts": {
-    "build": "babel --root-mode upward src --out-dir dist",
+    "build": "node ../../scripts/build",
     "lint": "eslint --ignore-path ../../.gitignore .",
-    "test": "cross-env NODE_ENV=test mocha",
-    "test:coverage": "nyc yarn test"
+    "test": "node ../../scripts/test",
+    "test:coverage": "yarn test --coverage"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "mocha": {
-    "require": "../../scripts/babel-register"
+  "dependencies": {
+    "@percy/env": "1.0.0-beta.73",
+    "@percy/logger": "1.0.0-beta.73"
   },
   "devDependencies": {
     "mock-require": "^3.0.3"
   },
-  "dependencies": {
-    "@percy/env": "^1.0.0-beta.7"
-  },
-  "gitHead": "5be796ec8f17958e93ada0b634899b945c9b0d60"
+  "gitHead": "aa8160e02bea3e04ab1d3605762f89fbe79605d4"
 }

package/test/helpers.js

@@ -0,0 +1,81 @@
+const nock = require('nock');
+
+const DEFAULT_REPLIES = {
+  '/builds': () => [201, {
+    data: {
+      id: '123',
+      attributes: {
+        'build-number': 1,
+        'web-url': 'https://percy.io/test/test/123'
+      }
+    }
+  }],
+
+  '/builds/123/snapshots': ({ body }) => [201, {
+    data: {
+      id: '4567',
+      attributes: body.attributes,
+      relationships: {
+        'missing-resources': {
+          data: body.data.relationships.resources
+            .data.map(({ id }) => ({ id }))
+        }
+      }
+    }
+  }]
+};
+
+const mockAPI = {
+  nock: null,
+  requests: null,
+  replies: null,
+
+  start(delay = 0) {
+    nock.cleanAll();
+    nock.disableNetConnect();
+    nock.enableNetConnect('storage.googleapis.com|localhost|127.0.0.1');
+
+    let n = this.nock = nock('https://percy.io/api/v1').persist();
+    let requests = this.requests = {};
+    let replies = this.replies = {};
+
+    function intercept(_, body) {
+      let { path, headers, method } = this.req;
+
+      try { body = JSON.parse(body); } catch {}
+      path = path.replace('/api/v1', '');
+
+      let req = { body, headers, method };
+      let reply = replies[path] && (
+        replies[path].length > 1
+          ? replies[path].shift()
+          : replies[path][0]
+      );
+
+      requests[path] = requests[path] || [];
+      requests[path].push(req);
+
+      return reply ? reply(req) : (
+        DEFAULT_REPLIES[path]
+          ? DEFAULT_REPLIES[path](req)
+          : [200]
+      );
+    }
+
+    n.get(/.*/).delay(delay).reply(intercept);
+    n.post(/.*/).delay(delay).reply(intercept);
+  },
+
+  reply(path, handler) {
+    this.replies[path] = this.replies[path] || [];
+    this.replies[path].push(handler);
+    return this;
+  },
+
+  cleanAll() {
+    nock.cleanAll();
+    return this;
+  }
+};
+
+module.exports = mockAPI;