@abtnode/core 1.6.8 → 1.6.12

package/lib/blocklet/manager/disk.js

@@ -20,12 +20,13 @@ const hashFiles = require('@abtnode/util/lib/hash-files');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
+const { updateBlocklet: updateDidDocument } = require('@abtnode/util/lib/did-document');
 const { BLOCKLET_PURCHASE_NFT_TYPE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
-const { isFreeBlocklet } = require('@blocklet/meta/lib/util');
+const { isFreeBlocklet, isDeletableBlocklet, getRequiredMissingConfigs } = require('@blocklet/meta/lib/util');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
-const { getRequiredMissingConfigs } = require('@blocklet/meta/lib/util');
+const { getBlockletInfo } = require('@blocklet/meta/lib');
 
 const {
   BlockletStatus,
@@ -243,7 +244,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preStart(b, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did,
             progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
@@ -315,7 +316,7 @@ class BlockletManager extends BaseBlockletManager {
         hooks.preStop({
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           did, // root blocklet did
           notification: states.notification,
           context,
@@ -380,6 +381,9 @@ class BlockletManager extends BaseBlockletManager {
 
     try {
       const blocklet = await this.ensureBlocklet(did);
+      if (isDeletableBlocklet(blocklet) === false) {
+        throw new Error('Blocklet is protected from accidental deletion');
+      }
 
       const nodeEnvironments = await states.node.getEnvironments();
 
@@ -388,7 +392,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks.preUninstall({
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did
             notification: states.notification,
             context,
@@ -513,7 +517,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // run hook
     const nodeEnvironments = await states.node.getEnvironments();
-    newConfigs.forEach((x) => {
+    for (const x of newConfigs) {
       if (x.key === 'BLOCKLET_APP_SK') {
         try {
           fromSecretKey(x.value);
@@ -524,6 +528,13 @@ class BlockletManager extends BaseBlockletManager {
             throw new Error('Invalid custom blocklet secret key');
           }
         }
+
+        // Ensure sk is not used by other blocklets, otherwise we may encounter appDid collision
+        const blocklets = await states.blocklet.getBlocklets({});
+        const others = blocklets.filter((b) => b.meta.did !== did);
+        if (others.some((b) => b.environments.find((e) => e.key === 'BLOCKLET_APP_SK').value === x.value)) {
+          throw new Error('Invalid custom blocklet secret key: already used by another blocklet');
+        }
       }
 
       if (x.key === 'BLOCKLET_WALLET_TYPE') {
@@ -532,8 +543,16 @@ class BlockletManager extends BaseBlockletManager {
         }
       }
 
+      if (x.key === 'BLOCKLET_DELETABLE') {
+        if (['yes', 'no'].includes(x.value) === false) {
+          throw new Error('BLOCKLET_DELETABLE must be either "yes" or "no"');
+        }
+      }
+
       blocklet.configObj[x.key] = x.value;
-    });
+    }
+
+    // FIXME: we should also call preConfig for child blocklets
     await hooks.preConfig({
       appDir: blocklet.env.appDir,
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
@@ -897,7 +916,7 @@ class BlockletManager extends BaseBlockletManager {
       };
 
       const childConfigs = await states.blockletExtras.getChildConfigs(did, childDid);
-      fillBlockletConfigs(child, childConfigs);
+      fillBlockletConfigs(child, childConfigs, blocklet);
     }
 
     return blocklet;
@@ -1496,6 +1515,15 @@ class BlockletManager extends BaseBlockletManager {
       return null;
     }
 
+    // When new version found from the store where the blocklet was installed from, we should use that store first
+    if (blocklet.source === BlockletSource.registry && blocklet.deployedFrom) {
+      const latestFromSameRegistry = versions.find((x) => x.registryUrl === blocklet.deployedFrom);
+      if (latestFromSameRegistry) {
+        return latestFromSameRegistry;
+      }
+    }
+
+    // Otherwise try upgrading from other store
     let latestBlockletVersion = versions[0];
     versions.forEach((item) => {
       if (semver.lt(latestBlockletVersion.version, item.version)) {
@@ -1561,7 +1589,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await this._setConfigs(did);
 
-      logger.info('blocklet added to database', { meta });
+      logger.info('blocklet added to database', { did: meta.did });
 
       const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
       this.emit(BlockletEvents.added, blocklet1);
@@ -1855,7 +1883,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: blocklet.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -1865,7 +1893,19 @@ class BlockletManager extends BaseBlockletManager {
 
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
-      logger.info('blocklet installed', { source, meta });
+      logger.info('blocklet installed', { source, did: meta.did });
+      if (process.env.NODE_ENV !== 'test') {
+        const nodeInfo = await states.node.read();
+        const blockletInfo = getBlockletInfo(blocklet, nodeInfo.sk);
+        const updateDidDnsResult = await updateDidDocument({
+          wallet: blockletInfo.wallet,
+          domain: nodeInfo.didDomain,
+          nodeDid: nodeInfo.did,
+          didRegistryUrl: nodeInfo.didRegistry,
+        });
+        logger.info('updated did document', { updateDidDnsResult, blockletId: blocklet.meta.did });
+      }
+
       this.emit(BlockletEvents.installed, { blocklet, context });
 
       states.notification.create({
@@ -1943,7 +1983,7 @@ class BlockletManager extends BaseBlockletManager {
       const postInstall = (b) =>
         hooks.postInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments),
+          env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
           did, // root blocklet did
           notification: states.notification,
@@ -1959,7 +1999,7 @@ class BlockletManager extends BaseBlockletManager {
             blocklet: b,
             oldVersion,
             newVersion: version,
-            env: getRuntimeEnvironments(b, nodeEnvironments),
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             appDir: b.env.appDir,
             did: b.meta.did,
             notification: states.notification,
@@ -2251,8 +2291,9 @@ class BlockletManager extends BaseBlockletManager {
     try {
       const state = await states.blocklet.getBlocklet(did);
       if (state && util.shouldUpdateBlockletStatus(state.status)) {
-        const result = await states.blocklet.setBlockletStatus(did, pm2StatusMap[pm2Status]);
-        logger.info('sync pm2 status to blocklet', { result });
+        const newStatus = pm2StatusMap[pm2Status];
+        await states.blocklet.setBlockletStatus(did, newStatus);
+        logger.info('sync pm2 status to blocklet', { did, pm2Status, newStatus });
       }
     } catch (error) {
       logger.error('sync pm2 status to blocklet failed', { did, pm2Status, error });

package/lib/cert.js

@@ -70,6 +70,10 @@ class Cert extends EventEmitter {
     return this.manager.getAllNormal();
   }
 
+  getNormalByDomain(domain) {
+    return this.manager.getNormalByDomain(domain);
+  }
+
   getByDomain(domain) {
     return this.manager.getByDomain(domain);
   }
@@ -111,6 +115,10 @@ class Cert extends EventEmitter {
   async addWithoutValidations(data) {
     return this.manager.addWithoutValidations(data);
   }
+
+  async updateWithoutValidations(id, data) {
+    return this.manager.updateWithoutValidations(id, data);
+  }
 }
 
 module.exports = Cert;

package/lib/event.js

@@ -1,5 +1,8 @@
+const get = require('lodash/get');
+const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
 const { BLOCKLET_MODES } = require('@blocklet/meta/lib/constants');
+const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
 const { BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/meta/lib/constants');
 
@@ -43,9 +46,13 @@ module.exports = ({
   let eventHandler = null;
 
   const onEvent = (name, data) => {
-    events.emit(name, data);
+    let safeData = data;
+    if (get(data, 'meta.did', '')) {
+      safeData = wipeSensitiveData(cloneDeep(data));
+    }
+    events.emit(name, safeData);
     if (typeof eventHandler === 'function') {
-      eventHandler({ name, data });
+      eventHandler({ name, data: safeData });
     }
   };
 

package/lib/index.js

@@ -132,8 +132,6 @@ function ABTNode(options) {
     daemon: options.daemon,
   });
 
-  certManager.start(); // 启动证书服务
-
   const {
     handleRouting,
     getRoutingRulesByDid,
@@ -169,10 +167,10 @@ function ABTNode(options) {
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
     takeRoutingSnapshot,
-    routerManager,
     handleRouting,
     domainStatus,
     teamAPI,
+    certManager,
   });
 
   const isInitialized = async () => {
@@ -395,11 +393,23 @@ function ABTNode(options) {
   };
 
   if (options.daemon) {
+    certManager.start(); // 启动证书服务
+
     if (process.env.NODE_ENV === 'development') {
       initCron();
     } else {
       // We should only respond to pm2 events when node is alive
-      events.on('node.started', () => {
+      events.on('node.started', async () => {
+        const info = await states.node.read();
+        certManager
+          .issue({ domain: `${info.did.toLowerCase()}.${info.didDomain}` })
+          .then(() => {
+            logger.info('add issue daemon certificate job');
+          })
+          .catch((error) => {
+            logger.error('issue daemon certificate job failed', { error });
+          });
+
         pm2Events.resume();
         initCron();
       });

package/lib/migrations/1.6.9-update-node-info-and-certificate.js

@@ -0,0 +1,38 @@
+/* eslint-disable no-await-in-loop */
+
+const { DEFAULT_DID_REGISTRY, DEFAULT_DID_DOMAIN } = require('@abtnode/constant');
+const { isEmpty, omit } = require('lodash');
+
+const updateNodeInfo = async ({ printInfo, states }) => {
+  // add didRegistry and didDomain
+  const info = await states.node.read();
+  const data = {};
+  if (!info.didRegistry) {
+    data.didRegistry = DEFAULT_DID_REGISTRY;
+  }
+
+  if (!info.didDomain) {
+    data.didDomain = DEFAULT_DID_DOMAIN;
+  }
+
+  if (!isEmpty(data)) {
+    await states.node.update({ _id: info._id }, { $set: data });
+  }
+
+  printInfo('update did registry and did domain successfully');
+};
+
+const updateCertificate = async ({ node, printInfo }) => {
+  const certs = await node.certManager.getAllNormal();
+  for (const cert of certs || []) {
+    await node.certManager.updateWithoutValidations(cert.id, omit(cert, 'id'));
+  }
+
+  printInfo('update certificate successfully');
+};
+
+/* eslint-disable no-underscore-dangle */
+module.exports = async ({ node, printInfo, states }) => {
+  await updateNodeInfo({ printInfo, states });
+  await updateCertificate({ node, printInfo, states });
+};

package/lib/router/helper.js

@@ -48,7 +48,7 @@ const {
   getWellknownSitePort,
 } = require('../util');
 const { getServicesFromBlockletInterface } = require('../util/service');
-const getIpDnsDomainForBlocklet = require('../util/get-ip-dns-domain-for-blocklet');
+const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
 const Router = require('./index');
@@ -623,11 +623,16 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       });
 
     const dashboardDomain = get(info, 'routing.dashboardDomain', '');
-    if (dashboardDomain && !isExistsInAlias(dashboardDomain)) {
+    const didDomain = `${info.did.toLowerCase()}.${info.didDomain}`;
+    const dashboardAliasDomains = [dashboardDomain, didDomain]
+      .filter((item) => item && !isExistsInAlias(item))
+      .map((item) => ({ value: item, isProtected: true }));
+
+    if (dashboardAliasDomains.length > 0) {
       try {
         const result = await siteState.update(
           { _id: dashboardSite.id },
-          { $push: { domainAliases: { value: dashboardDomain, isProtected: true } } }
+          { $push: { domainAliases: { $each: dashboardAliasDomains } } }
         );
 
         updatedResult.push(result);
@@ -690,7 +695,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     };
 
     const domainGroup = `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}`;
-    const domain = getIpDnsDomainForBlocklet(blocklet, webInterface);
+
     const pathPrefix = getPrefix(webInterface.prefix);
     const rule = {
       from: { pathPrefix },
@@ -705,11 +710,24 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const existSite = await states.site.findOne({ domain: domainGroup });
     if (!existSite) {
+      const ipEchoDnsDomain = getIpDnsDomainForBlocklet(blocklet, webInterface, nodeInfo.did);
+      const appIdEnv = blocklet.environments.find((e) => e.key === 'BLOCKLET_APP_ID');
+      const domainAliases = [{ value: ipEchoDnsDomain, isProtected: true }];
+
+      const didDomain = getDidDomainForBlocklet({
+        appId: appIdEnv.value,
+        didDomain: nodeInfo.didDomain,
+      });
+
+      if (blocklet.mode !== 'development') {
+        domainAliases.push({ value: didDomain, isProtected: true });
+      }
+
       await routerManager.addRoutingSite(
         {
           site: {
             domain: domainGroup,
-            domainAliases: [{ value: domain, isProtected: true }],
+            domainAliases,
             isProtected: true,
             rules: [rule],
           },
@@ -717,7 +735,14 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         },
         context
       );
-      logger.info('add routing site', { site: domain });
+      logger.info('add routing site', { site: domainGroup });
+      if (
+        process.env.NODE_ENV !== 'development' &&
+        process.env.NODE_ENV !== 'test' &&
+        blocklet.mode !== 'development'
+      ) {
+        await certManager.issue({ domain: didDomain });
+      }
 
       return true;
     }
@@ -732,13 +757,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         },
         skipProtectedRuleChecking: true,
       });
-      logger.info('update routing rule for site', { site: domain });
+      logger.info('update routing rule for site', { site: domainGroup });
     } else {
       await routerManager.addRoutingRule({
         id: existSite.id,
         rule,
       });
-      logger.info('add routing rule for site', { site: domain });
+      logger.info('add routing rule for site', { site: domainGroup });
     }
 
     return true;

package/lib/router/manager.js

@@ -459,9 +459,9 @@ class RouterManager extends EventEmitter {
       return {
         id: matchedCert.id,
         domain: matchedCert.domain,
-        issuer: matchedCert.issuer,
-        validFrom: matchedCert.validFrom,
-        validTo: matchedCert.validTo,
+        issuer: matchedCert.meta.issuer,
+        validFrom: matchedCert.meta.validFrom,
+        validTo: matchedCert.meta.validTo,
       };
     }
 

package/lib/states/node.js

@@ -90,6 +90,8 @@ class NodeState extends BaseState {
           runtimeConfig,
           ownerNft,
           launcherInfo,
+          didRegistry,
+          didDomain,
         } = this.options;
 
         if (nodeOwner && !validateOwner(nodeOwner)) {
@@ -122,6 +124,8 @@ class NodeState extends BaseState {
                 ownerNft,
                 diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,
                 launcherInfo: launcherInfo || undefined,
+                didRegistry,
+                didDomain,
               },
               async (e, data) => {
                 if (e) {
@@ -134,6 +138,10 @@ class NodeState extends BaseState {
                 }
 
                 logger.info('create', { data });
+                if (dek) {
+                  data.sk = security.decrypt(data.sk, data.did, dek);
+                }
+
                 return resolve(data);
               }
             )

package/lib/util/blocklet.js

@@ -5,6 +5,7 @@ const path = require('path');
 const os = require('os');
 const tar = require('tar');
 const get = require('lodash/get');
+const intersection = require('lodash/intersection');
 const streamToPromise = require('stream-to-promise');
 const { Throttle } = require('stream-throttle');
 const ssri = require('ssri');
@@ -69,7 +70,7 @@ const statusMap = {
   stopped: BlockletStatus.stopped,
 };
 
-const nodePrivateEnvs = [
+const PRIVATE_NODE_ENVS = [
   // 'NEDB_MULTI_PORT', // FIXME: 排查 abtnode 对外提供的 SDK(比如 @abtnode/queue), SDK 中不要自动使用 NEDB_MULTI_PORT 环境变量
   'ABT_NODE_UPDATER_PORT',
   'ABT_NODE_SESSION_TTL',
@@ -186,7 +187,7 @@ const getBlockletDirs = (blocklet, { rootBlocklet, dataDirs, ensure = false } =
  * @param {*} blocklet
  * @param {*} configs
  */
-const fillBlockletConfigs = (blocklet, configs) => {
+const fillBlockletConfigs = (blocklet, configs, parent) => {
   blocklet.configs = configs || [];
   blocklet.configObj = blocklet.configs.reduce((acc, x) => {
     acc[x.key] = x.value;
@@ -196,6 +197,13 @@ const fillBlockletConfigs = (blocklet, configs) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
+
+  const sharedConfigs = getSharedConfigs(blocklet, parent);
+  Object.keys(sharedConfigs).forEach((key) => {
+    blocklet.configObj[key] = sharedConfigs[key];
+    const item = blocklet.configs.find((x) => x.key === key);
+    item.value = sharedConfigs[key];
+  });
 };
 
 const ensureBlockletExpanded = async (meta, appDir) => {
@@ -297,10 +305,10 @@ const getSystemEnvironments = (blocklet) => {
   };
 };
 
-const getRuntimeEnvironments = (blocklet, nodeEnvironments) => {
+const getRuntimeEnvironments = (blocklet, nodeEnvironments, parent) => {
   // pm2 will force inject env variables of daemon process to blocklet process
   // we can only rewrite these private env variables to empty
-  const safeNodeEnvironments = nodePrivateEnvs.reduce((o, x) => {
+  const safeNodeEnvironments = PRIVATE_NODE_ENVS.reduce((o, x) => {
     o[x] = '';
     return o;
   }, {});
@@ -308,11 +316,28 @@ const getRuntimeEnvironments = (blocklet, nodeEnvironments) => {
   return {
     ...blocklet.environmentObj,
     ...blocklet.configObj,
+    ...getSharedConfigs(blocklet, parent),
     ...nodeEnvironments,
     ...safeNodeEnvironments,
   };
 };
 
+// we support share insecure same configs between parent and child blocklets
+const getSharedConfigs = (child, parent) => {
+  const sharedConfigs = {};
+  if (parent && Array.isArray(parent.configs) && child.meta.did !== parent.meta.did) {
+    const parentKeys = parent.configs.filter((x) => x.secure === false).map((x) => x.key);
+    const childKeys = child.configs.map((x) => x.key);
+    const sharedKeys = intersection(parentKeys, childKeys);
+    sharedKeys.forEach((key) => {
+      if (!child.configObj[key]) {
+        sharedConfigs[key] = parent.configObj[key];
+      }
+    });
+  }
+  return sharedConfigs;
+};
+
 const isUsefulError = (err) => err && err.message !== 'process or namespace not found';
 
 const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {

package/lib/util/{get-ip-dns-domain-for-blocklet.js → get-domain-for-blocklet.js}

@@ -16,4 +16,8 @@ const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
   }${iName}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DNS_DOMAIN_SUFFIX}`;
 };
 
-module.exports = getIpDnsDomainForBlocklet;
+const getDidDomainForBlocklet = ({ appId, didDomain }) => {
+  return `${appId.toLowerCase()}.${didDomain}`;
+};
+
+module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet };

package/lib/util/index.js

@@ -315,7 +315,6 @@ const getHttpsCertInfo = (certificate) => {
     validFrom,
     validTo,
     issuer,
-    serialNumber: info.serialNumber,
     sans: info.dnsNames,
     validityPeriod: info.validTo - info.validFrom,
     fingerprintAlg: 'SHA256',
@@ -358,39 +357,53 @@ const formatEnvironments = (environments) => Object.keys(environments).map((x) =
 const transformIPToDomain = (ip) => ip.split('.').join('-');
 
 const getBaseUrls = async (node, ips) => {
-  const ipTypes = {
-    internal: 'private',
-    external: 'public',
-  };
   const info = await node.getNodeInfo();
   const { https, httpPort, httpsPort } = info.routing;
-  const ipKeys = Object.keys(ips).filter((x) => ips[x]);
   const getPort = (port, defaultPort) => (port && port !== defaultPort ? `:${port}` : '');
+  const availableIps = ips.filter(Boolean);
+
+  const getHttpInfo = async (domain) => {
+    const certificate = https ? await node.certManager.getNormalByDomain(domain) : null;
+    const protocol = certificate ? 'https' : 'http';
+    const port = certificate ? getPort(httpsPort, DEFAULT_HTTPS_PORT) : getPort(httpPort, DEFAULT_HTTP_PORT);
+
+    return { protocol, port };
+  };
 
   if (info.routing.provider !== ROUTER_PROVIDER_NONE && info.routing.snapshotHash && info.routing.adminPath) {
     const sites = await node.getSitesFromSnapshot();
 
     const { dashboardDomain } = info.routing;
     const adminPath = normalizePathPrefix(info.routing.adminPath);
-    const httpUrls = ipKeys.map((x) => {
-      const port = getPort(httpPort, DEFAULT_HTTP_PORT);
+    const tmpHttpPort = getPort(httpPort, DEFAULT_HTTP_PORT);
+
+    const httpUrls = availableIps.map((ip) => {
       return {
-        url: `http://${ips[x]}${port}${adminPath}`,
-        type: ipTypes[x],
+        url: `http://${ip}${tmpHttpPort}${adminPath}`,
       };
     });
 
     if (dashboardDomain) {
       const site = sites.find((c) => (c.domainAliases || []).find((item) => item.value === dashboardDomain));
       if (site) {
-        const certificate = https ? await node.findCertificateByDomain(dashboardDomain) : null;
-        const protocol = certificate ? 'https' : 'http';
-        const port = certificate ? getPort(httpsPort, DEFAULT_HTTPS_PORT) : getPort(httpPort, DEFAULT_HTTP_PORT);
-        const httpsUrls = ipKeys.map((x) => ({
-          url: `${protocol}://${transformIPToDomain(ips[x])}.${dashboardDomain.substring(2)}${port}${adminPath}`,
-          type: ipTypes[x],
+        const httpInfo = await getHttpInfo(dashboardDomain);
+        const httpsUrls = availableIps.map((ip) => ({
+          url: `${httpInfo.protocol}://${transformIPToDomain(ip)}.${dashboardDomain.substring(2)}${
+            httpInfo.port
+          }${adminPath}`,
         }));
 
+        // add did domain access url
+        const didDomainAlias = site.domainAliases.find((item) => item.value.endsWith(info.didDomain));
+        if (didDomainAlias) {
+          const didDomain = didDomainAlias.value;
+          const didDomainHttpInfo = await getHttpInfo(didDomain);
+
+          httpsUrls.push({
+            url: `${didDomainHttpInfo.protocol}://${didDomain}${didDomainHttpInfo.port}${adminPath}`,
+          });
+        }
+
         return httpUrls.concat(httpsUrls);
       }
     }
@@ -399,9 +412,8 @@ const getBaseUrls = async (node, ips) => {
   }
 
   // port urls
-  return ipKeys.map((x) => ({
-    url: `http://${ips[x]}:${info.port}`,
-    type: ipTypes[x],
+  return availableIps.map((ip) => ({
+    url: `http://${ip}:${info.port}`,
   }));
 };
 

package/lib/util/ready.js

@@ -33,7 +33,7 @@ const createStateReadyHandler =
             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 Blocklet Server by ${chalk.cyan('abtnode stop --force')}`);
+            console.log(`  1. Stop Blocklet Server by ${chalk.cyan('blocklet server stop --force')}`);
             console.log(`  2. Clear data dir by ${chalk.cyan(`rm -r ${options.dataDir}`)}`);
             console.log('  3. Reinitialize and start Blocklet Server');
             process.exit(1);

package/lib/webhook/index.js

@@ -66,7 +66,7 @@ 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, [internal, external]);
       const senderFns = {};
 
       if (webhookList.length) {
@@ -76,8 +76,8 @@ 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 { name } = nodeInfo;
+          const options = { ...message, nodeInfo: `*${name}*` };
           if (item.type === 'slack') {
             options.urlInfo = getSlackUrlInfo(message.action, baseUrls);
           }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.8",
+  "version": "1.6.12",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,22 +19,22 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/certificate-manager": "1.6.8",
-    "@abtnode/constant": "1.6.8",
-    "@abtnode/cron": "1.6.8",
-    "@abtnode/db": "1.6.8",
-    "@abtnode/logger": "1.6.8",
-    "@abtnode/queue": "1.6.8",
-    "@abtnode/rbac": "1.6.8",
-    "@abtnode/router-provider": "1.6.8",
-    "@abtnode/static-server": "1.6.8",
-    "@abtnode/timemachine": "1.6.8",
-    "@abtnode/util": "1.6.8",
+    "@abtnode/certificate-manager": "1.6.12",
+    "@abtnode/constant": "1.6.12",
+    "@abtnode/cron": "1.6.12",
+    "@abtnode/db": "1.6.12",
+    "@abtnode/logger": "1.6.12",
+    "@abtnode/queue": "1.6.12",
+    "@abtnode/rbac": "1.6.12",
+    "@abtnode/router-provider": "1.6.12",
+    "@abtnode/static-server": "1.6.12",
+    "@abtnode/timemachine": "1.6.12",
+    "@abtnode/util": "1.6.12",
     "@arcblock/did": "^1.13.79",
     "@arcblock/event-hub": "1.13.79",
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/vc": "^1.13.79",
-    "@blocklet/meta": "1.6.8",
+    "@blocklet/meta": "1.6.12",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
@@ -75,5 +75,5 @@
     "express": "^4.17.1",
     "jest": "^27.4.5"
   },
-  "gitHead": "f97ec3a44250e034ff4b5e3f088c1417f448a7bb"
+  "gitHead": "dd79037978dc12f72330227a553a80a504f03fa7"
 }