@blamejs/blamejs-shop 0.4.85 → 0.4.87

package/lib/vendor/blamejs/test/layer-0-primitives/mail-auth-dmarc-policy-failclosed.test.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * b.mail.dmarc.evaluate — a DMARC record that lacks a valid required p=
+ * tag (RFC 7489 §6.3) must NOT recommend "deliver" for a failing/unaligned
+ * message.
+ *
+ * Regression: _parseDmarcRecord took p= / sp= verbatim and never required
+ * p=, so the disposition ternary mapped any policy.p that was not exactly
+ * "reject"/"quarantine" — including null (no p=) and typos ("rejct") —
+ * to recommendedAction "deliver". A spoofed sender with a
+ * failing SPF and no DKIM therefore got result:"fail" +
+ * recommendedAction:"deliver" (fail-open). The fix validates p=/sp= against
+ * {none,quarantine,reject}, requires a valid p= for the record to count,
+ * and fails closed (permerror, no "deliver") on an absent/invalid policy.
+ *
+ * Network-free: DNS is supplied via an operator dnsLookup mock.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+// Failing/unaligned auth for a spoofed sender: SPF fail, no DKIM, From a
+// domain whose published DMARC record is the one under test.
+var SPOOF = {
+  from: "ceo@victim.example",
+  spf:  { result: "fail", domain: "attacker.invalid" },
+  dkim: [],
+};
+
+function dnsReturning(record) {
+  return async function (host) {
+    if (host === "_dmarc.victim.example") {
+      return [[record]];
+    }
+    var err = new Error("ENOTFOUND"); err.code = "ENOTFOUND"; throw err;
+  };
+}
+
+async function testNoPolicyTagFailsClosed() {
+  // RFC 7489 §6.3 — p= is REQUIRED. A record without it carries no usable
+  // policy; the receiver must treat it as none/permerror, NOT deliver.
+  var rv = await b.mail.dmarc.evaluate(Object.assign({}, SPOOF, {
+    dnsLookup: dnsReturning("v=DMARC1; adkim=s; aspf=s"),
+  }));
+  check("dmarc.evaluate: missing p= → NOT deliver",
+        rv.recommendedAction !== "deliver");
+  check("dmarc.evaluate: missing p= → permerror",
+        rv.result === "permerror");
+}
+
+async function testTypoPolicyTagFailsClosed() {
+  // "rejct" is not a recognized policy; must not silently fall through to
+  // deliver.
+  var rv = await b.mail.dmarc.evaluate(Object.assign({}, SPOOF, {
+    dnsLookup: dnsReturning("v=DMARC1; p=rejct"),
+  }));
+  check("dmarc.evaluate: typo p=rejct → NOT deliver",
+        rv.recommendedAction !== "deliver");
+  check("dmarc.evaluate: typo p=rejct → permerror",
+        rv.result === "permerror");
+}
+
+async function testWhitespacePaddedPolicyTag() {
+  // RFC 7489 §6.4 tag-list grammar permits whitespace around the value;
+  // "p= reject " is a legitimate reject policy once the grammar's trim
+  // applies — it must NOT deliver the spoofed/failing message.
+  var rv = await b.mail.dmarc.evaluate(Object.assign({}, SPOOF, {
+    dnsLookup: dnsReturning("v=DMARC1; p= reject "),
+  }));
+  check("dmarc.evaluate: whitespace-padded p= reject → NOT deliver",
+        rv.recommendedAction !== "deliver");
+  check("dmarc.evaluate: whitespace-padded p= reject → fail + reject",
+        rv.result === "fail" && rv.recommendedAction === "reject");
+}
+
+async function testBadSpTagFailsClosed() {
+  // sp= feeds policy.p on the organizational-domain path; an invalid sp=
+  // value must fail closed there too (validated like p=).
+  var policy;
+  var threw = false;
+  try {
+    policy = b.mail.dmarc.parseRecord("v=DMARC1; p=reject; sp=quarntine");
+  } catch (e) {
+    threw = true;
+    check("dmarc.parseRecord: bad sp= throws dmarcbis-bad-tag",
+          e && e.code === "mail-auth/dmarcbis-bad-tag");
+  }
+  check("dmarc.parseRecord: bad sp= rejected", threw === true && !policy);
+}
+
+async function testMissingPolicyParseThrows() {
+  // parseRecord must reject a record missing the required p= outright.
+  var threw = false;
+  try {
+    b.mail.dmarc.parseRecord("v=DMARC1; adkim=s");
+  } catch (e) {
+    threw = true;
+    check("dmarc.parseRecord: missing p= throws dmarc-missing-policy",
+          e && e.code === "mail-auth/dmarc-missing-policy");
+  }
+  check("dmarc.parseRecord: missing p= rejected", threw === true);
+}
+
+async function testValidRejectStillFailsClosed() {
+  // Control: a well-formed p=reject for the same spoofed/failing message
+  // still reaches the reject disposition (the fix doesn't over-broaden).
+  var rv = await b.mail.dmarc.evaluate(Object.assign({}, SPOOF, {
+    dnsLookup: dnsReturning("v=DMARC1; p=reject"),
+  }));
+  check("dmarc.evaluate: valid p=reject + spoof → fail + reject",
+        rv.result === "fail" && rv.recommendedAction === "reject");
+}
+
+async function testValidNoneDelivers() {
+  // Control: p=none is monitor-only → deliver is the correct disposition.
+  var rv = await b.mail.dmarc.evaluate(Object.assign({}, SPOOF, {
+    dnsLookup: dnsReturning("v=DMARC1; p=none"),
+  }));
+  check("dmarc.evaluate: valid p=none + spoof → fail + deliver (monitor)",
+        rv.result === "fail" && rv.recommendedAction === "deliver");
+}
+
+async function run() {
+  await testNoPolicyTagFailsClosed();
+  await testTypoPolicyTagFailsClosed();
+  await testWhitespacePaddedPolicyTag();
+  await testBadSpTagFailsClosed();
+  await testMissingPolicyParseThrows();
+  await testValidRejectStillFailsClosed();
+  await testValidNoneDelivers();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/mail-bimi-cert-validity-unparseable.test.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * b.mail.bimi — VMC / CMC certificate validity-window enforcement when the
+ * cert's notBefore / notAfter are PRESENT but UNPARSEABLE.
+ *
+ * _verifyCertChain reads `current.validFrom` / `current.validTo` and runs
+ * `Date.parse` to derive the validity window. A cert whose date strings
+ * Date.parse cannot interpret yields NaN. The window checks were guarded by
+ * `isFinite(...)`, so a NaN date SKIPPED both the not-yet-valid and the
+ * expired check and the cert validated — a present-but-unparseable validity
+ * window must FAIL CLOSED, not be waved through.
+ *
+ * This drives the real consumer path: b.mail.bimi.fetchAndVerifyMark with a
+ * self-signed test chain + stubbed httpClient. Date.parse is stubbed to
+ * return NaN for exactly the leaf cert's two date strings (simulating a cert
+ * whose ASN.1 time fields node surfaces as a string Date.parse rejects);
+ * every other Date.parse call is unaffected, so chain signature / issuer /
+ * SAN / EKU validation proceed normally and the ONLY failing signal is the
+ * unparseable window.
+ *
+ * Live network is NOT used.
+ */
+
+var helpers = require("../helpers");
+var b       = helpers.b;
+var check   = helpers.check;
+
+var pki        = require("../../lib/vendor/pki.cjs");
+var x509       = pki.x509;
+var nodeCrypto = require("crypto");
+
+async function _generateTestChain() {
+  var caKeys = await pki.crypto.subtle.generateKey(
+    { name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]);
+  var leafKeys = await pki.crypto.subtle.generateKey(
+    { name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]);
+
+  var now = new Date();
+  var notAfter = new Date(now.getTime() + 365 * 24 * 60 * 60 * 1000);
+
+  var ca = await x509.X509CertificateGenerator.createSelfSigned({
+    serialNumber: "01",
+    name: "CN=BIMI Test Root",
+    notBefore: now,
+    notAfter: notAfter,
+    signingAlgorithm: { name: "ECDSA", hash: "SHA-256" },
+    keys: caKeys,
+    extensions: [
+      new x509.BasicConstraintsExtension(true, 1, true),
+      new x509.KeyUsagesExtension(
+        x509.KeyUsageFlags.keyCertSign | x509.KeyUsageFlags.cRLSign, true),
+    ],
+  });
+
+  var leaf = await x509.X509CertificateGenerator.create({
+    serialNumber: "02",
+    issuer: ca.subject,
+    subject: "CN=example.com",
+    notBefore: now,
+    notAfter: notAfter,
+    signingAlgorithm: { name: "ECDSA", hash: "SHA-256" },
+    publicKey: leafKeys.publicKey,
+    signingKey: caKeys.privateKey,
+    extensions: [
+      new x509.BasicConstraintsExtension(false, undefined, true),
+      new x509.KeyUsagesExtension(x509.KeyUsageFlags.digitalSignature, true),
+      new x509.SubjectAlternativeNameExtension([
+        { type: "dns", value: "example.com" },
+      ]),
+      new x509.ExtendedKeyUsageExtension(["1.3.6.1.5.5.7.3.31"], false),
+    ],
+  });
+
+  return { rootPem: ca.toString("pem"), leafPem: leaf.toString("pem") };
+}
+
+function _stubHttpClient(body) {
+  return {
+    request: function () {
+      return Promise.resolve({
+        statusCode: 200,
+        headers:    {},
+        body:       Buffer.from(String(body), "utf8"),
+      });
+    },
+  };
+}
+
+async function testUnparseableValidityFailsClosed() {
+  var chain = await _generateTestChain();
+
+  // Surface the leaf's exact date strings the lib will feed to Date.parse,
+  // then stub Date.parse to return NaN for ONLY those two strings — every
+  // other Date.parse call (and the rest of chain validation) is untouched.
+  var leafCert = new nodeCrypto.X509Certificate(chain.leafPem);
+  var certDateStrings = [leafCert.validFrom, leafCert.validTo];
+  var origParse = Date.parse;
+  Date.parse = function (value) {
+    if (certDateStrings.indexOf(value) !== -1) return NaN;
+    return origParse.call(Date, value);
+  };
+
+  var threw = null;
+  var rv = null;
+  try {
+    rv = await b.mail.bimi.fetchAndVerifyMark({
+      domain:          "example.com",
+      vmcUrl:          "https://example.com/cert.pem",
+      trustAnchorsPem: chain.rootPem,
+      httpClient:      _stubHttpClient(chain.leafPem),
+    });
+  } catch (e) {
+    threw = e;
+  } finally {
+    Date.parse = origParse;
+  }
+
+  // RED on the buggy tree: rv.ok === true (cert accepted despite an
+  // unparseable validity window). GREEN after the fix: rejected with
+  // bimi/vmc-chain-invalid and a "validity dates unparseable" reason.
+  check("fetchAndVerifyMark: present-but-unparseable cert validity is rejected",
+        rv === null && threw !== null &&
+        threw.code === "bimi/vmc-chain-invalid");
+  check("fetchAndVerifyMark: unparseable-validity rejection names the cause",
+        threw !== null && /unparseable/i.test(String(threw.message)));
+}
+
+async function run() {
+  await testUnparseableValidityFailsClosed();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () { console.log("OK"); })
+       .catch(function (e) { console.error(e.stack || e); process.exit(1); });
+}

