fsevents 1.0.11 → 1.0.17

package/node_modules/signal-exit/package.json

@@ -0,0 +1,106 @@
+{
+  "_args": [
+    [
+      {
+        "raw": "signal-exit@^3.0.0",
+        "scope": null,
+        "escapedName": "signal-exit",
+        "name": "signal-exit",
+        "rawSpec": "^3.0.0",
+        "spec": ">=3.0.0 <4.0.0",
+        "type": "range"
+      },
+      "/Users/eshanker/Code/fsevents/node_modules/gauge"
+    ]
+  ],
+  "_from": "signal-exit@>=3.0.0 <4.0.0",
+  "_id": "signal-exit@3.0.2",
+  "_inCache": true,
+  "_location": "/signal-exit",
+  "_nodeVersion": "6.5.0",
+  "_npmOperationalInternal": {
+    "host": "packages-18-east.internal.npmjs.com",
+    "tmp": "tmp/signal-exit-3.0.2.tgz_1480821660838_0.6809983775019646"
+  },
+  "_npmUser": {
+    "name": "isaacs",
+    "email": "i@izs.me"
+  },
+  "_npmVersion": "3.10.9",
+  "_phantomChildren": {},
+  "_requested": {
+    "raw": "signal-exit@^3.0.0",
+    "scope": null,
+    "escapedName": "signal-exit",
+    "name": "signal-exit",
+    "rawSpec": "^3.0.0",
+    "spec": ">=3.0.0 <4.0.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/gauge"
+  ],
+  "_resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
+  "_shasum": "b5fdc08f1287ea1178628e415e25132b73646c6d",
+  "_shrinkwrap": null,
+  "_spec": "signal-exit@^3.0.0",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/gauge",
+  "author": {
+    "name": "Ben Coe",
+    "email": "ben@npmjs.com"
+  },
+  "bugs": {
+    "url": "https://github.com/tapjs/signal-exit/issues"
+  },
+  "dependencies": {},
+  "description": "when you want to fire an event no matter how a process exits.",
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "coveralls": "^2.11.10",
+    "nyc": "^8.1.0",
+    "standard": "^7.1.2",
+    "standard-version": "^2.3.0",
+    "tap": "^8.0.1"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "b5fdc08f1287ea1178628e415e25132b73646c6d",
+    "tarball": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz"
+  },
+  "files": [
+    "index.js",
+    "signals.js"
+  ],
+  "gitHead": "9c5ad9809fe6135ef22e2623989deaffe2a4fa8a",
+  "homepage": "https://github.com/tapjs/signal-exit",
+  "keywords": [
+    "signal",
+    "exit"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "maintainers": [
+    {
+      "name": "bcoe",
+      "email": "ben@npmjs.com"
+    },
+    {
+      "name": "isaacs",
+      "email": "isaacs@npmjs.com"
+    }
+  ],
+  "name": "signal-exit",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tapjs/signal-exit.git"
+  },
+  "scripts": {
+    "coverage": "nyc report --reporter=text-lcov | coveralls",
+    "pretest": "standard",
+    "release": "standard-version",
+    "test": "tap --timeout=240 ./test/*.js --cov"
+  },
+  "version": "3.0.2"
+}

package/node_modules/signal-exit/signals.js

@@ -0,0 +1,53 @@
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM'
+]
+
+if (process.platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  )
+}
+
+if (process.platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  )
+}

package/node_modules/sntp/package.json

