@abtnode/core 1.8.31 → 1.8.32

package/lib/api/node.js

@@ -13,8 +13,8 @@ const logger = require('@abtnode/logger')('@abtnode/core:api:node');
 
 const IP = require('../util/ip');
 const { validateNodeInfo, validateUpdateGateway } = require('../validators/node');
-const BlockletRegistry = require('../blocklet/registry');
 const { getAll } = require('../blocklet/manager/engine');
+const StoreUtil = require('../util/store');
 const { getDelegateState } = require('../util');
 
 const sanitizeUrl = (url) => {
@@ -59,9 +59,9 @@ class NodeAPI {
       throw new Error(`Blocklet registry already exist: ${sanitized}`);
     }
 
-    await BlockletRegistry.validateRegistryURL(sanitized);
+    await StoreUtil.validateRegistryURL(sanitized);
 
-    const newBlockletRegistry = await BlockletRegistry.getRegistryMeta(sanitized);
+    const newBlockletRegistry = await StoreUtil.getRegistryMeta(sanitized);
     const newBlockletRegistryList = info.blockletRegistryList.map((x) => ({ ...x, selected: false }));
     newBlockletRegistryList.push({ ...newBlockletRegistry, url: sanitized, selected: true, protected: false });
 

package/lib/api/team.js

@@ -10,6 +10,7 @@ const {
   WHO_CAN_ACCESS,
   PASSPORT_STATUS,
   WELLKNOWN_SERVICE_PATH_PREFIX,
+  MAX_USER_PAGE_SIZE,
 } = require('@abtnode/constant');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { BlockletEvents } = require('@blocklet/constant');
@@ -30,8 +31,6 @@ const { validateCreatePermission, validateUpdatePermission } = require('../valid
 
 const { getBlocklet } = require('../util/blocklet');
 
-const MAX_USER_PAGE_SIZE = 100;
-
 const validateReservedRole = (role) => {
   if (Object.values(ROLES).includes(role)) {
     throw new Error(`The role ${role} is reserved`);
@@ -126,14 +125,33 @@ class TeamAPI extends EventEmitter {
     return doc;
   }
 
-  async getUsers({ teamDid, query, paging: inputPaging, sort }) {
+  async getUsers({ teamDid, query, paging: inputPaging, sort, dids }) {
     const state = await this.getUserState(teamDid);
 
     if (inputPaging?.pageSize > MAX_USER_PAGE_SIZE) {
       throw new Error(`Length of users should not exceed ${MAX_USER_PAGE_SIZE} per page`);
     }
 
-    const { list, paging } = await state.getUsers({ query, sort, paging: { pageSize: 20, ...inputPaging } });
+    if (dids && dids.length > MAX_USER_PAGE_SIZE) {
+      throw new Error(`Length of users should not exceed ${MAX_USER_PAGE_SIZE}`);
+    }
+
+    let list;
+    let paging;
+
+    if (dids) {
+      list = await state.getUsersByDids({ query, dids });
+      paging = {
+        total: list.length,
+        pageSize: dids.length,
+        pageCount: 1,
+        page: 1,
+      };
+    } else {
+      const doc = await state.getUsers({ query, sort, paging: { pageSize: 20, ...inputPaging } });
+      list = doc.list;
+      paging = doc.paging;
+    }
 
     return {
       users: list.map(

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) {
@@ -343,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);
@@ -356,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) {
@@ -388,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');
       }
@@ -400,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) {
@@ -811,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
@@ -1067,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
@@ -1359,13 +1409,24 @@ 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));
 
@@ -1397,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, { skipNavigation });
+    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 = {}) {
@@ -1881,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)) {
@@ -1895,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,
       });
     }
@@ -1966,6 +2066,8 @@ class BlockletManager extends BaseBlockletManager {
       source: BlockletSource.url,
       deployedFrom: url,
       sync,
+      delay,
+      controller,
       context,
     });
   }
@@ -1987,7 +2089,7 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('Root blocklet does not exist');
     }
 
-    const { inStore } = await parseSourceUrl(url);
+    const { inStore } = await StoreUtil.parseSourceUrl(url);
 
     const meta = await getBlockletMetaFromUrl(url);
 
@@ -2125,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 });
@@ -2437,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 });
 
