@abtnode/core 1.15.17 → 1.16.0-beta-b16cb035

package/lib/index.js

@@ -1,17 +1,15 @@
-const { listProviders } = require('@abtnode/router-provider');
+const fs = require('fs');
+const path = require('path');
 const md5 = require('@abtnode/util/lib/md5');
+const formatContext = require('@abtnode/util/lib/format-context');
 const Cron = require('@abtnode/cron');
 
 const logger = require('@abtnode/logger')('@abtnode/core');
-const {
-  fromBlockletStatus,
-  toBlockletStatus,
-  fromBlockletSource,
-  toBlockletSource,
-} = require('@blocklet/meta/lib/constants');
+const { fromBlockletStatus, toBlockletStatus, fromBlockletSource, toBlockletSource } = require('@blocklet/constant');
+const { listProviders } = require('@abtnode/router-provider');
+const { DEFAULT_CERTIFICATE_EMAIL, EVENTS } = require('@abtnode/constant');
 
 const RoutingSnapshot = require('./states/routing-snapshot');
-const BlockletRegistry = require('./blocklet/registry');
 const BlockletManager = require('./blocklet/manager/disk');
 const RouterManager = require('./router/manager');
 const getRouterHelpers = require('./router/helper');
@@ -20,18 +18,21 @@ const NodeAPI = require('./api/node');
 const TeamAPI = require('./api/team');
 const WebHook = require('./webhook');
 const states = require('./states');
+const Cert = require('./cert');
 
 const IP = require('./util/ip');
 const DomainStatus = require('./util/domain-status');
-const Upgrade = require('./util/upgrade');
+const Maintain = require('./util/maintain');
 const resetNode = require('./util/reset-node');
-const { getServices } = require('./util/service');
 const DiskMonitor = require('./util/disk-monitor');
-const createQueue = require('./queue');
+const StoreUtil = require('./util/store');
+const createQueue = require('./util/queue');
 const createEvents = require('./event');
 const pm2Events = require('./blocklet/manager/pm2-events');
 const { createStateReadyQueue, createStateReadyHandler } = require('./util/ready');
-const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem } = require('./util');
+const { createDataArchive } = require('./util/blocklet');
+const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem, getStateCrons } = require('./util');
+const getMetaFromUrl = require('./util/get-meta-from-url');
 
 /**
  * @param {object} options
@@ -46,6 +47,7 @@ const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem } = requi
  *   version
  *   runtimeConfig: {}
  *   autoUpgrade
+ *   registerUrl
  *   webWalletUrl
  */
 function ABTNode(options) {
@@ -53,6 +55,11 @@ function ABTNode(options) {
     throw new Error('Can not initialize ABTNode without dataDir');
   }
 
+  const ekFile = path.join(options.dataDir, '.sock');
+  if (fs.existsSync(ekFile)) {
+    options.dek = fs.readFileSync(ekFile);
+  }
+
   if (typeof options.daemon === 'undefined') {
     options.daemon = false;
   }
@@ -93,7 +100,25 @@ function ABTNode(options) {
       concurrency,
       maxRetries: 3,
       retryDelay: 5000, // retry after 5 seconds
-      maxTimeout: 60 * 1000 * 15, // throw timeout error after 5 minutes
+      maxTimeout: 60 * 1000 * 15, // throw timeout error after 15 minutes
+      id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
+    },
+  });
+
+  const backupQueue = createQueue({
+    daemon: options.daemon,
+    name: 'backup_queue',
+    dataDir: dataDirs.core,
+    onJob: async (job) => {
+      if (typeof blockletManager.onJob === 'function') {
+        await blockletManager.onJob(job);
+      }
+    },
+    options: {
+      concurrency,
+      maxRetries: 3,
+      retryDelay: 10000, // retry after 10 seconds
+      maxTimeout: 60 * 1000 * 30, // throw timeout error after 30 minutes
       id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
     },
   });
