@abtnode/core 1.8.30 → 1.8.32

package/lib/blocklet/manager/disk.js

@@ -23,7 +23,7 @@ const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
-const { VC_TYPE_BLOCKLET_PURCHASE, WHO_CAN_ACCESS } = require('@abtnode/constant');
+const { VC_TYPE_BLOCKLET_PURCHASE, WHO_CAN_ACCESS, SERVER_ROLES } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const {
@@ -38,6 +38,7 @@ const {
   forEachChild,
   getComponentId,
   getComponentBundleId,
+  isExternalBlocklet,
 } = require('@blocklet/meta/lib/util');
 const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
@@ -47,6 +48,8 @@ const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { titleSchema, descriptionSchema, mountPointSchema, logoSchema } = require('@blocklet/meta/lib/schema');
 const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
 
+const { toExternalBlocklet } = toBlockletDid;
+
 const {
   BlockletStatus,
   BlockletSource,
@@ -105,9 +108,8 @@ const {
   getBlocklet,
   ensureEnvDefault,
 } = require('../../util/blocklet');
-const { parseSourceUrl } = require('../../util/registry');
+const StoreUtil = require('../../util/store');
 const states = require('../../states');
-const BlockletRegistry = require('../registry');
 const BaseBlockletManager = require('./base');
 const { get: getEngine } = require('./engine');
 const blockletPm2Events = require('./pm2-events');
@@ -169,11 +171,14 @@ const getSkippedProcessIds = ({ newBlocklet, oldBlocklet, context = {} }) => {
   return res;
 };
 
+const getBlockletIndex = (meta, controller) =>
+  controller ? toExternalBlocklet(meta.name, controller.id) : { did: meta.did, name: meta.name };
+
 class BlockletManager extends BaseBlockletManager {
   /**
    * @param {*} dataDirs generate by ../../util:getDataDirs
    */
-  constructor({ dataDirs, registry, startQueue, installQueue, daemon = false, teamManager }) {
+  constructor({ dataDirs, startQueue, installQueue, daemon = false, teamManager }) {
     super();
 
     this.dataDirs = dataDirs;
@@ -190,7 +195,6 @@ class BlockletManager extends BaseBlockletManager {
      * { [download-did-version]: Lock }
      */
     this.downloadLocks = {};
-    this.registry = registry;
 
     // cached installed blocklets for performance
     this.cachedBlocklets = null;
@@ -198,7 +202,7 @@ class BlockletManager extends BaseBlockletManager {
     // 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 : 5 * 60 * 1000, // cache for 5 minute
+      maxAge: process.env.NODE_ENV === 'test' ? 500 : 0.5 * 60 * 1000, // cache for 0.5 minute
     });
 
     if (daemon) {
@@ -216,8 +220,17 @@ class BlockletManager extends BaseBlockletManager {
    *
    * @param {{
    *  url: string;
-   *  sync: boolean = false;
-   *  downloadTokenList: Array<{did: string, token: string};
+   *  file: string;
+   *  diffVersion: string;
+   *  deleteSet: Array<string>;
+   *  did: string;
+   *  title: string;
+   *  description: string;
+   *  sync: boolean = false; // download synchronously, not use queue
+   *  delay: number; // push download task to queue after a delay
+   *  downloadTokenList: Array<{did: string, token: string}>;
+   *  startImmediately: boolean;
+   *  controller: Controller
    * }} params
    * @param {{
    *  [key: string]: any
@@ -245,7 +258,8 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     if (source === BlockletSource.url) {
-      return this._installFromUrl({ url: params.url, sync: params.sync }, context);
+      const { url, controller, sync, delay } = params;
+      return this._installFromUrl({ url, controller, sync, delay }, context);
     }
 
     if (source === BlockletSource.upload) {
@@ -254,7 +268,8 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     if (source === BlockletSource.registry) {
-      return this._installFromStore({ did: params.did }, context);
+      const { did, controller, sync, delay } = params;
+      return this._installFromStore({ did, controller, sync, delay }, context);
     }
 
     if (source === BlockletSource.custom) {
@@ -283,15 +298,38 @@ class BlockletManager extends BaseBlockletManager {
    * @param {String} name custom component name
    *
    * @param {ConfigEntry} configs pre configs
+   * @param {Boolean} skipNavigation
    */
   async installComponent(
-    { rootDid, mountPoint, url, file, did, diffVersion, deleteSet, title, name, configs, downloadTokenList },
+    {
+      rootDid,
+      mountPoint,
+      url,
+      file,
+      did,
+      diffVersion,
+      deleteSet,
+      title,
+      name,
+      configs,
+      downloadTokenList,
+      skipNavigation,
+    },
     context = {}
   ) {
     logger.debug('start install component', { rootDid, mountPoint, url });
 
     if (file) {
-      return this._installComponentFromUpload({ rootDid, mountPoint, file, did, diffVersion, deleteSet, context });
+      return this._installComponentFromUpload({
+        rootDid,
+        mountPoint,
+        file,
+        did,
+        diffVersion,
+        deleteSet,
+        skipNavigation,
+        context,
+      });
     }
 
     if (url) {
@@ -305,6 +343,7 @@ class BlockletManager extends BaseBlockletManager {
         name,
         configs,
         downloadTokenList,
+        skipNavigation,
       });
     }
 
@@ -319,7 +358,7 @@ class BlockletManager extends BaseBlockletManager {
 
     if (checkPrice && !isFree && meta.nftFactory) {
       try {
-        const registryMeta = await BlockletRegistry.getRegistryMeta(new URL(url).origin);
+        const registryMeta = await StoreUtil.getRegistryMeta(new URL(url).origin);
 
         if (registryMeta.chainHost) {
           const state = await getFactoryState(registryMeta.chainHost, meta.nftFactory);
@@ -332,12 +371,33 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
-    const { inStore, registryUrl } = await parseSourceUrl(url);
+    const { inStore, registryUrl } = await StoreUtil.parseSourceUrl(url);
+
+    return { meta, isFree, inStore, registryUrl };
+  }
+
+  async getBlockletByBundle({ did, name }, context) {
+    if (toBlockletDid(name) !== did) {
+      throw new Error('did and name does not match');
+    }
+
+    if (!context?.user) {
+      throw new Error('user does not exist');
+    }
+
+    let blockletDid = did;
+    let isExternal = false;
+
+    if (context.user.role === SERVER_ROLES.EXTERNAL_BLOCKLET_CONTROLLER) {
+      blockletDid = toExternalBlocklet(name, context.user.did, { didOnly: true });
+      isExternal = true;
+    }
+
+    const blocklet = await states.blocklet.getBlocklet(blockletDid);
 
-    const blocklet = await states.blocklet.getBlocklet(meta.did);
     const isRunning = blocklet ? blocklet.status === BlockletStatus.running : false;
 
-    return { meta, isFree, isInstalled: !!blocklet, isRunning, inStore, registryUrl };
+    return { isInstalled: !!blocklet, isRunning, blockletDid, isExternal };
   }
 
   async installBlockletFromVc({ vcPresentation, challenge }, context) {
@@ -364,6 +424,15 @@ class BlockletManager extends BaseBlockletManager {
     const blocklet = await this.ensureBlocklet(did, { e2eMode });
 
     try {
+      // blocklet may be manually stopped durning starting
+      // so error message would not be sent if blocklet is stopped
+      // so we need update status first
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting);
+      blocklet.status = BlockletStatus.starting;
+
+      // validate requirement and engine
+      await validateBlocklet(blocklet);
+
       if (!hasRunnableComponent(blocklet)) {
         throw new Error('No runnable component found');
       }
@@ -376,9 +445,6 @@ class BlockletManager extends BaseBlockletManager {
         );
       }
 
-      // update status
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting);
-      blocklet.status = BlockletStatus.starting;
       this.emit(BlockletEvents.statusChange, blocklet);
 
       if (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT) {
@@ -787,36 +853,46 @@ class BlockletManager extends BaseBlockletManager {
     return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
-  async list({ includeRuntimeInfo = true, useCache = true } = {}, context) {
+  async list({ includeRuntimeInfo = true, useCache = true, filter } = {}, context) {
     const blocklets = await states.blocklet.getBlocklets();
-    if (!includeRuntimeInfo) {
-      return blocklets;
-    }
+    let list = blocklets;
+
+    if (includeRuntimeInfo) {
+      const nodeInfo = await states.node.read();
+      const updated = (
+        await Promise.all(
+          blocklets.map((x) => {
+            if (isBeforeInstalled(x.status)) {
+              return x;
+            }
 
-    const nodeInfo = await states.node.read();
-    const updated = (
-      await Promise.all(
-        blocklets.map((x) => {
-          if (isBeforeInstalled(x.status)) {
-            return x;
-          }
+            const cachedBlocklet =
+              useCache && this.cachedBlocklets ? this.cachedBlocklets.find((y) => y.meta.did === x.meta.did) : null;
 
-          const cachedBlocklet =
-            useCache && this.cachedBlocklets ? this.cachedBlocklets.find((y) => y.meta.did === x.meta.did) : null;
+            return this.attachRuntimeInfo({
+              did: x.meta.did,
+              nodeInfo,
+              diskInfo: false,
+              context,
+              cachedBlocklet,
+            });
+          })
+        )
+      ).filter(Boolean);
 
-          return this.attachRuntimeInfo({
-            did: x.meta.did,
-            nodeInfo,
-            diskInfo: false,
-            context,
-            cachedBlocklet,
-          });
-        })
-      )
-    ).filter(Boolean);
+      this.cachedBlocklets = cloneDeep(updated);
+      list = updated;
+    }
 
-    this.cachedBlocklets = cloneDeep(updated);
-    return updated;
+    if (filter === 'external-excluded') {
+      return list.filter((x) => !isExternalBlocklet(x));
+    }
+
+    if (filter === 'external-only') {
+      return list.filter(isExternalBlocklet);
+    }
+
+    return list;
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -1043,13 +1119,11 @@ class BlockletManager extends BaseBlockletManager {
 
     const upgradeFromRegistry = registryUrl || blocklet.deployedFrom;
 
-    const newVersionMeta = await this.registry.getBlockletMeta(
-      {
-        did: blocklet.meta.bundleDid,
-        registryUrl: upgradeFromRegistry,
-      },
-      context
-    );
+    let newVersionMeta = await StoreUtil.getBlockletMeta({
+      did: blocklet.meta.bundleDid,
+      registryUrl: upgradeFromRegistry,
+    });
+    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
@@ -1335,20 +1409,31 @@ class BlockletManager extends BaseBlockletManager {
 
     const oldBlocklet = { children: children.filter((x) => x.dynamic) }; // let downloader skip re-downloading dynamic blocklet
     await this._downloadBlocklet(added, oldBlocklet);
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
-    // Add environments
+    // Add Config
     await this._setConfigsFromMeta(did);
+    let blocklet = await this.ensureBlocklet(did);
+
+    // pre install
+    await this._runPreInstallHook(blocklet);
+
+    // Add environments
     await this.updateBlockletEnvironment(did);
+    blocklet = await this.ensureBlocklet(did);
 
-    const blocklet = await this.ensureBlocklet(did);
+    // post install
+    await this._runPostInstallHook(blocklet);
+
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
+
+    blocklet = await this.ensureBlocklet(did);
 
     await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
 
     return blocklet;
   }
 
-  async _devComponent({ folder, meta, rootDid, mountPoint }) {
+  async _devComponent({ folder, meta, rootDid, mountPoint, skipNavigation = true }) {
     const { did, version } = meta;
 
     const existRoot = await states.blocklet.getBlocklet(rootDid);
@@ -1373,36 +1458,44 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const defaultPath = formatName(meta.name);
-    const children = [
-      {
-        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(children[0]);
-    await states.blocklet.addChildren(rootDid, children);
+    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, existRoot);
     await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
 
-    await this._upsertDynamicNavigation(existRoot.meta.did, children[0]);
+    await this._upsertDynamicNavigation(existRoot.meta.did, component, { skipNavigation });
 
-    // Add environments
+    // Add Config
     await this._setConfigsFromMeta(rootDid);
+    let blocklet = await this.ensureBlocklet(rootDid);
+
+    // pre install
+    await this._runPreInstallHook(blocklet);
+
+    // Add environments
     await this.updateBlockletEnvironment(rootDid);
+    blocklet = await this.ensureBlocklet(rootDid);
+
+    // post install
+    await this._runPostInstallHook(blocklet);
 
     logger.info('add blocklet component for dev', { did, version, meta });
 
-    const rootBlocklet = await this.ensureBlocklet(rootDid);
+    blocklet = await this.ensureBlocklet(rootDid);
 
-    return rootBlocklet;
+    return blocklet;
   }
 
   async ensureBlocklet(did, opts = {}) {
@@ -1857,13 +1950,15 @@ class BlockletManager extends BaseBlockletManager {
    *  did: string;
    *  registry: string;
    *  sync: boolean;
+   *  delay: number;
+   *  controller: Controller;
    * }} params
    * @param {*} context
    * @return {*}
    * @memberof BlockletManager
    */
   async _installFromStore(params, context) {
-    const { did, registry, sync } = params;
+    const { did, registry, sync, delay, controller } = params;
 
     logger.debug('start install blocklet', { did });
     if (!isValidDid(did)) {
@@ -1871,67 +1966,96 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const registryUrl = registry || (await states.node.getBlockletRegistry());
-    const info = await BlockletRegistry.getRegistryMeta(registryUrl);
-    const meta = await this.registry.getBlocklet(did, registryUrl);
+    const info = await StoreUtil.getRegistryMeta(registryUrl);
+    const meta = await StoreUtil.getBlockletMeta({ did, registryUrl });
     if (!meta) {
       throw new Error('Can not install blocklet that not found in registry');
     }
 
-    const state = await states.blocklet.getBlocklet(meta.did);
+    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?.vcId) {
+      // sometimes nedb will throw error if use states.blocklet.count({ ['controller.vcId']: controller.vcId })
+      const blocklets = await states.blocklet.find({}, { controller: 1 });
+      const count = blocklets.filter((x) => x.controller?.vcId === controller.vcId).length;
+
+      if (count >= (controller.appMaxCount || 1)) {
+        throw new Error(
+          `You can only install ${controller.appMaxCount} blocklet with this credential: ${controller.vcId}`
+        );
+      }
+    }
+
     // install
     return this._install({
-      meta,
+      meta: ensureMeta(meta, { did: blockletDid, name: blockletName }),
       source: BlockletSource.registry,
       deployedFrom: info.cdnUrl || registryUrl,
       sync,
+      delay,
+      controller,
       context,
     });
   }
 
   /**
-   *
+   * @type {{
+   *  id: string;
+   *  vcId: string;
+   *  expireDate: Date;
+   * }} Controller
    *
    * @param {{
    *  url: string;
    *  sync: boolean;
+   *  delay: number;
+   *  controller: Controller;
    * }} params
    * @param {{}} context
    * @return {*}
    * @memberof BlockletManager
    */
   async _installFromUrl(params, context) {
-    const { url, sync } = params;
+    const { url, sync, delay, controller } = params;
 
     logger.debug('start install blocklet', { url });
 
-    const { inStore, registryUrl, blockletDid } = await parseSourceUrl(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);
     if (inStore) {
       const exist = await states.blocklet.getBlocklet(blockletDid);
       if (exist) {
-        return this.upgrade({ did: blockletDid, registryUrl }, context);
+        return this.upgrade({ did: blockletDid, registryUrl, sync, delay }, context);
       }
 
-      return this._installFromStore({ did: blockletDid, registry: registryUrl }, context);
+      return this._installFromStore({ did: bundleDid, registry: registryUrl, controller, sync, delay }, context);
     }
 
-    const meta = await getBlockletMetaFromUrl(url);
-
-    if (!meta) {
-      throw new Error(`Can not install blocklet that not found by url: ${url}`);
-    }
+    const meta = ensureMeta(bundleMeta, { name: blockletName, did: blockletDid });
 
     // upgrade
-    const exist = await states.blocklet.getBlocklet(meta.did);
+    const exist = await states.blocklet.getBlocklet(blockletDid);
     if (exist) {
       return this._upgrade({
         meta,
         source: BlockletSource.url,
         deployedFrom: url,
         sync,
+        delay,
         context,
       });
     }
@@ -1942,6 +2066,8 @@ class BlockletManager extends BaseBlockletManager {
       source: BlockletSource.url,
       deployedFrom: url,
       sync,
+      delay,
+      controller,
       context,
     });
   }
@@ -1956,13 +2082,14 @@ class BlockletManager extends BaseBlockletManager {
     did: inputDid,
     configs,
     downloadTokenList,
+    skipNavigation,
   }) {
     const blocklet = await this._getBlockletForInstallation(rootDid);
     if (!blocklet) {
       throw new Error('Root blocklet does not exist');
     }
 
-    const { inStore } = await parseSourceUrl(url);
+    const { inStore } = await StoreUtil.parseSourceUrl(url);
 
     const meta = await getBlockletMetaFromUrl(url);
 
@@ -2018,7 +2145,7 @@ class BlockletManager extends BaseBlockletManager {
       await states.blocklet.addChildren(rootDid, [newChild]);
 
       // update navigation
-      await this._upsertDynamicNavigation(blocklet.meta.did, newChild);
+      await this._upsertDynamicNavigation(blocklet.meta.did, newChild, { skipNavigation });
 
       // update configs
       if (Array.isArray(configs)) {
@@ -2100,7 +2227,7 @@ class BlockletManager extends BaseBlockletManager {
         .pipe(writeStream);
       readStream.on('error', (error) => {
         logger.error('File upload read stream failed', { error });
-        writeStream.destroy(new Error('File upload read stream failed'));
+        writeStream.destroy(new Error(`File upload read stream failed, ${error.message}`));
       });
       writeStream.on('error', (error) => {
         logger.error('File upload write stream failed', { error });
@@ -2213,7 +2340,16 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _installComponentFromUpload({ rootDid, mountPoint, file, did, diffVersion, deleteSet, context }) {
+  async _installComponentFromUpload({
+    rootDid,
+    mountPoint,
+    file,
+    did,
+    diffVersion,
+    deleteSet,
+    skipNavigation,
+    context,
+  }) {
     logger.info('install blocklet', { from: 'upload file' });
     // download
     const { cwd, tarFile } = await this._downloadFromUpload(file);
@@ -2280,7 +2416,7 @@ class BlockletManager extends BaseBlockletManager {
 
     checkDuplicateComponents(newBlocklet.children);
 
-    await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild);
+    await this._upsertDynamicNavigation(newBlocklet.meta.did, newChild, { skipNavigation });
 
     await this._downloadBlocklet(newBlocklet, oldBlocklet);
 
@@ -2403,12 +2539,14 @@ class BlockletManager extends BaseBlockletManager {
    *  deployedFrom: string;
    *  context: {}
    *  sync: boolean = false;
+   *  delay: number;
+   *  controller: Controller;
    * }} params
    * @return {*}
    * @memberof BlockletManager
    */
   async _install(params) {
-    const { meta, source, deployedFrom, context, sync } = params;
+    const { meta, source, deployedFrom, context, sync, delay, controller } = params;
 
     validateBlockletMeta(meta, { ensureDist: true });
 
@@ -2424,6 +2562,7 @@ class BlockletManager extends BaseBlockletManager {
         source,
         deployedFrom,
         children,
+        controller,
       });
 
       await validateBlocklet(blocklet);
@@ -2459,31 +2598,33 @@ class BlockletManager extends BaseBlockletManager {
         return states.blocklet.getBlocklet(did);
       }
 
-      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 });
-        }
+      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 });
+          }
 
-        states.notification.create({
-          title: 'Blocklet Install Failed',
-          description: `Blocklet ${name}@${version} install failed with error: ${err.message || 'queue exception'}`,
-          entityType: 'blocklet',
-          entityId: did,
-          severity: 'error',
+          states.notification.create({
+            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) {
@@ -2746,33 +2887,14 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // pre install
-      const nodeEnvironments = await states.node.getEnvironments();
-      const preInstall = (b) =>
-        hooks.preInstall(b.env.processId, {
-          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: { ...nodeEnvironments },
-          appDir: b.env.appDir,
-          did, // root blocklet did
-          notification: states.notification,
-          context,
-        });
-      await forEachBlocklet(blocklet, preInstall, { parallel: true });
+      await this._runPreInstallHook(blocklet, context);
 
       // Add environments
       await this.updateBlockletEnvironment(meta.did);
       blocklet = await this.ensureBlocklet(did);
 
       // post install
-      const postInstall = (b, { ancestors }) =>
-        hooks.postInstall(b.env.processId, {
-          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
-          appDir: b.env.appDir,
-          did, // root blocklet did
-          notification: states.notification,
-          context,
-        });
-      await forEachBlocklet(blocklet, postInstall, { parallel: true });
+      await this._runPostInstallHook(blocklet, context);
 
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
@@ -2858,33 +2980,14 @@ class BlockletManager extends BaseBlockletManager {
       let blocklet = await this.ensureBlocklet(did);
 
       // pre install
-      const nodeEnvironments = await states.node.getEnvironments();
-      const preInstall = (b) =>
-        hooks.preInstall(b.env.processId, {
-          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: { ...nodeEnvironments },
-          appDir: b.env.appDir,
-          did, // root blocklet did
-          notification: states.notification,
-          context,
-        });
-      await forEachBlocklet(blocklet, preInstall, { parallel: true });
+      await this._runPreInstallHook(blocklet, context);
 
       // Add environments
       await this.updateBlockletEnvironment(did);
       blocklet = await this.ensureBlocklet(did);
 
       // post install
-      const postInstall = (b, { ancestors }) =>
-        hooks.postInstall(b.env.processId, {
-          hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
-          env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
-          appDir: b.env.appDir,
-          did, // root blocklet did
-          notification: states.notification,
-          context,
-        });
-      await forEachBlocklet(blocklet, postInstall, { parallel: true });
+      await this._runPostInstallHook(blocklet, context);
 
       logger.info('start migration');
       try {
@@ -2892,6 +2995,7 @@ class BlockletManager extends BaseBlockletManager {
         forEachBlockletSync(oldBlocklet, (b, { id }) => {
           oldVersions[id] = b.meta.version;
         });
+        const nodeEnvironments = await states.node.getEnvironments();
         const runMigration = (b, { id, ancestors }) => {
           return runMigrationScripts({
             blocklet: b,
@@ -3241,11 +3345,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.info('Download Blocklet', { name, did, bundles: metas.map((x) => get(x, 'dist.tarball')) });
       const tasks = [];
       for (const meta of metas) {
-        const url = await this.registry.resolveTarballURL({
-          did,
-          tarball: get(meta, 'dist.tarball'),
-          registryUrl: blocklet.source === BlockletSource.registry ? blocklet.deployedFrom : undefined,
-        });
+        const url = meta.dist.tarball;
         tasks.push(this._downloadBundle(meta, did, url, context));
       }
       const results = await Promise.all(tasks);
@@ -3410,13 +3510,17 @@ class BlockletManager extends BaseBlockletManager {
     return { did, name };
   }
 
-  async _upsertDynamicNavigation(did, child) {
+  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) {
-      navigation.splice(index, 1, item);
-    } else {
+      if (skipNavigation) {
+        navigation.splice(index, 1);
+      } else {
+        navigation.splice(index, 1, item);
+      }
+    } else if (!skipNavigation) {
       navigation.push(item);
     }
     await states.blockletExtras.setSettings(did, { navigation });
@@ -3435,24 +3539,20 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _getLatestBlockletVersionFromStore({ blocklet, version }) {
+    const { deployedFrom: registryUrl } = blocklet;
     const { did, bundleDid } = blocklet.meta;
 
     let versions = this.cachedBlockletVersions.get(did);
 
     if (!versions) {
-      const { blockletRegistryList } = await states.node.read();
-      const tasks = blockletRegistryList.map((registry) =>
-        this.registry
-          .getBlockletMeta({ did: bundleDid, registryUrl: registry.url })
-          .then((item) => ({ did, version: item.version, registryUrl: registry.url }))
-          .catch((error) => {
-            if (error.response && error.response.status === 404) {
-              return;
-            }
-            logger.error('get blocklet meta from registry failed', { did, error });
-          })); // prettier-ignore
+      const item = await StoreUtil.getBlockletMeta({ did: bundleDid, registryUrl });
+
+      if (!item) {
+        return null;
+      }
+
+      versions = [{ did, version: item.version }];
 
-      versions = await Promise.all(tasks);
       this.cachedBlockletVersions.set(did, versions);
     }
 
@@ -3505,6 +3605,38 @@ class BlockletManager extends BaseBlockletManager {
 
     return versions[0];
   }
+
+  async _runPreInstallHook(blocklet, context) {
+    const nodeEnvironments = await states.node.getEnvironments();
+
+    const preInstall = (b) =>
+      hooks.preInstall(b.env.processId, {
+        hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+        env: { ...nodeEnvironments },
+        appDir: b.env.appDir,
+        did: blocklet.meta.did, // root blocklet did
+        notification: states.notification,
+        context,
+      });
+
+    await forEachBlocklet(blocklet, preInstall, { parallel: true });
+  }
+
+  async _runPostInstallHook(blocklet, context) {
+    const nodeEnvironments = await states.node.getEnvironments();
+
+    const postInstall = (b, { ancestors }) =>
+      hooks.postInstall(b.env.processId, {
+        hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
+        env: getRuntimeEnvironments(b, nodeEnvironments, ancestors),
+        appDir: b.env.appDir,
+        did: blocklet.meta.did, // root blocklet did
+        notification: states.notification,
+        context,
+      });
+
+    await forEachBlocklet(blocklet, postInstall, { parallel: true });
+  }
 }
 
 module.exports = BlockletManager;