@abtnode/core 1.15.17 → 1.16.0-beta-b16cb035

package/lib/util/sysinfo.js

@@ -0,0 +1,44 @@
+const maxBy = require('lodash/maxBy');
+const SysInfo = require('systeminformation');
+
+const getSysInfo = async () => {
+  const info = await SysInfo.get({
+    cpu: 'physicalCores',
+    mem: '*',
+    currentLoad: '*',
+    fsSize: '*',
+    diskLayout: '*',
+    osInfo: 'platform',
+  });
+
+  let drives = info.fsSize;
+  if (info.osInfo.platform === 'darwin') {
+    const systemDrives = (info.fsSize || []).filter((x) => x.type === 'APFS');
+    const rootDrive = systemDrives.find((x) => x.mount === '/');
+    if (rootDrive) {
+      const maxUsedDrive = maxBy(systemDrives, (x) => x.used);
+      rootDrive.used = maxUsedDrive.used;
+      drives = [rootDrive];
+    } else {
+      drives = [];
+    }
+  }
+
+  return {
+    cpu: {
+      ...info.currentLoad,
+      ...info.cpu,
+    },
+    mem: info.mem,
+    os: info.osInfo,
+    disks: drives.map((x) => ({
+      device: x.fs,
+      mountPoint: x.mount,
+      total: x.size,
+      used: x.used,
+      free: x.size - x.used,
+    })),
+  };
+};
+
+module.exports.getSysInfo = getSysInfo;

package/lib/util/ua.js

@@ -0,0 +1,54 @@
+const semver = require('semver');
+const parser = require('ua-parser-js');
+const packageJson = require('../../package.json');
+
+const { memoizeAsync } = require('./index');
+
+const parseWalletUA = (userAgent) => {
+  const ua = (userAgent || '').toString().toLowerCase();
+  let os = '';
+  let version = '';
+  if (ua.indexOf('android') > -1) {
+    os = 'android';
+  } else if (ua.indexOf('darwin') > -1) {
+    os = 'ios';
+  } else if (ua.indexOf('arcwallet') === 0) {
+    os = 'web';
+  }
+
+  const match = ua.split(/\s+/).find((x) => x.startsWith('arcwallet'));
+  if (match) {
+    const tmp = match.split('/');
+    if (tmp.length > 1 && semver.coerce(tmp[1])) {
+      version = semver.coerce(tmp[1]).version;
+    }
+  }
+
+  return { os, version };
+};
+
+const parse = memoizeAsync((ua) => {
+  let result = parser(ua);
+  if (result.browser.name) {
+    return result;
+  }
+
+  result = parseWalletUA(ua);
+  if (result.version) {
+    return {
+      browser: {
+        name: `DID Wallet ${result.os.toUpperCase()}`,
+        version: result.version,
+      },
+    };
+  }
+
+  return {
+    browser: {
+      name: 'CLI',
+      version: packageJson.version,
+    },
+  };
+});
+
+module.exports = { parse };

package/lib/validators/blocklet-extra.js

@@ -0,0 +1,24 @@
+const JOI = require('joi');
+const { didExtension } = require('@blocklet/meta/lib/extension');
+const { blockletController, createValidator } = require('./util');
+
+const Joi = JOI.extend(didExtension);
+
+const addMeta = Joi.object({
+  did: Joi.ref('meta.did'),
+  meta: Joi.object({
+    did: Joi.DID().required(),
+    name: Joi.string().required(),
+  }).required(),
+  controller: blockletController.optional(),
+}).required();
+
+const updateExpiredInfo = Joi.object({
+  did: Joi.DID().required(),
+  expiredAt: Joi.string().required(),
+});
+
+module.exports = {
+  validateAddMeta: createValidator(addMeta),
+  validateExpiredInfo: createValidator(updateExpiredInfo),
+};

package/lib/validators/node.js

@@ -1,4 +1,5 @@
 /* eslint-disable newline-per-chained-call */
+const { GATEWAY_REQ_LIMIT } = require('@abtnode/constant');
 const Joi = require('joi');
 const { getMultipleLangParams } = require('./util');
 
