@abtnode/core 1.8.69-beta-54faead3 → 1.8.69-beta-76f8a46f

package/lib/blocklet/manager/disk.js

@@ -7,33 +7,19 @@ const get = require('lodash/get');
 const merge = require('lodash/merge');
 const pick = require('lodash/pick');
 const cloneDeep = require('lodash/cloneDeep');
-const semver = require('semver');
-const capitalize = require('lodash/capitalize');
-const { Throttle } = require('stream-throttle');
-const LRU = require('lru-cache');
-const joi = require('joi');
 const { isNFTExpired, getNftExpirationDate } = require('@abtnode/util/lib/nft');
 const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
-const { isValid: isValidDid } = require('@arcblock/did');
 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 {
-  WHO_CAN_ACCESS,
-  SERVER_ROLES,
-  WHO_CAN_ACCESS_PREFIX_ROLES,
-  BLOCKLET_INSTALL_TYPE,
-  NODE_MODES,
-} = require('@abtnode/constant');
+const { WHO_CAN_ACCESS, WHO_CAN_ACCESS_PREFIX_ROLES, BLOCKLET_INSTALL_TYPE, NODE_MODES } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const {
-  isFreeBlocklet,
-  isComponentBlocklet,
   isDeletableBlocklet,
   getAppMissingConfigs,
   hasRunnableComponent,
@@ -45,15 +31,10 @@ const {
   getRolesFromAuthConfig,
 } = require('@blocklet/meta/lib/util');
 const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
-const toBlockletDid = require('@blocklet/meta/lib/did');
-const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { titleSchema, updateMountPointSchema, 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;
-
 const {
   BlockletStatus,
   BlockletSource,
@@ -79,7 +60,6 @@ const {
   getFromCache: getAccessibleExternalNodeIp,
 } = require('../../util/get-accessible-external-node-ip');
 const {
-  getBlockletMetaFromUrl,
   getAppSystemEnvironments,
   getComponentSystemEnvironments,
   getAppOverwrittenEnvironments,
@@ -94,45 +74,45 @@ const {
   statusMap,
   pruneBlockletBundle,
   getDiskInfo,
-  getUpdateMetaList,
   getRuntimeEnvironments,
   getTypeFromInstallParams,
-  parseChildrenFromMeta,
-  checkDuplicateComponents,
-  getDiffFiles,
+  parseComponents,
+  filterDuplicateComponents,
   getBundleDir,
-  findAvailableDid,
-  ensureMeta,
   getBlocklet,
   ensureEnvDefault,
   getConfigFromPreferences,
   consumeServerlessNFT,
   validateAppConfig,
-  checkDuplicateAppSk,
   checkDuplicateMountPoint,
   validateStore,
-  validateInServerless,
   isRotatingAppSk,
   isRotatingAppDid,
+  checkVersionCompatibility,
+  getBlockletKnownAs,
 } = require('../../util/blocklet');
-const StoreUtil = require('../../util/store');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
 const { get: getEngine } = require('./engine');
 const blockletPm2Events = require('./pm2-events');
-const { getFactoryState } = require('../../util/chain');
 const runMigrationScripts = require('../migration');
 const hooks = require('../hooks');
-const { formatName, getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
+const { getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
 const handleInstanceInStore = require('../../util/public-to-store');
 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 { installApplicationFromGeneral } = require('./helper/install-application-from-general');
+const { installApplicationFromDev } = require('./helper/install-application-from-dev');
+const { installApplicationFromBackup } = require('./helper/install-application-from-backup');
+const { installComponentFromDev } = require('./helper/install-component-from-dev');
+const { installComponentFromUrl } = require('./helper/install-component-from-url');
+const { installComponentFromUpload, diff } = require('./helper/install-component-from-upload');
+const UpgradeComponents = require('./helper/upgrade-components');
 const BlockletDownloader = require('../downloader/blocklet-downloader');
 const RollbackCache = require('./helper/rollback-cache');
+const { migrateApplicationToStructV2 } = require('./helper/migrate-application-to-struct-v2');
 
 const {
   isInProgress,
@@ -140,7 +120,6 @@ const {
   formatEnvironments,
   shouldUpdateBlockletStatus,
   getBlockletMeta,
-  validateBlockletMeta,
   validateOwner,
 } = util;
 
@@ -183,9 +162,6 @@ const getSkippedProcessIds = ({ newBlocklet, oldBlocklet, context = {} }) => {
   return res;
 };
 
-const getBlockletIndex = (meta, controller) =>
-  controller ? toExternalBlocklet(meta.name, controller.nftId) : { did: meta.did, name: meta.name };
-
 // 10s 上报统计一次
 const MONITOR_RECORD_INTERVAL_SEC = 10;
 
@@ -209,12 +185,6 @@ class BlockletManager extends BaseBlockletManager {
     // cached installed blocklets for performance
     this.cachedBlocklets = null;
 
-    // cached blocklet latest versions from each registries
-    this.cachedBlockletVersions = new LRU({
-      max: 40, // cache at most 40 blocklets
-      maxAge: process.env.NODE_ENV === 'test' ? 500 : 0.5 * 60 * 1000, // cache for 0.5 minute
-    });
-
     this.runtimeMonitor = new BlockletRuntimeMonitor({ historyLength: MONITOR_HISTORY_LENGTH, states });
 
     this.blockletDownloader = new BlockletDownloader({
@@ -232,7 +202,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   // ============================================================================================
-  // Public API that can be call from GQL, should have the same signature: doXXX(params, context)
+  // Public API for Installing/Upgrading Application or Components
   // ============================================================================================
 
   /**
@@ -240,9 +210,6 @@ class BlockletManager extends BaseBlockletManager {
    *
    * @param {{
    *  url: string;
-   *  file: string;
-   *  diffVersion: string;
-   *  deleteSet: Array<string>;
    *  did: string;
    *  title: string;
    *  description: string;
@@ -264,6 +231,13 @@ class BlockletManager extends BaseBlockletManager {
   async install(params, context = {}) {
     logger.debug('install blocklet', { params, context });
 
+    const type = getTypeFromInstallParams(params);
+
+    const { appSk } = params;
+    if (!appSk) {
+      throw new Error('appSk is required');
+    }
+
     if (!params.controller && context?.user?.controller) {
       params.controller = context.user.controller;
     }
@@ -280,40 +254,21 @@ class BlockletManager extends BaseBlockletManager {
     });
     context.downloadTokenList = params.downloadTokenList || [];
 
-    const type = getTypeFromInstallParams(params);
     if (typeof context.startImmediately === 'undefined') {
       context.startImmediately = !!params.startImmediately;
     }
 
-    const { appSk } = params;
-
-    if (type === BLOCKLET_INSTALL_TYPE.URL) {
-      const { url, controller, sync, delay } = params;
-      return this._installFromUrl({ url, controller, sync, delay, appSk }, context);
-    }
-
-    if (type === BLOCKLET_INSTALL_TYPE.UPLOAD) {
-      const { file, did, diffVersion, deleteSet } = params;
-      return this._installFromUpload({ file, did, diffVersion, deleteSet, appSk }, context);
-    }
-
-    if (type === BLOCKLET_INSTALL_TYPE.STORE) {
-      const { did, controller, sync, delay, storeUrl } = params;
-      return this._installFromStore({ did, controller, sync, delay, storeUrl, appSk }, context);
-    }
-
-    if (type === BLOCKLET_INSTALL_TYPE.CREATE) {
-      const { title, description } = params;
-      return this._installFromCreate({ title, description, appSk }, context);
-    }
-
     if (type === BLOCKLET_INSTALL_TYPE.RESTORE) {
       const { url } = params;
-      return this._installFromBackup({ url, appSk }, context);
+      return installApplicationFromBackup({ url, appSk, context, manager: this, states });
+    }
+
+    if ([BLOCKLET_INSTALL_TYPE.URL, BLOCKLET_INSTALL_TYPE.STORE, BLOCKLET_INSTALL_TYPE.CREATE].includes(type)) {
+      return installApplicationFromGeneral({ ...params, type, context, manager: this, states });
     }
 
     // should not be here
-    throw new Error('Unknown type');
+    throw new Error(`install from ${type} is not supported`);
   }
 
   /**
@@ -334,7 +289,6 @@ class BlockletManager extends BaseBlockletManager {
    * @param {String} name custom component name
    *
    * @param {ConfigEntry} configs pre configs
-   * @param {Boolean} skipNavigation
    */
   async installComponent(
     {
@@ -348,8 +302,8 @@ class BlockletManager extends BaseBlockletManager {
       title,
       name,
       configs,
+      sync,
       downloadTokenList,
-      skipNavigation,
     },
     context = {}
   ) {
@@ -363,15 +317,16 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error("Can't install component in serverless-mode server via upload");
       }
 
-      return this._installComponentFromUpload({
+      return installComponentFromUpload({
         rootDid,
         mountPoint,
         file,
         did,
         diffVersion,
         deleteSet,
-        skipNavigation,
         context,
+        states,
+        manager: this,
       });
     }
 
@@ -381,7 +336,7 @@ class BlockletManager extends BaseBlockletManager {
         validateStore(info, url);
       }
 
-      return this._installComponentFromUrl({
+      return installComponentFromUrl({
         rootDid,
         mountPoint,
         url,
@@ -390,8 +345,10 @@ class BlockletManager extends BaseBlockletManager {
         did,
         name,
         configs,
+        sync,
         downloadTokenList,
-        skipNavigation,
+        states,
+        manager: this,
       });
     }
 
@@ -399,57 +356,49 @@ class BlockletManager extends BaseBlockletManager {
     throw new Error('Unknown source');
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async getMetaFromUrl({ url, checkPrice = false }, context) {
-    const meta = await getBlockletMetaFromUrl(url);
-    let isFree = isFreeBlocklet(meta);
+  async diff({ did, hashFiles, rootDid }) {
+    return diff({ did, hashFiles, rootDid, states });
+  }
 
-    if (checkPrice && !isFree && meta.nftFactory) {
-      try {
-        const registryMeta = await StoreUtil.getRegistryMeta(new URL(url).origin);
+  /**
+   * After the dev function finished, the caller should send a BlockletEvents.installed event to the daemon
+   * @returns {Object} blocklet
+   */
+  async dev(folder, { rootDid, mountPoint, defaultStoreUrl } = {}) {
+    logger.info('dev component', { folder, rootDid, mountPoint });
 
-        if (registryMeta.chainHost) {
-          const state = await getFactoryState(registryMeta.chainHost, meta.nftFactory);
-          if (state) {
-            isFree = false;
-          }
-        }
-      } catch (error) {
-        logger.warn('failed when checking if the blocklet is free', { did: meta.did, error });
-      }
+    const meta = getBlockletMeta(folder, { defaultStoreUrl });
+    if (meta.group !== 'static' && (!meta.scripts || !meta.scripts.dev)) {
+      throw new Error('Incorrect blocklet.yml: missing `scripts.dev` field');
     }
 
-    const { inStore, registryUrl } = await StoreUtil.parseSourceUrl(url);
-
-    return { meta, isFree, inStore, registryUrl };
-  }
-
-  async getBlockletByBundle({ did, name, serverlessNftId }, context) {
-    if (toBlockletDid(name) !== did) {
-      throw new Error('did and name does not match');
+    if (!rootDid) {
+      return installApplicationFromDev({ folder, meta, manager: this, states });
     }
 
-    if (!context?.user) {
-      throw new Error('user does not exist');
-    }
+    return installComponentFromDev({ folder, meta, rootDid, mountPoint, manager: this, states });
+  }
 
-    if (context.user.role === SERVER_ROLES.EXTERNAL_BLOCKLET_CONTROLLER && !serverlessNftId) {
-      throw new Error('serverless nft id is required');
-    }
+  async checkComponentsForUpdates({ did }) {
+    return UpgradeComponents.check({ did, states });
+  }
 
-    let blockletDid = did;
-    let isExternal = false;
+  async upgradeComponents({ updateId, selectedComponents: selectedComponentDids }, context = {}) {
+    return UpgradeComponents.upgrade({ updateId, selectedComponentDids, context, states, manager: this });
+  }
 
-    if (serverlessNftId) {
-      blockletDid = toExternalBlocklet(name, serverlessNftId, { didOnly: true });
-      isExternal = true;
-    }
+  async migrateApplicationToStructV2({ did, appSk, context = {} }) {
+    return migrateApplicationToStructV2({ did, appSk, context, manager: this, states });
+  }
 
-    const blocklet = await states.blocklet.getBlocklet(blockletDid);
+  // ============================================================================================
+  // Public API for GQL or internal
+  // ============================================================================================
 
+  async getBlockletForLauncher({ did }) {
+    const blocklet = await states.blocklet.getBlocklet(did);
     const isRunning = blocklet ? blocklet.status === BlockletStatus.running : false;
-
-    return { isInstalled: !!blocklet, isRunning, blockletDid, isExternal };
+    return { did, isInstalled: !!blocklet, isRunning };
   }
 
   async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false }, context) {
@@ -524,7 +473,7 @@ class BlockletManager extends BaseBlockletManager {
       };
 
       if (checkHealthImmediately) {
-        await this.onCheckIfStarted(params, { throwOnError });
+        await this._onCheckIfStarted(params, { throwOnError });
       } else {
         this.startQueue.push({
           entity: 'blocklet',
@@ -662,15 +611,23 @@ class BlockletManager extends BaseBlockletManager {
     const params = await spacesRestore.restore();
 
     this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, message: 'Installing blocklet...' });
-    await this._installFromBackup({
+    await installApplicationFromBackup({
       url: `file://${spacesRestore.restoreDir}`,
       moveDir: true,
       ...merge(...params),
+      manager: this,
+      states,
     });
 
     this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, completed: true });
   }
 
+  /**
+   *
+   * @param {import('@abtnode/client').RequestBlockletInput} param0
+   * @param {Record<string, any>} context
+   * @returns {import('@abtnode/client').BlockletState}
+   */
   async restart({ did }, context) {
     logger.info('restart blocklet', { did });
 
@@ -714,8 +671,9 @@ class BlockletManager extends BaseBlockletManager {
   async delete({ did, keepData, keepLogsDir, keepConfigs }, context) {
     logger.info('delete blocklet', { did, keepData });
 
+    const blocklet = await this.getBlocklet(did);
+
     try {
-      const blocklet = await this.getBlocklet(did);
       if (isDeletableBlocklet(blocklet) === false) {
         throw new Error('Blocklet is protected from accidental deletion');
       }
@@ -785,7 +743,7 @@ class BlockletManager extends BaseBlockletManager {
       // Reset config in db
       await states.blockletExtras.remove({ did: blocklet.meta.did });
       await this._setConfigsFromMeta(did);
-      await this.updateBlockletEnvironment(did);
+      await this._updateBlockletEnvironment(did);
       await this.resetSiteByDid(did, context);
     } else {
       const child = blocklet.children.find((x) => x.meta.did === childDid);
@@ -803,7 +761,7 @@ class BlockletManager extends BaseBlockletManager {
       // Reset config in db
       await states.blockletExtras.delConfigs([blocklet.meta.did, child.meta.did]);
       await this._setConfigsFromMeta(blocklet.meta.did, child.meta.did);
-      await this.updateBlockletEnvironment(did);
+      await this._updateBlockletEnvironment(did);
     }
 
     logger.info('blocklet reset', { did, childDid });
@@ -814,6 +772,7 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('delete blocklet component', { did, rootDid, keepData });
 
     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');
@@ -822,9 +781,9 @@ class BlockletManager extends BaseBlockletManager {
     // delete state
     const doc = await states.blocklet.getBlocklet(rootDid);
     doc.children = doc.children.filter((x) => x.meta.did !== did);
-    const children = (await this._getDynamicChildrenFromSettings(blocklet.meta.did)).filter((x) => x.meta.did !== did);
+    const deletedChildren = await states.blockletExtras.getSettings(did, 'children', []);
     if (keepData !== false && keepState !== false) {
-      children.push({
+      deletedChildren.push({
         meta: pick(child.meta, ['did', 'name', 'bundleDid', 'bundleName', 'version', 'title', 'description']),
         mountPoint: child.mountPoint,
         status: BlockletStatus.deleted,
@@ -833,7 +792,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     await states.blocklet.updateBlocklet(rootDid, doc);
-    states.blockletExtras.setSettings(doc.meta.did, { children });
+    states.blockletExtras.setSettings(doc.meta.did, { children: deletedChildren });
 
     // delete process
     try {
@@ -849,14 +808,6 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('delete blocklet process for deleting component', { did, rootDid, error: err });
     }
 
-    // delete navigation
-    const navigation = await states.blockletExtras.getSettings(blocklet.meta.did, 'navigation', []);
-    await states.blockletExtras.setSettings(
-      blocklet.meta.did,
-      'navigation',
-      navigation.filter((x) => x.child !== blocklet.meta.name)
-    );
-
     // delete storage
     const childBlocklet = blocklet.children.find((x) => x.meta.did === did);
     const { cacheDir, logsDir, dataDir } = childBlocklet.env;
@@ -868,6 +819,9 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const newBlocklet = await this.getBlocklet(rootDid);
+
+    await this._updateDependents(rootDid);
+
     this.emit(BlockletEvents.upgraded, { blocklet: newBlocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
 
     this._createNotification(newBlocklet.meta.did, {
@@ -882,8 +836,7 @@ class BlockletManager extends BaseBlockletManager {
     return newBlocklet;
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async cancelDownload({ did: inputDid }, context) {
+  async cancelDownload({ did: inputDid }) {
     try {
       await statusLock.acquire();
       const blocklet = await states.blocklet.getBlocklet(inputDid);
@@ -1041,6 +994,7 @@ class BlockletManager extends BaseBlockletManager {
   // CAUTION: this method currently only support config by blocklet.meta.did
   // eslint-disable-next-line no-unused-vars
   async config({ did, configs: newConfigs, skipHook, skipDidDocument }, context) {
+    // todo: skipDidDocument will be deleted
     if (!Array.isArray(newConfigs)) {
       throw new Error('configs list is not an array');
     }
@@ -1116,12 +1070,11 @@ class BlockletManager extends BaseBlockletManager {
       this.emit(BlockletEvents.spaceConnected, blocklet);
     }
 
-    // FIXME: @zhenqiang best way to handle the did document: allow all appDids to resolve
     if (willAppDidChange && !skipDidDocument) {
       await this._updateDidDocument(blocklet);
     }
 
-    await this.updateBlockletEnvironment(rootDid);
+    await this._updateBlockletEnvironment(rootDid);
 
     // response
     const newState = await this.getBlocklet(rootDid);
@@ -1224,23 +1177,7 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('component does not exist');
     }
 
-    if (!component.dynamic) {
-      throw new Error('cannot update title of non-dynamic component');
-    }
-
     component.meta.title = title;
-
-    const navigation = await states.blockletExtras.getSettings(rootDid, 'navigation', []);
-    const nav = navigation.find((x) => x.child === component.meta.name);
-
-    if (nav) {
-      nav.title = title;
-    }
-
-    // update db
-    if (nav) {
-      await states.blockletExtras.setSettings(rootDid, { navigation });
-    }
     await states.blocklet.updateBlocklet(rootDid, { children });
 
     // trigger meta.js refresh
@@ -1260,6 +1197,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const rootDid = blocklet.meta.did;
+
     const isRootComponent = !did;
 
     const component = isRootComponent ? blocklet : blocklet.children.find((x) => x.meta.did === did);
@@ -1267,10 +1205,6 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('component does not exist');
     }
 
-    if (!isRootComponent && !component.dynamic) {
-      throw new Error('cannot update mountPoint of non-dynamic component');
-    }
-
     if (isRootComponent && component.group === BlockletGroup.gateway) {
       throw new Error('cannot update mountPoint of gateway blocklet');
     }
@@ -1286,550 +1220,172 @@ class BlockletManager extends BaseBlockletManager {
     return this.getBlocklet(rootDid);
   }
 
-  /**
-   * upgrade blocklet from registry
-   */
-  async upgrade({ did, storeUrl, sync }, context) {
-    const blocklet = await states.blocklet.getBlocklet(did);
-
-    if (!storeUrl && blocklet.source === BlockletSource.url) {
-      return this._installFromUrl({ url: blocklet.deployedFrom }, context);
-    }
-
-    // TODO: 查看了下目前页面中的升级按钮，都是会传 storeUrl 过来的，这个函数里的逻辑感觉需要在以后做一个简化
-    if (!storeUrl && blocklet.source !== BlockletSource.registry) {
-      throw new Error('Wrong upgrade source, empty storeUrl or not installed from blocklet registry');
-    }
-
-    const upgradeFromStore = storeUrl || blocklet.deployedFrom;
-
-    let newVersionMeta = await StoreUtil.getBlockletMeta({
-      did: blocklet.meta.bundleDid,
-      storeUrl: upgradeFromStore,
-    });
-    newVersionMeta = ensureMeta(newVersionMeta, { name: blocklet.meta.name, did: blocklet.meta.did });
-
-    function getSignature(signatures = [], oldSignatures = []) {
-      // if blocklet installed from local, upload, url, the signature is undefined, should return null
-      if (!Array.isArray(signatures) || signatures.length === 0) {
-        return null;
-      }
-      if (signatures.length > 3) {
-        throw new Error('Invalid blocklet signature length');
-      }
-      // if old signature is old registry version, return new signatures last one signature
-      if (oldSignatures.length > 0 && oldSignatures.length < 3) {
-        return signatures[signatures.length - 1];
-      }
-      // old registry signatures: [ registry 签名, developer-sk 签名]
-      // new registry signatures [ registry 签名, user wallet 签名, access-token 签名 ]
-      // old -> old: 需要对比 developer-sk 签名
-      // old -> new: 需要对比 developer-sk 和 access-token 签名
-      // new -> new: 需要对比 user-wallet 签名
-      return signatures.length === 1 ? signatures[0] : signatures[1];
-    }
-
-    const currentDeveloperSignature = getSignature(blocklet.meta.signatures);
-    const newVersionDeveloperSignature = getSignature(newVersionMeta.signatures, blocklet.meta.signatures);
-
-    if (!newVersionDeveloperSignature) {
-      throw new Error('Invalid upgrade blocklet signature');
-    }
-
-    if (
-      currentDeveloperSignature &&
-      blocklet.source === BlockletSource.registry &&
-      (currentDeveloperSignature.signer !== newVersionDeveloperSignature.signer ||
-        currentDeveloperSignature.pk !== newVersionDeveloperSignature.pk)
-    ) {
-      logger.error('invalid developer signature', { did, currentDeveloperSignature, newVersionDeveloperSignature });
-      throw new Error('Invalid developer signature');
-    }
-
-    if (blocklet.meta.version === newVersionMeta.version) {
-      throw new Error('Upgrade/downgrade blocklet to same version is noop');
-    }
+  // eslint-disable-next-line no-unused-vars
+  async getRuntimeHistory({ did, hours }, context) {
+    const metaDid = await states.blocklet.getBlockletMetaDid(did);
 
-    const action = semver.gt(blocklet.meta.version, newVersionMeta.version) ? 'downgrade' : 'upgrade';
-    logger.info(`${action} blocklet`, { did });
+    const history = this.runtimeMonitor.getHistory(metaDid);
 
-    return this._upgrade({
-      meta: newVersionMeta,
-      source: BlockletSource.registry,
-      deployedFrom: upgradeFromStore,
-      context,
-      sync,
+    return getHistoryList({
+      history,
+      hours,
+      recordIntervalSec: MONITOR_RECORD_INTERVAL_SEC,
+      props: ['date', 'cpu', 'mem'],
     });
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async diff({ did, hashFiles: clientFiles, rootDid: inputRootDid }, context) {
-    if (!did) {
-      throw new Error('did is empty');
-    }
-
-    if (!clientFiles || !clientFiles.length) {
-      throw new Error('hashFiles is empty');
-    }
-
-    const rootDid = inputRootDid || did;
-    const childDid = inputRootDid ? did : '';
+  async ensureBlocklet(did, opts = {}) {
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: true });
+  }
 
-    if (childDid === rootDid) {
-      throw new Error('Cannot add self as a component');
-    }
+  async getBlocklet(did, opts = {}) {
+    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
+  }
 
-    logger.info('Get blocklet diff', { rootDid, childDid, clientFilesNumber: clientFiles.length });
+  async hasBlocklet({ did }) {
+    return states.blocklet.hasBlocklet(did);
+  }
 
-    const rootBlocklet = await states.blocklet.getBlocklet(rootDid);
-    if (childDid && !rootBlocklet) {
-      throw new Error('Root blocklet does not exist');
+  async setInitialized({ did, owner }) {
+    if (!validateOwner(owner)) {
+      throw new Error('Blocklet owner is invalid');
     }
 
-    const state = childDid ? await (rootBlocklet.children || []).find((x) => x.meta.did === childDid) : rootBlocklet;
+    const blocklet = await states.blocklet.getBlocklet(did);
+    await states.blockletExtras.setSettings(blocklet.meta.did, { initialized: true, owner });
+    logger.info('Blocklet initialized', { did, owner });
 
-    if (!state) {
-      return {
-        hasBlocklet: false,
-      };
-    }
+    this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
 
-    if (state.source === BlockletSource.local) {
-      throw new Error(`Blocklet ${state.meta.name} is already deployed from local, can not deployed from remote.`);
-    }
+    return this.getBlocklet(did);
+  }
 
-    const { version } = state.meta;
-    const bundleDir = getBundleDir(this.installDir, state.meta);
-    const { addSet, changeSet, deleteSet } = await getDiffFiles(clientFiles, bundleDir);
+  async status(did, { forceSync = false } = {}) {
+    const fastReturnOnForceSync = async (blocklet = {}) => {
+      const { status } = blocklet;
+      const { added, waiting, downloading, installing, installed, upgrading } = BlockletStatus;
 
-    logger.info('Diff files', {
-      name: state.meta.name,
-      did: state.meta.did,
-      version: state.meta.version,
-      addNum: addSet.length,
-      changeNum: changeSet.length,
-      deleteNum: deleteSet.length,
-    });
+      if ([added, waiting, downloading, installing, installed, upgrading].includes(status)) {
+        return blocklet;
+      }
 
-    return {
-      hasBlocklet: true,
-      version,
-      addSet,
-      changeSet,
-      deleteSet,
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
+      this.emit(BlockletEvents.statusChange, res);
+      return res;
     };
-  }
 
-  async checkChildrenForUpdates({ did }) {
-    const blocklet = await states.blocklet.getBlocklet(did);
-
-    const newChildren = [];
+    const blocklet = await this.getBlocklet(did);
 
-    for (const child of blocklet.children || []) {
-      if (child.bundleSource) {
-        const config = {
-          source: child.bundleSource,
-          name: child.meta.name,
-          title: child.meta.title,
-          mountPoint: child.mountPoint,
-        };
-        newChildren.push(...(await parseChildrenFromMeta([config], { dynamic: child.dynamic })));
-      } else {
-        newChildren.push({
-          ...child,
-          children: await parseChildrenFromMeta(child.meta),
-        });
+    let shouldUpdateStatus = forceSync || shouldUpdateBlockletStatus(blocklet.status);
+    if (isInProgress(blocklet.status)) {
+      const uptime = Date.now() - new Date(blocklet.updatedAt).getTime();
+      // if uptime great than 30s, sync the status from pm2
+      if (uptime > 30 * 1000) {
+        shouldUpdateStatus = true;
       }
     }
 
-    checkDuplicateComponents(newChildren);
+    if (!shouldUpdateStatus) {
+      return blocklet;
+    }
 
-    const updateList = getUpdateMetaList(blocklet, { ...blocklet, children: newChildren });
+    try {
+      const status = await getBlockletStatusFromProcess(blocklet);
+      if (blocklet.status !== status) {
+        const res = await states.blocklet.setBlockletStatus(did, status);
+        this.emit(BlockletEvents.statusChange, res);
+        return res;
+      }
 
-    if (!updateList.length) {
-      return {};
+      return blocklet;
+    } catch (err) {
+      return fastReturnOnForceSync(blocklet);
     }
+  }
 
-    // start session
-    const { id: updateId } = await states.session.start({
-      did,
-      children: newChildren,
+  async refreshListCache() {
+    this.list({ useCache: false }).catch((err) => {
+      logger.error('refresh blocklet list failed', { error: err });
     });
-
-    return {
-      updateId,
-      updateList,
-    };
   }
 
-  async updateChildren(
-    {
-      updateId,
-      did: inputDid,
-      children: inputChildren,
-      oldBlocklet: inputOldBlocklet,
-      selectedComponents: selectedComponentDids,
-    },
-    context
-  ) {
-    let did;
-    let children;
-    let oldBlocklet;
-    if (!updateId && inputDid && inputChildren) {
-      did = inputDid;
-      children = inputChildren;
-      oldBlocklet = inputOldBlocklet;
-    } else {
-      const sessionData = await states.session.end(updateId);
-      did = sessionData.did;
-      oldBlocklet = await this._getBlockletForInstallation(did);
-
-      if (selectedComponentDids && selectedComponentDids.length) {
-        children = cloneDeep(oldBlocklet.children).map((oldComponent) => {
-          const newComponent = sessionData.children.find((x) => x.meta.did === oldComponent.meta.did);
-          if (newComponent && selectedComponentDids.includes(newComponent.meta.did)) {
-            return newComponent;
-          }
-          return oldComponent;
-        });
-      } else {
-        children = sessionData.children;
-      }
+  async updateAllBlockletEnvironment() {
+    const blocklets = await states.blocklet.getBlocklets();
+    for (let i = 0; i < blocklets.length; i++) {
+      const blocklet = blocklets[i];
+      await this._updateBlockletEnvironment(blocklet.meta.did);
     }
+  }
 
-    // get old blocklet
-    const { meta } = oldBlocklet;
-    const { name, version } = meta;
-
-    const action = 'upgrade';
-
-    logger.info(`${action} blocklet children`, {
-      did,
-      name,
-      version,
-      children: children.map((x) => ({ name: x.meta.name, version: x.meta.version })),
-    });
-
-    // new blocklet
-    const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
-
-    newBlocklet.children = children;
-    await validateBlocklet(newBlocklet);
-
-    this.emit(BlockletEvents.statusChange, newBlocklet);
-
-    // backup rollback data
-    await this._rollbackCache.backup({ did, action, oldBlocklet });
-
-    // add to queue
-    const ticket = this.installQueue.push(
-      {
-        entity: 'blocklet',
-        action: 'download',
-        id: did,
-        oldBlocklet: { ...oldBlocklet },
-        blocklet: { ...newBlocklet },
-        selectedComponentDids: selectedComponentDids || [],
-        version,
-        context,
-        postAction: action,
-      },
-      did
-    );
-
-    ticket.on('failed', async (err) => {
-      logger.error('queue failed', { entity: 'blocklet', action, did, version, name, error: err });
-      await this._rollback(action, did, oldBlocklet);
-      this.emit(`blocklet.${action}.failed`, { did, version, err });
-      this._createNotification(did, {
-        title: `Blocklet ${capitalize(action)} Failed`,
-        description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message || 'queue exception'}`,
-        entityType: 'blocklet',
-        entityId: did,
-        severity: 'error',
-      });
+  async prune() {
+    const blocklets = await states.blocklet.getBlocklets();
+    const settings = await states.blockletExtras.listSettings();
+    await pruneBlockletBundle({
+      installDir: this.dataDirs.blocklets,
+      blocklets,
+      blockletSettings: settings
+        .filter((x) => x.settings.children && x.settings.children.length)
+        .map((x) => x.settings),
     });
-    return newBlocklet;
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async getRuntimeHistory({ did, hours }, context) {
-    const metaDid = await states.blocklet.getBlockletMetaDid(did);
-
-    const history = this.runtimeMonitor.getHistory(metaDid);
+  async onJob(job) {
+    if (job.entity === 'blocklet') {
+      if (job.action === 'download') {
+        await this._downloadAndInstall(job);
+      }
+      if (job.action === 'restart') {
+        await this._onRestart(job);
+      }
 
-    return getHistoryList({
-      history,
-      hours,
-      recordIntervalSec: MONITOR_RECORD_INTERVAL_SEC,
-      props: ['date', 'cpu', 'mem'],
-    });
+      if (job.action === 'check_if_started') {
+        await this._onCheckIfStarted(job);
+      }
+    }
   }
 
-  // ============================================================================================
-  // Internal API that are used by public APIs and called from CLI
-  // ============================================================================================
-
-  /**
-   * After the dev function finished, the caller should send a BlockletEvents.installed event to the daemon
-   * @returns {Object} blocklet
-   */
-  async dev(folder, { rootDid, mountPoint, defaultStoreUrl } = {}) {
-    logger.info('dev component', { folder, rootDid, mountPoint });
-
-    const meta = getBlockletMeta(folder, { defaultStoreUrl });
-    if (meta.group !== 'static' && (!meta.scripts || !meta.scripts.dev)) {
-      throw new Error('Incorrect blocklet.yml: missing `scripts.dev` field');
-    }
-
-    if (rootDid) {
-      return this._devComponent({ folder, meta, rootDid, mountPoint });
-    }
-
-    return this._devBlocklet({ folder, meta });
-  }
-
-  async _devBlocklet({ folder, meta }) {
-    const { did, version } = meta;
-
-    const exist = await states.blocklet.getBlocklet(did);
-    if (exist) {
-      if (exist.mode === BLOCKLET_MODES.PRODUCTION) {
-        throw new Error('The blocklet of production mode already exists, please remove it before developing');
-      }
-
-      const status = fromBlockletStatus(exist.status);
-      if (['starting', 'running'].includes(status)) {
-        throw new Error(`The blocklet is already on ${status}, please stop it before developing`);
-      }
-
-      logger.info('remove blocklet for dev', { did, version });
-
-      await this.delete({ did, keepLogsDir: false });
-    }
-
-    // delete process
-    try {
-      await this.deleteProcess({ did });
-      logger.info('delete blocklet precess for dev', { did, version });
-    } catch (err) {
-      if (process.env.NODE_ENV !== 'development') {
-        logger.error('failed to delete blocklet process for dev', { error: err });
-      }
-    }
-
-    const children = await this._getChildrenForInstallation(meta);
-    await validateBlocklet({ meta, children });
-    const added = await states.blocklet.addBlocklet({
-      meta,
-      source: BlockletSource.local,
-      deployedFrom: folder,
-      mode: BLOCKLET_MODES.DEVELOPMENT,
-      children,
-    });
-    logger.info('add blocklet for dev', { did, version, meta });
-
-    await this._downloadBlocklet(added);
-
-    // Add Config
-    await this._setConfigsFromMeta(did);
-
-    // should ensure blocklet integrity
-    let blocklet = await this.ensureBlocklet(did);
-
-    // pre install
-    await this._runPreInstallHook(blocklet);
-
-    // Add environments
-    await this.updateBlockletEnvironment(did);
-    blocklet = await this.getBlocklet(did);
-
-    // post install
-    await this._runPostInstallHook(blocklet);
-
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
-
-    blocklet = await this.getBlocklet(did);
-
-    await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
-
-    return blocklet;
-  }
-
-  async _devComponent({ folder, meta, rootDid, mountPoint, skipNavigation = true }) {
-    const { did, version } = meta;
-
-    const existRoot = await states.blocklet.getBlocklet(rootDid);
-    if (!existRoot) {
-      throw new Error('Root blocklet does not exist');
-    }
-
-    const exist = existRoot.children.find((x) => x.meta.did === meta.did);
-    if (exist) {
-      if (exist.mode === BLOCKLET_MODES.PRODUCTION) {
-        throw new Error('The blocklet component of production mode already exists, please remove it before developing');
-      }
-
-      const status = fromBlockletStatus(exist.status);
-      if (['starting', 'running'].includes(status)) {
-        throw new Error(`The blocklet component is already on ${status}, please stop it before developing`);
-      }
-
-      logger.info('remove blocklet component for dev', { did, version });
-
-      await this.deleteComponent({ did, rootDid });
-    }
-
-    const defaultPath = formatName(meta.name);
-    const component = {
-      meta: ensureMeta(meta),
-      mountPoint: mountPoint || `/${defaultPath}`,
-      source: BlockletSource.local,
-      deployedFrom: folder,
-      status: BlockletStatus.installed,
-      mode: BLOCKLET_MODES.DEVELOPMENT,
-      dynamic: true,
-      children: await parseChildrenFromMeta(meta, { ancestors: [{ mountPoint: mountPoint || `/${defaultPath}` }] }),
-    };
-    await validateBlocklet(component);
-    await states.blocklet.addChildren(rootDid, [component]);
-
-    const newBlocklet = await states.blocklet.getBlocklet(rootDid);
-    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
-    await this._runPreInstallHook(blocklet);
-
-    // Add environments
-    await this.updateBlockletEnvironment(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.getBlocklet(rootDid);
-
-    return blocklet;
-  }
-
-  /**
-   * backup 目录结构
-   *  /blocklets/<name1>version>
-   *  /blocklets/<name2>version>
-   *  /blocklets/<name3>version>
-   *  /data
-   *  /blocklet.json
-   *  /blocklet_extras.json
-   * @see Blocklet 端到端备份方案的设计与实现（一期） https://team.arcblock.io/comment/discussions/e62084d5-fafa-489e-91d5-defcd6e93223
-   * @param {{ url: string, appSk: string, moveDir: boolean}} [{ url }={}]
-   * @param {Record<string, string>} [context={}]
-   * @return {Promise<any>}
-   * @memberof BlockletManager
-   */
-  async _installFromBackup({ url, appSk, moveDir } = {}, context = {}) {
-    return installFromBackup({ url, appSk, moveDir, context, manager: this, states });
-  }
-
-  async ensureBlocklet(did, opts = {}) {
-    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 }) {
-    return states.blocklet.hasBlocklet(did);
-  }
-
-  async setInitialized({ did, owner }) {
-    if (!validateOwner(owner)) {
-      throw new Error('Blocklet owner is invalid');
-    }
-
-    const blocklet = await states.blocklet.getBlocklet(did);
-    await states.blockletExtras.setSettings(blocklet.meta.did, { initialized: true, owner });
-    logger.info('Blocklet initialized', { did, owner });
-
-    this.emit(BlockletEvents.updated, { meta: { did: blocklet.meta.did } });
-
-    return this.getBlocklet(did);
-  }
-
-  async status(did, { forceSync = false } = {}) {
-    const fastReturnOnForceSync = async (blocklet = {}) => {
-      const { status } = blocklet;
-      const { added, waiting, downloading, installing, installed, upgrading } = BlockletStatus;
-
-      if ([added, waiting, downloading, installing, installed, upgrading].includes(status)) {
-        return blocklet;
-      }
-
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-      this.emit(BlockletEvents.statusChange, res);
-      return res;
-    };
-
-    const blocklet = await this.getBlocklet(did);
-
-    let shouldUpdateStatus = forceSync || shouldUpdateBlockletStatus(blocklet.status);
-    if (isInProgress(blocklet.status)) {
-      const uptime = Date.now() - new Date(blocklet.updatedAt).getTime();
-      // if uptime great than 30s, sync the status from pm2
-      if (uptime > 30 * 1000) {
-        shouldUpdateStatus = true;
-      }
-    }
-
-    if (!shouldUpdateStatus) {
-      return blocklet;
-    }
-
-    try {
-      const status = await getBlockletStatusFromProcess(blocklet);
-      if (blocklet.status !== status) {
-        const res = await states.blocklet.setBlockletStatus(did, status);
-        this.emit(BlockletEvents.statusChange, res);
-        return res;
-      }
-
-      return blocklet;
-    } catch (err) {
-      return fastReturnOnForceSync(blocklet);
-    }
-  }
-
-  async refreshListCache() {
-    this.list({ useCache: false }).catch((err) => {
-      logger.error('refresh blocklet list failed', { error: err });
-    });
+  getCrons() {
+    return [
+      {
+        name: 'sync-blocklet-status',
+        time: '*/60 * * * * *', // 60s
+        fn: this._syncBlockletStatus.bind(this),
+      },
+      {
+        name: 'sync-blocklet-list',
+        time: '*/60 * * * * *', // 60s
+        fn: this.refreshListCache.bind(this),
+      },
+      {
+        name: 'refresh-accessible-ip',
+        time: '0 */10 * * * *', // 10min
+        fn: async () => {
+          const nodeInfo = await states.node.read();
+          await refreshAccessibleExternalNodeIp(nodeInfo);
+        },
+      },
+      {
+        name: 'delete-expired-external-blocklet',
+        time: '0 */30 * * * *', // 30min
+        options: { runOnInit: false },
+        fn: () => this._deleteExpiredExternalBlocklet(),
+      },
+      {
+        name: 'clean-expired-blocklet-data',
+        time: '0 */20 0 * * *', // 每天凌晨 0 点的每 20 分钟
+        fn: () => this._cleanExpiredBlockletData(),
+      },
+      {
+        name: 'record-blocklet-runtime-history',
+        time: `*/${MONITOR_RECORD_INTERVAL_SEC} * * * * *`, // 10s
+        fn: () => this.runtimeMonitor.monitAll(),
+      },
+    ];
   }
 
-  async onJob(job) {
-    if (job.entity === 'blocklet') {
-      if (job.action === 'download') {
-        await this.downloadAndInstall(job);
-      }
-      if (job.action === 'restart') {
-        await this.onRestart(job);
-      }
-
-      if (job.action === 'check_if_started') {
-        await this.onCheckIfStarted(job);
-      }
-    }
-  }
+  // ============================================================================================
+  // Private API that are used by self of helper function
+  // ============================================================================================
 
   /**
    *
@@ -1837,7 +1393,7 @@ class BlockletManager extends BaseBlockletManager {
    * @param {{
    *  blocklet: {},
    *  context: {},
-   *  postAction: 'install' | 'upgrade' | 'downgrade',
+   *  postAction: 'install' | 'upgrade',
    *  oldBlocklet: {},
    *  throwOnError: Error,
    *  skipCheckStatusBeforeDownload: boolean,
@@ -1846,7 +1402,7 @@ class BlockletManager extends BaseBlockletManager {
    * @return {*}
    * @memberof BlockletManager
    */
-  async downloadAndInstall(params) {
+  async _downloadAndInstall(params) {
     const {
       blocklet,
       context,
@@ -1963,7 +1519,7 @@ class BlockletManager extends BaseBlockletManager {
         this.emit(BlockletEvents.statusChange, state);
       }
 
-      if (['upgrade', 'downgrade'].includes(postAction)) {
+      if (postAction === 'upgrade') {
         const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading);
         this.emit(BlockletEvents.statusChange, state);
       }
@@ -1978,13 +1534,13 @@ class BlockletManager extends BaseBlockletManager {
     try {
       // install blocklet
       if (postAction === 'install') {
-        await this.onInstall({ blocklet, context, oldBlocklet });
+        await this._onInstall({ blocklet, context, oldBlocklet });
         return;
       }
 
       // upgrade blocklet
-      if (['upgrade', 'downgrade'].includes(postAction)) {
-        await this.onUpgrade({ oldBlocklet, newBlocklet: blocklet, action: postAction, context });
+      if (postAction === 'upgrade') {
+        await this._onUpgrade({ oldBlocklet, newBlocklet: blocklet, context });
       }
     } catch (error) {
       if (throwOnError) {
@@ -1993,7 +1549,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async onInstall({ blocklet, context, oldBlocklet }) {
+  async _onInstall({ blocklet, context, oldBlocklet }) {
     const { meta } = blocklet;
     const { did, version } = meta;
     logger.info('do install blocklet', { did, version });
@@ -2021,9 +1577,9 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async onUpgrade({ oldBlocklet, newBlocklet, action, context }) {
+  async _onUpgrade({ oldBlocklet, newBlocklet, context }) {
     const { version, did } = newBlocklet.meta;
-    logger.info(`do ${action} blocklet`, { did, version });
+    logger.info('do upgrade blocklet', { did, version });
 
     try {
       await this._upgradeBlocklet({
@@ -2036,12 +1592,12 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async onRestart({ did, context }) {
+  async _onRestart({ did, context }) {
     await this.stop({ did, updateStatus: false }, context);
     await this.start({ did }, context);
   }
 
-  async onCheckIfStarted(jobInfo, { throwOnError } = {}) {
+  async _onCheckIfStarted(jobInfo, { throwOnError } = {}) {
     const { did, context, minConsecutiveTime = 5000, timeout } = jobInfo;
     const blocklet = await this.getBlocklet(did);
 
@@ -2083,7 +1639,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async updateBlockletEnvironment(did) {
+  async _updateBlockletEnvironment(did) {
     const blockletWithEnv = await this.getBlocklet(did);
     const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
@@ -2111,628 +1667,25 @@ class BlockletManager extends BaseBlockletManager {
       const childWithEnv = envMap[id];
       if (childWithEnv) {
         child.environments = formatEnvironments({
-          ...getComponentSystemEnvironments(childWithEnv), // system env of child blocklet
-          ...appSystemEnvironments, // system env of root blocklet
-        });
-      }
-    });
-
-    // put BLOCKLET_APP_ID at root level for indexing
-    blocklet.appDid = appSystemEnvironments.BLOCKLET_APP_ID;
-
-    if (!Array.isArray(blocklet.migratedFrom)) {
-      blocklet.migratedFrom = [];
-    }
-    // This can only be set once, can be used for indexing, will not change ever
-    if (!blocklet.appPid) {
-      blocklet.appPid = appSystemEnvironments.BLOCKLET_APP_PID;
-    }
-
-    // update state to db
-    return states.blocklet.updateBlocklet(did, blocklet);
-  }
-
-  async updateAllBlockletEnvironment() {
-    const blocklets = await states.blocklet.getBlocklets();
-    for (let i = 0; i < blocklets.length; i++) {
-      const blocklet = blocklets[i];
-      await this.updateBlockletEnvironment(blocklet.meta.did);
-    }
-  }
-
-  /**
-   ***
-   *
-   * @param {{
-   *  did: string;
-   *  sync: boolean;
-   *  delay: number;
-   *  controller: Controller;
-   *  appSk: string;
-   *  storeUrl: string;
-   * }} params
-   * @param {*} context
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _installFromStore(params, context) {
-    const { did, storeUrl, sync, delay, controller, appSk } = params;
-
-    logger.debug('start install blocklet', { did });
-    if (!isValidDid(did)) {
-      throw new Error('Blocklet did is invalid');
-    }
-
-    if (!storeUrl) {
-      throw new Error('registry url should not be empty');
-    }
-
-    const info = await StoreUtil.getRegistryMeta(storeUrl);
-    const meta = await StoreUtil.getBlockletMeta({ did, storeUrl });
-    if (!meta) {
-      throw new Error('Can not install blocklet that not found in registry');
-    }
-
-    const { did: blockletDid, name: blockletName } = getBlockletIndex(meta, controller);
-
-    const state = await states.blocklet.getBlocklet(blockletDid);
-
-    if (state) {
-      throw new Error('Can not install an already installed blocklet');
-    }
-
-    if (controller?.nftId) {
-      // sometimes nedb will throw error if use states.blocklet.count({ ['controller.nftId']: controller.nftId })
-      const installedCount = await states.blockletExtras.count({ 'controller.nftId': controller.nftId });
-
-      if (installedCount >= (controller.appMaxCount || 1)) {
-        throw new Error(
-          `You can only install ${controller.appMaxCount} blocklet with this credential: ${controller.nftId}`
-        );
-      }
-    }
-
-    // install
-    return this._install({
-      meta: ensureMeta(meta, { did: blockletDid, name: blockletName }),
-      source: BlockletSource.registry,
-      deployedFrom: info.cdnUrl || storeUrl,
-      sync,
-      delay,
-      controller,
-      appSk,
-      context,
-    });
-  }
-
-  /**
-   * @type {{
-   *  id: string;
-   *  nftId: string;
-   *  expireDate: Date;
-   * }} Controller
-   *
-   * @param {{
-   *  url: string;
-   *  sync: boolean;
-   *  delay: number;
-   *  controller: Controller;
-   *  appSk: string;
-   * }} params
-   * @param {{}} context
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _installFromUrl(params, context) {
-    const { url, sync, delay, controller, appSk } = params;
-
-    logger.debug('start install blocklet', { url });
-
-    const bundleMeta = await getBlockletMetaFromUrl(url);
-
-    if (!bundleMeta) {
-      throw new Error(`Can not install blocklet that not found by url: ${url}`);
-    }
-
-    const { did: blockletDid, name: blockletName } = getBlockletIndex(bundleMeta, controller);
-
-    // install from store if url is a store url
-    const { inStore, registryUrl, blockletDid: bundleDid } = await StoreUtil.parseSourceUrl(url, controller);
-
-    const nodeInfo = await states.node.read();
-
-    await validateStore(nodeInfo, registryUrl);
-
-    if (inStore) {
-      const exist = await states.blocklet.getBlocklet(blockletDid);
-      if (exist) {
-        return this.upgrade({ did: blockletDid, storeUrl: registryUrl, sync, delay }, context);
-      }
-
-      return this._installFromStore({ did: bundleDid, storeUrl: registryUrl, controller, sync, delay, appSk }, context);
-    }
-
-    const meta = ensureMeta(bundleMeta, { name: blockletName, did: blockletDid });
-
-    // upgrade
-    const exist = await states.blocklet.getBlocklet(blockletDid);
-    if (exist) {
-      return this._upgrade({
-        meta,
-        source: BlockletSource.url,
-        deployedFrom: url,
-        sync,
-        delay,
-        context,
-      });
-    }
-
-    // install
-    return this._install({
-      meta,
-      source: BlockletSource.url,
-      deployedFrom: url,
-      sync,
-      delay,
-      controller,
-      appSk,
-      context,
-    });
-  }
-
-  async _installComponentFromUrl({
-    rootDid,
-    mountPoint,
-    url,
-    context,
-    title,
-    name: inputName,
-    did: inputDid,
-    configs,
-    downloadTokenList,
-    skipNavigation,
-  }) {
-    const blocklet = await this._getBlockletForInstallation(rootDid);
-    if (!blocklet) {
-      throw new Error('Root blocklet does not exist');
-    }
-
-    const { inStore } = await StoreUtil.parseSourceUrl(url);
-
-    const meta = await getBlockletMetaFromUrl(url);
-
-    // 如果是一个付费的blocklet,并且url来源为Store, 需要携带token才能下载成功
-    if (!isFreeBlocklet(meta) && inStore) {
-      const info = await states.node.read();
-
-      // eslint-disable-next-line no-param-reassign
-      context = {
-        ...context,
-        headers: {
-          'x-server-did': info.did,
-          'x-server-public-key': info.pk,
-          'x-server-signature': sign(info.did, info.sk, {
-            exp: (Date.now() + 5 * 60 * 1000) / 1000,
-          }),
-        },
-        downloadTokenList: downloadTokenList || [],
-      };
-    }
-
-    if (!isComponentBlocklet(meta)) {
-      throw new Error('The blocklet cannot be a component');
-    }
-
-    if (title) {
-      meta.title = await titleSchema.validateAsync(title);
-    }
-
-    let name = inputName;
-    let did = inputDid;
-    if (!inputName && !inputDid) {
-      const found = findAvailableDid(meta, [
-        ...blocklet.children.map((x) => x.meta),
-        ...(await states.blockletExtras.getSettings(blocklet.meta.did, 'children', [])).map((x) => x.meta),
-      ]);
-      name = found.name;
-      did = found.did;
-    }
-
-    const newChild = {
-      meta: ensureMeta(meta, { did, name }),
-      mountPoint,
-      bundleSource: { url },
-      dynamic: true,
-      children: await parseChildrenFromMeta(meta, { ...context, ancestors: [{ mountPoint }] }),
-    };
-
-    checkDuplicateComponents([...blocklet.children, newChild]);
-
-    try {
-      // add component to db
-      await states.blocklet.addChildren(rootDid, [newChild]);
-
-      // update navigation
-      await this._upsertDynamicNavigation(blocklet.meta.did, newChild, { skipNavigation });
-
-      // update configs
-      if (Array.isArray(configs)) {
-        if (hasReservedKey(configs)) {
-          throw new Error('Component key of environments can not start with `ABT_NODE_` or `BLOCKLET_`');
-        }
-
-        await states.blockletExtras.setConfigs([blocklet.meta.did, newChild.meta.did], configs);
-      }
-    } catch (err) {
-      logger.error('Add component failed', err);
-      await this._rollback('upgrade', rootDid, blocklet);
-      throw err;
-    }
-
-    return this.updateChildren(
-      {
-        did: rootDid,
-        children: [...blocklet.children, newChild],
-        oldBlocklet: blocklet,
-        selectedComponents: [newChild.meta.did],
-      },
-      context
-    );
-  }
-
-  async _installFromCreate({ title, description, appSk }, context = {}) {
-    logger.debug('create blocklet', { title, description });
-
-    await joi.string().label('title').max(20).required().validateAsync(title);
-    await joi.string().label('description').max(80).required().validateAsync(description);
-
-    const { did, name } = await this._findNextCustomBlockletName();
-    const rawMeta = {
-      name,
-      did,
-      title,
-      description,
-      version: BLOCKLET_DEFAULT_VERSION,
-      group: BlockletGroup.gateway,
-      interfaces: [
-        {
-          type: BLOCKLET_INTERFACE_TYPE_WEB,
-          name: BLOCKLET_INTERFACE_PUBLIC,
-          path: BLOCKLET_DEFAULT_PATH_REWRITE,
-          prefix: BLOCKLET_DYNAMIC_PATH_PREFIX,
-          port: BLOCKLET_DEFAULT_PORT_NAME,
-          protocol: BLOCKLET_INTERFACE_PROTOCOL_HTTP,
-        },
-      ],
-      specVersion: BLOCKLET_LATEST_SPEC_VERSION,
-    };
-    const meta = validateMeta(rawMeta);
-
-    await states.blocklet.addBlocklet({ meta, source: BlockletSource.custom, externalSk: !!appSk });
-    await this._setConfigsFromMeta(did);
-    await this._setAppSk(did, appSk);
-
-    // check duplicate appSk
-    await checkDuplicateAppSk({ did, states });
-
-    // fake install bundle
-    const bundleDir = getBundleDir(this.installDir, meta);
-    fs.mkdirSync(bundleDir, { recursive: true });
-    updateMetaFile(path.join(bundleDir, BLOCKLET_META_FILE), meta);
-
-    return this._installBlocklet({ did, context });
-  }
-
-  async _downloadFromUpload(file) {
-    // const { filename, mimetype, encoding, createReadStream } = await file;
-    const { filename, createReadStream } = await file;
-    const cwd = path.join(this.dataDirs.tmp, 'download');
-    const tarFile = path.join(cwd, `${path.basename(filename, path.extname(filename))}.tgz`);
-    await fs.ensureDir(cwd);
-    await new Promise((resolve, reject) => {
-      const readStream = createReadStream();
-      const writeStream = fs.createWriteStream(tarFile);
-      readStream
-        .pipe(new Throttle({ rate: 1024 * 1024 * 20 })) // 20MB
-        .pipe(writeStream);
-      readStream.on('error', (error) => {
-        logger.error('File upload read stream failed', { error });
-        writeStream.destroy(new Error(`File upload read stream failed, ${error.message}`));
-      });
-      writeStream.on('error', (error) => {
-        logger.error('File upload write stream failed', { error });
-        fs.removeSync(tarFile);
-        reject(error);
-      });
-      writeStream.on('finish', resolve);
-    });
-
-    return { cwd, tarFile };
-  }
-
-  async _installFromUpload({ file, did, diffVersion, deleteSet, appSk }, context) {
-    logger.info('install blocklet', { from: 'upload file' });
-    const { tarFile } = await this._downloadFromUpload(file);
-
-    // diff deploy
-    if (did && diffVersion) {
-      const oldBlocklet = await this._getBlockletForInstallation(did);
-      if (!oldBlocklet) {
-        throw new Error(`Blocklet ${did} not found when diff deploying`);
-      }
-      if (oldBlocklet.meta.version !== diffVersion) {
-        logger.error('Diff deploy: Blocklet version changed', {
-          preVersion: diffVersion,
-          changedVersion: oldBlocklet.meta.version,
-          name: oldBlocklet.meta.name,
-          did: oldBlocklet.meta.did,
-        });
-        throw new Error('Blocklet version changed when diff deploying');
-      }
-      if (isInProgress(oldBlocklet.status)) {
-        logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-        throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-      }
-
-      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);
-
-      // backup rollback data
-      const action = 'upgrade';
-      await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
-
-      await this.downloadAndInstall({
-        blocklet: newBlocklet,
-        oldBlocklet,
-        context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
-        throwOnError: true,
-        postAction: action,
-        skipCheckStatusBeforeDownload: true,
-      });
-      return this.getBlocklet(newBlocklet.meta.did);
-    }
-
-    // full deploy
-    const { meta } = await resolveDownload(tarFile, this.installDir);
-    const oldBlocklet = await this._getBlockletForInstallation(meta.did);
-
-    // full deploy - upgrade
-    if (oldBlocklet) {
-      if (isInProgress(oldBlocklet.status)) {
-        logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-        throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-      }
-
-      const newBlocklet = await states.blocklet.getBlocklet(meta.did);
-      newBlocklet.meta = ensureMeta(meta);
-      newBlocklet.source = BlockletSource.upload;
-      newBlocklet.deployedFrom = `Upload by ${context.user.fullName}`;
-      newBlocklet.children = await this._getChildrenForInstallation(meta);
-
-      // backup rollback data
-      const action = 'upgrade';
-      await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
-
-      await validateBlocklet(newBlocklet);
-      await this.downloadAndInstall({
-        blocklet: newBlocklet,
-        oldBlocklet,
-        context: { ...context, forceStartProcessIds: [getComponentProcessId(newBlocklet)] },
-        throwOnError: true,
-        postAction: action,
-        skipCheckStatusBeforeDownload: true,
-      });
-      return this.getBlocklet(newBlocklet.meta.did);
-    }
-
-    // full deploy - install
-
-    const oldExtraState = await states.blockletExtras.findOne({ did: meta.did });
-    const children = await this._getChildrenForInstallation(meta);
-    const blocklet = await states.blocklet.addBlocklet({
-      meta,
-      source: BlockletSource.upload,
-      deployedFrom: `Upload by ${context.user.fullName}`,
-      children,
-      externalSk: !!appSk,
-    });
-
-    const action = 'install';
-    const oldState = { extraState: oldExtraState };
-    try {
-      await this._setConfigsFromMeta(meta.did);
-      await this._setAppSk(appSk);
-      await validateBlocklet(blocklet);
-
-      // check duplicate appSk
-      await checkDuplicateAppSk({ did: meta.did, states });
-    } catch (error) {
-      await this._rollback(action, meta.did, oldState);
-      throw error;
-    }
-
-    // backup rollback data
-    await this._rollbackCache.backup({ did: meta.did, action, oldBlocklet: oldState });
-
-    await this.downloadAndInstall({
-      blocklet,
-      oldBlocklet: oldState,
-      context,
-      throwOnError: true,
-      postAction: action,
-      skipCheckStatusBeforeDownload: true,
-    });
-    return this.getBlocklet(meta.did);
-  }
-
-  async _installComponentFromUpload({
-    rootDid,
-    mountPoint,
-    file,
-    did,
-    diffVersion,
-    deleteSet,
-    skipNavigation,
-    context,
-  }) {
-    logger.info('install blocklet', { from: 'upload file' });
-    // download
-    const { tarFile } = await this._downloadFromUpload(file);
-
-    const oldBlocklet = await this._getBlockletForInstallation(rootDid);
-    if (!oldBlocklet) {
-      throw new Error('Root blocklet does not exist');
-    }
-
-    if (isInProgress(oldBlocklet.status)) {
-      logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-      throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-    }
-
-    let meta;
-    // diff upload
-    if (did && diffVersion) {
-      const oldChild = oldBlocklet.children.find((x) => x.meta.did === did);
-      if (!oldChild) {
-        throw new Error(`Blocklet ${did} not found when diff deploying`);
-      }
-      if (oldChild.meta.version !== diffVersion) {
-        logger.error('Diff deploy: Blocklet version changed', {
-          preVersion: diffVersion,
-          changedVersion: oldChild.meta.version,
-          name: oldChild.meta.name,
-          did: oldChild.meta.did,
-        });
-        throw new Error('Blocklet version changed when diff deploying');
-      }
-
-      meta = (await resolveDiffDownload(tarFile, this.installDir, { deleteSet, meta: oldChild.meta })).meta;
-    } else {
-      // full deploy
-      meta = (await resolveDownload(tarFile, this.installDir)).meta;
-    }
-
-    if (meta.did === rootDid) {
-      // should not be here
-      throw new Error('Cannot add self as a component');
-    }
-
-    const newBlocklet = await states.blocklet.getBlocklet(rootDid);
-
-    if (newBlocklet.children.some((x) => !x.dynamic && x.meta.did === meta.did)) {
-      throw new Error('Cannot add duplicate component defined in app meta');
-    }
-
-    const newChild = {
-      meta: ensureMeta(meta),
-      mountPoint,
-      source: BlockletSource.upload,
-      deployedFrom: `Upload by ${context.user.fullName}`,
-      bundleSource: null,
-      dynamic: true,
-      children: await parseChildrenFromMeta(meta, { ancestors: [{ mountPoint }] }),
-    };
-    const index = newBlocklet.children.findIndex((child) => child.meta.did === meta.did);
-    if (index >= 0) {
-      newBlocklet.children.splice(index, 1, newChild);
-    } else {
-      newBlocklet.children.push(newChild);
-    }
-
-    checkDuplicateComponents(newBlocklet.children);
-
-    await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild, { skipNavigation });
-
-    // backup rollback data
-    const action = 'upgrade';
-    await this._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
-
-    await this.downloadAndInstall({
-      blocklet: newBlocklet,
-      oldBlocklet,
-      context: { ...context, forceStartProcessIds: [getComponentProcessId(newChild, [newBlocklet])] },
-      throwOnError: true,
-      postAction: action,
-      skipCheckStatusBeforeDownload: true,
-      selectedComponentDids: [newChild.meta.did],
-    });
-    return this.getBlocklet(newBlocklet.meta.did);
-  }
-
-  async prune() {
-    const blocklets = await states.blocklet.getBlocklets();
-    const settings = await states.blockletExtras.listSettings();
-    await pruneBlockletBundle({
-      installDir: this.dataDirs.blocklets,
-      blocklets,
-      blockletSettings: settings
-        .filter((x) => x.settings.children && x.settings.children.length)
-        .map((x) => x.settings),
+          ...getComponentSystemEnvironments(childWithEnv), // system env of child blocklet
+          ...appSystemEnvironments, // system env of root blocklet
+        });
+      }
     });
-  }
 
-  async getLatestBlockletVersion({ did, version }) {
-    const blocklet = await states.blocklet.getBlocklet(did);
-    if (!blocklet) {
-      throw new Error('the blocklet is not installed');
-    }
+    // put BLOCKLET_APP_ID at root level for indexing
+    blocklet.appDid = appSystemEnvironments.BLOCKLET_APP_ID;
 
-    if (blocklet.source === BlockletSource.registry && blocklet.deployedFrom) {
-      return this._getLatestBlockletVersionFromStore({ blocklet, version });
+    if (!Array.isArray(blocklet.migratedFrom)) {
+      blocklet.migratedFrom = [];
     }
-
-    if (blocklet.source === BlockletSource.url && blocklet.deployedFrom) {
-      return this._getLatestBlockletVersionFromUrl({ blocklet, version });
+    // This can only be set once, can be used for indexing, will not change ever
+    if (!blocklet.appPid) {
+      blocklet.appPid = appSystemEnvironments.BLOCKLET_APP_PID;
     }
 
-    return null;
-  }
-
-  getCrons() {
-    return [
-      {
-        name: 'sync-blocklet-status',
-        time: '*/60 * * * * *', // 60s
-        fn: this._syncBlockletStatus.bind(this),
-      },
-      {
-        name: 'sync-blocklet-list',
-        time: '*/60 * * * * *', // 60s
-        fn: this.refreshListCache.bind(this),
-      },
-      {
-        name: 'refresh-accessible-ip',
-        time: '0 */10 * * * *', // 10min
-        fn: async () => {
-          const nodeInfo = await states.node.read();
-          await refreshAccessibleExternalNodeIp(nodeInfo);
-        },
-      },
-      {
-        name: 'delete-expired-external-blocklet',
-        time: '0 */30 * * * *', // 30min
-        options: { runOnInit: false },
-        fn: () => this._deleteExpiredExternalBlocklet(),
-      },
-      {
-        name: 'clean-expired-blocklet-data',
-        time: '0 */20 0 * * *', // 每天凌晨 0 点的每 20 分钟
-        fn: () => this._cleanExpiredBlockletData(),
-      },
-      {
-        name: 'record-blocklet-runtime-history',
-        time: `*/${MONITOR_RECORD_INTERVAL_SEC} * * * * *`, // 10s
-        fn: () => this.runtimeMonitor.monitAll(),
-      },
-    ];
+    // update state to db
+    return states.blocklet.updateBlocklet(did, blocklet);
   }
 
   async _attachRuntimeInfo({ did, nodeInfo, diskInfo = true, context, cachedBlocklet }) {
@@ -2821,257 +1774,75 @@ class BlockletManager extends BaseBlockletManager {
     blocklets.forEach(run);
   }
 
-  async _getChildrenForInstallation(meta) {
-    const staticChildren = await parseChildrenFromMeta(meta);
-    const dynamicChildren = await this._getDynamicChildrenFromSettings(meta.did, { skipDeleted: true });
-    for (const dynamicChild of dynamicChildren) {
-      dynamicChild.children = await parseChildrenFromMeta(dynamicChild.meta, { ancestors: [dynamicChild] });
+  async _getChildrenForInstallation(component) {
+    if (!component) {
+      return [];
     }
-    checkDuplicateComponents([...dynamicChildren, ...staticChildren]);
-
-    return [...staticChildren, ...dynamicChildren];
-  }
-
-  async _getDynamicChildrenFromSettings(did, { skipDeleted } = {}) {
-    const children = await states.blockletExtras.getSettings(did, 'children', []);
-    return children
-      .map((x) => ({ ...x, dynamic: true }))
-      .filter((x) => (skipDeleted ? x.status !== BlockletStatus.deleted : true));
-  }
-
-  /**
-   *
-   *
-   * @param {{
-   *  meta: {}; // blocklet meta
-   *  source: number; // example: BlockletSource.registry,
-   *  deployedFrom: string;
-   *  appSk: string;
-   *  context: {}
-   *  sync: boolean = false;
-   *  delay: number;
-   *  controller: Controller;
-   * }} params
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _install(params) {
-    const { meta, source, deployedFrom, context, sync, delay, controller, appSk } = params;
 
-    validateBlockletMeta(meta, { ensureDist: true });
-
-    const info = await states.node.read();
-    if (info.mode === NODE_MODES.SERVERLESS) {
-      validateInServerless({ blockletMeta: meta });
+    const { dynamicComponents } = await parseComponents(component);
+    if (component.meta.group !== BlockletGroup.gateway) {
+      dynamicComponents.unshift(component);
     }
 
-    const { name, did, version } = meta;
-
-    const oldExtraState = await states.blockletExtras.findOne({ did: meta.did });
-
-    const children = await this._getChildrenForInstallation(meta);
-    try {
-      // 创建一个blocklet到database
-      const blocklet = await states.blocklet.addBlocklet({
-        meta,
-        source,
-        deployedFrom,
-        children,
-        externalSk: !!appSk,
-      });
-
-      await validateBlocklet(blocklet);
-
-      await states.blockletExtras.addMeta({ did, meta: { did, name }, controller });
-
-      await this._setConfigsFromMeta(did);
-      await this._setAppSk(did, appSk);
-
-      // check duplicate appSk
-      await checkDuplicateAppSk({ did, states });
-
-      logger.info('blocklet added to database', { did: meta.did });
-
-      const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
-      this.emit(BlockletEvents.added, blocklet1);
-
-      const action = 'install';
-      const oldBlocklet = {
-        extraState: oldExtraState,
-      };
-
-      /** @type {{
-       *  blocklet: any;
-       *  oldBlocklet: {
-       *    children: any[];
-       *    extraState: any;
-       *  };
-       *  context: {};
-       *  postAction: string
-       * }} */
-      const downloadParams = {
-        blocklet: { ...blocklet1 },
-        context,
-        postAction: action,
-        oldBlocklet,
-      };
-
-      // backup rollback data
-      await this._rollbackCache.backup({ did, action, oldBlocklet });
-
-      if (sync) {
-        await this.downloadAndInstall({ ...downloadParams, throwOnError: true });
-        return states.blocklet.getBlocklet(did);
-      }
-
-      setTimeout(() => {
-        const ticket = this.installQueue.push(
-          {
-            entity: 'blocklet',
-            action: 'download',
-            id: did,
-            ...downloadParams,
-          },
-          did
-        );
-        ticket.on('failed', async (err) => {
-          logger.error('failed to install blocklet', { name, did, version, error: err });
-          try {
-            await this._rollback('install', did, { extraState: oldExtraState });
-          } catch (e) {
-            logger.error('failed to remove blocklet on install error', { did: meta.did, error: e });
-          }
-
-          this._createNotification(did, {
-            title: 'Blocklet Install Failed',
-            description: `Blocklet ${name}@${version} install failed with error: ${err.message || 'queue exception'}`,
-            entityType: 'blocklet',
-            entityId: did,
-            severity: 'error',
-          });
-        });
-      }, delay || 0);
-
-      return blocklet1;
-    } catch (err) {
-      logger.error('failed to install blocklet', { name, did, version, error: err });
-      this._createNotification(did, {
-        title: 'Blocklet Install Failed',
-        description: `Blocklet ${name}@${version} install failed with error: ${err.message || 'queue exception'}`,
-        entityType: 'blocklet',
-        entityId: did,
-        severity: 'error',
-      });
-
-      try {
-        await this._rollback('install', did, { extraState: oldExtraState });
-      } catch (e) {
-        logger.error('failed to remove blocklet on install error', { did: meta.did, error: e });
-      }
-
-      throw err;
-    }
+    const children = filterDuplicateComponents(dynamicComponents);
+    checkVersionCompatibility(children);
+    return children;
   }
 
-  /**
-   *
-   *
-   * @param {{}} { meta, source, deployedFrom, context, sync }
-   * @return {*}
-   * @memberof BlockletManager
-   */
-  async _upgrade({ meta, source, deployedFrom, context, sync }) {
-    validateBlockletMeta(meta, { ensureDist: meta.group !== BlockletGroup.gateway });
-
-    const { name, version, did } = meta;
-
-    const oldBlocklet = await this._getBlockletForInstallation(did);
-
-    // NOTE: 目前的版本移除了降级通道，所以不需要考虑降级通道的情况
-    const action = semver.gt(oldBlocklet.meta.version, version) ? 'downgrade' : 'upgrade';
-    logger.info(`${action} blocklet`, { did, name, version });
-
-    const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
-
-    newBlocklet.meta = ensureMeta(meta);
-    newBlocklet.source = source;
-    newBlocklet.deployedFrom = deployedFrom;
-    newBlocklet.children = await this._getChildrenForInstallation(meta);
-
-    await validateBlocklet(newBlocklet);
-
-    this.emit(BlockletEvents.statusChange, newBlocklet);
-
-    // 如果是一个付费的blocklet,需要携带token才能下载成功
-    if (!isFreeBlocklet(meta)) {
-      const blocklet = await states.blocklet.getBlocklet(did);
-
-      const info = await states.node.read();
-
-      // eslint-disable-next-line no-param-reassign
-      context = {
-        ...context,
-        headers: {
-          'x-server-did': info.did,
-          'x-server-public-key': info.pk,
-          'x-server-signature': sign(info.did, info.sk, {
-            exp: (Date.now() + 5 * 60 * 1000) / 1000,
-          }),
+  async _addBlocklet({ component, mode = BLOCKLET_MODES.PRODUCTION, name, did, title, description }) {
+    const meta = {
+      name,
+      did,
+      title: title || component?.meta?.title || '',
+      description: description || component?.meta?.description || '',
+      version: BLOCKLET_DEFAULT_VERSION,
+      group: BlockletGroup.gateway,
+      interfaces: [
+        {
+          type: BLOCKLET_INTERFACE_TYPE_WEB,
+          name: BLOCKLET_INTERFACE_PUBLIC,
+          path: BLOCKLET_DEFAULT_PATH_REWRITE,
+          prefix: BLOCKLET_DYNAMIC_PATH_PREFIX,
+          port: BLOCKLET_DEFAULT_PORT_NAME,
+          protocol: BLOCKLET_INTERFACE_PROTOCOL_HTTP,
         },
-        downloadTokenList: blocklet?.tokens?.downloadTokenList || [],
-      };
-    }
-
-    // download
-    const downloadParams = {
-      oldBlocklet: { ...oldBlocklet },
-      blocklet: { ...newBlocklet },
-      version,
-      context,
-      postAction: action,
+      ],
+      specVersion: BLOCKLET_LATEST_SPEC_VERSION,
+      environments: component?.meta?.environments || [],
+      timeout: {
+        start: process.env.NODE_ENV === 'test' ? 10 : 60,
+      },
     };
 
-    // backup rollback data
-    await this._rollbackCache.backup({ did, action, oldBlocklet });
+    const children = component ? await this._getChildrenForInstallation(component) : [];
 
-    if (sync) {
-      await this.downloadAndInstall({ ...downloadParams, throwOnError: true });
-      return states.blocklet.getBlocklet(did);
+    if (children[0]?.meta?.logo) {
+      meta.logo = children[0].meta.logo;
     }
-    const ticket = this.installQueue.push(
-      {
-        entity: 'blocklet',
-        action: 'download',
-        id: did,
-        ...downloadParams,
-      },
-      did
-    );
 
-    ticket.on('failed', async (err) => {
-      logger.error('queue failed', { entity: 'blocklet', action, did, version, name, error: err });
-      await this._rollback(action, did, oldBlocklet);
-      const eventNames = {
-        upgrade: BlockletEvents.upgradeFailed,
-        downgrade: BlockletEvents.downgradeFailed,
-      };
-      this.emit(eventNames[action], { blocklet: oldBlocklet, context });
-      this._createNotification(did, {
-        title: `Blocklet ${capitalize(action)} Failed`,
-        description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message || 'queue exception'}`,
-        entityType: 'blocklet',
-        entityId: did,
-        severity: 'error',
-      });
+    await validateBlocklet({ meta, children });
+
+    // fake install bundle
+    const bundleDir = getBundleDir(this.installDir, meta);
+    fs.mkdirSync(bundleDir, { recursive: true });
+    updateMetaFile(path.join(bundleDir, BLOCKLET_META_FILE), meta);
+
+    // add blocklet to db
+    const blocklet = await states.blocklet.addBlocklet({
+      meta,
+      source: BlockletSource.custom,
+      children,
+      mode,
     });
-    return newBlocklet;
+
+    return blocklet;
   }
 
   /**
    * @param {string} opt.did
    * @param {object} opt.context
    */
-  async _installBlocklet({ did, oldBlocklet, context }) {
+  async _installBlocklet({ did, oldBlocklet, context, createNotification = true }) {
     try {
       // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
@@ -3089,7 +1860,7 @@ class BlockletManager extends BaseBlockletManager {
       await this._runPreInstallHook(blocklet, context);
 
       // Add environments
-      await this.updateBlockletEnvironment(meta.did);
+      await this._updateBlockletEnvironment(meta.did);
       blocklet = await this.getBlocklet(did);
 
       // post install
@@ -3099,15 +1870,27 @@ class BlockletManager extends BaseBlockletManager {
       blocklet = await this.getBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
 
+      // logo
+      if (blocklet.children[0]?.meta?.logo) {
+        const fileName = blocklet.children[0].meta.logo;
+        const src = path.join(getBundleDir(this.installDir, blocklet.children[0].meta), fileName);
+        const dist = path.join(getBundleDir(this.installDir, blocklet.meta), fileName);
+        await fs.copy(src, dist);
+      }
+
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
       // Init db
       await this.teamManager.initTeam(blocklet.meta.did);
 
+      // Update dependents
+      await this._updateDependents(did);
+      blocklet = await this.getBlocklet(did);
+
       this.emit(BlockletEvents.installed, { blocklet, context });
 
       // Update dynamic component meta in blocklet settings
-      await this._ensureDynamicChildrenInSettings(blocklet);
+      await this._ensureDeletedChildrenInSettings(blocklet);
 
       if (context?.downloadTokenList?.length) {
         await states.blocklet.updateBlocklet(did, {
@@ -3122,16 +1905,18 @@ class BlockletManager extends BaseBlockletManager {
         await consumeServerlessNFT({ nftId: blocklet.controller.nftId, nodeInfo, blocklet });
       }
 
-      this._createNotification(did, {
-        title: 'Blocklet Installed',
-        description: `Blocklet ${meta.name}@${meta.version} is installed successfully. (Source: ${
-          deployedFrom || fromBlockletSource(source)
-        })`,
-        action: `/blocklets/${did}/overview`,
-        entityType: 'blocklet',
-        entityId: did,
-        severity: 'success',
-      });
+      if (createNotification) {
+        this._createNotification(did, {
+          title: 'Blocklet Installed',
+          description: `Blocklet ${meta.name}@${meta.version} is installed successfully. (Source: ${
+            deployedFrom || fromBlockletSource(source)
+          })`,
+          action: `/blocklets/${did}/overview`,
+          entityType: 'blocklet',
+          entityId: did,
+          severity: 'success',
+        });
+      }
 
       await this._rollbackCache.remove({ did: blocklet.meta.did });
       return blocklet;
@@ -3169,7 +1954,6 @@ class BlockletManager extends BaseBlockletManager {
     // ids
     context.skippedProcessIds = getSkippedProcessIds({ newBlocklet, oldBlocklet, context });
 
-    const action = semver.gt(oldBlocklet.meta.version, version) ? 'downgrade' : 'upgrade';
     try {
       // delete old process
       try {
@@ -3190,7 +1974,7 @@ class BlockletManager extends BaseBlockletManager {
       await this._runPreInstallHook(blocklet, context);
 
       // Add environments
-      await this.updateBlockletEnvironment(did);
+      await this._updateBlockletEnvironment(did);
       blocklet = await this.getBlocklet(did);
 
       // post install
@@ -3235,17 +2019,15 @@ class BlockletManager extends BaseBlockletManager {
 
       await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
+      await this._updateDependents(did);
+
       this.refreshListCache();
 
       try {
-        const eventNames = {
-          upgrade: BlockletEvents.upgraded,
-          downgrade: BlockletEvents.downgraded,
-        };
-        this.emit(eventNames[action], { blocklet, context });
+        this.emit(BlockletEvents.upgraded, { blocklet, context });
         this._createNotification(did, {
-          title: `Blocklet ${capitalize(action)} Success`,
-          description: `Blocklet ${name}@${version} ${action} successfully. (Source: ${
+          title: 'Blocklet Upgrade Success',
+          description: `Blocklet ${name}@${version} upgrade successfully. (Source: ${
             deployedFrom || fromBlockletSource(source)
           })`,
           action: `/blocklets/${did}/overview`,
@@ -3258,26 +2040,25 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // Update dynamic component meta in blocklet settings
-      await this._ensureDynamicChildrenInSettings(blocklet);
+      await this._ensureDeletedChildrenInSettings(blocklet);
 
       await this._rollbackCache.remove({ did: blocklet.meta.did });
 
       return blocklet;
     } catch (err) {
-      const b = await this._rollback(action, did, oldBlocklet);
-      logger.error(`failed to ${action} blocklet`, { did, version, name, error: err });
+      const b = await this._rollback('upgrade', did, oldBlocklet);
+      logger.error('failed to upgrade blocklet', { did, version, name, error: err });
 
       this.emit(BlockletEvents.updated, b);
 
-      const eventNames = {
-        upgrade: BlockletEvents.upgradeFailed,
-        downgrade: BlockletEvents.downgradeFailed,
-      };
-      this.emit(eventNames[action], { blocklet: { ...oldBlocklet, error: { message: err.message } }, context });
+      this.emit(BlockletEvents.upgradeFailed, {
+        blocklet: { ...oldBlocklet, error: { message: err.message } },
+        context,
+      });
 
       this._createNotification(did, {
-        title: `Blocklet ${capitalize(action)} Failed`,
-        description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message}`,
+        title: 'Blocklet Upgrade Failed',
+        description: `Blocklet ${name}@${version} upgrade failed with error: ${err.message}`,
         entityType: 'blocklet',
         entityId: did,
         severity: 'error',
@@ -3286,21 +2067,17 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  // Update dynamic component meta in blocklet settings
-  async _ensureDynamicChildrenInSettings(blocklet) {
+  // Refresh deleted component in blocklet settings
+  async _ensureDeletedChildrenInSettings(blocklet) {
     const { did } = blocklet.meta;
-    const dynamicChildren = blocklet.children
-      .filter((x) => x.dynamic)
-      .map((x) => pick(x, ['meta', 'mountPoint', 'bundleSource', 'source']));
 
-    // deleted blocklet
-    let deletes = await states.blockletExtras.getSettings(did, 'children', []);
-    deletes = deletes.filter(
+    // TODO 不从 settings 中取值, 直接存在 extra 中
+    let deletedChildren = await states.blockletExtras.getSettings(did, 'children', []);
+    deletedChildren = deletedChildren.filter(
       (x) => x.status === BlockletStatus.deleted && !blocklet.children.some((y) => y.meta.did === x.meta.did)
     );
-    dynamicChildren.push(...deletes);
 
-    await states.blockletExtras.setSettings(did, { children: dynamicChildren });
+    await states.blockletExtras.setSettings(did, { children: deletedChildren });
   }
 
   /**
@@ -3483,6 +2260,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
+  // to be deleted
   async _setAppSk(did, appSk, context) {
     if (process.env.NODE_ENV === 'production' && !appSk) {
       throw new Error(`appSk for blocklet ${did} is required`);
@@ -3501,37 +2279,6 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _findNextCustomBlockletName(leftTimes = 10) {
-    if (leftTimes <= 0) {
-      throw new Error('Generate custom blocklet did too many times');
-    }
-    const number = await states.node.increaseCustomBlockletNumber();
-    const name = `custom-${number}`;
-    // MEMO: 空壳 APP可以保留原有的 did 生成逻辑
-    const did = toBlockletDid(name);
-    const blocklet = await states.blocklet.getBlocklet(did);
-    if (blocklet) {
-      return this._findNextCustomBlockletName(leftTimes - 1);
-    }
-    return { did, name };
-  }
-
-  async _upsertDynamicNavigation(did, child, { skipNavigation } = {}) {
-    const navigation = await states.blockletExtras.getSettings(did, 'navigation', []);
-    const item = { title: child.meta.title, child: child.meta.name };
-    const index = navigation.findIndex((x) => x.child === item.child);
-    if (index > -1) {
-      if (skipNavigation) {
-        navigation.splice(index, 1);
-      } else {
-        navigation.splice(index, 1, item);
-      }
-    } else if (!skipNavigation) {
-      navigation.push(item);
-    }
-    await states.blockletExtras.setSettings(did, { navigation });
-  }
-
   async _getBlockletForInstallation(did) {
     const blocklet = await states.blocklet.getBlocklet(did, { decryptSk: false });
     if (!blocklet) {
@@ -3544,58 +2291,6 @@ class BlockletManager extends BaseBlockletManager {
     return blocklet;
   }
 
-  async _getLatestBlockletVersionFromStore({ blocklet, version }) {
-    const { deployedFrom: storeUrl } = blocklet;
-    const { did, bundleDid } = blocklet.meta;
-
-    let versions = this.cachedBlockletVersions.get(did);
-
-    if (!versions) {
-      const item = await StoreUtil.getBlockletMeta({ did: bundleDid, storeUrl });
-
-      if (!item) {
-        return null;
-      }
-
-      versions = [{ did, version: item.version }];
-
-      this.cachedBlockletVersions.set(did, versions);
-    }
-
-    versions = versions.filter((item) => item && semver.gt(item.version, version));
-
-    if (versions.length === 0) {
-      return null;
-    }
-
-    return versions[0];
-  }
-
-  async _getLatestBlockletVersionFromUrl({ blocklet, version }) {
-    const { did } = blocklet.meta;
-
-    let versions = this.cachedBlockletVersions.get(did);
-
-    if (!versions) {
-      try {
-        const item = await getBlockletMetaFromUrl(blocklet.deployedFrom);
-        versions = [{ did, version: item.version }];
-      } catch (error) {
-        logger.error('get blocklet meta from url failed when checking latest version', { did, error });
-        versions = [];
-      }
-    }
-
-    this.cachedBlockletVersions.set(did, versions);
-    versions = versions.filter((item) => item && semver.gt(item.version, version));
-
-    if (versions.length === 0) {
-      return null;
-    }
-
-    return versions[0];
-  }
-
   async _runPreInstallHook(blocklet, context) {
     const nodeEnvironments = await states.node.getEnvironments();
 
@@ -3743,10 +2438,7 @@ class BlockletManager extends BaseBlockletManager {
       },
       nodeInfo.sk
     );
-    const didDomain = getDidDomainForBlocklet({
-      blockletAppDid: wallet.address,
-      didDomain: nodeInfo.didDomain,
-    });
+    const didDomain = getDidDomainForBlocklet({ appPid: blocklet.appPid, didDomain: nodeInfo.didDomain });
 
     const domainAliases = (get(blocklet, 'site.domainAliases') || []).filter(
       (item) => !item.value.endsWith(nodeInfo.didDomain) && !item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
@@ -3759,20 +2451,36 @@ class BlockletManager extends BaseBlockletManager {
 
     this.emit(BlockletEvents.appDidChanged, blocklet);
 
-    const blockletWithEnv = await this.getBlocklet(blocklet.meta.did);
-    const appSystemEnvironments = getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo);
-
     await didDocument.updateBlockletDocument({
       wallet,
-      blockletAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
+      appPid: blocklet.appPid,
+      alsoKnownAs: getBlockletKnownAs(blocklet),
       daemonDidDomain: util.getServerDidDomain(nodeInfo),
       didRegistryUrl: nodeInfo.didRegistry,
       domain: nodeInfo.didDomain,
     });
-    logger.info('updated blocklet dns document', {
-      did: blocklet.meta.did,
-      currentAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
+    logger.info('updated blocklet dns document', { appPid: blocklet.appPid, appDid: blocklet.appDid });
+  }
+
+  async _updateDependents(did) {
+    const blocklet = await states.blocklet.getBlocklet(did);
+    const map = {};
+    for (const child of blocklet.children) {
+      child.dependents = [];
+      map[child.meta.did] = child;
+    }
+
+    forEachBlockletSync(blocklet, (x, { id }) => {
+      if (x.dependencies) {
+        x.dependencies.forEach((y) => {
+          if (map[y.did]) {
+            map[y.did].dependents.push({ id, required: y.required });
+          }
+        });
+      }
     });
+
+    await states.blocklet.updateBlocklet(blocklet.meta.did, { children: blocklet.children });
   }
 }