@@ -2458,6 +2562,7 @@ class BlockletManager extends BaseBlockletManager {
         source,
         deployedFrom,
         children,
+        controller,
       });
 
       await validateBlocklet(blocklet);
@@ -2493,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) {
@@ -2780,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);
@@ -2892,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 {
@@ -2926,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,
@@ -3275,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);
@@ -3473,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);
     }
 
@@ -3543,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;

package/lib/index.js

@@ -11,7 +11,6 @@ const { listProviders } = require('@abtnode/router-provider');
 const { DEFAULT_CERTIFICATE_EMAIL, EVENTS } = require('@abtnode/constant');
 
 const RoutingSnapshot = require('./states/routing-snapshot');
-const BlockletRegistry = require('./blocklet/registry');
 const BlockletManager = require('./blocklet/manager/disk');
 const RouterManager = require('./router/manager');
 const getRouterHelpers = require('./router/helper');
@@ -27,6 +26,7 @@ const DomainStatus = require('./util/domain-status');
 const Upgrade = require('./util/upgrade');
 const resetNode = require('./util/reset-node');
 const DiskMonitor = require('./util/disk-monitor');
+const StoreUtil = require('./util/store');
 const createQueue = require('./queue');
 const createEvents = require('./event');
 const pm2Events = require('./blocklet/manager/pm2-events');
@@ -123,15 +123,12 @@ function ABTNode(options) {
     },
   });
 
-  const blockletRegistry = new BlockletRegistry();
-
   const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
 
   const blockletManager = new BlockletManager({
     dataDirs,
     startQueue,
     installQueue,
-    registry: blockletRegistry,
     daemon: options.daemon,
     teamManager,
   });