@@ -1,22 +1,48 @@
 {
-  "_from": "sntp@1.x.x",
+  "_args": [
+    [
+      {
+        "raw": "sntp@1.x.x",
+        "scope": null,
+        "escapedName": "sntp",
+        "name": "sntp",
+        "rawSpec": "1.x.x",
+        "spec": ">=1.0.0 <2.0.0",
+        "type": "range"
+      },
+      "/Users/eshanker/Code/fsevents/node_modules/hawk"
+    ]
+  ],
+  "_from": "sntp@>=1.0.0 <2.0.0",
   "_id": "sntp@1.0.9",
+  "_inCache": true,
   "_location": "/sntp",
   "_npmUser": {
-    "email": "eran@hueniverse.com",
-    "name": "hueniverse"
+    "name": "hueniverse",
+    "email": "eran@hueniverse.com"
   },
   "_npmVersion": "1.4.23",
   "_phantomChildren": {},
+  "_requested": {
+    "raw": "sntp@1.x.x",
+    "scope": null,
+    "escapedName": "sntp",
+    "name": "sntp",
+    "rawSpec": "1.x.x",
+    "spec": ">=1.0.0 <2.0.0",
+    "type": "range"
+  },
   "_requiredBy": [
     "/hawk"
   ],
   "_resolved": "https://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz",
   "_shasum": "6541184cc90aeea6c6e7b35e2659082443c66198",
   "_shrinkwrap": null,
+  "_spec": "sntp@1.x.x",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/hawk",
   "author": {
-    "email": "eran@hammer.io",
     "name": "Eran Hammer",
+    "email": "eran@hammer.io",
     "url": "http://hueniverse.com"
   },
   "bugs": {
@@ -33,7 +59,7 @@
   "directories": {},
   "dist": {
     "shasum": "6541184cc90aeea6c6e7b35e2659082443c66198",
-    "tarball": "http://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz"
+    "tarball": "https://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz"
   },
   "engines": {
     "node": ">=0.8.0"
@@ -41,8 +67,8 @@
   "gitHead": "ee2e35284f684609990681734d39010cd356d7da",
   "homepage": "https://github.com/hueniverse/sntp",
   "keywords": [
-    "ntp",
     "sntp",
+    "ntp",
     "time"
   ],
   "licenses": [

package/node_modules/sshpk/.travis.yml

@@ -1,11 +1,11 @@
 language: node_js
 node_js:
-  - "4.2"
+  - "5.10"
+  - "4.4"
   - "4.1"
   - "0.12"
   - "0.10"
-  - "0.8"
 before_install:
   - "make check"
 after_success:
-  - '[ "${TRAVIS_NODE_VERSION}" = "4.2" ] && make codecovio'
+  - '[ "${TRAVIS_NODE_VERSION}" = "4.4" ] && make codecovio'

package/node_modules/sshpk/README.md

@@ -111,7 +111,7 @@ Usage
 
 ## Public keys
 
-### `parseKey(data[, format = 'auto'[, name]])`
+### `parseKey(data[, format = 'auto'[, options]])`
 
 Parses a key from a given data format and returns a new `Key` object.
 
@@ -126,8 +126,12 @@ Parameters
   - `rfc4253`: raw OpenSSH wire format
   - `openssh`: new post-OpenSSH 6.5 internal format, produced by 
                `ssh-keygen -o`
-- `name` -- Optional name for the key being parsed (eg. the filename that
-            was opened). Used to generate Error messages
+- `options` -- Optional Object, extra options, with keys:
+  - `filename` -- Optional String, name for the key being parsed 
+                  (eg. the filename that was opened). Used to generate
+                  Error messages
+  - `passphrase` -- Optional String, encryption passphrase used to decrypt an
+                    encrypted PEM file
 
 ### `Key.isKey(obj)`
 
@@ -212,7 +216,7 @@ to call this function on other keys will yield an `Error`.
 
 ## Private keys
 
-### `parsePrivateKey(data[, format = 'auto'[, name]])`
+### `parsePrivateKey(data[, format = 'auto'[, options]])`
 
 Parses a private key from a given data format and returns a new
 `PrivateKey` object.
@@ -227,8 +231,12 @@ Parameters
                       `ssh-keygen -o`
   - `pkcs1`, `pkcs8`: variants of `pem`
   - `rfc4253`: raw OpenSSH wire format
-- `name` -- Optional name for the key being parsed (eg. the filename that
-            was opened). Used to generate Error messages
+- `options` -- Optional Object, extra options, with keys:
+  - `filename` -- Optional String, name for the key being parsed 
+                  (eg. the filename that was opened). Used to generate
+                  Error messages
+  - `passphrase` -- Optional String, encryption passphrase used to decrypt an
+                    encrypted PEM file
 
 ### `PrivateKey.isPrivateKey(obj)`
 
@@ -393,6 +401,206 @@ Parameters
 
 Same as `this.toBuffer(format).toString('base64')`.
 
+## Certificates
+
+`sshpk` includes basic support for parsing certificates in X.509 (PEM) format
+and the OpenSSH certificate format. This feature is intended to be used mainly
+to access basic metadata about certificates, extract public keys from them, and
+also to generate simple self-signed certificates from an existing key.
+
+Notably, there is no implementation of CA chain-of-trust verification, and no
+support for key usage restrictions (or other kinds of restrictions). Please do
+the security world a favour, and DO NOT use this code for certificate
+verification in the traditional X.509 CA chain style.
+
+### `parseCertificate(data, format)`
+
+Parameters
+
+ - `data` -- a Buffer or String
+ - `format` -- a String, format to use, one of `'openssh'`, `'pem'` (X.509 in a
+               PEM wrapper), or `'x509'` (raw DER encoded)
+
+### `createSelfSignedCertificate(subject, privateKey[, options])`
+
+Parameters
+
+ - `subject` -- an Identity, the subject of the certificate
+ - `privateKey` -- a PrivateKey, the key of the subject: will be used both to be
+                   placed in the certificate and also to sign it (since this is
+                   a self-signed certificate)
+ - `options` -- optional Object, with keys:
+   - `lifetime` -- optional Number, lifetime of the certificate from now in
+                   seconds
+   - `validFrom`, `validUntil` -- optional Dates, beginning and end of
+                                  certificate validity period. If given
+                                  `lifetime` will be ignored
+   - `serial` -- optional Buffer, the serial number of the certificate
+
+### `createCertificate(subject, key, issuer, issuerKey[, options])`
+
+Parameters
+
+ - `subject` -- an Identity, the subject of the certificate
+ - `key` -- a Key, the public key of the subject
+ - `issuer` -- an Identity, the issuer of the certificate who will sign it
+ - `issuerKey` -- a PrivateKey, the issuer's private key for signing
+ - `options` -- optional Object, with keys:
+   - `lifetime` -- optional Number, lifetime of the certificate from now in
+                   seconds
+   - `validFrom`, `validUntil` -- optional Dates, beginning and end of
+                                  certificate validity period. If given
+                                  `lifetime` will be ignored
+   - `serial` -- optional Buffer, the serial number of the certificate
+
+### `Certificate#subjects`
+
+Array of `Identity` instances describing the subject of this certificate.
+
+### `Certificate#issuer`
+
+The `Identity` of the Certificate's issuer (signer).
+
+### `Certificate#subjectKey`
+
+The public key of the subject of the certificate, as a `Key` instance.
+
+### `Certificate#issuerKey`
+
+The public key of the signing issuer of this certificate, as a `Key` instance.
+May be `undefined` if the issuer's key is unknown (e.g. on an X509 certificate).
+
+### `Certificate#serial`
+
+The serial number of the certificate. As this is normally a 64-bit or wider
+integer, it is returned as a Buffer.
+
+### `Certificate#isExpired([when])`
+
+Tests whether the Certificate is currently expired (i.e. the `validFrom` and
+`validUntil` dates specify a range of time that does not include the current
+time).
+
+Parameters
+
+ - `when` -- optional Date, if specified, tests whether the Certificate was or
+             will be expired at the specified time instead of now
+
+Returns a Boolean.
+
+### `Certificate#isSignedByKey(key)`
+
+Tests whether the Certificate was validly signed by the given (public) Key.
+
+Parameters
+
+ - `key` -- a Key instance
+
+Returns a Boolean.
+
+### `Certificate#isSignedBy(certificate)`
+
+Tests whether this Certificate was validly signed by the subject of the given
+certificate. Also tests that the issuer Identity of this Certificate and the
+subject Identity of the other Certificate are equivalent.
+
+Parameters
+
+ - `certificate` -- another Certificate instance
+
+Returns a Boolean.
+
+### `Certificate#fingerprint([hashAlgo])`
+
+Returns the X509-style fingerprint of the entire certificate (as a Fingerprint
+instance). This matches what a web-browser or similar would display as the
+certificate fingerprint and should not be confused with the fingerprint of the
+subject's public key.
+
+Parameters
+
+ - `hashAlgo` -- an optional String, any hash function name
+
+### `Certificate#toBuffer([format])`
+
+Serializes the Certificate to a Buffer and returns it.
+
+Parameters
+
+ - `format` -- an optional String, output format, one of `'openssh'`, `'pem'` or
+               `'x509'`. Defaults to `'x509'`.
+
+Returns a Buffer.
+
+### `Certificate#toString([format])`
+
+ - `format` -- an optional String, output format, one of `'openssh'`, `'pem'` or
+               `'x509'`. Defaults to `'pem'`.
+
+Returns a String.
+
+## Certificate identities
+
+### `identityForHost(hostname)`
+
+Constructs a host-type Identity for a given hostname.
+
+Parameters
+
+ - `hostname` -- the fully qualified DNS name of the host
+
+Returns an Identity instance.
+
+### `identityForUser(uid)`
+
+Constructs a user-type Identity for a given UID.
+
+Parameters
+
+ - `uid` -- a String, user identifier (login name)
+
+Returns an Identity instance.
+
+### `identityForEmail(email)`
+
+Constructs an email-type Identity for a given email address.
+
+Parameters
+
+ - `email` -- a String, email address
+
+Returns an Identity instance.
+
+### `identityFromDN(dn)`
+
+Parses an LDAP-style DN string (e.g. `'CN=foo, C=US'`) and turns it into an
+Identity instance.
+
+Parameters
+
+ - `dn` -- a String
+
+Returns an Identity instance.
+
+### `Identity#toString()`
+
+Returns the identity as an LDAP-style DN string.
+e.g. `'CN=foo, O=bar corp, C=us'`
+
+### `Identity#type`
+
+The type of identity. One of `'host'`, `'user'`, `'email'` or `'unknown'`
+
+### `Identity#hostname`
+### `Identity#uid`
+### `Identity#email`
+
+Set when `type` is `'host'`, `'user'`, or `'email'`, respectively. Strings.
+
+### `Identity#cn`
+
+The value of the first `CN=` in the DN, if any.
+
 Errors
 ------
 
@@ -425,8 +633,30 @@ The key data given could not be parsed as a valid key.
 
 Properties
 
-- `keyName` -- `name` that was given to `Key#parse`
+- `keyName` -- `filename` that was given to `parseKey`
+- `format` -- the `format` that was trying to parse the key (see `parseKey`)
+- `innerErr` -- the inner Error thrown by the format parser
+
+### `KeyEncryptedError`
+
+The key is encrypted with a symmetric key (ie, it is password protected). The
+parsing operation would succeed if it was given the `passphrase` option.
+
+Properties
+
+- `keyName` -- `filename` that was given to `parseKey`
+- `format` -- the `format` that was trying to parse the key (currently can only
+              be `"pem"`)
+
+### `CertificateParseError`
+
+The certificate data given could not be parsed as a valid certificate.
+
+Properties
+
+- `certName` -- `filename` that was given to `parseCertificate`
 - `format` -- the `format` that was trying to parse the key
+              (see `parseCertificate`)
 - `innerErr` -- the inner Error thrown by the format parser
 
 Friends of sshpk

package/node_modules/sshpk/bin/sshpk-conv

@@ -7,6 +7,9 @@ var dashdash = require('dashdash');
 var sshpk = require('../lib/index');
 var fs = require('fs');
 var path = require('path');
+var tty = require('tty');
+var readline = require('readline');
+var getPassword = require('getpass').getPass;
 
 var options = [
 	{
@@ -131,7 +134,9 @@ if (require.main === module) {
 		while ((data = inFile.read()))
 			bufs.push(data);
 	});
-	inFile.on('end', function () {
+	var parseOpts = {};
+	parseOpts.filename = inFileName;
+	inFile.on('end', function processKey() {
 		var buf = Buffer.concat(bufs);
 		var fmt = 'auto';
 		if (opts.informat)
@@ -140,8 +145,21 @@ if (require.main === module) {
 		if (opts.private)
 			f = sshpk.parsePrivateKey;
 		try {
-			var key = f(buf, fmt, inFileName);
+			var key = f(buf, fmt, parseOpts);
 		} catch (e) {
+			if (e.name === 'KeyEncryptedError') {
+				getPassword(function (err, pw) {
+					if (err) {
+						console.log('sshpk-conv: ' +
+						    err.name + ': ' +
+						    err.message);
+						process.exit(1);
+					}
+					parseOpts.passphrase = pw;
+					processKey();
+				});
+				return;
+			}
 			console.error('sshpk-conv: ' +
 			    e.name + ': ' + e.message);
 			process.exit(1);

package/node_modules/sshpk/bin/sshpk-sign

@@ -7,6 +7,7 @@ var dashdash = require('dashdash');
 var sshpk = require('../lib/index');
 var fs = require('fs');
 var path = require('path');
+var getPassword = require('getpass').getPass;
 
 var options = [
 	{
@@ -51,6 +52,8 @@ var options = [
 	}
 ];
 
+var parseOpts = {};
+
 if (require.main === module) {
 	var parser = dashdash.createParser({
 		options: options
@@ -79,11 +82,23 @@ if (require.main === module) {
 	}
 
 	var keyData = fs.readFileSync(opts.identity);
+	parseOpts.filename = opts.identity;
+
+	run();
+}
 
+function run() {
 	var key;
 	try {
-		key = sshpk.parsePrivateKey(keyData);
+		key = sshpk.parsePrivateKey(keyData, 'auto', parseOpts);
 	} catch (e) {
+		if (e.name === 'KeyEncryptedError') {
+			getPassword(function (err, pw) {
+				parseOpts.passphrase = pw;
+				run();
+			});
+			return;
+		}
 		console.error('sshpk-sign: error loading private key "' +
 		    opts.identity + '": ' + e.name + ': ' + e.message);
 		process.exit(1);