@@ -9,14 +10,23 @@ const nodeInfoSchema = Joi.object({
   description: Joi.string()
     .required()
     .messages({ zh: { 'string.empty': '描述不能为空' }, en: { 'string.empty': 'Description cannot be empty' } }),
+  registerUrl: Joi.string()
+    .uri({ scheme: [/https?/] })
+    .label('register url')
+    .allow('')
+    .optional()
+    .messages({
+      zh: { 'string.uriCustomScheme': '应用启动器必须是合法的 URL' },
+      en: { 'string.uriCustomScheme': 'Blocklet Launcher must be a valid URL' },
+    }),
   webWalletUrl: Joi.string()
     .uri({ scheme: [/https?/] })
     .label('web wallet url')
     .allow('')
     .optional()
     .messages({
-      zh: { 'string.uriCustomScheme': 'Web DID Wallet 必须是合法的 URL' },
-      en: { 'string.uriCustomScheme': 'Web DID Wallet must be a valid URL' },
+      zh: { 'string.uriCustomScheme': 'Web Wallet 必须是合法的 URL' },
+      en: { 'string.uriCustomScheme': 'Web Wallet must be a valid URL' },
     }),
   autoUpgrade: Joi.boolean(),
   enableWelcomePage: Joi.boolean(),
@@ -31,18 +41,21 @@ const nodeInfoSchema = Joi.object({
         'number.max': 'Disk usage alert threshold cannot be higher than 99%',
       },
     }),
-  // removed in 1.5.1
-  registerUrl: Joi.string()
-    .uri({ scheme: [/https?/] })
-    .label('register url')
-    .allow('')
-    .optional()
-    .messages({
-      zh: { 'string.uriCustomScheme': '注册地址必须是合法的 URL' },
-      en: { 'string.uriCustomScheme': 'Registry URL must be a valid URL' },
-    }),
 }).options({ stripUnknown: true });
 
+const updateGatewaySchema = Joi.object({
+  requestLimit: Joi.object({
+    enabled: Joi.bool().required(),
+    rate: Joi.number()
+      .min(GATEWAY_REQ_LIMIT.min)
+      .max(GATEWAY_REQ_LIMIT.max)
+      .when('requestLimit.enabled', { is: true, then: Joi.required() }),
+    ipHeader: Joi.string().allow('').trim(),
+  }),
+  cacheEnabled: Joi.bool().optional().default(true),
+});
+
 module.exports = {
   validateNodeInfo: (entity, context) => nodeInfoSchema.validateAsync(entity, getMultipleLangParams(context)),
+  validateUpdateGateway: (entity, context) => updateGatewaySchema.validateAsync(entity, getMultipleLangParams(context)),
 };

package/lib/validators/permission.js

@@ -2,7 +2,22 @@
 const JOI = require('joi');
 const { getMultipleLangParams } = require('./util');
 