package/lib/vendor/blamejs/test/layer-0-primitives/mail-crypto-smime-bad-validity.test.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * b.mail.crypto.smime.checkCert — fail closed on unparseable validity.
+ *
+ * RFC 5280 §4.1.2.5 makes notBefore / notAfter mandatory; checkCert's
+ * validity-window guard refuses certs outside that window. The guard
+ * gated each comparison behind isFinite(Date.parse(...)), so a cert
+ * carrying a PRESENT-but-unparseable validFrom / validTo (Date.parse
+ * → NaN) silently skipped BOTH checks and passed validity. A signing
+ * cert whose dates a peer cannot parse must be refused at preflight,
+ * not accepted and left to fail interop later.
+ *
+ * This drives the real operator consumer path
+ * b.mail.crypto.smime.checkCert({ certPem }). node:crypto's
+ * X509Certificate always exposes parseable RFC date strings, so we
+ * stub the parser on the shared crypto module (require("node:crypto")
+ * === require("crypto"); lib reads X509Certificate off it) to present
+ * unparseable validity to the real checkCert logic.
+ *
+ * Run standalone: `node test/layer-0-primitives/mail-crypto-smime-bad-validity.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+var helpers    = require("../helpers");
+var check      = helpers.check;
+var nodeCrypto = require("crypto");
+
+var b     = helpers.b;
+var smime = b.mail.crypto.smime;
+
+// ---- Stub: a cert that parses fine but carries unparseable dates ----
+//
+// Passes the sig-algorithm (sha256WithRSAEncryption) and RSA-bit
+// (publicKey null → bit-floor check skipped) gates so execution
+// reaches the validity window — the only thing under test here.
+function _withUnparseableValidityCert(validFrom, validTo, fn) {
+  var Real = nodeCrypto.X509Certificate;
+  function StubCert(_input) {
+    return {
+      subject:               "CN=signer.example",
+      issuer:                "CN=signer.example",
+      signatureAlgorithm:    "sha256WithRSAEncryption",
+      signatureAlgorithmOid: "1.2.840.113549.1.1.11",
+      publicKey:             null,
+      fingerprint256:        "AA:BB:CC",
+      validFrom:             validFrom,
+      validTo:               validTo,
+    };
+  }
+  nodeCrypto.X509Certificate = StubCert;
+  try {
+    return fn();
+  } finally {
+    nodeCrypto.X509Certificate = Real;
+  }
+}
+
+var DUMMY_PEM =
+  "-----BEGIN CERTIFICATE-----\nMIIBdummy\n-----END CERTIFICATE-----\n";
+
+function testRejectsUnparseableValidity() {
+  // Both dates unparseable.
+  var threw = null, res = null;
+  _withUnparseableValidityCert("GARBAGE-NOT-A-DATE", "ALSO-GARBAGE", function () {
+    try { res = smime.checkCert({ certPem: DUMMY_PEM }); }
+    catch (e) { threw = e; }
+  });
+  check("checkCert refuses cert with unparseable validity (does not return)",
+    res === null);
+  check("checkCert throws on unparseable validity",
+    threw instanceof Error);
+  check("checkCert unparseable-validity uses the bad-validity code",
+    threw && threw.code === "mail-crypto/smime/bad-validity");
+  check("checkCert unparseable-validity message names the dates",
+    threw && /unparseable validity/.test(threw.message) &&
+    threw.message.indexOf("GARBAGE-NOT-A-DATE") !== -1);
+}
+
+function testRejectsUnparseableNotBeforeOnly() {
+  var threw = null, res = null;
+  // validTo parseable + in the future, validFrom unparseable — the
+  // old isFinite-gated notAfter check passes, so only fail-closed on
+  // the NaN notBefore catches this.
+  var future = new Date(Date.now() + 86400000).toUTCString();
+  _withUnparseableValidityCert("NOT-A-REAL-DATE", future, function () {
+    try { res = smime.checkCert({ certPem: DUMMY_PEM }); }
+    catch (e) { threw = e; }
+  });
+  check("checkCert refuses cert with unparseable notBefore only",
+    res === null && threw && threw.code === "mail-crypto/smime/bad-validity");
+}
+
+function testRejectsUnparseableNotAfterOnly() {
+  var threw = null, res = null;
+  var past = new Date(Date.now() - 86400000).toUTCString();
+  _withUnparseableValidityCert(past, "NOT-A-REAL-DATE", function () {
+    try { res = smime.checkCert({ certPem: DUMMY_PEM }); }
+    catch (e) { threw = e; }
+  });
+  check("checkCert refuses cert with unparseable notAfter only",
+    res === null && threw && threw.code === "mail-crypto/smime/bad-validity");
+}
+
+function testParseableValidityStillPasses() {
+  // Regression: a cert with parseable, in-window dates must NOT be
+  // tripped by the new fail-closed branch.
+  var threw = null, res = null;
+  var past   = new Date(Date.now() - 86400000).toUTCString();
+  var future = new Date(Date.now() + 86400000).toUTCString();
+  _withUnparseableValidityCert(past, future, function () {
+    try { res = smime.checkCert({ certPem: DUMMY_PEM }); }
+    catch (e) { threw = e; }
+  });
+  check("checkCert accepts cert with parseable in-window validity",
+    threw === null && res && res.subject === "CN=signer.example");
+}
+
+function run() {
+  testRejectsUnparseableValidity();
+  testRejectsUnparseableNotBeforeOnly();
+  testRejectsUnparseableNotAfterOnly();
+  testParseableValidityStillPasses();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  try {
+    run();
+    console.log("OK — " + helpers.getChecks() + " checks passed");
+  } catch (e) {
+    console.error("FAIL:", e && e.stack || e);
+    process.exit(1);
+  }
+}

package/lib/vendor/blamejs/test/layer-0-primitives/mail-dkim-numericdate-failclosed.test.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * b.mail.dkim.verify — x= / t= present-but-unparseable must FAIL CLOSED.
+ *
+ * RFC 6376 §3.5 — x= (expiration) and t= (timestamp) are NumericDate
+ * (digits-only seconds-since-epoch). The prior code parsed each with
+ * parseInt() guarded by isFinite(): a present-but-unparseable value
+ * (x=abc, x=, t=oops) yielded NaN, isFinite() was false, and the WHOLE
+ * expiry / future-date / ordering check SILENTLY SKIPPED — verification
+ * then proceeded to result:"pass" with no expiry enforced. An attacker
+ * replaying a message could neuter x= expiry by corrupting the tag.
+ *
+ * Mirrors the SAML Conditions present-but-unparseable fail-closed fix:
+ * when x= / t= is PRESENT it MUST parse as a finite NumericDate, else
+ * verify() returns result:"permerror".
+ *
+ * Drives the real consumer path b.mail.dkim.verify (not an internal
+ * helper). The x=/t= checks run BEFORE the DNS key fetch + signature
+ * verify, so a spliced tag over an otherwise-valid signature reaches
+ * them regardless of the (mocked) key.
+ *
+ * Run standalone: `node test/layer-0-primitives/mail-dkim-numericdate-failclosed.test.js`
+ * Or via smoke:   `node test/smoke.js`
+ */
+
+var helpers    = require("../helpers");
+var b          = helpers.b;
+var check      = helpers.check;
+var nodeCrypto = require("crypto");
+
+function _rsaKeypair() {
+  return nodeCrypto.generateKeyPairSync("rsa", {
+    modulusLength: 2048,
+    publicKeyEncoding:  { type: "spki",  format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" },
+  });
+}
+
+function _spkiPemToB64(pem) {
+  return pem.replace(/-----[A-Z ]+-----/g, "").replace(/\s+/g, "");
+}
+
+function _signedMessage(keypair) {
+  var signer = b.mail.dkim.create({
+    domain:     "example.com",
+    selector:   "s1",
+    privateKey: keypair.privateKey,
+  });
+  var rfc822 =
+    "From: alice@example.com\r\n" +
+    "To: bob@example.org\r\n" +
+    "Subject: Test\r\n" +
+    "Date: Mon, 5 May 2026 12:00:00 +0000\r\n" +
+    "Message-ID: <abc@example.com>\r\n" +
+    "\r\n" +
+    "Hello world.\r\n";
+  return signer.sign(rfc822);
+}
+
+// Splice a tag (e.g. "x=abc") into the DKIM-Signature header value, right
+// after the "v=1" prefix, leaving the rest of the (valid) signature intact.
+function _spliceTag(signed, tag) {
+  return signed.replace("DKIM-Signature: v=1", "DKIM-Signature: v=1; " + tag);
+}
+
+async function _verify(signed, kp) {
+  b.mail.dkim._resetDkimKeyCacheForTest();
+  var b64 = _spkiPemToB64(kp.publicKey);
+  var dnsLookup = async function () { return [["v=DKIM1; k=rsa; p=" + b64]]; };
+  return b.mail.dkim.verify(signed, { dnsLookup: dnsLookup });
+}
+
+async function testDkimXTagUnparseableFailsClosed() {
+  var kp = _rsaKeypair();
+  var signed = await _signedMessage(kp);
+
+  var rvAbc = await _verify(_spliceTag(signed, "x=abc"), kp);
+  check("verify: x=abc → permerror (not pass)",
+        rvAbc[0] && rvAbc[0].result === "permerror");
+  check("verify: x=abc error names present-but-unparseable",
+        rvAbc[0] && /x=.*unparseable/i.test((rvAbc[0].errors || []).join(" ")));
+
+  var rvEmpty = await _verify(_spliceTag(signed, "x="), kp);
+  check("verify: x= (empty) → permerror (not pass)",
+        rvEmpty[0] && rvEmpty[0].result === "permerror");
+
+  var rvLenient = await _verify(_spliceTag(signed, "x=12abc"), kp);
+  check("verify: x=12abc (parseInt-lenient) → permerror (not pass)",
+        rvLenient[0] && rvLenient[0].result === "permerror");
+}
+
+async function testDkimLTagUnparseableFailsClosed() {
+  // Sibling of the same root: l= (body-length cap, §3.5 unsigned integer).
+  // A present-but-unparseable l= previously fell through to lcap=undefined,
+  // silently hashing the WHOLE body instead of refusing the malformed tag.
+  var kp = _rsaKeypair();
+  var signed = await _signedMessage(kp);
+
+  var rv = await _verify(_spliceTag(signed, "l=abc"), kp);
+  check("verify: l=abc → permerror (not fall-through)",
+        rv[0] && rv[0].result === "permerror");
+  check("verify: l=abc error names present-but-unparseable",
+        rv[0] && /l=.*unparseable/i.test((rv[0].errors || []).join(" ")));
+}
+
+async function testDkimTTagUnparseableFailsClosed() {
+  var kp = _rsaKeypair();
+  var signed = await _signedMessage(kp);
+
+  var rv = await _verify(_spliceTag(signed, "t=oops"), kp);
+  check("verify: t=oops → permerror (not pass)",
+        rv[0] && rv[0].result === "permerror");
+  check("verify: t=oops error names present-but-unparseable",
+        rv[0] && /t=.*unparseable/i.test((rv[0].errors || []).join(" ")));
+}
+
+// Guard against over-correction: a well-formed x= far in the future + a
+// well-formed t= still verify to "pass" (the fix must not reject valid
+// NumericDate values).
+async function testDkimWellFormedNumericDateStillPasses() {
+  var kp = _rsaKeypair();
+  var signed = await _signedMessage(kp);
+
+  // x= 1 year out, t= now — both well-formed, ordering valid.
+  var nowSec = Math.floor(Date.now() / 1000);
+  var future = nowSec + (365 * 24 * 60 * 60);
+  // Note: splicing x=/t= changes the signed header value, so the body-hash
+  // / signature won't match — but the verdict must be a CRYPTO failure
+  // ("fail"/"permerror" from sig mismatch), NEVER skip the well-formed
+  // time checks. The point of THIS case: well-formed values are PARSED
+  // (don't trip the present-but-unparseable refusal). Assert the error,
+  // if any, is not the unparseable refusal.
+  var rv = await _verify(_spliceTag(signed, "t=" + nowSec + "; x=" + future), kp);
+  var joined = (rv[0].errors || []).join(" ");
+  check("verify: well-formed x=/t= not refused as unparseable",
+        !/unparseable/i.test(joined));
+}
+
+async function run() {
+  await testDkimXTagUnparseableFailsClosed();
+  await testDkimLTagUnparseableFailsClosed();
+  await testDkimTTagUnparseableFailsClosed();
+  await testDkimWellFormedNumericDateStillPasses();
+}
+
+module.exports = { run: run };
+
+if (require.main === module) {
+  run().then(function () {
+    console.log("mail-dkim-numericdate-failclosed: OK");
+  }).catch(function (e) {
+    console.error(e && e.stack ? e.stack : e);
+    process.exit(1);
+  });
+}