fsevents 1.1.2 → 1.2.3

package/node_modules/needle/test/utils/test.js

@@ -0,0 +1,104 @@
+// TODO: write specs. :)
+
+var fs = require('fs'),
+    client = require('./../../');
+
+process.env.DEBUG = true;
+
+var response_callback = function(err, resp, body){
+	console.log(err);
+	if(resp) console.log("Got status code " + resp.statusCode)
+	console.log(body);
+}
+
+function simple_head(){
+	client.head('http://www.amazon.com', response_callback);
+}
+
+function simple_get(){
+	client.get('http://www.nodejs.org', response_callback);
+}
+
+function proxy_get(){
+	client.get('https://www.google.com/search?q=nodejs', {proxy: 'http://localhost:1234'}, response_callback);
+}
+
+function auth_get(){
+	client.get('https://www.twitter.com', {username: 'asd', password: '123'}, response_callback);
+}
+
+function simple_post(url){
+
+	var data = {
+		foo: 'bar',
+		baz: {
+			nested: 'attribute'
+		}
+	}
+
+	client.post(url, data, response_callback);
+
+}
+
+function multipart_post(url){
+
+	var filename = 'test_file.txt';
+	var data = 'Plain text data.\nLorem ipsum dolor sit amet.\nBla bla bla.\n';
+	fs.writeFileSync(filename, data);
+
+	var black_pixel = new Buffer("data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=".replace(/^data:image\/\w+;base64,/, ""), "base64");
+
+	var data = {
+		foo: 'bar',
+		bar: 'baz',
+		nested: {
+			my_document: { file: filename, content_type: 'text/plain' },
+			even: {
+				more: 'nesting'
+			}
+		},
+    pixel: { filename: 'black_pixel.gif', buffer: black_pixel, content_type: 'image/gif' },
+    field2: {value: JSON.stringify({"json":[ {"one":1}, {"two":2} ]}), content_type: 'application/json' }
+	}
+
+	client.post(url, data, {multipart: true}, function(err, resp, body){
+
+		console.log(err);
+		console.log("Got status code " + resp.statusCode)
+		console.log(body);
+		fs.unlink(filename);
+
+	});
+
+}
+
+switch(process.argv[2]){
+	case 'head':
+		simple_head();
+		break;
+	case 'get':
+		simple_get();
+		break;
+	case 'auth':
+		auth_get();
+		break;
+	case 'proxy':
+		proxy_get();
+		break;
+	case 'post':
+		simple_post(process.argv[3] || 'http://posttestserver.com/post.php');
+		break;
+	case 'multipart':
+		multipart_post(process.argv[3] || 'http://posttestserver.com/post.php?dir=example');
+		break;
+	case 'all':
+		simple_head();
+		simple_get();
+		auth_get();
+		proxy_get();
+		simple_post(process.argv[3] || 'http://posttestserver.com/post.php');
+		multipart_post(process.argv[3] || 'http://posttestserver.com/post.php?dir=example');
+		break;
+	default:
+		console.log("Usage: ./test.js [head|get|auth|proxy|multipart]")
+}

package/node_modules/node-pre-gyp/CHANGELOG.md

@@ -1,5 +1,48 @@
 # node-pre-gyp changelog
 
