@abtnode/core 1.8.65-beta-81d3340c → 1.8.65-beta-f7af64a4

package/lib/blocklet/manager/disk.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable no-await-in-loop */
 const fs = require('fs-extra');
-const { fileURLToPath } = require('url');
 const path = require('path');
 const flat = require('flat');
 const get = require('lodash/get');
@@ -17,14 +16,12 @@ const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { verifyPresentation } = require('@arcblock/vc');
-const { toBase58 } = require('@ocap/util');
 const { toSvg: createDidLogo } =
   process.env.NODE_ENV !== 'test' ? require('@arcblock/did-motif') : require('@arcblock/did-motif/dist/did-motif.cjs');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
+const sleep = require('@abtnode/util/lib/sleep');
 
 const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
-const downloadFile = require('@abtnode/util/lib/download-file');
-const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
 const {
   VC_TYPE_BLOCKLET_PURCHASE,
@@ -45,17 +42,16 @@ const {
   forEachChildSync,
   forEachBlocklet,
   getComponentId,
-  getComponentBundleId,
   isPreferenceKey,
   getRolesFromAuthConfig,
 } = require('@blocklet/meta/lib/util');
 const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
-const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { titleSchema, mountPointSchema, environmentNameSchema } = require('@blocklet/meta/lib/schema');
 const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
+const Lock = require('@abtnode/util/lib/lock');
 
 const { toExternalBlocklet } = toBlockletDid;
 
@@ -63,7 +59,6 @@ const {
   BlockletStatus,
   BlockletSource,
   BlockletEvents,
-  BLOCKLET_BUNDLE_FOLDER,
   BLOCKLET_MODES,
   BlockletGroup,
   fromBlockletStatus,
@@ -86,7 +81,6 @@ const {
 } = require('../../util/get-accessible-external-node-ip');
 const {
   getBlockletMetaFromUrl,
-  ensureBlockletExpanded,
   getAppSystemEnvironments,
   getComponentSystemEnvironments,
   getAppOverwrittenEnvironments,
@@ -99,8 +93,6 @@ const {
   checkBlockletProcessHealthy,
   validateBlocklet,
   statusMap,
-  expandTarball,
-  verifyIntegrity,
   pruneBlockletBundle,
   getDiskInfo,
   getUpdateMetaList,
@@ -110,7 +102,6 @@ const {
   checkDuplicateComponents,
   getDiffFiles,
   getBundleDir,
-  needBlockletDownload,
   findAvailableDid,
   ensureMeta,
   getBlocklet,
@@ -131,12 +122,13 @@ const runMigrationScripts = require('../migration');
 const hooks = require('../hooks');
 const { formatName, getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
 const handleInstanceInStore = require('../../util/public-to-store');
-const { getNFTState, getServerDidDomain } = require('../../util');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
 const { SpacesBackup } = require('../storage/backup/spaces');
 const { SpacesRestore } = require('../storage/restore/spaces');
 const installFromBackup = require('./helper/install-from-backup');
+const { resolveDownload, resolveDiffDownload } = require('../downloader/resolve-download');
+const BlockletDownloader = require('../downloader/blocklet-downloader');
 
 const {
   isInProgress,
@@ -150,8 +142,6 @@ const {
 
 const statusLock = new Lock('blocklet-status-lock');
 
-const asyncFs = fs.promises;
-
 const pm2StatusMap = {
   online: BlockletStatus.running,
   stop: BlockletStatus.stopped,
@@ -211,15 +201,6 @@ class BlockletManager extends BaseBlockletManager {
     this.installQueue = installQueue;
     this.teamManager = teamManager;
 
-    /**
-     * { did: Map({ <childDid>: <downloadFile.cancelCtrl> }) }
-     */
-    this.downloadCtrls = {};
-    /**
-     * { [download-did-version]: Lock }
-     */
-    this.downloadLocks = {};
-
     // cached installed blocklets for performance
     this.cachedBlocklets = null;
 
@@ -231,6 +212,12 @@ class BlockletManager extends BaseBlockletManager {
 
     this.runtimeMonitor = new BlockletRuntimeMonitor({ historyLength: MONITOR_HISTORY_LENGTH, states });
 
+    this.blockletDownloader = new BlockletDownloader({
+      installDir: this.installDir,
+      downloadDir: this.dataDirs.tmp,
+      cache: states.cache,
+    });
+
     if (daemon) {
       blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid));
       blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid));
@@ -457,6 +444,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false }, context) {
     logger.info('start blocklet', { did });
+    // should check blocklet integrity
     const blocklet = await this.ensureBlocklet(did, { e2eMode });
 
     try {
@@ -570,7 +558,7 @@ class BlockletManager extends BaseBlockletManager {
   async stop({ did, updateStatus = true, silent = false }, context) {
     logger.info('stop blocklet', { did });
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
     const { processId } = blocklet.env;
 
     if (updateStatus) {
@@ -668,7 +656,7 @@ class BlockletManager extends BaseBlockletManager {
 
   // eslint-disable-next-line no-unused-vars
   async reload({ did }, context) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
     await reloadBlockletProcess(blocklet);
@@ -684,13 +672,12 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('delete blocklet', { did, keepData });
 
     try {
-      const blocklet = await this.ensureBlocklet(did, { validateEnv: false });
+      const blocklet = await this.getBlocklet(did);
       if (isDeletableBlocklet(blocklet) === false) {
         throw new Error('Blocklet is protected from accidental deletion');
       }
 
       const nodeEnvironments = await states.node.getEnvironments();
-
       await deleteBlockletProcess(blocklet, {
         preDelete: (b, { ancestors }) =>
           hooks.preUninstall(b.env.processId, {
@@ -713,31 +700,27 @@ class BlockletManager extends BaseBlockletManager {
         severity: 'success',
       });
       return doc;
-    } catch (err) {
+    } catch (error) {
       // If we installed a corrupted blocklet accidentally, just cleanup the disk and state db
-      if (err.code === 'BLOCKLET_CORRUPTED') {
-        logger.info('blocklet is corrupted, will delete again', { did });
-        const doc = await this._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
-
-        this._createNotification(doc.meta.did, {
-          title: 'Blocklet Deleted',
-          description: `Blocklet ${doc.meta.name}@${doc.meta.version} is deleted.`,
-          entityType: 'blocklet',
-          entityId: doc.meta.did,
-          severity: 'success',
-        });
+      logger.error('blocklet delete failed, will delete again', { did, error });
+      const doc = await this._deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context);
 
-        return doc;
-      }
+      this._createNotification(doc.meta.did, {
+        title: 'Blocklet Deleted',
+        description: `Blocklet ${doc.meta.name}@${doc.meta.version} is deleted.`,
+        entityType: 'blocklet',
+        entityId: doc.meta.did,
+        severity: 'success',
+      });
 
-      throw err;
+      return doc;
     }
   }
 
   async reset({ did, childDid }, context = {}) {
     logger.info('reset blocklet', { did, childDid });
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     if (isInProgress(blocklet.status || blocklet.status === BlockletStatus.running)) {
       throw new Error('Cannot reset when blocklet is in progress');
@@ -787,7 +770,7 @@ class BlockletManager extends BaseBlockletManager {
   async deleteComponent({ did, rootDid, keepData, keepState }, context) {
     logger.info('delete blocklet component', { did, rootDid, keepData });
 
-    const blocklet = await this.ensureBlocklet(rootDid, { validateEnv: false });
+    const blocklet = await this.getBlocklet(rootDid);
     const child = blocklet.children.find((x) => x.meta.did === did);
     if (!child) {
       throw new Error('Component does not exist');
@@ -841,7 +824,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
     }
 
-    const newBlocklet = await this.ensureBlocklet(rootDid);
+    const newBlocklet = await this.getBlocklet(rootDid);
     this.emit(BlockletEvents.upgraded, { blocklet: newBlocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
 
     this._createNotification(newBlocklet.meta.did, {
@@ -877,7 +860,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       if (blocklet.status === BlockletStatus.downloading) {
-        await this._cancelDownload(blocklet.meta, context);
+        await this.blockletDownloader.cancelDownload(blocklet.meta.did);
       } else if (blocklet.status === BlockletStatus.waiting) {
         await this._cancelWaiting(blocklet.meta, context);
       }
@@ -894,7 +877,7 @@ class BlockletManager extends BaseBlockletManager {
 
   // eslint-disable-next-line no-unused-vars
   async deleteProcess({ did }, context) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     logger.info('delete blocklet process', { did });
 
@@ -917,17 +900,17 @@ class BlockletManager extends BaseBlockletManager {
 
     if (!attachRuntimeInfo) {
       try {
-        const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
+        const blocklet = await this.getBlocklet(did, { throwOnNotExist: false });
         return blocklet;
       } catch (e) {
-        logger.error('get blocklet detail error', { error: e.message });
-        return null;
+        logger.error('get blocklet detail error', { error: e });
+        return states.blocklet.getBlocklet(did);
       }
     }
 
     const nodeInfo = await states.node.read();
 
-    return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
+    return this._attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
   async attachBlockletListRuntimeInfo({ blocklets, useCache }, context) {
@@ -942,7 +925,7 @@ class BlockletManager extends BaseBlockletManager {
           const cachedBlocklet =
             useCache && this.cachedBlocklets ? this.cachedBlocklets.find((y) => y.meta.did === x.meta.did) : null;
 
-          return this.attachRuntimeInfo({
+          return this._attachRuntimeInfo({
             did: x.meta.did,
             nodeInfo,
             diskInfo: false,
@@ -990,7 +973,7 @@ class BlockletManager extends BaseBlockletManager {
     const [rootDid, ...childDids] = dids;
     logger.info('config blocklet', { dids });
 
-    let blocklet = await this.ensureBlocklet(rootDid);
+    let blocklet = await this.getBlocklet(rootDid);
     for (const childDid of childDids) {
       blocklet = blocklet.children.find((x) => x.meta.did === childDid);
       if (!blocklet) {
@@ -1048,20 +1031,20 @@ class BlockletManager extends BaseBlockletManager {
     await this.updateBlockletEnvironment(rootDid);
 
     // response
-    const newState = await this.ensureBlocklet(rootDid);
+    const newState = await this.getBlocklet(rootDid);
     this.emit(BlockletEvents.updated, newState);
     return newState;
   }
 
   async configPublicToStore({ did, publicToStore = false }) {
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
     // publicToStore 由用户传入
     // handleInstanceInStore 方法写在前面，保证向 store 操作成功后才会更改 blocklet 中的 publicToStore值
     // handleInstanceInStore 中会校验修改 publicToStore字段 的条件，不符合则会抛错，就不会执行下面更新 publicToStore 的逻辑
     await handleInstanceInStore(blocklet, { publicToStore });
     await states.blockletExtras.setSettings(did, { publicToStore });
 
-    const newState = await this.ensureBlocklet(did);
+    const newState = await this.getBlocklet(did);
     return newState;
   }
 
@@ -1071,7 +1054,7 @@ class BlockletManager extends BaseBlockletManager {
     }
     await states.blockletExtras.setSettings(did, { navigations });
 
-    const newState = await this.ensureBlocklet(did);
+    const newState = await this.getBlocklet(did);
     this.emit(BlockletEvents.updated, newState);
     return newState;
   }
@@ -1123,7 +1106,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blockletExtras.setConfigs(dids, configs);
     }
 
-    const blocklet = await this.ensureBlocklet(rootDid);
+    const blocklet = await this.getBlocklet(rootDid);
 
     this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
 
@@ -1171,7 +1154,7 @@ class BlockletManager extends BaseBlockletManager {
     // trigger dashboard frontend refresh
     this.emit(BlockletEvents.updated, blocklet);
 
-    return this.ensureBlocklet(rootDid);
+    return this.getBlocklet(rootDid);
   }
 
   async updateComponentMountPoint({ did, rootDid: inputRootDid, mountPoint }, context) {
@@ -1207,7 +1190,7 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.upgraded, { blocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
 
-    return this.ensureBlocklet(rootDid);
+    return this.getBlocklet(rootDid);
   }
 
   /**
@@ -1549,11 +1532,12 @@ class BlockletManager extends BaseBlockletManager {
     });
     logger.info('add blocklet for dev', { did, version, meta });
 
-    const oldBlocklet = { children: children.filter((x) => x.dynamic) }; // let downloader skip re-downloading dynamic blocklet
-    await this._downloadBlocklet(added, oldBlocklet);
+    await this._downloadBlocklet(added);
 
     // Add Config
     await this._setConfigsFromMeta(did);
+
+    // should ensure blocklet integrity
     let blocklet = await this.ensureBlocklet(did);
 
     // pre install
@@ -1561,14 +1545,14 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add environments
     await this.updateBlockletEnvironment(did);
-    blocklet = await this.ensureBlocklet(did);
+    blocklet = await this.getBlocklet(did);
 
     // post install
     await this._runPostInstallHook(blocklet);
 
     await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
-    blocklet = await this.ensureBlocklet(did);
+    blocklet = await this.getBlocklet(did);
 
     await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
@@ -1614,13 +1598,15 @@ class BlockletManager extends BaseBlockletManager {
     await states.blocklet.addChildren(rootDid, [component]);
 
     const newBlocklet = await states.blocklet.getBlocklet(rootDid);
-    await this._downloadBlocklet(newBlocklet, existRoot);
+    await this._downloadBlocklet(newBlocklet);
     await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
 
     await this._upsertDynamicNavigation(existRoot.meta.did, component, { skipNavigation });
 
     // Add Config
     await this._setConfigsFromMeta(rootDid);
+
+    // should ensure blocklet integrity
     let blocklet = await this.ensureBlocklet(rootDid);
 
     // pre install
@@ -1628,14 +1614,14 @@ class BlockletManager extends BaseBlockletManager {
 
     // Add environments
     await this.updateBlockletEnvironment(rootDid);
-    blocklet = await this.ensureBlocklet(rootDid);
+    blocklet = await this.getBlocklet(rootDid);
 
     // post install
     await this._runPostInstallHook(blocklet);
 
     logger.info('add blocklet component for dev', { did, version, meta });
 
-    blocklet = await this.ensureBlocklet(rootDid);
+    blocklet = await this.getBlocklet(rootDid);
 
     return blocklet;
   }
@@ -1659,7 +1645,11 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async ensureBlocklet(did, opts = {}) {
-    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did });
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: true });
+  }
+
+  async getBlocklet(did, opts = {}) {
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
   }
 
   async hasBlocklet({ did }) {
@@ -1677,7 +1667,7 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
 
-    return this.ensureBlocklet(did);
+    return this.getBlocklet(did);
   }
 
   async status(did, { forceSync = false } = {}) {
@@ -1694,7 +1684,7 @@ class BlockletManager extends BaseBlockletManager {
       return res;
     };
 
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     let shouldUpdateStatus = forceSync || shouldUpdateBlockletStatus(blocklet.status);
     if (isInProgress(blocklet.status)) {
@@ -1723,80 +1713,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
-    if (!did) {
-      throw new Error('did should not be empty');
-    }
-
-    try {
-      const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
-
-      if (!blocklet) {
-        return null;
-      }
-
-      const fromCache = !!cachedBlocklet;
-
-      // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
-      if (fromCache) {
-        const cached = {};
-        forEachBlockletSync(cachedBlocklet, (component, { id }) => {
-          cached[id] = component;
-        });
-
-        Object.assign(blocklet, pick(cachedBlocklet, ['appRuntimeInfo', 'diskInfo']));
-
-        forEachBlockletSync(blocklet, (component, { id }) => {
-          if (cached[id]) {
-            Object.assign(component, pick(cached[id], ['runtimeInfo']));
-          }
-        });
-      }
-
-      // 处理 domainAliases#value SLOT_FOR_IP_DNS_SITE
-      if (blocklet?.site?.domainAliases?.length) {
-        const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
-        blocklet.site.domainAliases = blocklet.site.domainAliases.map((x) => ({
-          ...x,
-          value: util.replaceDomainSlot({ domain: x.value, context, nodeIp }),
-        }));
-      }
-
-      // app runtime info, app status
-      blocklet.appRuntimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did);
-
-      if (!fromCache) {
-        // app disk info, component runtime info, component status, component engine
-        await forEachBlocklet(blocklet, async (component, { level }) => {
-          component.engine = getEngine(getBlockletEngineNameByPlatform(component.meta)).describe();
-
-          if (level === 0) {
-            component.diskInfo = await getDiskInfo(component, {
-              useFakeDiskInfo: !diskInfo,
-            });
-          }
-
-          component.runtimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did, component.env.id);
-
-          if (component.runtimeInfo?.status && shouldUpdateBlockletStatus(component.status)) {
-            component.status = statusMap[component.runtimeInfo.status];
-          }
-        });
-      }
-
-      return blocklet;
-    } catch (err) {
-      const simpleState = await states.blocklet.getBlocklet(did);
-      logger.error('failed to get blocklet info', {
-        did,
-        name: get(simpleState, 'meta.name'),
-        status: get(simpleState, 'status'),
-        error: err,
-      });
-      return simpleState;
-    }
-  }
-
   async refreshListCache() {
     this.list({ useCache: false }).catch((err) => {
       logger.error('refresh blocklet list failed', { error: err });
@@ -1862,7 +1778,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // download bundle
     try {
-      const { isCancelled } = await this._downloadBlocklet(blocklet, oldBlocklet, context);
+      const { isCancelled } = await this._downloadBlocklet(blocklet, context);
 
       if (isCancelled) {
         logger.info('Download was canceled', { name, did, version });
@@ -1995,7 +1911,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async onCheckIfStarted(jobInfo, { throwOnError } = {}) {
     const { did, context, minConsecutiveTime = 5000, timeout } = jobInfo;
-    const blocklet = await this.ensureBlocklet(did);
+    const blocklet = await this.getBlocklet(did);
 
     const { meta } = blocklet;
     const { name } = meta;
@@ -2036,7 +1952,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async updateBlockletEnvironment(did) {
-    const blockletWithEnv = await this.ensureBlocklet(did);
+    const blockletWithEnv = await this.getBlocklet(did);
     const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
 
@@ -2388,7 +2304,7 @@ class BlockletManager extends BaseBlockletManager {
 
   async _installFromUpload({ file, did, diffVersion, deleteSet, context }) {
     logger.info('install blocklet', { from: 'upload file' });
-    const { cwd, tarFile } = await this._downloadFromUpload(file);
+    const { tarFile } = await this._downloadFromUpload(file);
 
     // diff deploy
     if (did && diffVersion) {
@@ -2410,14 +2326,17 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
       }
 
-      const { meta } = await this._resolveDiffDownload(cwd, tarFile, deleteSet, oldBlocklet.meta);
+      const { meta } = await resolveDiffDownload(tarFile, this.installDir, {
+        deleteSet,
+        meta: oldBlocklet.meta,
+      });
       const newBlocklet = await states.blocklet.getBlocklet(did);
       newBlocklet.meta = ensureMeta(meta);
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
       newBlocklet.children = await this._getChildrenForInstallation(meta);
       await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet, oldBlocklet);
+      await this._downloadBlocklet(newBlocklet);
 
       return this._upgradeBlocklet({
         oldBlocklet,
@@ -2427,7 +2346,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // full deploy
-    const { meta } = await this._resolveDownload(cwd, tarFile);
+    const { meta } = await resolveDownload(tarFile, this.installDir);
     const oldBlocklet = await this._getBlockletForInstallation(meta.did);
 
     // full deploy - upgrade
@@ -2444,7 +2363,7 @@ class BlockletManager extends BaseBlockletManager {
       newBlocklet.children = await this._getChildrenForInstallation(meta);
 
       await validateBlocklet(newBlocklet);
-      await this._downloadBlocklet(newBlocklet, oldBlocklet);
+      await this._downloadBlocklet(newBlocklet);
 
       return this._upgradeBlocklet({
         oldBlocklet,
@@ -2472,11 +2391,7 @@ class BlockletManager extends BaseBlockletManager {
       await checkDuplicateAppSk({ did: meta.did, states });
 
       // download
-      await this._downloadBlocklet(
-        blocklet,
-        // let downloader skip re-downloading dynamic blocklet
-        { children: children.filter((x) => x.dynamic) }
-      );
+      await this._downloadBlocklet(blocklet);
 
       return this._installBlocklet({
         did: meta.did,
@@ -2501,7 +2416,7 @@ class BlockletManager extends BaseBlockletManager {
   }) {
     logger.info('install blocklet', { from: 'upload file' });
     // download
-    const { cwd, tarFile } = await this._downloadFromUpload(file);
+    const { tarFile } = await this._downloadFromUpload(file);
 
     const oldBlocklet = await this._getBlockletForInstallation(rootDid);
     if (!oldBlocklet) {
@@ -2530,10 +2445,10 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error('Blocklet version changed when diff deploying');
       }
 
-      meta = (await this._resolveDiffDownload(cwd, tarFile, deleteSet, oldChild.meta)).meta;
+      meta = (await resolveDiffDownload(tarFile, this.installDir, { deleteSet, meta: oldChild.meta })).meta;
     } else {
       // full deploy
-      meta = (await this._resolveDownload(cwd, tarFile)).meta;
+      meta = (await resolveDownload(tarFile, this.installDir)).meta;
     }
 
     if (meta.did === rootDid) {
@@ -2567,7 +2482,7 @@ class BlockletManager extends BaseBlockletManager {
 
     await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild, { skipNavigation });
 
-    await this._downloadBlocklet(newBlocklet, oldBlocklet);
+    await this._downloadBlocklet(newBlocklet);
 
     await validateBlocklet(newBlocklet);
 
@@ -2649,6 +2564,7 @@ class BlockletManager extends BaseBlockletManager {
       {
         name: 'delete-expired-external-blocklet',
         time: '0 */30 * * * *', // 30min
+        options: { runOnInit: false },
         fn: () => this._deleteExpiredExternalBlocklet(),
       },
       {
@@ -2664,6 +2580,80 @@ class BlockletManager extends BaseBlockletManager {
     ];
   }
 
+  async _attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
+    if (!did) {
+      throw new Error('did should not be empty');
+    }
+
+    try {
+      const blocklet = await this.getBlocklet(did, { throwOnNotExist: false });
+
+      if (!blocklet) {
+        return null;
+      }
+
+      const fromCache = !!cachedBlocklet;
+
+      // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
+      if (fromCache) {
+        const cached = {};
+        forEachBlockletSync(cachedBlocklet, (component, { id }) => {
+          cached[id] = component;
+        });
+
+        Object.assign(blocklet, pick(cachedBlocklet, ['appRuntimeInfo', 'diskInfo']));
+
+        forEachBlockletSync(blocklet, (component, { id }) => {
+          if (cached[id]) {
+            Object.assign(component, pick(cached[id], ['runtimeInfo']));
+          }
+        });
+      }
+
+      // 处理 domainAliases#value SLOT_FOR_IP_DNS_SITE
+      if (blocklet?.site?.domainAliases?.length) {
+        const nodeIp = await getAccessibleExternalNodeIp(nodeInfo);
+        blocklet.site.domainAliases = blocklet.site.domainAliases.map((x) => ({
+          ...x,
+          value: util.replaceDomainSlot({ domain: x.value, context, nodeIp }),
+        }));
+      }
+
+      // app runtime info, app status
+      blocklet.appRuntimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did);
+
+      if (!fromCache) {
+        // app disk info, component runtime info, component status, component engine
+        await forEachBlocklet(blocklet, async (component, { level }) => {
+          component.engine = getEngine(getBlockletEngineNameByPlatform(component.meta)).describe();
+
+          if (level === 0) {
+            component.diskInfo = await getDiskInfo(component, {
+              useFakeDiskInfo: !diskInfo,
+            });
+          }
+
+          component.runtimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did, component.env.id);
+
+          if (component.runtimeInfo?.status && shouldUpdateBlockletStatus(component.status)) {
+            component.status = statusMap[component.runtimeInfo.status];
+          }
+        });
+      }
+
+      return blocklet;
+    } catch (err) {
+      const simpleState = await states.blocklet.getBlocklet(did);
+      logger.error('failed to get blocklet info', {
+        did,
+        name: get(simpleState, 'meta.name'),
+        status: get(simpleState, 'status'),
+        error: err,
+      });
+      return simpleState;
+    }
+  }
+
   async _syncBlockletStatus() {
     const run = async (blocklet) => {
       try {
@@ -2906,143 +2896,13 @@ class BlockletManager extends BaseBlockletManager {
     return newBlocklet;
   }
 
-  /**
-   * decompress file, format dir and move to installDir
-   * @param {string} cwd
-   * @param {string} tarFile
-   * @param {object} originalMeta for verification
-   * @param {object} option
-   */
-  async _resolveDownload(cwd, tarFile, originalMeta, { removeTarFile = true } = {}) {
-    const downloadDir = path.join(cwd, `${path.basename(tarFile, path.extname(tarFile))}`);
-    const tmp = `${downloadDir}-tmp`;
-    try {
-      await expandTarball({ source: tarFile, dest: tmp, strip: 0 });
-    } catch (error) {
-      logger.error('expand blocklet tar file error');
-      throw error;
-    } finally {
-      if (removeTarFile) {
-        fs.removeSync(tarFile);
-      }
-    }
-    let installDir;
-    let meta;
-    try {
-      // resolve dir
-      let dir = tmp;
-      const files = await asyncFs.readdir(dir);
-      if (files.includes('package')) {
-        dir = path.join(tmp, 'package');
-      } else if (files.length === 1) {
-        const d = path.join(dir, files[0]);
-        if ((await asyncFs.stat(d)).isDirectory()) {
-          dir = d;
-        }
-      }
-
-      if (fs.existsSync(path.join(dir, BLOCKLET_BUNDLE_FOLDER))) {
-        dir = path.join(dir, BLOCKLET_BUNDLE_FOLDER);
-      }
-
-      logger.info('Move downloadDir to installDir', { downloadDir });
-      await fs.move(dir, downloadDir, { overwrite: true });
-      fs.removeSync(tmp);
-
-      meta = getBlockletMeta(downloadDir, { ensureMain: true });
-      const { did, name, version } = meta;
-
-      // validate
-      if (
-        originalMeta &&
-        (originalMeta.did !== did || originalMeta.name !== name || originalMeta.version !== version)
-      ) {
-        logger.error('Meta has differences', { originalMeta, meta });
-        throw new Error('There are differences between the meta from tarball file and the original meta');
-      }
-      await validateBlockletEntry(downloadDir, meta);
-
-      await ensureBlockletExpanded(meta, downloadDir);
-
-      installDir = getBundleDir(this.installDir, meta);
-      if (fs.existsSync(installDir)) {
-        fs.removeSync(installDir);
-        logger.info('cleanup blocklet upgrade dir', { name, version, installDir });
-      }
-
-      fs.mkdirSync(installDir, { recursive: true });
-
-      await fs.move(downloadDir, installDir, { overwrite: true });
-    } catch (error) {
-      fs.removeSync(downloadDir);
-      fs.removeSync(tmp);
-      throw error;
-    }
-
-    return { meta, installDir };
-  }
-
-  async _resolveDiffDownload(cwd, tarFile, deleteSet, bundle) {
-    logger.info('Resolve diff download', { tarFile, cwd });
-    const downloadDir = path.join(cwd, `${path.basename(tarFile, path.extname(tarFile))}`);
-    const diffDir = `${downloadDir}-diff`;
-    try {
-      await expandTarball({ source: tarFile, dest: diffDir, strip: 0 });
-      fs.removeSync(tarFile);
-    } catch (error) {
-      fs.removeSync(tarFile);
-      logger.error('expand blocklet tar file error');
-      throw error;
-    }
-    logger.info('Copy installDir to downloadDir', { installDir: this.installDir, downloadDir });
-    await fs.copy(getBundleDir(this.installDir, bundle), downloadDir);
-    try {
-      // delete
-      logger.info('Delete files from downloadDir', { fileNum: deleteSet.length });
-      // eslint-disable-next-line no-restricted-syntax
-      for (const file of deleteSet) {
-        await fs.remove(path.join(downloadDir, file));
-      }
-      // walk & cover
-      logger.info('Move files from diffDir to downloadDir', { diffDir, downloadDir });
-      const walkDiff = async (dir) => {
-        const files = await asyncFs.readdir(dir);
-        // eslint-disable-next-line no-restricted-syntax
-        for (const file of files) {
-          const p = path.join(dir, file);
-          const stat = await asyncFs.stat(p);
-          if (stat.isDirectory()) {
-            await walkDiff(p);
-          } else if (stat.isFile()) {
-            await fs.move(p, path.join(downloadDir, path.relative(diffDir, p)), { overwrite: true });
-          }
-        }
-      };
-      await walkDiff(diffDir);
-      fs.removeSync(diffDir);
-      const meta = getBlockletMeta(downloadDir, { ensureMain: true });
-
-      await ensureBlockletExpanded(meta, downloadDir);
-
-      // move to installDir
-      const bundleDir = getBundleDir(this.installDir, meta);
-      logger.info('Move downloadDir to installDir', { downloadDir, bundleDir });
-      await fs.move(downloadDir, bundleDir, { overwrite: true });
-
-      return { meta, installDir: bundleDir };
-    } catch (error) {
-      fs.removeSync(downloadDir);
-      fs.removeSync(diffDir);
-      throw error;
-    }
-  }
-
   /**
    * @param {string} opt.did
    * @param {object} opt.context
    */
   async _installBlocklet({ did, oldBlocklet, context }) {
     try {
+      // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
       const { meta, source, deployedFrom } = blocklet;
 
@@ -3059,13 +2919,13 @@ class BlockletManager extends BaseBlockletManager {
 
       // Add environments
       await this.updateBlockletEnvironment(meta.did);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
 
       // post install
       await this._runPostInstallHook(blocklet, context);
 
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
 
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
@@ -3150,6 +3010,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
       await this._setConfigsFromMeta(did);
 
+      // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
 
       // pre install
@@ -3157,7 +3018,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // Add environments
       await this.updateBlockletEnvironment(did);
-      blocklet = await this.ensureBlocklet(did);
+      blocklet = await this.getBlocklet(did);
 
       // post install
       await this._runPostInstallHook(blocklet, context);
@@ -3197,7 +3058,7 @@ class BlockletManager extends BaseBlockletManager {
         logger.info('started blocklet for upgrading', { did, version });
       }
 
-      blocklet = await this.ensureBlocklet(did, context);
+      blocklet = await this.getBlocklet(did, context);
 
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
@@ -3267,275 +3128,33 @@ class BlockletManager extends BaseBlockletManager {
     await states.blockletExtras.setSettings(did, { children: dynamicChildren });
   }
 
-  /**
-   *
-   *
-   * @param {{
-   *   url: string,
-   *   cwd: string,
-   *   tarball: string,
-   *   did: string,
-   *   integrity: string,
-   *   verify: boolean = true,
-   *   ctrlStore: {},
-   *   rootDid: string,
-   *   context: {} = {},
-   * }} { url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _downloadTarball({ url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }) {
-    fs.mkdirSync(cwd, { recursive: true });
-
-    const tarballName = url.split('/').slice(-1)[0];
-
-    const tarballPath = path.join(cwd, tarballName);
-
-    const { protocol } = new URL(url);
-
-    const cachedTarFile = await this._getCachedTarFile(integrity);
-    if (cachedTarFile) {
-      logger.info('found cache tarFile', { did, tarballName, integrity });
-      await fs.move(cachedTarFile, tarballPath, { overwrite: true });
-    } else if (protocol.startsWith('file')) {
-      await fs.copy(decodeURIComponent(fileURLToPath(url)), tarballPath);
-    } else {
-      const cancelCtrl = new downloadFile.CancelCtrl();
-
-      if (!ctrlStore[rootDid]) {
-        ctrlStore[rootDid] = new Map();
-      }
-      ctrlStore[rootDid].set(did, cancelCtrl);
-
-      const headers = context.headers ? cloneDeep(context.headers) : {};
-      const exist = (context.downloadTokenList || []).find((x) => x.did === did);
-      if (exist) {
-        headers['x-download-token'] = exist.token;
-      }
-
-      await downloadFile(url, path.join(cwd, tarballName), { cancelCtrl }, { ...context, headers });
-
-      if (ctrlStore[rootDid]) {
-        ctrlStore[rootDid].delete(did);
-        if (!ctrlStore[rootDid].size) {
-          delete ctrlStore[rootDid];
-        }
-      }
-
-      if (cancelCtrl.isCancelled) {
-        return downloadFile.CANCEL;
-      }
-    }
-
-    if (verify) {
-      try {
-        await verifyIntegrity({ file: tarballPath, integrity });
-      } catch (error) {
-        logger.error('verify integrity error', { error, tarball, url });
-        throw new Error(`${tarball} integrity check failed.`);
-      }
-    }
-
-    return tarballPath;
-  }
-
-  /**
-   * use LRU algorithm
-   */
-  async _addCacheTarFile(tarballPath, integrity) {
-    // eslint-disable-next-line no-param-reassign
-    integrity = toBase58(integrity);
-
-    // move tarball to cache dir
-    const cwd = path.join(this.dataDirs.tmp, 'download-cache');
-    const cachePath = path.join(cwd, `${integrity}.tar.gz`);
-    await fs.ensureDir(cwd);
-    await fs.move(tarballPath, cachePath, { overwrite: true });
-
-    const key = 'blocklet:manager:downloadCache';
-    const cacheList = (await states.cache.get(key)) || [];
-    const exist = cacheList.find((x) => x.integrity === integrity);
-
-    // update
-    if (exist) {
-      logger.info('update cache tarFile', { base58: integrity });
-      exist.accessAt = Date.now();
-      await states.cache.set(key, cacheList);
-      return;
-    }
-
-    // add
-    cacheList.push({ integrity, accessAt: Date.now() });
-    if (cacheList.length > 10) {
-      // find and remove
-      let minIndex = 0;
-      let min = cacheList[0];
-      cacheList.forEach((x, i) => {
-        if (x.accessAt < min.accessAt) {
-          minIndex = i;
-          min = x;
-        }
-      });
-
-      cacheList.splice(minIndex, 1);
-      await fs.remove(path.join(cwd, `${min.integrity}.tar.gz`));
-      logger.info('remove cache tarFile', { base58: min.integrity });
-    }
-    logger.info('add cache tarFile', { base58: integrity });
-
-    // update
-    await states.cache.set(key, cacheList);
-  }
-
-  async _getCachedTarFile(integrity) {
-    // eslint-disable-next-line no-param-reassign
-    integrity = toBase58(integrity);
-
-    const cwd = path.join(this.dataDirs.tmp, 'download-cache');
-    const cachePath = path.join(cwd, `${integrity}.tar.gz`);
-
-    if (fs.existsSync(cachePath)) {
-      return cachePath;
-    }
-
-    return null;
-  }
-
-  /**
-   *
-   *
-   * @param {*} meta
-   * @param {*} rootDid
-   * @param {*} url
-   * @param {{}} [context={}]
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _downloadBundle(meta, rootDid, url, context = {}) {
-    const { bundleName: name, bundleDid: did, version, dist = {} } = meta;
-    const { tarball, integrity } = dist;
-
-    const lockName = `download-${did}-${version}`;
-    let lock = this.downloadLocks[lockName];
-    if (!lock) {
-      lock = new Lock(lockName);
-      this.downloadLocks[lockName] = lock;
-    }
-
-    try {
-      await lock.acquire();
-      logger.info('downloaded blocklet for installing', { name, version, tarball, integrity });
-      const cwd = path.join(this.dataDirs.tmp, 'download', name);
-      await fs.ensureDir(cwd);
-      logger.info('start download blocklet', { name, version, cwd, tarball, integrity });
-      const tarballPath = await this._downloadTarball({
-        name,
-        did,
-        version,
-        cwd,
-        tarball,
-        integrity,
-        verify: true,
-        ctrlStore: this.downloadCtrls,
-        rootDid,
-        url,
-        context,
-      });
-      logger.info('downloaded blocklet tar file', { name, version, tarballPath });
-      if (tarballPath === downloadFile.CANCEL) {
-        lock.release();
-        return { isCancelled: true };
-      }
-
-      // resolve tarball and mv tarball to cache after resolved
-      await this._resolveDownload(cwd, tarballPath, null, { removeTarFile: false });
-      await this._addCacheTarFile(tarballPath, integrity);
-
-      logger.info('resolved blocklet tar file to install dir', { name, version });
-      lock.release();
-      return { isCancelled: false };
-    } catch (error) {
-      lock.release();
-      throw error;
-    }
-  }
-
   /**
    *
    *
    * @param {{}} blocklet
-   * @param {{}} [oldBlocklet={}]
    * @param {{}} [context={}]
    * @return {*}
    * @memberof BlockletManager
    */
-  async _downloadBlocklet(blocklet, oldBlocklet = {}, context = {}) {
+  async _downloadBlocklet(blocklet, context = {}) {
     const {
-      meta: { name, did },
+      meta: { did },
     } = blocklet;
 
-    const oldComponentObj = {};
-    const downloadComponentIds = [];
-    const metaObj = {};
-    const metas = [];
-
-    forEachBlockletSync(oldBlocklet, (oldComponent, { id }) => {
-      if (oldComponent.meta) {
-        oldComponentObj[id] = oldComponent;
-        metaObj[getComponentBundleId(oldComponent)] = oldComponent.meta;
-      }
-    });
-
-    forEachBlockletSync(blocklet, (component, { id: componentId }) => {
-      if (needBlockletDownload(component, oldComponentObj[componentId])) {
-        const bundleId = getComponentBundleId(component);
-
-        if (metaObj[bundleId]) {
-          if (get(component, 'meta.dist.integrity') !== get(metaObj[bundleId], 'dist.integrity')) {
-            // FIXME: what should we do if component bundle integrity not same in different apps
-            logger.error(`find duplicate bundle with different integrity when downloading ${blocklet.meta.title}`, {
-              bundleId,
-            });
-          }
-
-          logger.info(`skip download duplicate bundle ${bundleId}`);
-          return;
-        }
-
-        metaObj[bundleId] = component.meta;
-        metas.push(component.meta);
-        downloadComponentIds.push(componentId);
-      }
-    });
-
-    // update children status
-    const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
-      children: downloadComponentIds,
+    return this.blockletDownloader.download(blocklet, {
+      ...context,
+      preDownload: async ({ downloadComponentIds }) => {
+        // update children status
+        const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
+          children: downloadComponentIds,
+        });
+        this.emit(BlockletEvents.statusChange, blocklet1);
+      },
+      postDownload: async () => {
+        // since preferences only exist in blocklet bundle, we need to populate then after downloaded
+        await this._setConfigsFromMeta(did);
+      },
     });
-    this.emit(BlockletEvents.statusChange, blocklet1);
-
-    try {
-      logger.info('Download Blocklet', { name, did, bundles: metas.map((x) => get(x, 'dist.tarball')) });
-      const tasks = [];
-      for (const meta of metas) {
-        const url = meta.dist.tarball;
-        tasks.push(this._downloadBundle(meta, did, url, context));
-      }
-      const results = await Promise.all(tasks);
-
-      // since preferences only exist in blocklet bundle, we need to populate then after downloaded
-      await this._setConfigsFromMeta(did);
-
-      if (results.find((x) => x.isCancelled)) {
-        return { isCancelled: true };
-      }
-    } catch (error) {
-      logger.error('Download blocklet failed', { did, name, error });
-      await this._cancelDownload(blocklet.meta);
-      throw error;
-    }
-
-    return { isCancelled: false };
   }
 
   async _syncPm2Status(pm2Status, did) {
@@ -3551,17 +3170,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async _cancelDownload(blockletMeta, context) {
-    const { did } = blockletMeta;
-
-    if (this.downloadCtrls[did]) {
-      for (const cancelCtrl of this.downloadCtrls[did].values()) {
-        cancelCtrl.cancel();
-      }
-    }
-  }
-
   // eslint-disable-next-line no-unused-vars
   async _cancelWaiting(blockletMeta, context) {
     const { did } = blockletMeta;
@@ -3681,7 +3289,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _setConfigsFromMeta(did, childDid) {
-    const blocklet = await getBlocklet({ states, dataDirs: this.dataDirs, did, validateEnv: false, ensureDirs: false });
+    const blocklet = await getBlocklet({ states, dataDirs: this.dataDirs, did });
 
     if (!childDid) {
       await forEachBlocklet(blocklet, async (b, { ancestors }) => {
@@ -3848,48 +3456,55 @@ class BlockletManager extends BaseBlockletManager {
   async _deleteExpiredExternalBlocklet() {
     try {
       logger.info('start check expired external blocklet');
-      const blocklets = await states.blocklet.getBlocklets({
-        controller: {
-          $exists: true,
+      const blockletExtras = await states.blockletExtras.find(
+        {
+          controller: {
+            $exists: true,
+          },
+          'controller.expiredAt': {
+            $exists: false,
+          },
         },
-      });
-
-      const nodeInfo = await states.node.read();
+        { did: 1, meta: 1, controller: 1 }
+      );
 
-      const tasks = blocklets.map(async (blocklet) => {
+      for (const data of blockletExtras) {
         try {
-          const assetState = await getNFTState(nodeInfo.launcher.chainHost, blocklet.controller.nftId);
+          const assetState = await util.getNFTState(data.controller.chainHost, data.controller.nftId);
           const isExpired = isNFTExpired(assetState);
+
           if (isExpired) {
             logger.info('the blocklet already expired', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
+              blockletDid: data.meta.did,
+              nftId: data.controller.nftId,
             });
 
-            await this.delete({ did: blocklet.meta.did, keepData: true, keepConfigs: true, keepLogsDir: true });
+            await this.delete({ did: data.meta.did, keepData: true, keepConfigs: true, keepLogsDir: true });
             logger.info('the expired blocklet already deleted', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
-              did: blocklet.meta.did,
+              blockletDid: data.meta.did,
+              nftId: data.controller.nftId,
             });
 
             const expiredAt = getNftExpirationDate(assetState);
-            await states.blockletExtras.updateExpireInfo({ did: blocklet.meta.did, expiredAt });
+            await states.blockletExtras.updateExpireInfo({ did: data.meta.did, expiredAt });
             logger.info('updated expired blocklet extra info', {
-              blockletId: blocklet._id,
-              nftId: blocklet.controller.nftId,
-              did: blocklet.meta.did,
+              nftId: data.controller.nftId,
+              blockletDid: data.meta.did,
             });
+
+            // 删除 blocklet 后会 reload nginx, 所以这里每次删除一个
+            if (process.env.NODE_ENV !== 'test') {
+              await sleep(10 * 1000);
+            }
           }
         } catch (error) {
-          logger.error('get asset state failed when check expired external blocklet', {
-            blockletId: blocklet._id,
-            nftId: blocklet.controller.nftId,
+          logger.error('delete expired blocklet failed', {
+            blockletDid: data.meta.did,
+            nftId: data.controller.nftId,
+            error,
           });
         }
-      });
-
-      await Promise.all(tasks);
+      }
 
       logger.info('check expired external blocklet end');
     } catch (error) {
@@ -3954,13 +3569,13 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.appDidChanged, blocklet);
 
-    const blockletWithEnv = await this.ensureBlocklet(blocklet.meta.did);
+    const blockletWithEnv = await this.getBlocklet(blocklet.meta.did);
     const appSystemEnvironments = getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo);
 
     await didDocument.updateBlockletDocument({
       wallet,
       blockletAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
-      daemonDidDomain: getServerDidDomain(nodeInfo),
+      daemonDidDomain: util.getServerDidDomain(nodeInfo),
       didRegistryUrl: nodeInfo.didRegistry,
       domain: nodeInfo.didDomain,
     });