@abtnode/core 1.7.26 → 1.8.1

package/lib/blocklet/manager/disk.js

@@ -10,7 +10,7 @@ const capitalize = require('lodash/capitalize');
 const { Throttle } = require('stream-throttle');
 const LRU = require('lru-cache');
 const joi = require('joi');
-
+const { sign } = require('@arcblock/jwt');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { verifyPresentation } = require('@arcblock/vc');
 const { toBase58, isHex } = require('@ocap/util');
@@ -22,6 +22,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 handleInstanceInStore = require('@abtnode/util/lib/public-to-store');
 const { VC_TYPE_BLOCKLET_PURCHASE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
@@ -45,6 +46,7 @@ const toBlockletDid = require('@blocklet/meta/lib/did');
 const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { titleSchema, descriptionSchema } = require('@blocklet/meta/lib/schema');
+const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
 
 const {
   BlockletStatus,
@@ -101,7 +103,6 @@ const {
   getDiffFiles,
   getBundleDir,
   needBlockletDownload,
-  verifyPurchase,
   findAvailableDid,
   ensureMeta,
 } = require('../../util/blocklet');
@@ -172,13 +173,15 @@ class BlockletManager extends BaseBlockletManager {
   /**
    * @param {*} dataDirs generate by ../../util:getDataDirs
    */
-  constructor({ dataDirs, registry, startQueue, installQueue, daemon = false }) {
+  constructor({ dataDirs, registry, startQueue, installQueue, daemon = false, teamManager }) {
     super();
 
     this.dataDirs = dataDirs;
     this.installDir = dataDirs.blocklets;
     this.startQueue = startQueue;
     this.installQueue = installQueue;
+    this.teamManager = teamManager;
+
     /**
      * { did: Map({ <childDid>: <downloadFile.cancelCtrl> }) }
      */
@@ -209,13 +212,35 @@ class BlockletManager extends BaseBlockletManager {
   // ============================================================================================
 
   /**
-   * @param {Object} params
-   * @param {string} params.installId
-   * @param {string} params.sync default: false
+   *
+   *
+   * @param {{
+   *  url: string;
+   *  sync: boolean = false;
+   *  downloadToken: string;
+   * }} params
+   * @param {{
+   *  [key: string]: any
+   * }} context
+   * @return {*}
+   * @memberof BlockletManager
    */
-  async install(params, context) {
+  async install(params, context = {}) {
     logger.debug('install blocklet', { params, context });
 
+    if (params.downloadToken) {
+      const info = await states.node.read();
+
+      context.headers = Object.assign(context?.headers || {}, {
+        'x-server-did': info.did,
+        'x-download-token': params.downloadToken,
+        'x-server-publick-key': info.pk,
+        'x-server-signature': sign(info.did, info.sk, {
+          exp: (Date.now() + 5 * 60 * 1000) / 1000,
+        }),
+      });
+    }
+
     const source = getSourceFromInstallParams(params);
     if (typeof context.startImmediately === 'undefined') {
       context.startImmediately = !!params.startImmediately;
@@ -245,7 +270,6 @@ class BlockletManager extends BaseBlockletManager {
   /**
    * @param {String} rootDid
    * @param {String} mountPoint
-   * @param {Boolean} context.blockletPurchaseVerified
    *
    * installFromUrl
    * @param {String} url
@@ -259,8 +283,13 @@ class BlockletManager extends BaseBlockletManager {
    * Custom info
    * @param {String} title custom component title
    * @param {String} name custom component name
+   *
+   * @param {ConfigEntry} configs pre configs
    */
-  async installComponent({ rootDid, mountPoint, url, file, did, diffVersion, deleteSet, title, name }, context = {}) {
+  async installComponent(
+    { rootDid, mountPoint, url, file, did, diffVersion, deleteSet, title, name, configs, downloadToken },
+    context = {}
+  ) {
     logger.debug('start install component', { rootDid, mountPoint, url });
 
     if (file) {
@@ -268,7 +297,17 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     if (url) {
-      return this._installComponentFromUrl({ rootDid, mountPoint, url, context, title, did, name });
+      return this._installComponentFromUrl({
+        rootDid,
+        mountPoint,
+        url,
+        context,
+        title,
+        did,
+        name,
+        configs,
+        downloadToken,
+      });
     }
 
     // should not be here
@@ -295,10 +334,12 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
+    const { inStore, registryUrl } = await parseSourceUrl(url);
+
     const blocklet = await states.blocklet.getBlocklet(meta.did);
     const isRunning = blocklet ? blocklet.status === BlockletStatus.running : false;
 
-    return { meta, isFree, isInstalled: !!blocklet, isRunning };
+    return { meta, isFree, isInstalled: !!blocklet, isRunning, inStore, registryUrl };
   }
 
   async installBlockletFromVc({ vcPresentation, challenge }, context) {
@@ -317,7 +358,7 @@ class BlockletManager extends BaseBlockletManager {
     const did = get(vc, 'credentialSubject.purchased.blocklet.id');
     const registry = urlObject.origin;
 
-    return this._installFromStore({ did, registry }, { ...context, blockletPurchaseVerified: true });
+    return this._installFromStore({ did, registry }, context);
   }
 
   async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false }, context) {
@@ -399,7 +440,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await this.deleteProcess({ did });
       const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
-      this.emit(BlockletEvents.startFailed, res);
+      this.emit(BlockletEvents.startFailed, { ...res, error: { message: error.message } });
 
       if (throwOnError) {
         throw new Error(description);
@@ -577,7 +618,7 @@ class BlockletManager extends BaseBlockletManager {
   async deleteComponent({ did, rootDid, keepData, keepState }, context) {
     logger.info('delete blocklet component', { did, rootDid, keepData });
 
-    const blocklet = await this.ensureBlocklet(rootDid);
+    const blocklet = await this.ensureBlocklet(rootDid, { validateEnv: false });
     const child = blocklet.children.find((x) => x.meta.did === did);
     if (!child) {
       throw new Error('Component does not exist');
@@ -684,7 +725,7 @@ class BlockletManager extends BaseBlockletManager {
 
     if (!attachRuntimeInfo) {
       try {
-        const blocklet = await this.ensureBlocklet(did);
+        const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
         return blocklet;
       } catch (e) {
         logger.error('get blocklet detail error', { error: e.message });
@@ -827,12 +868,26 @@ class BlockletManager extends BaseBlockletManager {
     return newState;
   }
 
+  async configPublicToStore({ did, publicToStore = false }) {
+    const blocklet = await this.ensureBlocklet(did);
+
+    await handleInstanceInStore(blocklet, { publicToStore });
+    await states.blockletExtras.setSettings(did, { publicToStore });
+
+    const newState = await this.ensureBlocklet(did);
+    return newState;
+  }
+
   /**
    * upgrade blocklet from registry
    */
   async upgrade({ did, registryUrl, sync }, context) {
     const blocklet = await states.blocklet.getBlocklet(did);
 
+    if (!registryUrl && blocklet.source === BlockletSource.url) {
+      return this._installFromUrl({ url: blocklet.deployedFrom }, context);
+    }
+
     // TODO: 查看了下目前页面中的升级按钮，都是会传 registryUrl 过来的，这个函数里的逻辑感觉需要在以后做一个简化
     if (!registryUrl && blocklet.source !== BlockletSource.registry) {
       throw new Error('Wrong upgrade source, empty registryUrl or not installed from blocklet registry');
@@ -1202,14 +1257,17 @@ class BlockletManager extends BaseBlockletManager {
     return rootBlocklet;
   }
 
-  async ensureBlocklet(did, { e2eMode = false, validateEnv = true } = {}) {
+  async ensureBlocklet(did, { e2eMode = false, validateEnv = true, throwOnNotExist = true } = {}) {
     if (!isValidDid(did)) {
       throw new Error(`Blocklet did is invalid: ${did}`);
     }
 
     const blocklet = await states.blocklet.getBlocklet(did);
     if (!blocklet) {
-      throw new Error(`Can not find blocklet in database by did ${did}`);
+      if (throwOnNotExist) {
+        throw new Error(`Can not find blocklet in database by did ${did}`);
+      }
+      return null;
     }
 
     // app settings
@@ -1311,7 +1369,12 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     try {
-      let blocklet = await this.ensureBlocklet(did);
+      let blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
+
+      if (!blocklet) {
+        return null;
+      }
+
       const fromCache = !!cachedBlocklet;
 
       // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
@@ -1408,7 +1471,21 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async onDownload({ blocklet, context, postAction, oldBlocklet, throwOnError }) {
+  /**
+   *
+   *
+   * @param {{
+   *  blocklet: {},
+   *  context: {},
+   *  postAction: 'install' | 'upgrade' | 'downgrade',
+   *  oldBlocklet: {},
+   *  throwOnError: Error
+   * }} params
+   * @return {*}
+   * @memberof BlockletManager
+   */
+  async onDownload(params) {
+    const { blocklet, context, postAction, oldBlocklet, throwOnError } = params;
     const { meta } = blocklet;
     const { name, did, version } = meta;
 
@@ -1433,7 +1510,7 @@ class BlockletManager extends BaseBlockletManager {
 
       preDownloadLock.release();
 
-      const { isCancelled } = await this._downloadBlocklet(blocklet, oldBlocklet);
+      const { isCancelled } = await this._downloadBlocklet(blocklet, oldBlocklet, context);
 
       if (isCancelled) {
         logger.info('Download was canceled manually', { name, did, version });
@@ -1445,7 +1522,12 @@ class BlockletManager extends BaseBlockletManager {
 
       preDownloadLock.release();
 
-      this.emit(BlockletEvents.downloadFailed, { meta: did });
+      this.emit(BlockletEvents.downloadFailed, {
+        meta: { did },
+        error: {
+          message: err.message,
+        },
+      });
       states.notification.create({
         title: 'Blocklet Download Failed',
         description: `Blocklet ${name}@${version} download failed with error: ${err.message}`,
@@ -1624,7 +1706,21 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _installFromStore({ did, registry, sync }, context) {
+  /**
+   ***
+   *
+   * @param {{
+   *  did: string;
+   *  registry: string;
+   *  sync: boolean;
+   * }} params
+   * @param {*} context
+   * @return {*}
+   * @memberof BlockletManager
+   */
+  async _installFromStore(params, context) {
+    const { did, registry, sync } = params;
+
     logger.debug('start install blocklet', { did });
     if (!isValidDid(did)) {
       throw new Error('Blocklet did is invalid');
@@ -1642,8 +1738,6 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('Can not install an already installed blocklet');
     }
 
-    verifyPurchase(meta, context);
-
     // install
     return this._install({
       meta,
@@ -1654,7 +1748,20 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
-  async _installFromUrl({ url, sync }, context) {
+  /**
+   *
+   *
+   * @param {{
+   *  url: string;
+   *  sync: boolean;
+   * }} params
+   * @param {{}} context
+   * @return {*}
+   * @memberof BlockletManager
+   */
+  async _installFromUrl(params, context) {
+    const { url, sync } = params;
+
     logger.debug('start install blocklet', { url });
 
     const { inStore, registryUrl, blockletDid } = await parseSourceUrl(url);
@@ -1695,20 +1802,48 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
-  async _installComponentFromUrl({ rootDid, mountPoint, url, context, title, name: inputName, did: inputDid }) {
+  async _installComponentFromUrl({
+    rootDid,
+    mountPoint,
+    url,
+    context,
+    title,
+    name: inputName,
+    did: inputDid,
+    configs,
+    downloadToken,
+  }) {
     const blocklet = await this._getBlockletForInstallation(rootDid);
     if (!blocklet) {
       throw new Error('Root blocklet does not exist');
     }
 
+    const { inStore } = await 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-download-token': downloadToken,
+          'x-server-publick-key': info.pk,
+          'x-server-signature': sign(info.did, info.sk, {
+            exp: (Date.now() + 5 * 60 * 1000) / 1000,
+          }),
+        },
+      };
+    }
+
     if (!isComponentBlocklet(meta)) {
       throw new Error('The blocklet cannot be a component');
     }
 
-    verifyPurchase(meta, context);
-
     if (title) {
       meta.title = await titleSchema.validateAsync(title);
     }
@@ -1724,26 +1859,41 @@ class BlockletManager extends BaseBlockletManager {
       did = found.did;
     }
 
-    const newChildren = [
-      {
-        meta: ensureMeta(meta, { did, name }),
-        mountPoint,
-        bundleSource: { url },
-        dynamic: true,
-        children: await parseChildrenFromMeta(meta, { ...context, ancestors: [{ mountPoint }] }),
-      },
-    ];
+    const newChild = {
+      meta: ensureMeta(meta, { did, name }),
+      mountPoint,
+      bundleSource: { url },
+      dynamic: true,
+      children: await parseChildrenFromMeta(meta, { ...context, ancestors: [{ mountPoint }] }),
+    };
 
-    checkDuplicateComponents([...blocklet.children, ...newChildren]);
+    checkDuplicateComponents([...blocklet.children, newChild]);
 
-    // add component to db
-    await states.blocklet.addChildren(rootDid, newChildren);
-    await this._upsertDynamicNavigation(blocklet.meta.did, newChildren[0]);
+    try {
+      // add component to db
+      await states.blocklet.addChildren(rootDid, [newChild]);
+
+      // update navigation
+      await this._upsertDynamicNavigation(blocklet.meta.did, newChild);
+
+      // 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, ...newChildren],
+        children: [...blocklet.children, newChild],
         oldBlocklet: blocklet,
       },
       context
@@ -2033,50 +2183,15 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('the blocklet is not installed');
     }
 
-    const { 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
-
-      versions = await Promise.all(tasks);
-      this.cachedBlockletVersions.set(did, versions);
-    }
-
-    versions = versions.filter((item) => item && semver.gt(item.version, version));
-
-    if (versions.length === 0) {
-      return null;
-    }
-
-    // When new version found from the store where the blocklet was installed from, we should use that store first
     if (blocklet.source === BlockletSource.registry && blocklet.deployedFrom) {
-      const latestFromSameRegistry = versions.find((x) => x.registryUrl === blocklet.deployedFrom);
-      if (latestFromSameRegistry) {
-        return latestFromSameRegistry;
-      }
+      return this._getLatestBlockletVersionFromStore({ blocklet, version });
     }
 
-    // Otherwise try upgrading from other store
-    let latestBlockletVersion = versions[0];
-    versions.forEach((item) => {
-      if (semver.lt(latestBlockletVersion.version, item.version)) {
-        latestBlockletVersion = item;
-      }
-    });
+    if (blocklet.source === BlockletSource.url && blocklet.deployedFrom) {
+      return this._getLatestBlockletVersionFromUrl({ blocklet, version });
+    }
 
-    return latestBlockletVersion;
+    return null;
   }
 
   getCrons() {
@@ -2132,7 +2247,22 @@ class BlockletManager extends BaseBlockletManager {
       .filter((x) => (skipDeleted ? x.status !== BlockletStatus.deleted : true));
   }
 
-  async _install({ meta, source, deployedFrom, context, sync }) {
+  /**
+   *
+   *
+   * @param {{
+   *  meta: {}; // blocklet meta
+   *  source: number; // example: BlockletSource.registry,
+   *  deployedFrom: string;
+   *  context: {}
+   *  sync: boolean = false;
+   * }} params
+   * @return {*}
+   * @memberof BlockletManager
+   */
+  async _install(params) {
+    const { meta, source, deployedFrom, context, sync } = params;
+
     validateBlockletMeta(meta, { ensureDist: true });
 
     const { name, did, version } = meta;
@@ -2141,6 +2271,7 @@ class BlockletManager extends BaseBlockletManager {
 
     const children = await this._getChildrenForInstallation(meta);
     try {
+      // 创建一个blocklet到database
       const blocklet = await states.blocklet.addBlocklet({
         meta,
         source,
@@ -2157,7 +2288,15 @@ class BlockletManager extends BaseBlockletManager {
       const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
       this.emit(BlockletEvents.added, blocklet1);
 
-      // download
+      /** @type {{
+       *  blocklet: any;
+       *  oldBlocklet: {
+       *    children: any[];
+       *    extraState: any;
+       *  };
+       *  context: {};
+       *  postAction: string
+       * }} */
       const downloadParams = {
         blocklet: { ...blocklet1 },
         oldBlocklet: {
@@ -2220,6 +2359,13 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
+  /**
+   *
+   *
+   * @param {{}} { meta, source, deployedFrom, context, sync }
+   * @return {*}
+   * @memberof BlockletManager
+   */
   async _upgrade({ meta, source, deployedFrom, context, sync }) {
     validateBlockletMeta(meta, { ensureDist: meta.group !== BlockletGroup.gateway });
 
@@ -2242,6 +2388,26 @@ class BlockletManager extends BaseBlockletManager {
 
     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-download-token': blocklet?.tokens?.paidBlockletDownloadToken,
+          'x-server-publick-key': info.pk,
+          'x-server-signature': sign(info.did, info.sk, {
+            exp: (Date.now() + 5 * 60 * 1000) / 1000,
+          }),
+        },
+      };
+    }
+
     // download
     const downloadParams = {
       oldBlocklet: { ...oldBlocklet },
@@ -2255,7 +2421,6 @@ class BlockletManager extends BaseBlockletManager {
       await this.onDownload({ ...downloadParams, throwOnError: true });
       return states.blocklet.getBlocklet(did);
     }
-
     const ticket = this.installQueue.push(
       {
         entity: 'blocklet',
@@ -2469,6 +2634,14 @@ class BlockletManager extends BaseBlockletManager {
       // Update dynamic component meta in blocklet settings
       await this._ensureDynamicChildrenInSettings(blocklet);
 
+      if (context?.headers?.['x-download-token']) {
+        await states.blocklet.updateBlocklet(did, {
+          tokens: {
+            paidBlockletDownloadToken: context.headers['x-download-token'],
+          },
+        });
+      }
+
       states.notification.create({
         title: 'Blocklet Installed',
         description: `Blocklet ${meta.name}@${meta.version} is installed successfully. (Source: ${
@@ -2486,7 +2659,12 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('failed to install blocklet', { name, did, version, error: err });
       try {
         await this._rollback('install', did, oldBlocklet);
-        this.emit(BlockletEvents.installFailed, { meta: { did } });
+        this.emit(BlockletEvents.installFailed, {
+          meta: { did },
+          error: {
+            message: err.message,
+          },
+        });
         states.notification.create({
           title: 'Blocklet Install Failed',
           description: `Blocklet ${meta.name}@${meta.version} install failed with error: ${err.message}`,
@@ -2657,11 +2835,23 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   /**
-   * for download: cwd, tarball, did
-   * for verify: verify, integrity
-   * for cancel control: ctrlStore, rootDid
+   *
+   *
+   * @param {{
+   *   url: string,
+   *   cwd: string,
+   *   tarball: string,
+   *   did: string,
+   *   integrity: string,
+   *   verify: boolean = true,
+   *   ctrlStore: {},
+   *   rootDid: string,
+   *   context: {} = {},
+   * }} { url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }
+   * @return {*}
+   * @memberof BlockletManager
    */
-  async _downloadTarball({ url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid }) {
+  async _downloadTarball({ url, cwd, tarball, did, integrity, verify = true, ctrlStore = {}, rootDid, context = {} }) {
     fs.mkdirSync(cwd, { recursive: true });
 
     const tarballName = url.split('/').slice(-1)[0];
@@ -2673,7 +2863,7 @@ class BlockletManager extends BaseBlockletManager {
     const cachedTarFile = await this._getCachedTarFile(integrity);
     if (cachedTarFile) {
       logger.info('found cache tarFile', { did, tarballName, integrity });
-      await fs.move(cachedTarFile, tarballPath);
+      await fs.move(cachedTarFile, tarballPath, { overwrite: true });
     } else if (protocol.startsWith('file')) {
       await fs.copy(decodeURIComponent(pathname), tarballPath);
     } else {
@@ -2684,7 +2874,7 @@ class BlockletManager extends BaseBlockletManager {
       }
       ctrlStore[rootDid].set(did, cancelCtrl);
 
-      await downloadFile(url, path.join(cwd, tarballName), { cancelCtrl });
+      await downloadFile(url, path.join(cwd, tarballName), { cancelCtrl }, context);
 
       if (ctrlStore[rootDid]) {
         ctrlStore[rootDid].delete(did);
@@ -2773,12 +2963,16 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   /**
-   * download bundle, verify bundle, resolve bundle to installDir
-   * @param {object} meta
-   * @param {string} rootDid root blocklet did of the blocklet to be downloaded
-   * @return {object} { isCancelled: Boolean }
+   *
+   *
+   * @param {*} meta
+   * @param {*} rootDid
+   * @param {*} url
+   * @param {{}} [context={}]
+   * @return {*}
+   * @memberof BlockletManager
    */
-  async _downloadBundle(meta, rootDid, url) {
+  async _downloadBundle(meta, rootDid, url, context = {}) {
     const { bundleName: name, bundleDid: did, version, dist = {} } = meta;
     const { tarball, integrity } = dist;
 
@@ -2806,6 +3000,7 @@ class BlockletManager extends BaseBlockletManager {
         ctrlStore: this.downloadCtrls,
         rootDid,
         url,
+        context,
       });
       logger.info('downloaded blocklet tar file', { name, version, tarballPath });
       if (tarballPath === downloadFile.CANCEL) {
@@ -2826,7 +3021,16 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _downloadBlocklet(blocklet, oldBlocklet = {}) {
+  /**
+   *
+   *
+   * @param {{}} blocklet
+   * @param {{}} [oldBlocklet={}]
+   * @param {{}} [context={}]
+   * @return {*}
+   * @memberof BlockletManager
+   */
+  async _downloadBlocklet(blocklet, oldBlocklet = {}, context = {}) {
     const {
       meta: { name, did },
     } = blocklet;
@@ -2880,7 +3084,7 @@ class BlockletManager extends BaseBlockletManager {
           tarball: get(meta, 'dist.tarball'),
           registryUrl: blocklet.source === BlockletSource.registry ? blocklet.deployedFrom : undefined,
         });
-        tasks.push(this._downloadBundle(meta, did, url));
+        tasks.push(this._downloadBundle(meta, did, url, context));
       }
       const results = await Promise.all(tasks);
       if (results.find((x) => x.isCancelled)) {
@@ -2976,6 +3180,9 @@ class BlockletManager extends BaseBlockletManager {
     const logsDir = path.join(this.dataDirs.logs, name);
     const cacheDir = path.join(this.dataDirs.cache, name);
 
+    // Cleanup db
+    await this.teamManager.deleteTeam(blocklet.meta.did);
+
     // Cleanup disk storage
     fs.removeSync(cacheDir);
     if (keepData === false) {
@@ -3068,6 +3275,78 @@ class BlockletManager extends BaseBlockletManager {
 
     return blocklet;
   }
+
+  async _getLatestBlockletVersionFromStore({ blocklet, version }) {
+    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
+
+      versions = await Promise.all(tasks);
+      this.cachedBlockletVersions.set(did, versions);
+    }
+
+    versions = versions.filter((item) => item && semver.gt(item.version, version));
+
+    if (versions.length === 0) {
+      return null;
+    }
+
+    // When new version found from the store where the blocklet was installed from, we should use that store first
+    if (blocklet.source === BlockletSource.registry && blocklet.deployedFrom) {
+      const latestFromSameRegistry = versions.find((x) => x.registryUrl === blocklet.deployedFrom);
+      if (latestFromSameRegistry) {
+        return latestFromSameRegistry;
+      }
+    }
+
+    // Otherwise try upgrading from other store
+    let latestBlockletVersion = versions[0];
+    versions.forEach((item) => {
+      if (semver.lt(latestBlockletVersion.version, item.version)) {
+        latestBlockletVersion = item;
+      }
+    });
+
+    return latestBlockletVersion;
+  }
+
+  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];
+  }
 }
 
 module.exports = BlockletManager;