-const nameSchema = JOI.string().trim().max(64);
+const nameSchema = JOI.string()
+  .trim()
+  .max(64)
+  .custom((name) => {
+    const arr = name.split('_');
+    const formatTip = 'The format of permission name should be "{action}_{resource}", e.g. query_data';
+    if (arr.length > 2) {
+      throw new Error(`Too much "_". ${formatTip}`);
+    }
+
+    if (arr.length < 2) {
+      throw new Error(formatTip);
+    }
+
+    return name;
+  });
 const descriptionSchema = JOI.string().trim().max(600);
 
 const createPermissionSchema = JOI.object({

package/lib/validators/role.js

@@ -2,18 +2,32 @@
 const JOI = require('joi');
 const { getMultipleLangParams } = require('./util');
 
-const nameSchema = JOI.string().trim().max(64);
+const roleNameSchema = JOI.string()
+  .trim()
+  .max(64)
+  .custom((value) => {
+    if (value.startsWith('blocklet')) {
+      throw new Error('role name cannot start with "blocklet"');
+    }
+
+    if (/[^a-zA-z0-9]/.test(value)) {
+      throw new Error('role name can include only numbers or letters');
+    }
+
+    return value;
+  });
+
 const titleSchema = JOI.string().trim().max(25);
 const descriptionSchema = JOI.string().trim().max(600);
 
 const createRoleSchema = JOI.object({
-  name: nameSchema.required(),
+  name: roleNameSchema.required(),
   title: titleSchema.required(),
   description: descriptionSchema.required(),
 });
 
 const updateRoleSchema = JOI.object({
-  name: nameSchema.required(),
+  name: roleNameSchema.required(),
   title: titleSchema,
   description: descriptionSchema,
 });

package/lib/validators/router.js

@@ -1,10 +1,13 @@
 /* eslint-disable newline-per-chained-call */
 const Joi = require('joi');
-const { DOMAIN_FOR_DEFAULT_SITE, ROUTING_RULE_TYPES } = require('@abtnode/constant');
+const { DOMAIN_FOR_DEFAULT_SITE, ROUTING_RULE_TYPES, ROUTER_CACHE_GROUPS } = require('@abtnode/constant');
+const urlFriendly = require('@blocklet/meta/lib/url-friendly').default;
 const { getMultipleLangParams } = require('./util');
 
 const WILDCARD_DOMAIN_REGEX = /^\*.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]/;
 
+const DOMAIN_SCHEMA = Joi.string().domain({ minDomainSegments: 1, tlds: false }).lowercase();
+
 const domainMessages = {
   en: {
     'alternatives.match': 'Illegal domain, please enter a domain like arcblock, arcblock.io, *.arcblock.io',
@@ -25,7 +28,8 @@ const ruleSchema = {
       .messages({
         zh: { 'string.empty': 'URL 前缀不能为空', 'string.max': 'URL 前缀的最大长度是 150' },
         en: { 'string.empty': 'URL prefix cannot be empty', 'string.max': 'The maximum length of URL prefix is 150' },
-      }),
+      })
+      .custom((value) => urlFriendly(value)),
     groupPathPrefix: Joi.string().trim().min(1).max(150), // path prefix of interface of root blocklet
     header: Joi.any(), // TODO: header does not take effect
   }),
@@ -39,21 +43,33 @@ const ruleSchema = {
         ROUTING_RULE_TYPES.BLOCKLET,
         ROUTING_RULE_TYPES.REDIRECT,
         ROUTING_RULE_TYPES.GENERAL_PROXY,
+        ROUTING_RULE_TYPES.DIRECT_RESPONSE,
         ROUTING_RULE_TYPES.NONE
       )
       .required(),
     did: Joi.string().label('did').when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }), // root blocklet did
-    realDid: Joi.string().label('real did'), // child blocklet did
     port: Joi.number().label('port').port().when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }),
     url: Joi.string().label('url').when('type', { is: ROUTING_RULE_TYPES.REDIRECT, then: Joi.required() }),
     redirectCode: Joi.alternatives()
-      .try(301, 302)
+      .try(301, 302, 307, 308)
       .label('redirect code')
       .when('type', { is: ROUTING_RULE_TYPES.REDIRECT, then: Joi.required() }),
     interfaceName: Joi.string() // root interface
       .label('interface name')
       .when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }),
-    realInterfaceName: Joi.string().label('real interface name'), // child blocklet interface
+    response: Joi.object({ status: Joi.number().required(), contentType: Joi.string(), body: Joi.string().required() })
+      .label('response')
+      .when('type', {
+        is: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
+        then: Joi.required(),
+      }),
+    componentId: Joi.string().label('component id'), // component global id
+    // FUTURE: blocklets can register routing rules for provider cache
+    cacheGroup: Joi.string()
+      .label('cache group')
+      .valid(...Object.keys(ROUTER_CACHE_GROUPS))
+      .allow('')
+      .default(''),
   },
 
   // List of services that manipulate the request before the upstream blocklet
@@ -73,11 +89,7 @@ const ruleSchema = {
 };
 
 const corsSchema = Joi.array()
-  .items(
-    Joi.string().domain({ minDomainSegments: 1, tlds: false }),
-    Joi.string().valid(DOMAIN_FOR_DEFAULT_SITE),
-    Joi.string().ip()
-  )
+  .items(DOMAIN_SCHEMA, Joi.string().valid(DOMAIN_FOR_DEFAULT_SITE, '__none__'), Joi.string().ip())
   .min(1)
   .optional();
 