+## 0.9.1
+
+- Fixed regression (in v0.9.0) with support for http redirects @allenluce (https://github.com/mapbox/node-pre-gyp/pull/361)
+
+## 0.9.0
+
+- Switched from using `request` to `needle` to reduce size of module deps (https://github.com/mapbox/node-pre-gyp/pull/350)
+
+## 0.8.0
+
+- N-API support (@inspiredware)
+
+## 0.7.1
+
+- Upgraded to tar v4.x
+
+## 0.7.0
+
+ - Updated request and hawk (#347)
+ - Dropped node v0.10.x support
+
+## 0.6.40
+
+ - Improved error reporting if an install fails
+
+## 0.6.39
+
+ - Support for node v9
+ - Support for versioning on `{libc}` to allow binaries to work on non-glic linux systems like alpine linux
+
+
+## 0.6.38
+
+ - Maintaining compatibility (for v0.6.x series) with node v0.10.x
+
+## 0.6.37
+
+ - Solved one part of #276: now now deduce the node ABI from the major version for node >= 2 even when not stored in the abi_crosswalk.json
+ - Fixed docs to avoid mentioning the deprecated and dangerous `prepublish` in package.json (#291)
+ - Add new node versions to crosswalk
+ - Ported tests to use tape instead of mocha
+ - Got appveyor tests passing by downgrading npm and node-gyp
+
 ## 0.6.36
 
  - Removed the running of `testbinary` during install. Because this was regressed for so long, it is too dangerous to re-enable by default. Developers needing validation can call `node-pre-gyp testbinary` directory.

package/node_modules/node-pre-gyp/README.md

@@ -30,7 +30,7 @@ See the [Frequently Ask Questions](https://github.com/mapbox/node-pre-gyp/wiki/F
 
 ## Depends
 
- - Node.js >= node v0.10.x
+ - Node.js >= node v4.x
 
 ## Install
 
@@ -74,7 +74,7 @@ Options include:
  - `--update-binary`: reinstall by replacing previously installed local binary with remote binary
  - `--runtime=node-webkit`: customize the runtime: `node`, `electron` and `node-webkit` are the valid options
  - `--fallback-to-build`: fallback to building from source if pre-built binary is not available
- - `--target=0.10.25`: Pass the target node or node-webkit version to compile against
+ - `--target=0.4.0`: Pass the target node or node-webkit version to compile against
  - `--target_arch=ia32`: Pass the target arch and override the host `arch`. Valid values are 'ia32','x64', or `arm`.
  - `--target_platform=win32`: Pass the target platform and override the host `platform`. Valid values are `linux`, `darwin`, `win32`, `sunos`, `freebsd`, `openbsd`, and `aix`.
 
@@ -124,7 +124,7 @@ Let's break this down:
  - Dependencies need to list `node-pre-gyp`
  - Your devDependencies should list `aws-sdk` so that you can run `node-pre-gyp publish` locally or a CI system. We recommend using `devDependencies` only since `aws-sdk` is large and not needed for `node-pre-gyp install` since it only uses http to fetch binaries
  - You should add `"bundledDependencies":["node-pre-gyp"]`. This ensures that when you publish your module that the correct version of node-pre-gyp will be included in the `node_modules` folder during publishing. Then when uses install your module `node-pre-gyp` will already be present. Without this your module will not be safely installable for downstream applications that have a depedency on node-pre-gyp in the npm tree (without bundling npm deduping might break the install when node-pre-gyp is moved in flight)
- - Your `scripts` section should optionally add `"prepublish": "npm ls"` to ensure the right node-pre-gyp version is bundled before publishing your module. If node-pre-gyp is missing or an old version is present then this will catch that error before you publish a broken package.
+ - Your `scripts` section should optionally add `"prepublishOnly": "npm ls"` to ensure the right node-pre-gyp version is bundled before publishing your module. If node-pre-gyp is missing or an old version is present then this will catch that error before you publish a broken package.
  - Your `scripts` section should override the `install` target with `"install": "node-pre-gyp install --fallback-to-build"`. This allows node-pre-gyp to be used instead of the default npm behavior of always source compiling with `node-gyp` directly.
  - Your package.json should contain a `binary` section describing key properties you provide to allow node-pre-gyp to package optimally. They are detailed below.
 
@@ -285,6 +285,81 @@ What will happen is this:
 
 If a a binary was not available for a given platform and `--fallback-to-build` was used then `node-gyp rebuild` will be called to try to source compile the module.
 
+## N-API Considerations
+
+[N-API](https://nodejs.org/api/n-api.html#n_api_n_api) is an ABI-stable alternative to previous technologies such as [nan](https://github.com/nodejs/nan) which are tied to a specific Node runtime engine. N-API is Node runtime engine agnostic and guarantees modules created today will continue to run, without changes, into the future. 
+
+Using `node-pre-gyp` with N-API projects requires a handful of additional configuration values and imposes some additional requirements. 
+
+The most significant difference is that an N-API module can be coded to target multiple  N-API versions. Therefore, an N-API module must declare in its `package.json` file which N-API versions the module is designed to run against. In addition, since multiple builds may be required for a single module, path and file names must be specified in way that avoids naming conflicts. 
+
+### The `napi_versions` array property
+
+An N-API modules must declare in its `package.json` file, the N-API versions the module is intended to support. This is accomplished by including an `napi-versions` array property in the `binary` object. For example:
+
+```js
+"binary": {
+    "module_name": "your_module",
+    "module_path": "your_module_path",
+    "host": "https://your_bucket.s3-us-west-1.amazonaws.com",
+    "napi_versions": [1,3]
+  }
+```
+
+If the `napi_versions` array property is *not* present, `node-pre-gyp` operates as it always has. Including the `napi_versions` array property instructs `node-pre-gyp` that this is a N-API module build.
+
+When the `napi_versions` array property is present, `node-pre-gyp` fires off multiple operations, one for each of the N-API versions in the array. In the example above, two operations are initiated, one for N-API version 1 and second for N-API version 3. How this version number is communicated is described next. 
+
+### The `napi_build_version` value
+
+For each of the N-API module operations `node-pre-gyp` initiates, it insures that the `napi_build_version` is set appropriately. 
+
+This value is of importance in two areas:
+
+1. The C/C++ code which needs to know against which N-API version it should compile.
+2. `node-pre-gyp` itself which must assign appropriate path and file names to avoid collisions. 
+
+### Defining `NAPI_BUILD_VERSION` for the C/C++ code
+
+The `napi_build_version` value is communicated to the C/C++ code by adding this code to the `binding.gyp` file:
+
+```
+"defines": [
+    "NAPI_BUILD_VERSION=<(napi_build_version)",
+]
+```
+
+This insures that `NAPI_BUILD_VERSION`, an integer value, is declared appropriately to the C/C++ code for each build.
+
+### Path and file naming requirements in `package.json`
+
+Since `node-pre-gyp` fires off multiple operations for each request, it is essential that path and file names be created in such a way as to avoid collisions. This is accomplished by imposing additional path and file naming requirements. 
+
+Specifically, when performing N-API builds, the `{napi_build_version}` text substitution string  *must* be present in the `module_path` property. In addition, the `{napi_build_version}` text substitution string  *must* be present in either the `remote_path` or `package_name` property. (No problem if it's in both.)
+
+Here's an example:
+
+```js
+"binary": {
+    "module_name": "your_module",
+    "module_path": "./lib/binding/napi-v{napi_build_version}",
+    "remote_path": "./{module_name}/v{version}/{configuration}/",
+    "package_name": "{platform}-{arch}-napi-v{napi_build_version}.tar.gz",
+    "host": "https://your_bucket.s3-us-west-1.amazonaws.com",
+    "napi_versions": [1,3]
+  }
+```
+
+### Two additional configuration values
+
+For those who need them in legacy projects, two additional configuration values are available for all builds. 
+
+1. `napi_version` If N-API is supported by the currently executing Node instance, this value is the N-API version number supported by Node. If N-API is not supported, this value is an empty string. 
+
+2. `node_abi_napi` If the value returned for `napi_version` is non empty, this value is `'napi'`. If the value returned for `napi_version` is empty, this value is the value returned for `node_abi`.
+
+These values are present for use in the `binding.gyp` file and may be used as `{napi_version}` and `{node_abi_napi}` for text substituion in the `binary` properties of the `package.json` file. 
+
 ## S3 Hosting
 
 You can host wherever you choose but S3 is cheap, `node-pre-gyp publish` expects it, and S3 can be integrated well with [Travis.ci](http://travis-ci.org) to automate builds for OS X and Ubuntu, and with [Appveyor](http://appveyor.com) to automate builds for Windows. Here is an approach to do this:
@@ -482,8 +557,8 @@ os:
 
 env:
   matrix:
-    - NODE_VERSION="0.10"
-    - NODE_VERSION="0.11.14"
+    - NODE_VERSION="4"
+    - NODE_VERSION="6"
 
 before_install:
 - rm -rf ~/.nvm/ && git clone --depth 1 https://github.com/creationix/nvm.git ~/.nvm
@@ -518,8 +593,8 @@ By doing:
 ```yml
 env:
   matrix:
-    - NODE_VERSION="0.10"
-    - NODE_VERSION="0.11.14"
+    - NODE_VERSION="4"
+    - NODE_VERSION="6"
 
 before_install:
  - rm -rf ~/.nvm/ && git clone --depth 1 https://github.com/creationix/nvm.git ~/.nvm
@@ -532,8 +607,8 @@ You can easily recreate the previous behavior of this matrix:
 
 ```yml
 node_js:
-  - "0.10"
-  - "0.11.14"
+  - "4"
+  - "6"
 ```
 
 #### 4) Publish when you want
@@ -562,6 +637,7 @@ The `binary` properties of `module_path`, `remote_path`, and `package_name` supp
  - `node_abi`: The node C++ `ABI` number. This value is available in Javascript as `process.versions.modules` as of [`>= v0.10.4 >= v0.11.7`](https://github.com/joyent/node/commit/ccabd4a6fa8a6eb79d29bc3bbe9fe2b6531c2d8e) and in C++ as the `NODE_MODULE_VERSION` define much earlier. For versions of Node before this was available we fallback to the V8 major and minor version.
  - `platform` matches node's `process.platform` like `linux`, `darwin`, and `win32` unless the user passed the `--target_platform` option to override.
  - `arch` matches node's `process.arch` like `x64` or `ia32` unless the user passes the `--target_arch` option to override.
+ - `libc` matches `require('detect-libc').family` like `glibc` or `musl` unless the user passes the `--target_libc` option to override.
  - `configuration` - Either 'Release' or 'Debug' depending on if `--debug` is passed during the build.
  - `module_name` - the `binary.module_name` attribute from `package.json`.
  - `version` - the semver `version` value for your module from `package.json` (NOTE: ignores the `semver.build` property).

package/node_modules/node-pre-gyp/appveyor.yml

@@ -2,9 +2,10 @@ os: Visual Studio 2015
 
 environment:
   matrix:
-    - nodejs_version: 0.10
     - nodejs_version: 4
     - nodejs_version: 6
+    - nodejs_version: 8
+    - nodejs_version: 9
 
 platform:
   - x64
@@ -15,21 +16,22 @@ shallow_clone: true
 install:
   - ps: Install-Product node $env:nodejs_version $env:Platform
   - ps: Set-ExecutionPolicy Unrestricted -Scope CurrentUser -Force
-  # https://github.com/nodejs/node-gyp/issues/972#issuecomment-231055109
-  - npm install --production node-gyp
+  - npm config get
+  # upgrade node-gyp to dodge https://github.com/mapbox/node-pre-gyp/issues/209#issuecomment-307641388
+  # and allow make node 4.x x86 builds work
+  - IF "%nodejs_version:~0,1%" EQU "4" npm install node-gyp@3.x
   - node --version
   - npm --version
-  #- SET PATH=%APPDATA%\npm;%PATH%
-  #- npm install -g node-gyp
-  - npm install -g node-gyp@3.2.1
   - node -e "console.log(process.arch);"
   - IF /I "%PLATFORM%" == "x64" set PATH=C:\Python27-x64;%PATH%
   - IF /I "%PLATFORM%" == "x86" SET PATH=C:\python27;%PATH%
   - IF /I "%PLATFORM%" == "x64" CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
   - IF /I "%PLATFORM%" == "x86" CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x86
   - npm install
+  # workaround https://github.com/mapbox/node-pre-gyp/issues/300#issuecomment-328179994
+  - IF "%nodejs_version:~0,1%" GEQ "6" npm install npm@2 -g
   - npm test
 
 build: off
 test: off
-deploy: off
+deploy: off

package/node_modules/node-pre-gyp/bin/node-pre-gyp

@@ -26,10 +26,13 @@ prog.parseArgv(process.argv);
 if (prog.todo.length === 0) {
   if (~process.argv.indexOf('-v') || ~process.argv.indexOf('--version')) {
     console.log('v%s', prog.version);
-  } else {
+    return process.exit(0);
+  } else if (~process.argv.indexOf('-h') || ~process.argv.indexOf('--help')) {
     console.log('%s', prog.usage());
+    return process.exit(0);
   }
-  return process.exit(0);
+  console.log('%s', prog.usage());
+  return process.exit(1);
 }
 
 // if --no-color is passed

package/node_modules/node-pre-gyp/lib/build.js

@@ -4,6 +4,7 @@ module.exports = exports = build;
 
 exports.usage = 'Attempts to compile the module by dispatching to node-gyp or nw-gyp';
 
+var napi = require('./util/napi.js');
 var compile = require('./util/compile.js');
 var handle_gyp_opts = require('./util/handle_gyp_opts.js');
 var configure = require('./configure.js');
@@ -16,7 +17,13 @@ function do_build(gyp,argv,callback) {
                           concat(['--']).
                           concat(result.unparsed);
         }
+        if (!err && result.opts.napi_build_version) {
+            napi.swap_build_dir_in(result.opts.napi_build_version);
+        }
         compile.run_gyp(final_args,result.opts,function(err) {
+            if (!err && result.opts.napi_build_version) {
+                napi.swap_build_dir_out(result.opts.napi_build_version);
+            }
             return callback(err);
         });
     });
@@ -28,6 +35,7 @@ function build(gyp, argv, callback) {
     // We map `node-pre-gyp build` to `node-gyp configure build` so that we do not
     // trigger a clean and therefore do not pay the penalty of a full recompile
     if (argv.length && (argv.indexOf('rebuild') > -1)) {
+        argv.shift(); // remove `rebuild`
         // here we map `node-pre-gyp rebuild` to `node-gyp rebuild` which internally means
         // "clean + configure + build" and triggers a full recompile
         compile.run_gyp(['clean'],{},function(err) {

package/node_modules/node-pre-gyp/lib/clean.js

@@ -8,16 +8,25 @@ var fs = require('fs');
 var rm = require('rimraf');
 var exists = require('fs').exists || require('path').exists;
 var versioning = require('./util/versioning.js');
+var napi = require('./util/napi.js');
+var path = require('path');
 
 function clean (gyp, argv, callback) {
     var package_json = JSON.parse(fs.readFileSync('./package.json'));
-    var opts = versioning.evaluate(package_json, gyp.opts);
+    var napi_build_version = napi.get_napi_build_version_from_command_args(argv);
+    var opts = versioning.evaluate(package_json, gyp.opts, napi_build_version);
     var to_delete = opts.module_path;
-    exists(to_delete, function(found) {
-        if (found) {
-            if (!gyp.opts.silent_clean) console.log('['+package_json.name+'] Removing "%s"', to_delete);
-            return rm(to_delete, callback);
-        }
-        return callback();
-    });
+    if (!to_delete) {
+        return callback(new Error("module_path is empty, refusing to delete"));
+    } else if (path.normalize(to_delete) == path.normalize(process.cwd())) {
+        return callback(new Error("module_path is not set, refusing to delete"));
+    } else {
+        exists(to_delete, function(found) {
+            if (found) {
+                if (!gyp.opts.silent_clean) console.log('['+package_json.name+'] Removing "%s"', to_delete);
+                return rm(to_delete, callback);
+            }
+            return callback();
+        });
+    }
 }

package/node_modules/node-pre-gyp/lib/configure.js

@@ -4,6 +4,7 @@ module.exports = exports = configure;
 
 exports.usage = 'Attempts to configure node-gyp or nw-gyp build';
 
+var napi = require('./util/napi.js');
 var compile = require('./util/compile.js');
 var handle_gyp_opts = require('./util/handle_gyp_opts.js');
 
@@ -41,6 +42,9 @@ function configure(gyp, argv, callback) {
                               concat(result.unparsed);
             }
             compile.run_gyp(['configure'].concat(final_args),result.opts,function(err) {
+                if (!err && result.opts.napi_build_version) {
+                    napi.swap_build_dir_out(result.opts.napi_build_version);
+                }
                 return callback(err);
             });
         }

package/node_modules/node-pre-gyp/lib/install.js

@@ -6,10 +6,11 @@ exports.usage = 'Attempts to install pre-built binary for module';
 
 var fs = require('fs');
 var path = require('path');
-var zlib = require('zlib');
 var log = require('npmlog');
 var existsAsync = fs.exists || path.exists;
 var versioning = require('./util/versioning.js');
+var napi = require('./util/napi.js');
+var mkdirp = require('mkdirp');
 
 var npgVersion = 'unknown';
 try {
@@ -31,7 +32,8 @@ function download(uri,opts,callback) {
         uri: uri.replace('+','%2B'),
         headers: {
           'User-Agent': 'node-pre-gyp (v' + npgVersion + ', ' + envVersionInfo + ')'
-        }
+        },
+        follow_max: 10,
     };
 
     if (opts.cafile) {
@@ -57,7 +59,7 @@ function download(uri,opts,callback) {
       }
     }
     try {
-        req = require('request')(requestOpts);
+        req = require('needle').get(requestOpts.uri, requestOpts);
     } catch (e) {
         return callback(e);
     }
@@ -75,8 +77,7 @@ function place_binary(from,to,opts,callback) {
         if (!req) return callback(new Error("empty req"));
         var badDownload = false;
         var extractCount = 0;
-        var gunzip = zlib.createGunzip();
-        var extracter = require('tar').Extract({ path: to, strip: 1});
+        var tar = require('tar');
 
         function afterTarball(err) {
             if (err) return callback(err);
@@ -89,18 +90,10 @@ function place_binary(from,to,opts,callback) {
         }
 
         function filter_func(entry) {
-            // ensure directories are +x
-            // https://github.com/mapnik/node-mapnik/issues/262
-            entry.props.mode |= (entry.props.mode >>> 2) & parseInt('0111',8);
             log.info('install','unpacking ' + entry.path);
             extractCount++;
         }
 
-        gunzip.on('error', callback);
-        extracter.on('entry', filter_func);
-        extracter.on('error', callback);
-        extracter.on('end', afterTarball);
-
         req.on('error', function(err) {
             badDownload = true;
             return callback(err);
@@ -112,36 +105,60 @@ function place_binary(from,to,opts,callback) {
             }
         });
 
-        req.on('response', function(res) {
-            if (res.statusCode !== 200) {
+      req.on('response', function(res) {
+           // ignore redirects, needle handles these automatically.
+           if (res.headers.hasOwnProperty('location') && res.headers.location !== '') {
+             return;
+           }
+           if (res.statusCode !== 200) {
                 badDownload = true;
                 var err = new Error(res.statusCode + ' status code downloading tarball ' + from);
                 err.statusCode = res.statusCode;
                 return callback(err);
             }
             // start unzipping and untaring
-            req.pipe(gunzip).pipe(extracter);
+            req.pipe(tar.extract({
+              cwd: to,
+              strip: 1,
+              onentry: filter_func
+            }).on('close', afterTarball).on('error', callback));
         });
     });
 }
 
 function do_build(gyp,argv,callback) {
-  gyp.todo.push( { name: 'build', args: ['rebuild'] } );
+  var args = ['rebuild'].concat(argv);
+  gyp.todo.push( { name: 'build', args: args } );
   process.nextTick(callback);
 }
 
 function print_fallback_error(err,opts,package_json) {
     var fallback_message = ' (falling back to source compile with node-gyp)';
-    var full_message = "Pre-built binaries not found for " + package_json.name + "@" + package_json.version;
-    full_message += " and " + opts.runtime + "@" + (opts.target || process.versions.node) + " (" + opts.node_abi + " ABI)";
-    full_message += fallback_message;
-    log.error("Tried to download(" + err.statusCode + "): " + opts.hosted_tarball);
-    log.error(full_message);
-    log.http(err.message);
+    var full_message = '';
+    if (err.statusCode !== undefined) {
+        // If we got a network response it but failed to download
+        // it means remote binaries are not available, so let's try to help
+        // the user/developer with the info to debug why
+        full_message = "Pre-built binaries not found for " + package_json.name + "@" + package_json.version;
+        full_message += " and " + opts.runtime + "@" + (opts.target || process.versions.node) + " (" + opts.node_abi + " ABI, " + opts.libc + ")";
+        full_message += fallback_message;
+        log.error("Tried to download(" + err.statusCode + "): " + opts.hosted_tarball);
+        log.error(full_message);
+        log.http(err.message);
+    } else {
+        // If we do not have a statusCode that means an unexpected error
+        // happened and prevented an http response, so we output the exact error
+        full_message = "Pre-built binaries not installable for " + package_json.name + "@" + package_json.version;
+        full_message += " and " + opts.runtime + "@" + (opts.target || process.versions.node) + " (" + opts.node_abi + " ABI, " + opts.libc + ")";
+        full_message += fallback_message;
+        log.error(full_message);
+        log.error("Hit error " + err.message);
+    }
 }
 
 function install(gyp, argv, callback) {
     var package_json = JSON.parse(fs.readFileSync('./package.json'));
+	var napi_build_version = napi.get_napi_build_version_from_command_args(argv);
     var source_build = gyp.opts['build-from-source'] || gyp.opts.build_from_source;
     var update_binary = gyp.opts['update-binary'] || gyp.opts.update_binary;
     var should_do_source_build = source_build === package_json.name || (source_build === true || source_build === 'true');
@@ -162,7 +179,7 @@ function install(gyp, argv, callback) {
         }
         var opts;
         try {
-            opts = versioning.evaluate(package_json, gyp.opts);
+            opts = versioning.evaluate(package_json, gyp.opts, napi_build_version);
         } catch (err) {
             return callback(err);
         }
@@ -173,25 +190,32 @@ function install(gyp, argv, callback) {
         var from = opts.hosted_tarball;
         var to = opts.module_path;
         var binary_module = path.join(to,opts.module_name + '.node');
-        if (existsAsync(binary_module,function(found) {
+        existsAsync(binary_module,function(found) {
             if (found && !update_binary) {
                 console.log('['+package_json.name+'] Success: "' + binary_module + '" already installed');
                 console.log('Pass --update-binary to reinstall or --build-from-source to recompile');
                 return callback();
             } else {
                 if (!update_binary) log.info('check','checked for "' + binary_module + '" (not found)');
-                place_binary(from,to,opts,function(err) {
-                    if (err && should_do_fallback_build) {
-                        print_fallback_error(err,opts,package_json);
-                        return do_build(gyp,argv,callback);
-                    } else if (err) {
-                        return callback(err);
+                mkdirp(to,function(err) {
+                    if (err) {
+                        after_place(err);
                     } else {
-                        console.log('['+package_json.name+'] Success: "' + binary_module + '" is installed via remote');
-                        return callback();
+                        place_binary(from,to,opts,after_place);
                     }
                 });
             }
-        }));
+            function after_place(err) {
+                if (err && should_do_fallback_build) {
+                    print_fallback_error(err,opts,package_json);
+                    return do_build(gyp,argv,callback);
+                } else if (err) {
+                    return callback(err);
+                } else {
+                    console.log('['+package_json.name+'] Success: "' + binary_module + '" is installed via remote');
+                    return callback();
+                }
+            }
+        });
     }
 }

package/node_modules/node-pre-gyp/lib/node-pre-gyp.js

@@ -10,10 +10,12 @@ module.exports = exports;
  * Module dependencies.
  */
 
+var fs = require('fs');
 var path = require('path');
 var nopt = require('nopt');
 var log = require('npmlog');
 log.disableProgress();
+var napi = require('./util/napi.js');
 
 var EE = require('events').EventEmitter;
 var inherits = require('util').inherits;
@@ -128,6 +130,13 @@ proto.parseArgv = function parseOpts (argv) {
     commands[commands.length - 1].args = argv.splice(0);
   }
 
+  // expand commands entries for multiple napi builds
+  var dir = this.opts.directory;
+  if (dir == null) dir = process.cwd();
+  var package_json = JSON.parse(fs.readFileSync(path.join(dir,'package.json')));
+
+  this.todo = napi.expand_commands (package_json, commands);
+
   // support for inheriting config env variables from npm
   var npm_config_prefix = 'npm_config_';
   Object.keys(process.env).forEach(function (name) {