@@ -101,7 +126,13 @@ function ABTNode(options) {
   // Initialize storage
   states.init(dataDirs, options);
 
-  const routerManager = new RouterManager();
+  const certManager = new Cert({
+    maintainerEmail: DEFAULT_CERTIFICATE_EMAIL,
+    dataDir: dataDirs.certManagerModule,
+    states,
+  });
+
+  const routerManager = new RouterManager({ certManager });
   const routingSnapshot = new RoutingSnapshot({
     baseDir: dataDirs.core,
     getRoutingData: async () => {
@@ -111,18 +142,21 @@ function ABTNode(options) {
     },
   });
 
-  const blockletRegistry = new BlockletRegistry();
+  const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
+
   const blockletManager = new BlockletManager({
     dataDirs,
     startQueue,
     installQueue,
-    registry: blockletRegistry,
+    backupQueue,
     daemon: options.daemon,
+    teamManager,
   });
+  blockletManager.setMaxListeners(0);
 
   const {
     handleRouting,
-    getRoutingRulesByDid,
+    resetSiteByDid,
     updateNodeRouting,
     takeRoutingSnapshot,
     getRoutingSites,
@@ -134,32 +168,27 @@ function ABTNode(options) {
     getCertificates,
     getSitesFromSnapshot,
     getRoutingCrons,
-  } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager });
-
-  const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
-
-  const nodeAPI = new NodeAPI(states.node, blockletRegistry);
-  const teamAPI = new TeamAPI({ states, teamManager });
-
-  blockletManager.getRoutingRulesByDid = getRoutingRulesByDid;
+    ensureWildcardCerts,
+    getRouterProvider,
+    addRoutingSite,
+    deleteRoutingSite,
+    updateRoutingSite,
+    addRoutingRule,
+    updateRoutingRule,
+    deleteRoutingRule,
+    addDomainAlias,
+    deleteDomainAlias,
+  } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager });
+
+  const nodeAPI = new NodeAPI(states.node);
+  const teamAPI = new TeamAPI({ states, teamManager, dataDirs });
+
+  blockletManager.resetSiteByDid = resetSiteByDid;
 
   // Generate an on node ready callback
   const onStatesReady = createStateReadyQueue({ states, options, dataDirs });
   onStatesReady(createStateReadyHandler(routingSnapshot));
