@abtnode/util 1.15.17 → 1.16.0-beta-b16cb035

package/lib/async-pm2.js

@@ -20,6 +20,19 @@ const api = [
   'stop',
 ];
 
+const nodeArgs = [];
+
+const originStart = pm2.start.bind(pm2);
+pm2.start = (opts, cb) => {
+  if (opts.node_args) {
+    opts.node_args = `${opts.node_args} ${nodeArgs.join(' ')}`.trim();
+  } else {
+    opts.node_args = nodeArgs.join(' ');
+  }
+
+  return originStart(opts, cb);
+};
+
 api.forEach((x) => {
   if (typeof pm2[x] === 'function') {
     pm2[`${x}Async`] = promisify(pm2[x]).bind(pm2);

package/lib/axios.js

@@ -1,7 +1,35 @@
-// set proxy to false to fix bug with HTTPS_PROXY environment
-// https://github.com/axios/axios/issues/3384
-const axios = require('axios');
+const axios = require('axios').default;
+const { HttpProxyAgent, HttpsProxyAgent } = require('hpagent');
 
-axios.defaults.proxy = false;
+function proxyInterceptor(config) {
+  /* istanbul ignore if */
+  if (config.socketPath != null) return config;
+
+  const { proxy } = config;
+
+  /* istanbul ignore if */
+  if (proxy === false) return config;
+
+  const httpProxyUrl = process.env.HTTP_PROXY || process.env.http_proxy;
+  const httpsProxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy;
+
+  const proxyOptions = Object.assign(
+    { keepAlive: true, keepAliveMsecs: 1000, maxSockets: 256, maxFreeSockets: 256 },
+    config.proxyOptions || {}
+  );
+
+  if (httpProxyUrl) {
+    config.proxy = false;
+    config.httpAgent = new HttpProxyAgent({ proxy: httpProxyUrl, ...proxyOptions });
+  }
+  if (httpsProxyUrl) {
+    config.proxy = false;
+    config.httpsAgent = new HttpsProxyAgent({ proxy: httpsProxyUrl, ...proxyOptions });
+  }
+
+  return config;
+}
+
+axios.interceptors.request.use(proxyInterceptor);
 
 module.exports = axios;

package/lib/base32.js

@@ -0,0 +1,14 @@
+const { toBuffer } = require('@ocap/util');
+const { base32 } = require('multiformats/bases/base32');
+
+const encode = (did) => {
+  if (!did) {
+    return did;
+  }
+
+  const buffer = toBuffer(did);
+
+  return base32.encode(buffer);
+};
+
+module.exports = { encode };

package/lib/can-pkg-rw.js

@@ -3,7 +3,7 @@ const locateNpmGlobalByBinary = require('./locate-npm-global-by-binary');
 const { canReadAndWriteDir } = require('./fs');
 
 module.exports = (cmdName, packageName) => {
-  const installDir = locateNpmGlobalByBinary(cmdName);
+  const installDir = locateNpmGlobalByBinary(cmdName, packageName);
   if (!installDir) {
     throw new Error(`${packageName} is not installed as a global package`);
   }

package/lib/check-domain-match.js

@@ -1,11 +1,16 @@
+const toLower = require('lodash/toLower');
+
 const WILDCARD = '*';
 
 /**
  * check two domains match or not. e.g. *.arcblock.io matches www.arcblock.io
- * @param {String} domain1
- * @param {String} domain2
+ * @param {String} domainX
+ * @param {String} domainY
  */
-const checkDomainMatch = (domain1, domain2) => {
+const checkDomainMatch = (domainX, domainY) => {
+  const domain1 = toLower(domainX);
+  const domain2 = toLower(domainY);
+
   if (!domain1 || !domain2) return false;
   if (typeof domain1 !== 'string' || typeof domain2 !== 'string') return false;
   if (domain1 === domain2) return true;

package/lib/did-document.js

@@ -0,0 +1,128 @@
+const stringify = require('json-stable-stringify');
+const { toBase64, toBase58 } = require('@ocap/util');
+const joinUrl = require('url-join');
+const pRetry = require('p-retry');
+const debug = require('debug')('@abtnode/util:did-document');
+const axios = require('./axios');
+const { encode: encodeBase32 } = require('./base32');
+
+const getDID = (address) => {
+  if (!address || typeof address !== 'string') {
+    return address;
+  }
+
+  if (address.startsWith('did:abt:')) {
+    return address;
+  }
+
+  return `did:abt:${address}`;
+};
+
+const update = async ({ services, didRegistryUrl, wallet, alsoKnownAs = [] }) => {
+  debug('update did document', { didRegistryUrl });
+
+  const did = getDID(wallet.address);
+  const time = new Date().toISOString();
+
+  const document = {
+    '@context': 'https://www.w3.org/ns/did/v1',
+    id: did,
+    controller: did,
+    service: services,
+    alsoKnownAs,
+    verificationMethod: [
+      {
+        id: `${did}#key-1`,
+        type: 'Ed25519Signature',
+        controller: did,
+        publicKeyMultibase: toBase58(wallet.publicKey),
+      },
+    ],
+    authentication: [`${did}#key-1`],
+    created: time,
+    updated: time,
+  };
+
+  const proof = {
+    type: 'Ed25519Signature',
+    created: time,
+    verificationMethod: `${did}#key-1`,
+    jws: toBase64(wallet.sign(stringify(document))),
+  };
+
+  document.proof = proof;
+
+  return axios.post(joinUrl(didRegistryUrl, '/.well-known/did-resolver/registries'), document, { timeout: 10 * 1000 });
+};
+
+const updateWithRetry = async (...args) => pRetry(() => update(...args), { retries: 3 });
+
+const getServerServices = ({ ips, wallet, domain }) => {
+  const records = ips.map((ip) => ({
+    type: 'A',
+    rr: encodeBase32(wallet.address),
+    value: ip,
+    domain,
+  }));
+
+  const services = [
+    {
+      id: getDID(wallet.address),
+      type: 'DNSRecords',
+      records,
+    },
+  ];
+
+  return services;
+};
+
+const getBlockletServices = ({ appPid, daemonDidDomain, domain }) => {
+  return [
+    {
+      id: getDID(appPid),
+      type: 'DNSRecords',
+      records: [
+        {
+          type: 'CNAME',
+          rr: encodeBase32(appPid),
+          value: daemonDidDomain,
+          domain,
+        },
+      ],
+    },
+  ];
+};
+
+const updateServerDocument = async ({ ips, wallet, didRegistryUrl, domain }) => {
+  const filteredIps = (ips || []).filter(Boolean);
+  if (filteredIps.length === 0) {
+    throw new Error('No DID Document to update');
+  }
+
+  const services = getServerServices({ ips: filteredIps, domain, wallet });
+
+  return updateWithRetry({ services, didRegistryUrl, wallet });
+};
+
+const updateBlockletDocument = async ({
+  wallet,
+  didRegistryUrl,
+  domain,
+  daemonDidDomain,
+  appPid,
+  alsoKnownAs = [],
+}) => {
+  const services = getBlockletServices({ appPid, daemonDidDomain, domain });
+  return updateWithRetry({ services, didRegistryUrl, alsoKnownAs, wallet });
+};
+
+const disableDNS = async ({ wallet, didRegistryUrl }) => updateWithRetry({ services: [], didRegistryUrl, wallet });
+
+module.exports = {
+  updateServerDocument,
+  updateBlockletDocument,
+  disableDNS,
+  getDID,
+  getServerServices,
+  getBlockletServices,
+};

package/lib/download-file.js

@@ -7,18 +7,56 @@ const axios = require('./axios');
 const CANCEL = '__cancel__';
 
 /**
- * download file
- * @param {string} url
- * @param {string} dest directory
- * @param {Number} timeout unit: ms
- * @param {CancelCtrl} cancelCtrl
+ *
+ *
+ * @param {Stream} stream
+ * @returns {Promise<string>}
  */
-const downloadFile = async (url, dest, { timeout = 600 * 1000, cancelCtrl } = {}) => {
+async function getErrorMessageFromStream(stream) {
+  const str = await streamToString(stream);
+
+  try {
+    const json = JSON.parse(str);
+    return json.error;
+  } catch (error) {
+    return str;
+  }
+}
+
+/**
+ *
+ *
+ * @param {*} stream
+ * @return {Promise<string>}
+ */
+async function streamToString(stream) {
+  const chunks = [];
+
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+  }
+
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+/**
+ *
+ *
+ * @param {*} url
+ * @param {*} dest directory
+ * @param {{
+ *  timeout: number; // unit: ms
+ *  cancelCtrl: any;
+ * }} [{ timeout = 600 * 1000, cancelCtrl, data }={}]
+ * @param {{}} context
+ * @return {*}
+ */
+const downloadFile = async (url, dest, { timeout = 600 * 1000, cancelCtrl } = {}, context = {}) => {
   const CONNECTION_TIMEOUT = 20 * 1000;
   const source = CancelToken.source();
 
   try {
-    const result = await tryWithTimeout(async () => {
+    return await tryWithTimeout(async () => {
       const timer = setTimeout(() => {
         source.cancel(`Connection timeout: ${Math.ceil(CONNECTION_TIMEOUT / 1000)}s`);
       }, CONNECTION_TIMEOUT);
@@ -39,6 +77,7 @@ const downloadFile = async (url, dest, { timeout = 600 * 1000, cancelCtrl } = {}
 
       const response = await axios({
         url,
+        headers: context?.headers,
         method: 'GET',
         responseType: 'stream',
         cancelToken: source.token,
@@ -61,8 +100,6 @@ const downloadFile = async (url, dest, { timeout = 600 * 1000, cancelCtrl } = {}
 
       return dest;
     }, timeout);
-
-    return result;
   } catch (err) {
     if (fs.existsSync(dest)) {
       fs.unlinkSync(dest);
@@ -76,6 +113,11 @@ const downloadFile = async (url, dest, { timeout = 600 * 1000, cancelCtrl } = {}
     }
 
     source.cancel();
+
+    if (err?.response?.data) {
+      throw new Error(await getErrorMessageFromStream(err.response.data));
+    }
+
     throw err;
   }
 };

package/lib/ensure-endpoint-healthy.js

@@ -62,7 +62,7 @@ module.exports = async ({
   host = '127.0.0.1',
   port,
   timeout = 10 * ONE_SECOND,
-  minConsecutiveTime = 5 * ONE_SECOND,
+  minConsecutiveTime = (+process.env.ENDPOINT_CONSECUTIVE_TIME || 5) * ONE_SECOND,
 }) => {
   debug('ensure endpoint healthy', { port, minConsecutiveTime });
 

package/lib/format-back-slash.js

@@ -0,0 +1,9 @@
+const lodash = require('lodash');
+
+/**
+ * Replace the back slack('\') with forward slash('/')
+ * @param {*} str
+ * @param {*} flag RegExp flag, default is 'g'
+ * @returns
+ */
+module.exports = (str) => lodash.replace(str, new RegExp(lodash.escapeRegExp('\\'), 'g'), '/');

package/lib/format-context.js

@@ -0,0 +1,28 @@
+const get = require('lodash/get');
+
+// Format context: https://github.com/graphql/express-graphql
+module.exports = (ctx = {}) => {
+  if (ctx && ctx.user) {
+    delete ctx.user.avatar;
+  }
+
+  const safeGet = (key, _default = '') =>
+    (typeof ctx.get === 'function' ? ctx.get(key) : get(ctx, `headers[${key}]`)) || _default;
+  const port = process.env.NODE_ENV === 'production' ? safeGet('x-real-port') : '';
+  const result = {
+    ip: safeGet('x-real-ip', '127.0.0.1'),
+    ua: safeGet('user-agent'),
+    protocol: safeGet('x-real-protocol').replace(/:$/, '') || 'http',
+    user: ctx.user || {},
+    url: ctx.originalUrl,
+    query: ctx.query,
+    hostname: safeGet('x-real-hostname'),
+    port: Number(port) === 80 ? '' : Number(port),
+    nodeMode: ctx.nodeMode,
+    referrer: safeGet('referrer'),
+  };
+
+  // 警告，尽量不要在这里传递整个 headers 对象，因为可能会影响后续流程
+
+  return result;
+};

package/lib/format-name.js

@@ -0,0 +1,5 @@
+const slugify = require('slugify');
+
+const formatName = (name) => slugify(name.replace(/^[@./-]/, '').replace(/[@./_]/g, '-'));
+
+module.exports = formatName;

package/lib/get-folder-size.js

@@ -1,6 +1,7 @@
+const getSize = require('get-folder-size');
 const exec = require('child_process').execFile;
 
-module.exports = (dir) => {
+const getOnUnixLike = (dir) => {
   const regex = /^(\d*)/;
 
   return new Promise((resolve, reject) => {
@@ -16,3 +17,17 @@ module.exports = (dir) => {
     });
   });
 };
+
+const getOnWindows = (dir) => {
+  return new Promise((resolve, reject) => {
+    getSize(dir, (err, size) => {
+      if (err) {
+        return reject(err);
+      }
+
+      return resolve(size);
+    });
+  });
+};
+
+module.exports = process.platform === 'win32' ? getOnWindows : getOnUnixLike;

package/lib/get-ip.js

@@ -14,23 +14,23 @@ const getExternalIp = async ({ v6 = false, timeout = 5000 } = {}) => {
   }
 };
 
-const getIP = async ({ includeV6 = false, timeout = 5000 } = {}) => {
+const getIP = async ({ includeV6 = false, timeout = 5000, includeExternal = true } = {}) => {
   try {
-    if (isEC2()) {
+    if (await isEC2()) {
       const [internal, external, internalV6, externalV6] = await Promise.all([
         getEc2Meta('local-ipv4', timeout),
-        getEc2Meta('public-ipv4', timeout),
+        includeExternal ? getEc2Meta('public-ipv4', timeout) : '',
         includeV6 ? getEc2Meta('local-ipv6', timeout) : '',
-        includeV6 ? getEc2Meta('public-ipv6', timeout) : '',
+        includeV6 && includeExternal ? getEc2Meta('public-ipv6', timeout) : '',
       ]);
       return { internal, external, internalV6, externalV6 };
     }
 
     const [internal, external, internalV6, externalV6] = await Promise.all([
       internalIp.v4(),
-      getExternalIp({ timeout }),
+      includeExternal ? getExternalIp({ timeout }) : '',
       includeV6 ? internalIp.v6() : '',
-      includeV6 ? getExternalIp({ v6: true, timeout }) : '',
+      includeV6 && includeExternal ? getExternalIp({ v6: true, timeout }) : '',
     ]);
     return { internal, external, internalV6, externalV6 };
   } catch (err) {

package/lib/is-ec2.js

@@ -1,14 +1,15 @@
-const fs = require('fs');
+const axios = require('./axios');
 
 // Whether we are running in an pre-baked image
-function isEC2() {
-  const identifyFile = '/sys/hypervisor/uuid';
-  if (fs.existsSync(identifyFile)) {
-    const identity = fs.readFileSync(identifyFile).toString();
-    return identity.toLowerCase().startsWith('ec2');
+// refer: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/identify_ec2_instances.html
+async function isEC2() {
+  try {
+    const url = 'http://169.254.169.254/latest/dynamic/instance-identity/document';
+    const { status } = await axios.get(url, { timeout: 1000 });
+    return status === 200;
+  } catch {
+    return false;
   }
-
-  return false;
 }
 
 module.exports = isEC2;

package/lib/is-path-prefix-equal.js

@@ -0,0 +1,3 @@
+const normalizePathPrefix = require('./normalize-path-prefix');
+
+module.exports = (a, b) => normalizePathPrefix(a) === normalizePathPrefix(b);

package/lib/locate-npm-global-by-binary.js

@@ -1,22 +1,32 @@
-/* eslint-disable no-unused-vars, no-console */
-
 const fs = require('fs');
 const path = require('path');
-const shelljs = require('shelljs');
+const shell = require('shelljs');
 
-module.exports = (binaryName) => {
+module.exports = (binaryName, packageName) => {
   if (!binaryName) {
     throw new Error('binaryName is required');
   }
 
-  const result = shelljs.which(binaryName);
+  let result = shell.which(binaryName);
   if (!result || !result.stdout) {
     return '';
   }
 
-  const binPath = result.stdout;
+  const binPath = result.stdout.trim();
 
+  // Check if the package is installed via pnpm: only if we have packageName set
   let binDir = path.dirname(fs.realpathSync(binPath));
+  if (packageName) {
+    const { stdout: pnpmPath } = shell.which('pnpm') || {};
+    if (pnpmPath) {
+      result = shell.exec('pnpm bin -g', { silent: true });
+      const pnpmBinDir = result.stdout.trim();
+      if (binDir === pnpmBinDir) {
+        result = shell.exec(`pnpm root -g ${packageName}`, { silent: true });
+        return path.join(result.stdout.trim(), packageName);
+      }
+    }
+  }
 
   while (binDir && binDir !== path.sep && path.basename(binDir) !== 'node_modules') {
     const packageJsonPath = path.join(binDir, 'package.json');