@@ -207,6 +204,7 @@ function ABTNode(options) {
     upgradeComponents: blockletManager.updateChildren.bind(blockletManager),
     getLatestBlockletVersion: blockletManager.getLatestBlockletVersion.bind(blockletManager),
     getBlockletMetaFromUrl: blockletManager.getMetaFromUrl.bind(blockletManager),
+    getBlockletByBundle: blockletManager.getBlockletByBundle.bind(blockletManager),
     resetBlocklet: blockletManager.reset.bind(blockletManager),
     deleteBlockletProcess: blockletManager.deleteProcess.bind(blockletManager),
     configPublicToStore: blockletManager.configPublicToStore.bind(blockletManager),
@@ -226,9 +224,9 @@ function ABTNode(options) {
     updateAllBlockletEnvironment: blockletManager.updateAllBlockletEnvironment.bind(blockletManager),
     setBlockletInitialized: blockletManager.setInitialized.bind(blockletManager),
 
-    // Registry
-    getBlockletMeta: blockletRegistry.getBlockletMeta.bind(blockletRegistry),
-    getRegistryMeta: BlockletRegistry.getRegistryMeta,
+    // Store
+    getBlockletMeta: StoreUtil.getBlockletMeta,
+    getRegistryMeta: StoreUtil.getRegistryMeta,
 
     // Node State
     getNodeInfo: nodeAPI.getInfo.bind(nodeAPI),

package/lib/states/README.md

@@ -33,3 +33,6 @@ All Blocklet Server states are managed by files in this folder.
 - `children`: component of app, same structure as parent, can be nested
 - `mountPoint` mount path of web site. _component only_
 - `dynamic` is dynamically added. _component only_
+- `controller`
+- `tokens`
+  - `downloadTokenList`

package/lib/states/blocklet.js

@@ -23,6 +23,7 @@ const logger = require('@abtnode/logger')('state-blocklet');
 const BaseState = require('./base');
 const { checkDuplicateComponents, ensureMeta } = require('../util/blocklet');
 const { validateBlockletMeta } = require('../util');
+const { validateBlockletController } = require('../validators/blocklet');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
@@ -180,11 +181,12 @@ class BlockletState extends BaseState {
     deployedFrom = '',
     mode = BLOCKLET_MODES.PRODUCTION,
     children: rawChildren = [],
+    controller,
   } = {}) {
     return this.getBlocklet(meta.did).then(
-      (doc) =>
+      (exist) =>
         new Promise(async (resolve, reject) => {
-          if (doc) {
+          if (exist) {
             reject(new Error('Blocklet already added'));
             return;
           }
@@ -208,29 +210,33 @@ class BlockletState extends BaseState {
 
             fixChildren(children);
 
+            const data = {
+              appDid: null, // will updated later when updating blocklet environments
+              mode,
+              meta: sanitized,
+              status,
+              source,
+              deployedFrom,
+              ports,
+              environments: [],
+              children,
+              controller,
+            };
+
+            if (controller) {
+              data.controller = await validateBlockletController(controller);
+            }
+
             // add to db
-            this.insert(
-              {
-                appDid: null, // will updated later when updating blocklet environments
-                mode,
-                meta: sanitized,
-                status,
-                source,
-                deployedFrom,
-                ports,
-                environments: [],
-                children,
-              },
-              (err, newDoc) => {
-                lock.release();
-                if (err) {
-                  return reject(err);
-                }
-
-                this.emit('add', newDoc);
-                return resolve(newDoc);
+            this.insert(data, (err, doc) => {
+              lock.release();
+              if (err) {
+                return reject(err);
               }
-            );
+
+              this.emit('add', doc);
+              return resolve(doc);
+            });
           } catch (err) {
             lock.release();
             reject(err);

package/lib/states/user.js

@@ -124,6 +124,22 @@ class User extends BaseState {
     };
   }
 
+  async getUsersByDids({ dids, query } = {}) {
+    const { approved } = query || {};
+    const didList = dids || [];
+
+    const queryParam = {
+      did: { $in: didList },
+    };
+
+    if (!isNullOrUndefined(approved)) {
+      queryParam.approved = !!approved;
+    }
+
+    // get data
+    return this.find(queryParam);
+  }
+
   async getUser(did) {
     const doc = await this.findOne({ did });
     return doc;

package/lib/util/requirement.js

@@ -1,8 +1,10 @@
 const semver = require('semver');
 
-let { version: actualVersion } = require('../../package.json');
+let { version: actualServerVersion } = require('../../package.json');
 
-const defaults = { abtnode: '>= 1.1.0', os: '*', cpu: '*' };
+const { version: actualNodejsVersion } = process;
+
+const defaults = { abtnode: '>= 1.1.0', os: '*', cpu: '*', nodejs: '*' };
 
 const isSatisfied = (requirements, throwOnUnsatisfied = true) => {
   if (!requirements || typeof requirements !== 'object') {
@@ -10,15 +12,23 @@ const isSatisfied = (requirements, throwOnUnsatisfied = true) => {
   }
 
   const { platform: actualOs, arch: actualCpu } = process;
-  const { os: expectedOs, cpu: expectedCpu, abtnode, server } = Object.assign(defaults, requirements);
-  const expectedVersion = server || abtnode;
+  const {
+    os: expectedOs,
+    cpu: expectedCpu,
+    abtnode,
+    server,
+    nodejs: expectedNodejsVersion,
+  } = Object.assign(defaults, requirements);
+  const expectedServerVersion = server || abtnode;
 
   const isOsSatisfied =
     expectedOs === '*' || expectedOs === actualOs || (Array.isArray(expectedOs) && expectedOs.includes(actualOs));
   const isCpuSatisfied =
     expectedCpu === '*' || expectedCpu === actualCpu || (Array.isArray(expectedCpu) && expectedCpu.includes(actualCpu));
 
-  const isVersionSatisfied = semver.satisfies(semver.coerce(actualVersion), expectedVersion);
+  const isServerVersionSatisfied = semver.satisfies(semver.coerce(actualServerVersion), expectedServerVersion);
+
+  const isNodejsVersionSatisfied = semver.satisfies(semver.coerce(actualNodejsVersion), expectedNodejsVersion);
 
   if (throwOnUnsatisfied) {
     if (isOsSatisfied === false) {
@@ -27,19 +37,25 @@ const isSatisfied = (requirements, throwOnUnsatisfied = true) => {
     if (isCpuSatisfied === false) {
       throw new Error(`Your blocklet is not supported on architecture ${actualCpu}`);
     }
-    if (isVersionSatisfied === false) {
+    if (isServerVersionSatisfied === false) {
+      throw new Error(
+        `Expected server version for the blocklet is ${expectedServerVersion}, but your server version is ${actualServerVersion}, please upgrade or downgrade your server to continue.`
+      );
+    }
+    if (isNodejsVersionSatisfied === false) {
       throw new Error(
-        `Expected server version for the blocklet is ${expectedVersion}, but your server version is ${actualVersion}, please upgrade or downgrade your server to continue.`
+        `Expected Nodejs version for the blocklet is ${expectedNodejsVersion}, but your Nodejs version is ${actualNodejsVersion}, please upgrade or downgrade Nodejs and restart your server.`
       );
     }
   }
 
-  return isOsSatisfied && isCpuSatisfied && isVersionSatisfied;
+  return isOsSatisfied && isCpuSatisfied && isServerVersionSatisfied;
 };
 
 // Just for test
-isSatisfied._setActualVersion = (d) => {
-  actualVersion = d;
+isSatisfied._setActualServerVersion = (d) => {
+  actualServerVersion = d;
 };
+isSatisfied._actualNodejsVersion = actualNodejsVersion;
 
 module.exports = isSatisfied;

package/lib/util/{registry.js → store.js}

@@ -8,6 +8,7 @@ const { name } = require('../../package.json');
 const logger = require('@abtnode/logger')(`${name}:util:registry`); // eslint-disable-line
 
 const request = require('./request');
+const { fixAndVerifyMetaFromStore } = require('./blocklet');
 
 const validateRegistryURL = async (registry) => {
   const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
@@ -83,8 +84,58 @@ const parseSourceUrl = async (url) => {
   };
 };
 
+const resolveTarballURL = async ({ did, tarball = '', registryUrl = '' }) => {
+  if (!tarball) {
+    return '';
+  }
+
+  if (tarball.startsWith('file://')) {
+    return decodeURIComponent(tarball);
+  }
+
+  if (tarball.startsWith('http://') || tarball.startsWith('https://')) {
+    return tarball;
+  }
+
+  if (!registryUrl) {
+    return '';
+  }
+
+  if (!did) {
+    return '';
+  }
+
+  return joinURL(registryUrl, 'api', 'blocklets', did, tarball);
+};
+
+const getBlockletMeta = async ({ did, registryUrl }) => {
+  const url = joinURL(registryUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`);
+
+  const { data } = await request.get(url);
+  try {
+    if (data.did !== did) {
+      throw new Error('Invalid blocklet meta: did does not match');
+    }
+
+    const meta = fixAndVerifyMetaFromStore(data);
+
+    meta.dist.tarball = await resolveTarballURL({
+      did,
+      tarball: meta.dist.tarball,
+      registryUrl,
+    });
+
+    return meta;
+  } catch (err) {
+    logger.error('failed to get blocklet meta', { did, data, error: err });
+    throw err;
+  }
+};
+
 module.exports = {
   validateRegistryURL,
   getRegistryMeta,
   parseSourceUrl,
+  getBlockletMeta,
+  resolveTarballURL,
 };

package/lib/validators/blocklet.js

@@ -0,0 +1,15 @@
+const JOI = require('joi');
+const { didExtension } = require('@blocklet/meta/lib/extension');
+
+const Joi = JOI.extend(didExtension);
+
+const blockletController = Joi.object({
+  id: Joi.DID().required(), // userDid
+  vcId: Joi.DID().required(),
+  appMaxCount: Joi.number().required().min(1),
+  expireDate: Joi.date(),
+}).options({ stripUnknown: true });
+
+module.exports = {
+  validateBlockletController: (entity) => blockletController.validateAsync(entity),
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.31",
+  "version": "1.8.32",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,32 +19,32 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.8.31",
-    "@abtnode/certificate-manager": "1.8.31",
-    "@abtnode/constant": "1.8.31",
-    "@abtnode/cron": "1.8.31",
-    "@abtnode/db": "1.8.31",
-    "@abtnode/logger": "1.8.31",
-    "@abtnode/queue": "1.8.31",
-    "@abtnode/rbac": "1.8.31",
-    "@abtnode/router-provider": "1.8.31",
-    "@abtnode/static-server": "1.8.31",
-    "@abtnode/timemachine": "1.8.31",
-    "@abtnode/util": "1.8.31",
-    "@arcblock/did": "1.17.23",
+    "@abtnode/auth": "1.8.32",
+    "@abtnode/certificate-manager": "1.8.32",
+    "@abtnode/constant": "1.8.32",
+    "@abtnode/cron": "1.8.32",
+    "@abtnode/db": "1.8.32",
+    "@abtnode/logger": "1.8.32",
+    "@abtnode/queue": "1.8.32",
+    "@abtnode/rbac": "1.8.32",
+    "@abtnode/router-provider": "1.8.32",
+    "@abtnode/static-server": "1.8.32",
+    "@abtnode/timemachine": "1.8.32",
+    "@abtnode/util": "1.8.32",
+    "@arcblock/did": "1.18.1",
     "@arcblock/did-motif": "^1.1.10",
-    "@arcblock/did-util": "1.17.23",
-    "@arcblock/event-hub": "1.17.23",
-    "@arcblock/jwt": "^1.17.23",
+    "@arcblock/did-util": "1.18.1",
+    "@arcblock/event-hub": "1.18.1",
+    "@arcblock/jwt": "^1.18.1",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "1.17.23",
-    "@blocklet/constant": "1.8.31",
-    "@blocklet/meta": "1.8.31",
-    "@blocklet/sdk": "1.8.31",
+    "@arcblock/vc": "1.18.1",
+    "@blocklet/constant": "1.8.32",
+    "@blocklet/meta": "1.8.32",
+    "@blocklet/sdk": "1.8.32",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.17.23",
-    "@ocap/util": "1.17.23",
-    "@ocap/wallet": "1.17.23",
+    "@ocap/mcrypto": "1.18.1",
+    "@ocap/util": "1.18.1",
+    "@ocap/wallet": "1.18.1",
     "@slack/webhook": "^5.0.4",
     "axios": "^0.27.2",
     "axon": "^2.0.3",
@@ -81,5 +81,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "f3cc8becdca1b8c5e645eb8cf751fa780cf09cfe"
+  "gitHead": "8502244aeda5926b3433c1dd9142e63233e3c23c"
 }

package/lib/blocklet/registry.js

@@ -1,74 +0,0 @@
-const joinURL = require('url-join');
-const { BLOCKLET_STORE_API_PREFIX } = require('@abtnode/constant');
-
-const { name } = require('../../package.json');
-
-const logger = require('@abtnode/logger')(`${name}:blocklet:registry`); // eslint-disable-line
-
-const request = require('../util/request');
-
-const states = require('../states');
-const { fixAndVerifyMetaFromStore } = require('../util/blocklet');
-const { validateRegistryURL, getRegistryMeta } = require('../util/registry');
-
-class BlockletRegistry {
-  constructor() {
-    this.blocklets = [];
-    this.cacheId = '';
-  }
-
-  getBlocklet(id, registryUrl) {
-    return this.getBlockletMeta({ did: id, registryUrl });
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  async getBlockletMeta({ did, registryUrl }, context) {
-    const defaultRegistryUrl = await states.node.getBlockletRegistry();
-
-    const url = joinURL(
-      registryUrl || defaultRegistryUrl,
-      BLOCKLET_STORE_API_PREFIX,
-      `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`
-    );
-
-    const { data } = await request.get(url);
-    try {
-      if (data.did !== did) {
-        throw new Error('Invalid blocklet meta: did does not match');
-      }
-
-      return fixAndVerifyMetaFromStore(data);
-    } catch (err) {
-      logger.error('failed to get blocklet meta', { did, data, error: err });
-      throw err;
-    }
-  }
-
-  async resolveTarballURL({ did, tarball = '', registryUrl = '' }) {
-    if (!tarball) {
-      return '';
-    }
-
-    if (tarball.startsWith('file://')) {
-      return decodeURIComponent(tarball);
-    }
-
-    if (tarball.startsWith('http://') || tarball.startsWith('https://')) {
-      return tarball;
-    }
-
-    const defaultRegistryUrl = await states.node.getBlockletRegistry();
-    return joinURL(registryUrl || defaultRegistryUrl, 'api', 'blocklets', did, tarball);
-  }
-
-  clearCache() {
-    this.cacheId = '';
-    this.blocklets = [];
-  }
-}
-
-BlockletRegistry.validateRegistryURL = validateRegistryURL;
-
-BlockletRegistry.getRegistryMeta = getRegistryMeta;
-
-module.exports = BlockletRegistry;