@abtnode/core 1.5.13 → 1.15.17

package/lib/router/helper.js

@@ -28,11 +28,14 @@ const {
   CERTIFICATE_EXPIRES_WARNING_OFFSET,
   DEFAULT_DAEMON_PORT,
   DEFAULT_SERVICE_PATH,
+  SLOT_FOR_IP_DNS_SITE,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
   BLOCKLET_INTERFACE_TYPE_WEB,
   BLOCKLET_INTERFACE_WELLKNOWN,
+  BLOCKLET_INTERFACE_TYPE_WELLKNOWN,
 } = require('@blocklet/meta/lib/constants');
 
 // eslint-disable-next-line global-require
@@ -48,15 +51,58 @@ const {
 } = require('../util');
 const { getServicesFromBlockletInterface } = require('../util/service');
 const getIpDnsDomainForBlocklet = require('../util/get-ip-dns-domain-for-blocklet');
+const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
 const Router = require('./index');
 const states = require('../states');
 
-const attachInterfaceUrls = async ({ sites = [], context }) => {
+/**
+ * replace 888-888-888-888 with accessible ip for domain
+ */
+const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) => {
+  let ip;
+  const ipRegex = /\d+[-.]\d+[-.]\d+[-.]\d+/;
+  const match = ipRegex.exec(context.hostname);
+  if (match) {
+    ip = match[0];
+  } else if (node) {
+    const nodeInfo = await node.read();
+    const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+    if (nodeIp) {
+      ip = nodeIp;
+    }
+  }
+
+  const getDomainAliases = (site) =>
+    (site.domainAliases || []).map((domain) => {
+      if (!domain.value) {
+        return domain;
+      }
+      if (domain.value.includes(SLOT_FOR_IP_DNS_SITE) && ip) {
+        domain.value = domain.value.replace(SLOT_FOR_IP_DNS_SITE, ip.replace(/\./g, '-'));
+      }
+      return domain;
+    });
+
+  if (!Array.isArray(sites)) {
+    sites.domainAliases = getDomainAliases(sites);
+    return sites;
+  }
+
+  return sites.map((site) => {
+    site.domainAliases = getDomainAliases(site);
+
+    return site;
+  });
+};
+
+const attachInterfaceUrls = async ({ sites = [], context, node }) => {
   if (!sites) {
     return [];
   }
 
+  attachRuntimeDomainAliases({ sites, context, node });
+
   const getUrl = (rule, domain = '') => {
     const host = getBlockletHost({ domain, context });
     const prefix = trimSlash(rule.from.pathPrefix);
@@ -340,7 +386,7 @@ const ensureAuthService = async (sites = [], blockletManager) => {
       // we should only use rule.to.realInterfaceName, rule.to.interfaceName is for backward compatible
       const interfaceName = rule.to.realInterfaceName || rule.to.interfaceName;
       const { interfaces } = blocklet.meta;
-      const _interface = interfaces.find((x) => x.type === 'web' && x.name === interfaceName);
+      const _interface = interfaces.find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
       if (_interface) {
         rule.services = rule.services || [];
         rule.services.unshift(...getServicesFromBlockletInterface(_interface, { logError: logger.error }));
@@ -596,10 +642,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   /**
    * Add system sites for blocklet
    *
-   * @returns {boolean} if routing changed
+   * @returns {boolean} if routing state db changed
    */
   const _ensureBlockletSites = async (blocklet, sites, nodeInfo, context = {}) => {
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    const webInterface = (blocklet.meta.interfaces || []).find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    if (!webInterface) {
+      return false;
+    }
 
     const getPrefix = (str) => {
       if (!str || str === '*') {
@@ -608,68 +657,59 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return `/${str}`.replace(/^\/+/, '/');
     };
 
-    const changes = await Promise.all(
-      interfaces.map(async (x) => {
-        const domain = getIpDnsDomainForBlocklet(blocklet, x);
-        const pathPrefix = getPrefix(x.prefix);
-        const rule = {
-          from: { pathPrefix },
-          to: {
-            port: findInterfacePortByName(blocklet, x.name),
-            did: blocklet.meta.did,
-            type: ROUTING_RULE_TYPES.BLOCKLET,
-            interfaceName: x.name, // root blocklet interface
-          },
-          isProtected: true,
-        };
+    const domainGroup = `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}`;
+    const domain = getIpDnsDomainForBlocklet(blocklet, webInterface);
+    const pathPrefix = getPrefix(webInterface.prefix);
+    const rule = {
+      from: { pathPrefix },
+      to: {
+        port: findInterfacePortByName(blocklet, webInterface.name),
+        did: blocklet.meta.did,
+        type: ROUTING_RULE_TYPES.BLOCKLET,
+        interfaceName: webInterface.name, // root blocklet interface
+      },
+      isProtected: true,
+    };
 
-        let changed = false; // if state db changed
-
-        const exist = await states.site.findOne({ domain });
-        if (!exist) {
-          await routerManager.addRoutingSite(
-            {
-              site: {
-                domain,
-                isProtected: true,
-                // FIXME: tmp fix for https://github.com/ArcBlock/abt-node/issues/3526
-                corsAllowedOrigins: ['*'],
-                rules: [rule],
-              },
-              skipCheckDynamicBlacklist: true,
-            },
-            context
-          );
-          logger.info('add routing site', { site: domain });
+    const existSite = await states.site.findOne({ domain: domainGroup });
+    if (!existSite) {
+      await routerManager.addRoutingSite(
+        {
+          site: {
+            domain: domainGroup,
+            domainAliases: [{ value: domain, isProtected: true }],
+            isProtected: true,
+            rules: [rule],
+          },
+          skipCheckDynamicBlacklist: true,
+        },
+        context
+      );
+      logger.info('add routing site', { site: domain });
 
-          changed = true;
-        } else {
-          const existRule = (exist.rules || []).find((y) => get(y, 'from.pathPrefix') === pathPrefix);
-          if (existRule) {
-            await routerManager.updateRoutingRule({
-              id: exist.id,
-              rule: {
-                ...rule,
-                id: exist.id,
-              },
-              skipProtectedRuleChecking: true,
-            });
-            logger.info('update routing rule for site', { site: domain });
-          } else {
-            await routerManager.addRoutingRule({
-              id: exist.id,
-              rule,
-            });
-            logger.info('add routing rule for site', { site: domain });
-          }
-          changed = true;
-        }
+      return true;
+    }
 
-        return changed;
-      })
-    );
+    const existRule = (existSite.rules || []).find((y) => get(y, 'from.pathPrefix') === pathPrefix);
+    if (existRule) {
+      await routerManager.updateRoutingRule({
+        id: existSite.id,
+        rule: {
+          ...rule,
+          id: existRule.id,
+        },
+        skipProtectedRuleChecking: true,
+      });
+      logger.info('update routing rule for site', { site: domain });
+    } else {
+      await routerManager.addRoutingRule({
+        id: existSite.id,
+        rule,
+      });
+      logger.info('add routing rule for site', { site: domain });
+    }
 
-    return changes.some(Boolean);
+    return true;
   };
 
   /**
@@ -684,7 +724,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     }
 
     const tasks = (blocklet.meta.interfaces || [])
-      .filter((x) => x.name === BLOCKLET_INTERFACE_WELLKNOWN)
+      .filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WELLKNOWN)
       .map(async (x) => {
         const pathPrefix = normalizePathPrefix(x.prefix);
         if (!pathPrefix.startsWith(WELLKNOWN_PATH_PREFIX)) {
@@ -811,30 +851,15 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   };
 
   const _removeBlockletSites = async (blocklet, nodeInfo, context = {}) => {
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
-
-    const changes = await Promise.all(
-      interfaces.map(async (x) => {
-        let changed = false;
-
-        const domain = getIpDnsDomainForBlocklet(blocklet, x);
-
-        const site = await states.site.findOne({ domain });
-        if (
-          site &&
-          site.isProtected &&
-          (!site.domainAliases || !site.domainAliases.length) &&
-          (!site.rules || !site.rules.length)
-        ) {
-          await routerManager.deleteRoutingSite({ id: site.id }, context);
-          changed = true;
-        }
+    let changed = false;
 
-        return changed;
-      })
-    );
+    const site = await states.site.findOne({ domain: `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}` });
+    if (site) {
+      await routerManager.deleteRoutingSite({ id: site.id }, context);
+      changed = true;
+    }
 
-    return changes.some(Boolean);
+    return changed;
   };
 
   /**
@@ -854,8 +879,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return false;
     }
 
-    const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
-    if (interfaces.length === 0) {
+    const hasWebInterface = (blocklet.meta.interfaces || []).some((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
+    if (!hasWebInterface) {
       return false;
     }
 
@@ -886,9 +911,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * @returns {boolean} if routing changed
    */
   const ensureBlockletCustomRouting = async (blocklet) => {
+    // Only one blocklet web interface can be declared since router 2.0
     const interfaces = (blocklet.meta.interfaces || []).filter((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
     const hasInterface = (name) => interfaces.some((x) => x.name === name);
-    const sites = await siteState.getRulesByDid(blocklet.meta.did);
+
+    const sites = await siteState.getSitesByBlocklet(blocklet.meta.did);
     let changed = false;
 
     for (const site of sites) {
@@ -1164,7 +1191,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       if (msg.length < 5) {
         throw new Error('Message cannot be less than 5 characters');
       }
-      if (msg.length > 100) {
+      if (msg.length > 150) {
         throw new Error('Message cannot exceed 100 characters');
       }
     }
@@ -1216,12 +1243,17 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return attachInterfaceUrls({
       sites: await ensureLatestInfo(sites, { withDefaultCors }),
       context,
+      node: nodeState,
     });
   };
 
   const getSnapshotSites = async ({ hash }, context = {}, { withDefaultCors = true } = {}) => {
     const sites = await routingSnapshot.readSnapshotSites(hash);
-    return attachInterfaceUrls({ sites: await ensureLatestInfo(sites, { withDefaultCors }), context });
+    return attachInterfaceUrls({
+      sites: await ensureLatestInfo(sites, { withDefaultCors }),
+      context,
+      node: nodeState,
+    });
   };
 
   const getCertificates = async () => {
@@ -1262,7 +1294,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         logger.info('send certificate expire notification', { domain: cert.domain });
         notification.create({
           title: 'SSL Certificate Expired',
-          description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in ABT Node`,
+          description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in Blocklet Server`,
           severity: 'error',
           entityType: 'certificate',
           entityId: cert._id, // eslint-disable-line no-underscore-dangle
@@ -1276,7 +1308,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             cert.domain
           } will expire in ${expireInDays} days (on ${new Date(
             cert.validTo
-          ).toLocaleString()}), please remember to update it in ABT Node`,
+          ).toLocaleString()}), please remember to update it in Blocklet Server`,
           severity: 'warning',
           entityType: 'certificate',
           entityId: cert._id, // eslint-disable-line no-underscore-dangle

package/lib/router/index.js

@@ -6,6 +6,7 @@ const {
   ROUTING_RULE_TYPES,
   DEFAULT_DASHBOARD_DOMAIN,
   BLOCKLET_PROXY_PATH_PREFIX,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
 const { BLOCKLET_UI_INTERFACES } = require('@blocklet/meta/lib/constants');
 const { pick } = require('lodash');
@@ -26,7 +27,11 @@ const expandSites = (sites = []) => {
     });
 
     delete site.domainAliases;
-    result.push(site);
+
+    // skip site if domain is BLOCKLET_SITE_GROUP
+    if (!site.domain.endsWith(BLOCKLET_SITE_GROUP_SUFFIX)) {
+      result.push(site);
+    }
   });
 
   const defaultSite = result.find((site) => site.domain === DOMAIN_FOR_DEFAULT_SITE);
@@ -45,7 +50,10 @@ const mergeAllowedOrigins = (domain, allowedOrigins) => {
     origins.push(domain);
   }
 
-  return origins;
+  // skip site if domain is BLOCKLET_SITE_GROUP
+  const res = origins.filter((x) => !x.endsWith(BLOCKLET_SITE_GROUP_SUFFIX));
+
+  return res;
 };
 
 const getRoutingTable = ({ sites, nodeInfo }) => {

package/lib/router/manager.js

@@ -121,7 +121,7 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('addRoutingSite', { site: newSite });
 
     const result = await states.site.add(newSite);
-    await attachInterfaceUrls({ sites: result, context });
+    await attachInterfaceUrls({ sites: result, context, node: states.node });
 
     this.emit('router.site.created', result);
     return result;
@@ -181,7 +181,7 @@ class RouterManager extends EventEmitter {
     this.emit('router.site.updated', params.id);
 
     const dbSite = await states.site.findOne({ _id: params.id });
-    await attachInterfaceUrls({ sites: dbSite, context });
+    await attachInterfaceUrls({ sites: dbSite, context, node: states.node });
     return dbSite;
   }
 
@@ -207,7 +207,7 @@ class RouterManager extends EventEmitter {
     logger.debug('add domain alias update result', { id, updateResult, domainAlias });
 
     const newSite = await states.site.findOne({ _id: id });
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     return newSite;
   }
@@ -230,7 +230,7 @@ class RouterManager extends EventEmitter {
     const updateResult = await states.site.update({ _id: id }, { $set: { domainAliases: dbSite.domainAliases } });
     logger.debug('remove domain alias update result', { id, updateResult, domainAlias });
 
-    await attachInterfaceUrls({ sites: dbSite, context });
+    await attachInterfaceUrls({ sites: dbSite, context, node: states.node });
 
     return dbSite;
   }
@@ -265,7 +265,7 @@ class RouterManager extends EventEmitter {
     }
 
     const newSite = await states.site.findOne({ _id: id });
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.created', newSite);
     return newSite;
@@ -306,7 +306,7 @@ class RouterManager extends EventEmitter {
     logger.info('update result', { updateResult });
     const newSite = await states.site.findOne({ _id: id });
 
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.updated', newSite);
 
@@ -335,7 +335,7 @@ class RouterManager extends EventEmitter {
     logger.info('router.rule.removed', { id, ruleId });
     const newSite = await states.site.findOne({ _id: id });
 
-    await attachInterfaceUrls({ sites: newSite, context });
+    await attachInterfaceUrls({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.removed', newSite);
     return newSite;

package/lib/states/site.js

@@ -33,7 +33,7 @@ class SiteState extends BaseState {
     return SiteState.renameIdFiledName(result);
   }
 
-  async getRulesByDid(did) {
+  async getSitesByBlocklet(did) {
     const rules = await this.asyncDB.find({ 'rules.to.did': did });
     return SiteState.renameIdFiledName(rules);
   }

package/lib/team/manager.js

@@ -190,7 +190,7 @@ class TeamManager extends EventEmitter {
     // first getRBAC after blocklet added
     if (!this.cache[did].rbac) {
       if (this.isNodeTeam(did)) {
-        throw new Error('ABT Node rbac instance has not been initialized');
+        throw new Error('Blocklet Server rbac instance has not been initialized');
       }
 
       // FIXME: cross process lock

package/lib/util/default-node-config.js

@@ -1,7 +1,7 @@
 const {
   NODE_REGISTER_URL,
-  BLOCKLET_REGISTRY_URL,
-  BLOCKLET_REGISTRY_URL_DEV,
+  BLOCKLET_STORE_URL,
+  BLOCKLET_STORE_URL_DEV,
   WEB_WALLET_URL,
   NODE_PACKAGE_NAME,
   NODE_COMMAND_NAME,
@@ -23,18 +23,18 @@ const defaultNodeConfigs = {
   blockletRegistryList: {
     getDefaultValue: () => [
       {
-        name: 'Official Registry',
+        name: 'Official Store',
         description: 'ArcBlock official blocklet registry',
-        url: BLOCKLET_REGISTRY_URL,
+        url: BLOCKLET_STORE_URL,
         logoUrl: '/logo.png',
         maintainer: 'arcblock',
         selected: true,
         protected: true,
       },
       {
-        name: 'Dev Registry',
+        name: 'Dev Store',
         description: 'ArcBlock dev registry that contains demo and example blocklets',
-        url: BLOCKLET_REGISTRY_URL_DEV,
+        url: BLOCKLET_STORE_URL_DEV,
         maintainer: 'arcblock',
         logoUrl: '/logo.png',
         selected: false,

package/lib/util/index.js

@@ -7,6 +7,7 @@ const crypto = require('crypto');
 const shell = require('shelljs');
 const get = require('lodash/get');
 const uniqBy = require('lodash/uniqBy');
+const pickBy = require('lodash/pickBy');
 const { isFromPublicKey } = require('@arcblock/did');
 const joinUrl = require('url-join');
 const { Certificate } = require('@fidm/x509');
@@ -28,7 +29,9 @@ const {
   ROUTING_RULE_TYPES,
   SLOT_FOR_IP_DNS_SITE,
   DEFAULT_IP_DNS_DOMAIN_SUFFIX,
+  BLOCKLET_SITE_GROUP_SUFFIX,
 } = require('@abtnode/constant');
+const { BLOCKLET_INTERFACE_TYPE_WEB } = require('@blocklet/meta/lib/constants');
 
 const DEFAULT_WELLKNOWN_PORT = 8088;
 
@@ -136,7 +139,7 @@ const getAuthConfig = (rule, blocklet) => {
   // find interface in meta
   const interfaceName = rule.to.realInterfaceName;
   const { interfaces } = _blocklet.meta;
-  const _interface = interfaces.find((x) => x.type === 'web' && x.name === interfaceName);
+  const _interface = interfaces.find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB && x.name === interfaceName);
 
   if (!_interface) {
     return null;
@@ -154,13 +157,14 @@ const getAuthConfig = (rule, blocklet) => {
   return auth.config;
 };
 
-const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context = {}, blocklet, nodeIp }) => {
+const getBlockletBaseUrls = ({ routingEnabled = false, port, rules = [], context = {}, blocklet, nodeIp }) => {
   let baseUrls = [];
 
-  if (routingEnabled && Array.isArray(sites) && sites.length > 0) {
-    baseUrls = sites
-      .map((site) => {
-        const host = getBlockletHost({ domain: site.from.domain, context, nodeIp });
+  if (routingEnabled && Array.isArray(rules) && rules.length > 0) {
+    baseUrls = rules
+      .filter((rule) => !(rule.from.domain || '').endsWith(BLOCKLET_SITE_GROUP_SUFFIX))
+      .map((rule) => {
+        const host = getBlockletHost({ domain: rule.from.domain, context, nodeIp });
         if (host) {
           let protocol = 'http'; // TODO: 这里固定为 http, 因为判断 url 是不是 https 和证书相关，这里实现的话比较复杂
           if (host.includes(DEFAULT_IP_DNS_DOMAIN_SUFFIX)) {
@@ -168,10 +172,10 @@ const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context
           }
 
           return {
-            ruleId: site.id,
-            baseUrl: `${protocol}://${host}/${trimSlash(site.from.pathPrefix)}`,
-            interfaceName: get(site, 'to.interfaceName', ''),
-            authConfig: getAuthConfig(site, blocklet),
+            ruleId: rule.id,
+            baseUrl: `${protocol}://${host}/${trimSlash(rule.from.pathPrefix)}`,
+            interfaceName: get(rule, 'to.interfaceName', ''),
+            authConfig: getAuthConfig(rule, blocklet),
           };
         }
 
@@ -187,7 +191,7 @@ const getBlockletBaseUrls = ({ routingEnabled = false, port, sites = [], context
   return baseUrls;
 };
 
-const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) => {
+const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, nodeIp }) => {
   const interfaces = [];
   (blocklet.meta.interfaces || []).forEach((x) => {
     if (x.port && x.port.external) {
@@ -195,7 +199,7 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) =
       const baseUrls = getBlockletBaseUrls({
         routingEnabled: false,
         port: x.port.external,
-        sites: [],
+        rules: [],
         context,
       });
       baseUrls.forEach(({ baseUrl }) => interfaces.push({ type: x.type, name: x.name, url: baseUrl }));
@@ -205,9 +209,11 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, sites, nodeIp }) =
       const baseUrls = getBlockletBaseUrls({
         routingEnabled: isRoutingEnabled(nodeInfo.routing),
         port,
-        sites: (sites || []).filter((r) => {
+        rules: (routingRules || []).filter((r) => {
           return (
             // don't show wellknown interface
+            r.to.type !== ROUTING_RULE_TYPES.GENERAL_PROXY &&
+            // LEGACY don't show wellknown interface
             r.to.interfaceName !== BLOCKLET_INTERFACE_WELLKNOWN &&
             // don't show child blocklet interface
             (!r.from.groupPathPrefix || r.from.pathPrefix === r.from.groupPathPrefix)
@@ -328,7 +334,7 @@ const getDataDirs = (dataDir) => ({
   services: path.join(dataDir, 'services'),
 });
 
-// Ensure data dir for ABT Node exists
+// Ensure data dir for Blocklet Server exists
 const ensureDataDirs = (dataDir) => {
   try {
     logger.info('ensure data dir', { dataDir });
@@ -519,6 +525,14 @@ const getQueueConcurrencyByMem = () => {
   return 1;
 };
 
+const getSafeEnv = (inputEnv, processEnv = process.env) => {
+  const whiteList = ['ABT_NODE', 'ABT_NODE_DID', 'ABT_NODE_PK', 'ABT_NODE_PORT', 'ABT_NODE_SERVICE_PORT'];
+  // 此处需要保留 process.env 中的环境变量，只移除和 ABT_NODE 相关的环境变量（否则丢失了 process.env.SHELL 变量可能会造成无法使用 nodejs 的情况）
+  const filterProcessEnv = pickBy(processEnv, (value, key) => !key.startsWith('ABT_NODE') || whiteList.includes(key));
+  const mergedEnv = { ...filterProcessEnv, ...inputEnv };
+  return mergedEnv;
+};
+
 const lib = {
   validateOwner,
   getProviderFromNodeInfo,
@@ -558,6 +572,7 @@ const lib = {
   shouldUpdateBlockletStatus,
   transformIPToDomain,
   getQueueConcurrencyByMem,
+  getSafeEnv,
 };
 
 module.exports = lib;

package/lib/util/ready.js

@@ -29,19 +29,19 @@ const createStateReadyHandler =
             // eslint-disable-next-line no-underscore-dangle
             await states.node.remove({ _id: state._id });
             console.error('\n\x1b[31m======================================================');
-            console.error(`Data dir: ${options.dataDir} is used by another ABT Node instance, abort!`);
-            console.error('Sharing data dir between ABT Node instances may break things!');
+            console.error(`Data dir: ${options.dataDir} is used by another Blocklet Server instance, abort!`);
+            console.error('Sharing data dir between Blocklet Server instances may break things!');
             console.error('======================================================\x1b[0m');
             console.log('\nIf you intend to use this dir:');
-            console.log(`  1. Stop ABT Node by ${chalk.cyan('abtnode stop --force')}`);
+            console.log(`  1. Stop Blocklet Server by ${chalk.cyan('abtnode stop --force')}`);
             console.log(`  2. Clear data dir by ${chalk.cyan(`rm -r ${options.dataDir}`)}`);
-            console.log(`  3. Reinitialize and start ABT Node`);
+            console.log('  3. Reinitialize and start Blocklet Server');
             process.exit(1);
           }
         }
       })
       .catch((err) => {
-        console.error('Can not ready node state on ABT Node start:', err.message);
+        console.error('Can not ready node state on Blocklet Server start:', err.message);
         process.exit(1);
       });
   };

package/lib/util/upgrade.js

@@ -36,15 +36,15 @@ const checkNewVersion = async (params, context) => {
       const latestVersion = versions[0].version;
       if (semver.gt(latestVersion, info.version)) {
         // if (semver.gte(latestVersion, info.version)) {
-        logger.info('New version found for abt node', {
+        logger.info('New version found for Blocklet Server', {
           latestVersion,
           currentVersion: info.version,
           nextVersion: info.nextVersion,
         });
         await states.node.updateNodeInfo({ nextVersion: latestVersion });
         await states.notification.create({
-          title: 'ABT Node upgrade available',
-          description: 'A new and improved version of ABT Node is now available',
+          title: 'Blocklet Server upgrade available',
+          description: 'A new and improved version of blocklet server is now available',
           entityType: 'node',
           severity: 'info',
           sticky: true,
@@ -57,7 +57,7 @@ const checkNewVersion = async (params, context) => {
 
     return '';
   } catch (err) {
-    logger.error('Failed to check new version for abt node', { error: err });
+    logger.error('Failed to check new version for Blocklet Server', { error: err });
   }
 
   return '';