@@ -85,26 +97,30 @@ const ruleJoiSchema = Joi.object(ruleSchema);
 
 const addDomainAlias = Joi.alternatives()
   .try(
-    Joi.string().domain({ minDomainSegments: 1, tlds: false }),
+    DOMAIN_SCHEMA,
     Joi.string().regex(WILDCARD_DOMAIN_REGEX) // 这种其实是一种特殊的 tld
   )
   .required();
 
+const domainAliases = Joi.array().items(
+  Joi.object({
+    value: addDomainAlias,
+    isProtected: Joi.boolean(),
+  })
+);
+
+const updateAliases = domainAliases.required();
+
 const addSiteSchema = Joi.object({
   domain: Joi.alternatives()
     .try(
-      Joi.string().domain({ minDomainSegments: 1, tlds: false }),
+      DOMAIN_SCHEMA,
       Joi.string().valid('', DOMAIN_FOR_DEFAULT_SITE),
       Joi.string().regex(WILDCARD_DOMAIN_REGEX) // 这种其实是一种特殊的 tld
     )
     .required()
     .messages(domainMessages),
-  domainAliases: Joi.array().items(
-    Joi.object({
-      value: addDomainAlias,
-      isProtected: Joi.boolean(),
-    })
-  ),
+  domainAliases,
   isProtected: Joi.boolean(),
   rules: Joi.array().items(ruleJoiSchema),
   corsAllowedOrigins: corsSchema,
@@ -115,12 +131,12 @@ const updateSite = Joi.object({
   corsAllowedOrigins: corsSchema,
   domain: Joi.alternatives()
     .try(
-      Joi.string().domain({ minDomainSegments: 1, tlds: false }),
+      DOMAIN_SCHEMA,
       Joi.string().regex(WILDCARD_DOMAIN_REGEX) // 这种其实是一种特殊的 tld
     )
     .optional()
     .messages(domainMessages),
-});
+}).unknown();
 
 const addRuleSchema = Joi.object({
   id: Joi.string().required(),
@@ -142,10 +158,14 @@ const validateUpdateSite = (entity, context) => updateSite.validateAsync(entity,
 const validateAddRule = (entity, context) => addRuleSchema.validateAsync(entity, getMultipleLangParams(context));
 const validateEditRule = (entity, context) => editRuleSchema.validateAsync(entity, getMultipleLangParams(context));
 
+const validateUpdateDomainAliases = (entity, context) =>
+  updateAliases.validateAsync(entity, getMultipleLangParams(context));
+
 module.exports = {
   validateAddRule,
   validateAddSite,
   validateEditRule,
   validateAddDomainAlias,
   validateUpdateSite,
+  validateUpdateDomainAliases,
 };

package/lib/validators/trusted-passport.js

@@ -8,6 +8,7 @@ const Joi = JOI.extend(didExtension);
 const trustedPassportsSchema = Joi.array().items(
   Joi.object({
     issuerDid: Joi.DID().required(),
+    remark: Joi.string().trim(),
     mappings: Joi.array().items(
       Joi.object({
         from: Joi.object({

package/lib/validators/util.js

@@ -1,9 +1,26 @@
 const get = require('lodash/get');
+const JOI = require('joi');
+const { didExtension } = require('@blocklet/meta/lib/extension');
+
+const Joi = JOI.extend(didExtension);
+
+const getMultipleLangParams = (context) => ({
+  errors: {
+    language: get(context, 'query.locale', 'en'),
+  },
+});
+
+const blockletController = Joi.object({
+  nftId: Joi.DID().required(),
+  nftOwner: Joi.DID().required(),
+  chainHost: Joi.string().uri().required(),
+  appMaxCount: Joi.number().required().min(1),
+}).options({ stripUnknown: true });
+
+const createValidator = (schema) => (entity) => schema.validateAsync(entity);
 
 module.exports = {
-  getMultipleLangParams: (context) => ({
-    errors: {
-      language: get(context, 'query.locale', 'en'),
-    },
-  }),
+  createValidator,
+  getMultipleLangParams,
+  blockletController,
 };

package/lib/webhook/index.js

@@ -1,13 +1,16 @@
 const logger = require('@abtnode/logger')('@abtnode/core:webhook:index');
-const upperFirst = require('lodash/upperFirst');
 
+const { evaluateURLs } = require('@abtnode/util/lib/url-evaluation');
+const checkURLAccessible = require('@abtnode/util/lib/url-evaluation/check-accessible-node');
+const { EVENTS } = require('@abtnode/constant');
 const WebHookSender = require('./sender');
-const createQueue = require('../queue');
+const WalletSender = require('./sender/wallet');
+const createQueue = require('../util/queue');
 const IP = require('../util/ip');
 const states = require('../states');
 const { getBaseUrls } = require('../util');
 
-const getSlackUrlInfo = (actionPath = '/notifications', urls) => {
+const getSlackUrlInfo = async (actionPath = '/notifications', urls) => {
   const info = [];
 
   if (actionPath && actionPath.startsWith('/blocklet/')) {
@@ -28,29 +31,30 @@ const getSlackUrlInfo = (actionPath = '/notifications', urls) => {
     });
   }
 
-  const httpUrls = urls.filter((x) => x.url.startsWith('http://'));
-  const httpsUrls = urls.filter((x) => x.url.startsWith('https://'));
-
-  const showUrls = httpsUrls.length ? httpsUrls : httpUrls;
-  const elements = [];
-  showUrls.forEach((x) => {
-    const { protocol } = new URL(x.url);
-    const normalized = `${x.url}${actionPath}`.replace(`${protocol}//`, '').replace(/\/+/g, '/');
-    const url = `${protocol}//${normalized}`;
-    elements.push({
-      type: 'button',
-      text: {
-        type: 'plain_text',
-        text: `${upperFirst(x.type)} Address`,
-      },
-      style: 'primary',
-      value: `${upperFirst(x.type)} Address`,
-      url,
-    });
-  });
+  const prioritys = await evaluateURLs(
+    urls.map((item) => item.url),
+    { checkAccessble: checkURLAccessible }
+  );
+  const priorityUrl = prioritys[0].url;
+
+  const { protocol } = new URL(priorityUrl);
+  const normalized = `${priorityUrl}${actionPath}`.replace(`${protocol}//`, '').replace(/\/+/g, '/');
+  const url = `${protocol}//${normalized}`;
+
   info.push({
     type: 'actions',
-    elements,
+    elements: [
+      {
+        type: 'button',
+        text: {
+          type: 'plain_text',
+          text: 'Click Me',
+        },
+        style: 'primary',
+        value: 'Click Me',
+        url,
+      },
+    ],
   });
 
   return info;
@@ -66,9 +70,14 @@ module.exports = ({ events, dataDirs, instance }) => {
       const webhookList = await webhookState.list();
       const nodeInfo = await nodeState.read();
       const { internal, external } = await IP.get();
-      const baseUrls = await getBaseUrls(instance, { internal, external });
+      const baseUrls = await getBaseUrls(instance, [external, internal]);
       const senderFns = {};
 
+      // Always send message to wallet
+      webhookList.push({
+        type: WalletSender.type,
+      });
+
       if (webhookList.length) {
         for (let i = 0; i < webhookList.length; i++) {
           const item = webhookList[i];
@@ -76,10 +85,10 @@ module.exports = ({ events, dataDirs, instance }) => {
             const senderInstance = WebHookSender.getMessageSender(item.type);
             senderFns[item.type] = senderInstance.send.bind(senderInstance);
           }
-          const { description } = nodeInfo;
-          const options = { ...message, nodeInfo: `*${description}*` };
+          const options = { ...message, nodeInfo, node: instance };
           if (item.type === 'slack') {
-            options.urlInfo = getSlackUrlInfo(message.action, baseUrls);
+            // eslint-disable-next-line
+            options.urlInfo = await getSlackUrlInfo(message.action, baseUrls);
           }
           try {
             // eslint-disable-next-line
@@ -106,15 +115,15 @@ module.exports = ({ events, dataDirs, instance }) => {
     },
   });
 
-  events.on('notification.create', (data) => {
+  events.on(EVENTS.NOTIFICATION_CREATE, (data) => {
     const { title, description, severity, action, entityType } = data;
     queue.push({ title, description, status: severity, action, entityType });
   });
 
-  events.on('node.started', async (message) => {
+  events.on(EVENTS.NODE_STARTED, async (message) => {
     await sendMessage(message);
   });
-  events.on('node.stopped', async (message) => {
+  events.on(EVENTS.NODE_STOPPED, async (message) => {
     await sendMessage(message);
   });
 
@@ -125,13 +134,14 @@ module.exports = ({ events, dataDirs, instance }) => {
 
   const createWebhook = async (webhook) => {
     try {
-      const createRes = await webhookState.create(webhook);
-      await sentTextMessage(createRes, `A ${createRes.type} integration is now *successfully added*`);
+      const mockCreateRes = await webhookState.create(webhook, { mock: true });
+      await sentTextMessage(mockCreateRes, `A ${mockCreateRes.type} integration is now *successfully added*`);
 
+      const createRes = await webhookState.create(webhook);
       return createRes;
     } catch (err) {
-      logger.error('create webhook error', { err });
-      throw new Error(err.message);
+      logger.error('Failed to create webhook', { err });
+      throw new Error(`Failed to create webhook: ${err.message}`);
     }
   };
 

package/lib/webhook/sender/index.js

@@ -3,6 +3,7 @@ const logger = require('@abtnode/logger')('@abtnode/core:sender');
 
 const Slack = require('./slack');
 const Api = require('./api');
+const Wallet = require('./wallet');
 
 const SenderMap = new Map([
   [Slack.type, Slack],
@@ -12,6 +13,10 @@ const SenderMap = new Map([
 const getSenderNames = () => [...SenderMap.keys()];
 
 const getSender = (name) => {
+  if (name === Wallet.type) {
+    return Wallet;
+  }
+
   if (!SenderMap.has(name)) {
     logger.error(`getSender:sender name [${name}] does not exist`);
     return null;

package/lib/webhook/sender/slack/index.js

@@ -29,7 +29,7 @@ class SlackSender extends BaseSender {
             type: 'section',
             text: {
               type: 'mrkdwn',
-              text: nodeInfo,
+              text: `*${nodeInfo?.name}*`,
             },
           },
           {

package/lib/webhook/sender/wallet/index.js

@@ -0,0 +1,48 @@
+const logger = require('@abtnode/logger')('@abtnode/core:sender:api');
+const { sendToUser } = require('@blocklet/sdk/lib/util/send-notification');
+const { ROLES, PASSPORT_STATUS } = require('@abtnode/constant');
+const BaseSender = require('../base');
+
+class WalletSender extends BaseSender {
+  async send(params, data = {}) {
+    const { title, description, nodeInfo, node } = data;
+
+    try {
+      const sender = {
+        appDid: nodeInfo.did,
+        appSk: nodeInfo.sk,
+      };
+
+      const message = {
+        title,
+        body: description,
+      };
+
+      const { users } = await node.getUsers({ teamDid: nodeInfo.did, paging: { pageSize: 100 } });
+      const adminUsers = users
+        .filter(
+          (x) =>
+            x.approved &&
+            (x.passports || []).some(
+              (y) => [ROLES.OWNER, ROLES.ADMIN].includes(y.name) && y.status === PASSPORT_STATUS.VALID
+            )
+        )
+        .map((x) => x.did);
+
+      if (!adminUsers.length) {
+        return;
+      }
+
+      await sendToUser(adminUsers, message, sender, process.env.ABT_NODE_SERVICE_PORT);
+    } catch (error) {
+      delete error.request;
+      delete error.response;
+      delete error.config;
+      logger.error('failed to push notification to wallet', { error });
+    }
+  }
+}
+
+WalletSender.type = 'wallet';
+
+module.exports = WalletSender;