-  const domainStatus = new DomainStatus(routerManager);
-
-  const events = createEvents({
-    blockletManager,
-    blockletRegistry,
-    ensureBlockletRouting,
-    ensureBlockletRoutingForUpgrade,
-    removeBlockletRouting,
-    takeRoutingSnapshot,
-    routerManager,
-    handleRouting,
-    domainStatus,
-    teamAPI,
-  });
+  const domainStatus = new DomainStatus({ routerManager, states });
 
   const isInitialized = async () => {
     const state = await states.node.read();
@@ -183,23 +212,30 @@ function ABTNode(options) {
 
     // Blocklet manager
     installBlocklet: blockletManager.install.bind(blockletManager),
-    installBlockletFromVc: blockletManager.installBlockletFromVc.bind(blockletManager),
+    installComponent: blockletManager.installComponent.bind(blockletManager),
     startBlocklet: blockletManager.start.bind(blockletManager),
     stopBlocklet: blockletManager.stop.bind(blockletManager),
     reloadBlocklet: blockletManager.reload.bind(blockletManager),
     restartBlocklet: blockletManager.restart.bind(blockletManager),
     deleteBlocklet: blockletManager.delete.bind(blockletManager),
+    deleteComponent: blockletManager.deleteComponent.bind(blockletManager),
     cancelDownloadBlocklet: blockletManager.cancelDownload.bind(blockletManager),
-    upgradeBlocklet: blockletManager.upgrade.bind(blockletManager),
     configBlocklet: blockletManager.config.bind(blockletManager),
     devBlocklet: blockletManager.dev.bind(blockletManager),
-    getBlockletStatus: blockletManager.getStatus.bind(blockletManager),
-    checkChildBlockletsForUpdates: blockletManager.checkChildrenForUpdates.bind(blockletManager),
-    updateChildBlocklets: blockletManager.updateChildren.bind(blockletManager),
-    getLatestBlockletVersion: blockletManager.getLatestBlockletVersion.bind(blockletManager),
-    getBlockletMetaFromUrl: blockletManager.getMetaFromUrl.bind(blockletManager),
-
+    checkComponentsForUpdates: blockletManager.checkComponentsForUpdates.bind(blockletManager),
+    upgradeComponents: blockletManager.upgradeComponents.bind(blockletManager),
+    getBlockletMetaFromUrl: getMetaFromUrl.bind(blockletManager),
+    getBlockletForLauncher: blockletManager.getBlockletForLauncher.bind(blockletManager),
+    resetBlocklet: blockletManager.reset.bind(blockletManager),
     deleteBlockletProcess: blockletManager.deleteProcess.bind(blockletManager),
+    configPublicToStore: blockletManager.configPublicToStore.bind(blockletManager),
+    configNavigations: blockletManager.configNavigations.bind(blockletManager),
+    updateWhoCanAccess: blockletManager.updateWhoCanAccess.bind(blockletManager),
+    updateComponentTitle: blockletManager.updateComponentTitle.bind(blockletManager),
+    updateComponentMountPoint: blockletManager.updateComponentMountPoint.bind(blockletManager),
+    backupToSpaces: blockletManager.backupToSpaces.bind(blockletManager),
+    restoreFromSpaces: blockletManager.restoreFromSpaces.bind(blockletManager),
+    migrateApplicationToStructV2: blockletManager.migrateApplicationToStructV2.bind(blockletManager),
 
     // For diagnose purpose
     syncBlockletStatus: blockletManager.status.bind(blockletManager),
@@ -209,39 +245,50 @@ function ABTNode(options) {
     getBlocklets: blockletManager.list.bind(blockletManager),
     getBlocklet: blockletManager.detail.bind(blockletManager),
     getBlockletDiff: blockletManager.diff.bind(blockletManager),
+    hasBlocklet: blockletManager.hasBlocklet.bind(blockletManager),
     updateAllBlockletEnvironment: blockletManager.updateAllBlockletEnvironment.bind(blockletManager),
+    setBlockletInitialized: blockletManager.setInitialized.bind(blockletManager),
+    getBlockletRuntimeHistory: blockletManager.getRuntimeHistory.bind(blockletManager),
 
-    // Registry
-    listBlocklets: blockletRegistry.listBlocklets.bind(blockletRegistry),
-    getBlockletMeta: blockletRegistry.getBlockletMeta.bind(blockletRegistry),
-    getRegistryMeta: BlockletRegistry.getRegistryMeta,
+    // Store
+    getBlockletMeta: StoreUtil.getBlockletMeta,
+    getStoreMeta: StoreUtil.getStoreMeta,
 
     // Node State
     getNodeInfo: nodeAPI.getInfo.bind(nodeAPI),
     getNodeEnv: nodeAPI.getEnv.bind(nodeAPI),
     updateNodeInfo: nodeAPI.updateNodeInfo.bind(nodeAPI),
-    addBlockletRegistry: nodeAPI.addRegistry.bind(nodeAPI),
-    deleteBlockletRegistry: nodeAPI.deleteRegistry.bind(nodeAPI),
-    selectBlockletRegistry: nodeAPI.selectRegistry.bind(nodeAPI),
-    cleanupDirtyUpgradeState: states.node.cleanupDirtyUpgradeState.bind(states.node),
-    addNodeOwner: states.node.addNodeOwner.bind(states.node),
+    getDelegationState: nodeAPI.getDelegationState.bind(nodeAPI),
+    cleanupDirtyMaintainState: states.node.cleanupDirtyMaintainState.bind(states.node),
+    updateNodeOwner: states.node.updateNodeOwner.bind(states.node),
+    updateNftHolder: states.node.updateNftHolder.bind(states.node),
     updateNodeRouting,
     isInitialized,
     resetNode: (params, context) =>
-      resetNode({ params, context, blockletManager, routerManager, takeRoutingSnapshot, teamManager }),
+      resetNode({ params, context, blockletManager, routerManager, takeRoutingSnapshot, teamManager, certManager }),
+    updateNodeStatus: states.node.updateStatus.bind(states.node),
+    resetNodeStatus: states.node.resetStatus.bind(states.node),
+
+    // Gateway
+    updateGateway: nodeAPI.updateGateway.bind(nodeAPI),
 
     // Team && Access control
 
     // Invitation
-    createInvitation: teamAPI.createInvitation.bind(teamAPI),
+    createMemberInvitation: teamAPI.createMemberInvitation.bind(teamAPI),
+    createTransferInvitation: teamAPI.createTransferInvitation.bind(teamAPI),
+    getInvitation: teamAPI.getInvitation.bind(teamAPI),
     getInvitations: teamAPI.getInvitations.bind(teamAPI),
-    processInvitation: teamAPI.processInvitation.bind(teamAPI),
+    checkInvitation: teamAPI.checkInvitation.bind(teamAPI),
     deleteInvitation: teamAPI.deleteInvitation.bind(teamAPI),
+    closeInvitation: teamAPI.closeInvitation.bind(teamAPI),
 
     // Account
     getUsers: teamAPI.getUsers.bind(teamAPI),
     getUsersCount: teamAPI.getUsersCount.bind(teamAPI),
+    getUsersCountPerRole: teamAPI.getUsersCountPerRole.bind(teamAPI),
     getUser: teamAPI.getUser.bind(teamAPI),
+    getOwner: teamAPI.getOwner.bind(teamAPI),
     getNodeUsers: () => teamAPI.getUsers({ teamDid: options.nodeDid }),
     getNodeUser: (user) => teamAPI.getUser({ teamDid: options.nodeDid, user }),
     addUser: teamAPI.addUser.bind(teamAPI),
@@ -272,6 +319,8 @@ function ABTNode(options) {
     // Passport
     revokeUserPassport: teamAPI.revokeUserPassport.bind(teamAPI),
     enableUserPassport: teamAPI.enableUserPassport.bind(teamAPI),
+    issuePassportToUser: teamAPI.issuePassportToUser.bind(teamAPI),
+
     createPassportIssuance: teamAPI.createPassportIssuance.bind(teamAPI),
     getPassportIssuances: teamAPI.getPassportIssuances.bind(teamAPI),
     getPassportIssuance: teamAPI.getPassportIssuance.bind(teamAPI),
@@ -280,23 +329,31 @@ function ABTNode(options) {
     configTrustedPassports: teamAPI.configTrustedPassports.bind(teamAPI),
     configPassportIssuance: teamAPI.configPassportIssuance.bind(teamAPI),
 
+    // Team Settings
+    addBlockletStore: teamAPI.addStore.bind(teamAPI),
+    deleteBlockletStore: teamAPI.deleteStore.bind(teamAPI),
+
     // Challenge
     generateChallenge: states.challenge.generate.bind(states.challenge),
     verifyChallenge: states.challenge.verify.bind(states.challenge),
 
     // Notifications
-    getNotifications: states.notification.find.bind(states.notification),
+    getNotifications: states.notification.findPaginated.bind(states.notification),
     readNotifications: states.notification.read.bind(states.notification),
     unreadNotifications: states.notification.unread.bind(states.notification),
 
+    // AuditLog
+    createAuditLog: (params) => states.auditLog.create(params, instance),
+    getAuditLogs: states.auditLog.findPaginated.bind(states.auditLog),
+
     // Routing
     routerManager,
-    addRoutingSite: routerManager.addRoutingSite.bind(routerManager),
-    deleteRoutingSite: routerManager.deleteRoutingSite.bind(routerManager),
-    updateRoutingSite: routerManager.updateRoutingSite.bind(routerManager),
-    addRoutingRule: routerManager.addRoutingRule.bind(routerManager),
-    updateRoutingRule: routerManager.updateRoutingRule.bind(routerManager),
-    deleteRoutingRule: routerManager.deleteRoutingRule.bind(routerManager),
+    addRoutingSite,
+    deleteRoutingSite,
+    updateRoutingSite,
+    addRoutingRule,
+    updateRoutingRule,
+    deleteRoutingRule,
     getRoutingRuleById: states.site.getRuleById.bind(states.site),
     getRoutingSites: (params, context) => getRoutingSites(params, context, { withDefaultCors: false }),
     getRoutingSnapshots: routingSnapshot.listSnapshots.bind(routingSnapshot),
@@ -304,23 +361,27 @@ function ABTNode(options) {
     takeRoutingSnapshot,
     getSitesFromSnapshot,
     ensureDashboardRouting,
+    ensureWildcardCerts,
 
-    addDomainAlias: routerManager.addDomainAlias.bind(routerManager),
-    deleteDomainAlias: routerManager.deleteDomainAlias.bind(routerManager),
+    addDomainAlias,
+    deleteDomainAlias,
 
     getRoutingProviders: () => listProviders(dataDirs.router),
     checkDomains: domainStatus.checkDomainsStatus.bind(domainStatus),
     handleRouting,
 
-    updateNginxHttpsCert: routerManager.updateNginxHttpsCert.bind(routerManager),
+    certManager,
+    updateCertificate: certManager.update.bind(certManager),
     getCertificates,
-    addCertificate: routerManager.addCertificate.bind(routerManager),
-    deleteCertificate: routerManager.deleteCertificate.bind(routerManager),
-    findCertificateByDomain: routerManager.findCertificateByDomain.bind(routerManager),
+    addCertificate: certManager.add.bind(certManager),
+    deleteCertificate: certManager.remove.bind(certManager),
+    findCertificateByDomain: certManager.getByDomain.bind(certManager),
+    issueLetsEncryptCert: certManager.issue.bind(certManager),
 
     // Access Key
     getAccessKeys: states.accessKey.list.bind(states.accessKey),
     getAccessKey: states.accessKey.detail.bind(states.accessKey),
+    getAccessKeyByTag: states.accessKey.getAccessKeyByTag.bind(states.accessKey),
     createAccessKey: states.accessKey.create.bind(states.accessKey),
     updateAccessKey: states.accessKey.update.bind(states.accessKey),
     deleteAccessKey: states.accessKey.remove.bind(states.accessKey),
@@ -331,10 +392,11 @@ function ABTNode(options) {
     markMigrationExecuted: states.migration.markExecuted.bind(states.migration),
 
     // Upgrading
-    upgradeNodeVersion: Upgrade.startUpgrade,
-    checkNodeVersion: Upgrade.checkNewVersion,
-    isUpgrading: Upgrade.isUpgrading,
-    doUpgrade: Upgrade.doUpgrade,
+    upgradeNodeVersion: () => Maintain.triggerMaintain({ action: 'upgrade', next: Maintain.resumeMaintain }),
+    checkNodeVersion: Maintain.checkNewVersion,
+    restartServer: () => Maintain.triggerMaintain({ action: 'restart', next: Maintain.resumeMaintain }),
+    isBeingMaintained: Maintain.isBeingMaintained,
+    resumeMaintain: Maintain.resumeMaintain,
 
     // Session
     getSession: (params, context) => states.session.read(params.id, context),
@@ -348,10 +410,31 @@ function ABTNode(options) {
       ),
     endSession: (params, context) => states.session.end(params.id, context),
 
-    // Services
-    getServices: (params, context) => getServices({ stringifySchema: true }, context),
+    getNodeRuntimeHistory: nodeAPI.getHistory.bind(nodeAPI),
+    getNodeRuntimeInfo: nodeAPI.getRealtimeData.bind(nodeAPI),
+
+    getRouterProvider,
+
+    // for exporting blocklet data dir
+    createBlockletDataArchive: createDataArchive,
   };
 
+  const events = createEvents({
+    blockletManager,
+    ensureBlockletRouting,
+    ensureBlockletRoutingForUpgrade,
+    removeBlockletRouting,
+    takeRoutingSnapshot,
+    handleRouting,
+    domainStatus,
+    teamAPI,
+    teamManager,
+    certManager,
+    routerManager,
+    node: instance,
+    nodeRuntimeMonitor: nodeAPI.runtimeMonitor,
+  });
+
   const webhook = WebHook({ events, dataDirs, instance });
 
   const initCron = () => {
@@ -359,11 +442,12 @@ function ABTNode(options) {
       context: { states, events, webhook },
       jobs: [
         IP.cron,
-        blockletRegistry.getCron(),
-        Upgrade.getCron(),
+        Maintain.getCron(),
         ...getRoutingCrons(),
         ...blockletManager.getCrons(),
         DiskMonitor.getCron(),
+        ...getStateCrons(states),
+        ...nodeAPI.getCrons(),
       ],
       onError: (error, name) => {
         states.notification.create({
@@ -377,20 +461,44 @@ function ABTNode(options) {
     });
   };
 
+  const createCLILog = (action) => {
+    instance
+      .createAuditLog({
+        action,
+        args: {},
+        context: formatContext({
+          user: { fullName: 'CLI', role: 'admin', did: options.nodeDid },
+          headers: { 'user-agent': 'CLI' },
+        }),
+        result: null,
+      })
+      .catch(console.error);
+  };
+
   if (options.daemon) {
+    // 启动证书服务
+    certManager
+      .start()
+      .then(() => logger.info('start certificate manager service successfully'))
+      .catch((error) => logger.error('start certificate manager service failed', { error }));
+
     if (process.env.NODE_ENV === 'development') {
-      initCron();
+      setTimeout(() => {
+        initCron();
+      }, 1000);
     } else {
       // We should only respond to pm2 events when node is alive
-      events.on('node.started', () => {
+      events.on(EVENTS.NODE_STARTED, () => {
         pm2Events.resume();
         initCron();
+        createCLILog('startServer');
       });
     }
   }
 
-  events.on('node.stopped', () => {
+  events.on(EVENTS.NODE_STOPPED, () => {
     pm2Events.pause();
+    createCLILog('stopServer');
   });
 
   return Object.assign(events, {

package/lib/migrations/1.0.21-update-config.js

@@ -7,7 +7,7 @@ module.exports = async ({ states, config, configFile, printInfo }) => {
   printInfo('Try to update node config to 1.0.21...');
   let changed = false;
 
-  const rawConfig = yaml.safeLoad(fs.readFileSync(configFile).toString());
+  const rawConfig = yaml.load(fs.readFileSync(configFile).toString());
   const info = await states.node.read();
 
   const updates = [

package/lib/migrations/1.0.22-max-memory.js

@@ -13,7 +13,7 @@ module.exports = async ({ states, config, configFile, printInfo }) => {
   printInfo('Try to update node config to 1.0.22...');
   let changed = false;
 
-  const rawConfig = yaml.safeLoad(fs.readFileSync(configFile).toString());
+  const rawConfig = yaml.load(fs.readFileSync(configFile).toString());
   const info = await states.node.read();
 
   const updates = [

package/lib/migrations/1.0.25.js

@@ -10,7 +10,7 @@ module.exports = async ({ states, config, configFile, printInfo }) => {
   printInfo('Try to update node config to 1.0.25...');
   let changed = false;
 
-  const rawConfig = yaml.safeLoad(fs.readFileSync(configFile).toString());
+  const rawConfig = yaml.load(fs.readFileSync(configFile).toString());
   const info = await states.node.read();
 
   const updates = [

package/lib/migrations/1.0.32-update-config.js

@@ -7,7 +7,7 @@ module.exports = async ({ states, config, configFile, printInfo }) => {
   printInfo('Try to update node config to 1.0.32...');
   let changed = false;
 
-  const rawConfig = yaml.safeLoad(fs.readFileSync(configFile).toString());
+  const rawConfig = yaml.load(fs.readFileSync(configFile).toString());
   const info = await states.node.read();
 
   const updates = [{ key: 'routing.https', value: true }];

package/lib/migrations/1.0.33-blocklets.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-underscore-dangle */
-const { BLOCKLET_DEFAULT_PORT_NAME } = require('@blocklet/meta/lib/constants');
+const { BLOCKLET_DEFAULT_PORT_NAME } = require('@blocklet/constant');
 
 module.exports = async ({ states, printInfo }) => {
   printInfo('Try to update node config to 1.0.33...');

package/lib/migrations/1.5.20-registry.js

@@ -0,0 +1,15 @@
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to rename Blocklet Registry to Blocklet Store in db...');
+
+  const info = await states.node.read();
+  (info.blockletRegistryList || []).forEach((item) => {
+    if (!item) {
+      return;
+    }
+    item.name = (item.name || '').replace('Registry', 'Store');
+    item.description = (item.description || '').replace('registry', 'store');
+    item.url = (item.url || '').replace('registry.arcblock.io', 'store.blocklet.dev');
+  });
+
+  await states.node.updateNodeInfo(info);
+};

package/lib/migrations/1.6.17-blocklet-children.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-underscore-dangle */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update blocklet to 1.6.17...');
+  const blockletState = states.blocklet;
+
+  const blocklets = await blockletState.getBlocklets();
+  for (const blocklet of blocklets) {
+    if (!blocklet) {
+      continue;
+    }
+
+    if (!blocklet.children || !blocklet.children.length) {
+      continue;
+    }
+
+    const meta = blocklet.meta || {};
+    const { did } = meta;
+    if (!did) {
+      continue;
+    }
+
+    const children = (blocklet.children || []).map((child) => {
+      if (child.mountPoint) {
+        return child;
+      }
+
+      const config = (meta.children || []).find((x) => x.name === child.meta.name);
+
+      if (
+        config &&
+        config.mountPoints &&
+        config.mountPoints[0] &&
+        config.mountPoints[0].root &&
+        config.mountPoints[0].root.prefix
+      ) {
+        child.mountPoint = config.mountPoints[0].root.prefix;
+      }
+      printInfo(`Set mountPoint: ${child.mountPoint} to child ${child.meta.name} in ${blocklet.meta.name}`);
+
+      return child;
+    });
+
+    await blockletState.update(blocklet._id, { $set: { children } });
+  }
+};

package/lib/migrations/1.6.21-rename-ip-echo-domain.js

@@ -0,0 +1,35 @@
+const yaml = require('js-yaml');
+const fs = require('fs');
+const set = require('lodash/set');
+const omit = require('lodash/omit');
+const {
+  DEFAULT_WILDCARD_CERT_HOST,
+  DEFAULT_DID_DOMAIN,
+  DEFAULT_DID_REGISTRY,
+  DEFAULT_IP_DOMAIN,
+} = require('@abtnode/constant');
+
+module.exports = async ({ states, printInfo, configFile }) => {
+  printInfo('Try to rename dashboardDomain to ipWildcardDomain in db...');
+
+  let info = await states.node.read();
+  set(info, 'routing.ipWildcardDomain', info.routing.dashboardDomain || DEFAULT_IP_DOMAIN);
+  set(info, 'routing.wildcardCertHost', DEFAULT_WILDCARD_CERT_HOST);
+  set(info, 'didDomain', DEFAULT_DID_DOMAIN);
+  set(info, 'didRegistry', DEFAULT_DID_REGISTRY);
+  info = omit(info, 'routing.dashboardDomain');
+
+  await states.node.updateNodeInfo(info);
+
+  if (process.env.NODE_ENV !== 'development') {
+    let rawConfig = yaml.load(fs.readFileSync(configFile).toString());
+    set(rawConfig, 'node.routing.ipWildcardDomain', info.routing.ipWildcardDomain);
+    set(rawConfig, 'node.routing.wildcardCertHost', DEFAULT_WILDCARD_CERT_HOST);
+    set(rawConfig, 'node.didDomain', DEFAULT_DID_DOMAIN);
+    set(rawConfig, 'node.didRegistry', DEFAULT_DID_REGISTRY);
+    rawConfig = omit(rawConfig, 'node.routing.dashboardDomain');
+    fs.writeFileSync(configFile, yaml.dump(rawConfig));
+  }
+
+  printInfo(`> Persist new config to file: ${configFile}`);
+};