@abtnode/core 1.6.4 → 1.6.5

package/lib/blocklet/manager/disk.js

@@ -114,8 +114,6 @@ class BlockletManager extends BaseBlockletManager {
 
     this.dataDirs = dataDirs;
     this.installDir = dataDirs.blocklets;
-    this.state = states.blocklet;
-    this.node = states.node;
     this.startQueue = startQueue;
     this.installQueue = installQueue;
     /**
@@ -127,10 +125,6 @@ class BlockletManager extends BaseBlockletManager {
      */
     this.downloadLocks = {};
     this.registry = registry;
-    this.notification = states.notification;
-    this.session = states.session;
-    this.extras = states.blockletExtras;
-    this.cache = states.cache;
 
     // cached installed blocklets for performance
     this.cachedBlocklets = null;
@@ -232,7 +226,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // update status
-      await this.state.setBlockletStatus(did, BlockletStatus.starting);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting);
       blocklet.status = BlockletStatus.starting;
       this.emit(BlockletEvents.statusChange, blocklet);
 
@@ -243,7 +237,7 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // start process
-      const nodeEnvironments = await this.node.getEnvironments();
+      const nodeEnvironments = await states.node.getEnvironments();
       await startBlockletProcess(blocklet, {
         preStart: (b) =>
           hooks.preStart(b, {
@@ -254,13 +248,13 @@ class BlockletManager extends BaseBlockletManager {
             progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
         nodeEnvironments,
-        nodeInfo: await this.node.read(),
+        nodeInfo: await states.node.read(),
       });
 
       // check blocklet healthy
       const { startTimeout, minConsecutiveTime } = getHealthyCheckTimeout(blocklet, { checkHealthImmediately });
       const params = {
-        blocklet,
+        did,
         context,
         minConsecutiveTime,
         timeout: startTimeout,
@@ -282,7 +276,7 @@ class BlockletManager extends BaseBlockletManager {
       const error = Array.isArray(err) ? err[0] : err;
       logger.error('Failed to start blocklet', { error, did, name: blocklet.meta.name });
       const description = `Start blocklet ${blocklet.meta.name} failed with error: ${error.message}`;
-      this.notification.create({
+      states.notification.create({
         title: 'Start Blocklet Failed',
         description,
         entityType: 'blocklet',
@@ -291,7 +285,7 @@ class BlockletManager extends BaseBlockletManager {
       });
 
       await this.deleteProcess({ did });
-      const res = await this.state.setBlockletStatus(did, BlockletStatus.error);
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
       this.emit(BlockletEvents.startFailed, res);
 
       if (throwOnError) {
@@ -309,12 +303,12 @@ class BlockletManager extends BaseBlockletManager {
     const { appId } = blocklet.env;
 
     if (updateStatus) {
-      await this.state.setBlockletStatus(did, BlockletStatus.stopping);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
       blocklet.status = BlockletStatus.stopping;
       this.emit(BlockletEvents.statusChange, blocklet);
     }
 
-    const nodeEnvironments = await this.node.getEnvironments();
+    const nodeEnvironments = await states.node.getEnvironments();
 
     await stopBlockletProcess(blocklet, {
       preStop: (b) =>
@@ -323,7 +317,7 @@ class BlockletManager extends BaseBlockletManager {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments),
           did, // root blocklet did
-          notification: this.notification,
+          notification: states.notification,
           context,
           exitOnError: false,
           progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
@@ -344,18 +338,18 @@ class BlockletManager extends BaseBlockletManager {
   async restart({ did }, context) {
     logger.info('restart blocklet', { did });
 
-    await this.state.setBlockletStatus(did, BlockletStatus.stopping);
-    const result = await this.state.getBlocklet(did);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
+    const result = await states.blocklet.getBlocklet(did);
     this.emit(BlockletEvents.statusChange, result);
 
     const ticket = this.startQueue.push({ entity: 'blocklet', action: 'restart', id: did, did, context });
     ticket.on('failed', async (err) => {
       logger.error('failed to restart blocklet', { did, error: err });
 
-      const state = await this.state.setBlockletStatus(did, BlockletStatus.stopped);
+      const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
       this.emit(BlockletEvents.statusChange, state);
 
-      this.notification.create({
+      states.notification.create({
         title: 'Blocklet Restart Failed',
         description: `Blocklet ${did} restart failed with error: ${err.message || 'queue exception'}`,
         entityType: 'blocklet',
@@ -371,9 +365,9 @@ class BlockletManager extends BaseBlockletManager {
   async reload({ did }, context) {
     const blocklet = await this.ensureBlocklet(did);
 
-    await this.state.setBlockletStatus(did, BlockletStatus.stopping);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
     await reloadBlockletProcess(blocklet);
-    await this.state.setBlockletStatus(did, BlockletStatus.running);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.running);
     logger.info('blocklet reload successfully', { did });
 
     const res = await this.status(did);
@@ -387,7 +381,7 @@ class BlockletManager extends BaseBlockletManager {
     try {
       const blocklet = await this.ensureBlocklet(did);
 
-      const nodeEnvironments = await this.node.getEnvironments();
+      const nodeEnvironments = await states.node.getEnvironments();
 
       await deleteBlockletProcess(blocklet, {
         preDelete: (b) =>
@@ -396,7 +390,7 @@ class BlockletManager extends BaseBlockletManager {
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
             env: getRuntimeEnvironments(b, nodeEnvironments),
             did, // root blocklet did
-            notification: this.notification,
+            notification: states.notification,
             context,
             exitOnError: false,
           }),
@@ -417,7 +411,7 @@ class BlockletManager extends BaseBlockletManager {
   async cancelDownload({ did }, context) {
     await preDownloadLock.acquire();
     try {
-      const blocklet = await this.state.getBlocklet(did);
+      const blocklet = await states.blocklet.getBlocklet(did);
       if (!blocklet) {
         throw new Error('Can not cancel download for non-exist blocklet in database.', { did });
       }
@@ -446,7 +440,7 @@ class BlockletManager extends BaseBlockletManager {
 
     await deleteBlockletProcess(blocklet);
 
-    const result = await this.state.setBlockletStatus(did, BlockletStatus.stopped);
+    const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
     logger.info('blocklet process deleted successfully', { did });
     return result;
   }
@@ -456,22 +450,27 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('did should not be empty');
     }
 
-    const nodeInfo = await this.node.read();
+    const nodeInfo = await states.node.read();
 
     if (!attachRuntimeInfo) {
-      return this.state.getBlocklet(did);
+      try {
+        const blocklet = await this.ensureBlocklet(did);
+        return blocklet;
+      } catch {
+        return null;
+      }
     }
 
     return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
   async list({ includeRuntimeInfo = true, useCache = true } = {}, context) {
-    const blocklets = await this.state.getBlocklets();
+    const blocklets = await states.blocklet.getBlocklets();
     if (!includeRuntimeInfo) {
       return blocklets;
     }
 
-    const nodeInfo = await this.node.read();
+    const nodeInfo = await states.node.read();
     const updated = (
       await Promise.all(
         blocklets.map((x) => {
@@ -513,7 +512,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // run hook
-    const nodeEnvironments = await this.node.getEnvironments();
+    const nodeEnvironments = await states.node.getEnvironments();
     newConfigs.forEach((x) => {
       if (x.key === 'BLOCKLET_APP_SK') {
         try {
@@ -540,7 +539,7 @@ class BlockletManager extends BaseBlockletManager {
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
       exitOnError: true,
       env: { ...getRuntimeEnvironments(blocklet, nodeEnvironments), ...blocklet.configObj },
-      notification: this.notification,
+      notification: states.notification,
       did,
       context,
       progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
@@ -548,8 +547,8 @@ class BlockletManager extends BaseBlockletManager {
 
     // update db
     const configs = childDid
-      ? await this.extras.setChildConfigs(did, childDid, newConfigs)
-      : await this.extras.setConfigs(did, newConfigs);
+      ? await states.blockletExtras.setChildConfigs(did, childDid, newConfigs)
+      : await states.blockletExtras.setConfigs(did, newConfigs);
 
     const newState = await this.updateBlockletEnvironment(did);
 
@@ -569,7 +568,7 @@ class BlockletManager extends BaseBlockletManager {
    * upgrade blocklet from registry
    */
   async upgrade({ did, registryUrl }, context) {
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
 
     // TODO: 查看了下目前页面中的升级按钮，都是会传 registryUrl 过来的，这个函数里的逻辑感觉需要在以后做一个简化
     if (!registryUrl && blocklet.source !== BlockletSource.registry) {
@@ -649,7 +648,7 @@ class BlockletManager extends BaseBlockletManager {
 
     logger.info('Get blocklet diff', { did, clientFilesNumber: clientFiles.length });
 
-    const state = await this.state.getBlocklet(did);
+    const state = await states.blocklet.getBlocklet(did);
     if (!state) {
       return {
         hasBlocklet: false,
@@ -707,7 +706,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async checkChildrenForUpdates({ did }) {
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
     const childrenMeta = await getChildrenMeta(blocklet.meta);
     const updateList = getUpdateMetaList(
       blocklet.children.map((x) => x.meta),
@@ -719,7 +718,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // start session
-    const { id: updateId } = await this.session.start({
+    const { id: updateId } = await states.session.start({
       did,
       childrenMeta,
     });
@@ -731,10 +730,10 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async updateChildren({ updateId }, context) {
-    const { did, childrenMeta } = await this.session.end(updateId);
+    const { did, childrenMeta } = await states.session.end(updateId);
 
     // get old blocklet
-    const oldBlocklet = await this.state.getBlocklet(did);
+    const oldBlocklet = await states.blocklet.getBlocklet(did);
     const { meta } = oldBlocklet;
     const { name, version } = meta;
 
@@ -748,10 +747,10 @@ class BlockletManager extends BaseBlockletManager {
     });
 
     // new blocklet
-    const newBlocklet = await this.state.setBlockletStatus(did, BlockletStatus.waiting);
+    const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
     mergeMeta(meta, childrenMeta);
     newBlocklet.meta = meta;
-    newBlocklet.children = await this.state.getChildrenFromMetas(childrenMeta);
+    newBlocklet.children = await states.blocklet.getChildrenFromMetas(childrenMeta);
     await validateBlocklet(newBlocklet);
 
     this.emit(BlockletEvents.statusChange, newBlocklet);
@@ -775,7 +774,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('queue failed', { entity: 'blocklet', action, did, version, name, error: err });
       await this._rollback(action, did, oldBlocklet);
       this.emit(`blocklet.${action}.failed`, { did, version, err });
-      this.notification.create({
+      states.notification.create({
         title: `Blocklet ${capitalize(action)} Failed`,
         description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message || 'queue exception'}`,
         entityType: 'blocklet',
@@ -800,7 +799,7 @@ class BlockletManager extends BaseBlockletManager {
     const { did, version } = meta;
     meta.title = `[DEV] ${meta.title || meta.name}`;
 
-    const exist = await this.state.getBlocklet(did);
+    const exist = await states.blocklet.getBlocklet(did);
     if (exist) {
       if (exist.mode === BLOCKLET_MODES.PRODUCTION) {
         throw new Error('The blocklet of production mode already exists, please remove it before developing');
@@ -826,7 +825,7 @@ class BlockletManager extends BaseBlockletManager {
 
     const childrenMeta = await getChildrenMeta(meta);
     mergeMeta(meta, childrenMeta);
-    const blocklet = await this.state.addBlocklet({
+    const blocklet = await states.blocklet.addBlocklet({
       did,
       meta,
       source: BlockletSource.local,
@@ -837,7 +836,7 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('add blocklet for dev', { did, version, meta });
 
     await this._downloadBlocklet(blocklet);
-    await this.state.setBlockletStatus(did, BlockletStatus.installed);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
     // Add environments
     await this._setConfigs(did);
@@ -852,7 +851,7 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error(`Blocklet did is invalid: ${did}`);
     }
 
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
     if (!blocklet) {
       throw new Error(`Can not find blocklet in database by did ${did}`);
     }
@@ -868,11 +867,11 @@ class BlockletManager extends BaseBlockletManager {
       }),
     };
 
-    const configs = await this.extras.getConfigs(did);
+    const configs = await states.blockletExtras.getConfigs(did);
     fillBlockletConfigs(blocklet, configs);
 
     // merge settings to blocklet
-    const settings = await this.extras.getSettings(did);
+    const settings = await states.blockletExtras.getSettings(did);
     blocklet.trustedPassports = get(settings, 'trustedPassports') || [];
     blocklet.enablePassportIssuance = get(settings, 'enablePassportIssuance', true);
 
@@ -897,7 +896,7 @@ class BlockletManager extends BaseBlockletManager {
         }),
       };
 
-      const childConfigs = await this.extras.getChildConfigs(did, childDid);
+      const childConfigs = await states.blockletExtras.getChildConfigs(did, childDid);
       fillBlockletConfigs(child, childConfigs);
     }
 
@@ -913,7 +912,7 @@ class BlockletManager extends BaseBlockletManager {
         return blocklet;
       }
 
-      return this.state.setBlockletStatus(did, BlockletStatus.stopped);
+      return states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
     };
 
     const blocklet = await this.ensureBlocklet(did);
@@ -931,9 +930,9 @@ class BlockletManager extends BaseBlockletManager {
       const status = await getBlockletStatusFromProcess(blocklet);
       if (shouldUpdateStatus) {
         if (status === BlockletStatus.stopped) {
-          await this.state.stopBlocklet(did);
+          await states.blocklet.stopBlocklet(did);
         }
-        return this.state.setBlockletStatus(did, status);
+        return states.blocklet.setBlockletStatus(did, status);
       }
     } catch (err) {
       if (shouldUpdateStatus) {
@@ -990,7 +989,7 @@ class BlockletManager extends BaseBlockletManager {
           }
 
           if (blocklet.status === BlockletStatus.running) {
-            await this.state.setBlockletStatus(did, BlockletStatus.stopped);
+            await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
             blocklet.status = BlockletStatus.stopped;
           }
         }
@@ -1017,7 +1016,7 @@ class BlockletManager extends BaseBlockletManager {
 
       return blocklet;
     } catch (err) {
-      const simpleState = await this.state.getBlocklet(did);
+      const simpleState = await states.blocklet.getBlocklet(did);
       logger.error('failed to get blocklet info', {
         did,
         name: get(simpleState, 'meta.name'),
@@ -1056,7 +1055,7 @@ class BlockletManager extends BaseBlockletManager {
     try {
       await preDownloadLock.acquire();
 
-      const b0 = await this.state.getBlocklet(did);
+      const b0 = await states.blocklet.getBlocklet(did);
       if (!b0 || ![BlockletStatus.waiting, BlockletStatus.downloading].includes(b0.status)) {
         if (!b0) {
           logger.error('blocklet does not exist before downloading', { name, did });
@@ -1072,7 +1071,7 @@ class BlockletManager extends BaseBlockletManager {
         return;
       }
 
-      const blocklet1 = await this.state.setBlockletStatus(did, BlockletStatus.downloading);
+      const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading);
       this.emit(BlockletEvents.statusChange, blocklet1);
 
       preDownloadLock.release();
@@ -1090,7 +1089,7 @@ class BlockletManager extends BaseBlockletManager {
       preDownloadLock.release();
 
       this.emit(BlockletEvents.downloadFailed, { meta: did });
-      this.notification.create({
+      states.notification.create({
         title: 'Blocklet Download Failed',
         description: `Blocklet ${name}@${version} download failed with error: ${err.message}`,
         entityType: 'blocklet',
@@ -1134,7 +1133,7 @@ class BlockletManager extends BaseBlockletManager {
     const { did, version } = meta;
     logger.info('do install blocklet', { did, version });
 
-    const state = await this.state.setBlockletStatus(did, BlockletStatus.installing);
+    const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.installing);
     this.emit(BlockletEvents.statusChange, state);
 
     try {
@@ -1160,7 +1159,7 @@ class BlockletManager extends BaseBlockletManager {
     const { version, did } = newBlocklet.meta;
     logger.info(`do ${action} blocklet`, { did, version });
 
-    const state = await this.state.setBlockletStatus(did, BlockletStatus.upgrading);
+    const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading);
     this.emit(BlockletEvents.statusChange, state);
 
     try {
@@ -1180,9 +1179,11 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async onCheckIfStarted(jobInfo, { throwOnError } = {}) {
-    const { blocklet, context, minConsecutiveTime = 5000, timeout } = jobInfo;
+    const { did, context, minConsecutiveTime = 5000, timeout } = jobInfo;
+    const blocklet = await this.ensureBlocklet(did);
+
     const { meta } = blocklet;
-    const { did, name } = meta;
+    const { name } = meta;
 
     try {
       // healthy check
@@ -1195,9 +1196,9 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('check blocklet if started failed', { did, name, context, timeout, error });
 
       await this.deleteProcess({ did }, context);
-      await this.state.setBlockletStatus(did, BlockletStatus.error);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
 
-      this.notification.create({
+      states.notification.create({
         title: 'Blocklet Start Failed',
         description: `Blocklet ${name} start failed: ${error.message}`,
         entityType: 'blocklet',
@@ -1215,16 +1216,14 @@ class BlockletManager extends BaseBlockletManager {
 
   async updateBlockletEnvironment(did) {
     const blockletWithEnv = await this.ensureBlocklet(did);
-    const blocklet = await this.state.getBlocklet(did);
-    const nodeInfo = await this.node.read();
+    const blocklet = await states.blocklet.getBlocklet(did);
+    const nodeInfo = await states.node.read();
 
     const rootSystemEnvironments = getRootSystemEnvironments(blockletWithEnv, nodeInfo);
-    const rootConfig = blockletWithEnv.configObj;
     const overwrittenEnvironments = getOverwrittenEnvironments(blockletWithEnv, nodeInfo);
 
     // fill environments to blocklet and blocklet.children
     blocklet.environments = formatEnvironments({
-      ...rootConfig,
       ...getSystemEnvironments(blockletWithEnv),
       ...rootSystemEnvironments,
       ...overwrittenEnvironments,
@@ -1233,10 +1232,7 @@ class BlockletManager extends BaseBlockletManager {
     for (const child of blocklet.children) {
       const childWithEnv = blockletWithEnv.children.find((x) => x.meta.did === child.meta.did);
       if (childWithEnv) {
-        const childConfig = childWithEnv.configObj;
         child.environments = formatEnvironments({
-          ...childConfig, // custom env of child blocklet
-          ...rootConfig, // // custom env of root blocklet FIXME: use options or hooks to make merge logic flexible
           ...getSystemEnvironments(childWithEnv), // system env of child blocklet
           ...rootSystemEnvironments, // system env of root blocklet
           ...overwrittenEnvironments,
@@ -1245,11 +1241,11 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // update state to db
-    return this.state.updateById(blocklet._id, blocklet);
+    return states.blocklet.updateBlocklet(did, blocklet);
   }
 
   async updateAllBlockletEnvironment() {
-    const blocklets = await this.state.getBlocklets();
+    const blocklets = await states.blocklet.getBlocklets();
     for (let i = 0; i < blocklets.length; i++) {
       const blocklet = blocklets[i];
       await this.updateBlockletEnvironment(blocklet.meta.did);
@@ -1269,7 +1265,7 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('Can not install blocklet that not found in registry');
     }
 
-    const state = await this.state.getBlocklet(blocklet.did);
+    const state = await states.blocklet.getBlocklet(blocklet.did);
     if (state) {
       throw new Error('Can not install an already installed blocklet');
     }
@@ -1297,7 +1293,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // upgrade
-    const exist = await this.state.getBlocklet(meta.did);
+    const exist = await states.blocklet.getBlocklet(meta.did);
     if (exist) {
       return this._upgrade({
         meta,
@@ -1346,7 +1342,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // diff deploy
     if (did && diffVersion) {
-      const oldBlocklet = await this.state.getBlocklet(did);
+      const oldBlocklet = await states.blocklet.getBlocklet(did);
       if (!oldBlocklet) {
         throw new Error(`Blocklet ${did} not found when diff deploying`);
       }
@@ -1367,11 +1363,11 @@ class BlockletManager extends BaseBlockletManager {
       const { meta } = await this._resolveDiffDownload(cwd, tarFile, deleteSet, oldBlocklet);
       const childrenMeta = await getChildrenMeta(meta);
       mergeMeta(meta, childrenMeta);
-      const newBlocklet = await this.state.getBlocklet(did);
+      const newBlocklet = await states.blocklet.getBlocklet(did);
       newBlocklet.meta = meta;
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.did}`;
-      newBlocklet.children = await this.state.getChildrenFromMetas(childrenMeta);
+      newBlocklet.children = await states.blocklet.getChildrenFromMetas(childrenMeta);
       await validateBlocklet(newBlocklet);
       await this._downloadBlocklet(newBlocklet, oldBlocklet);
 
@@ -1384,7 +1380,7 @@ class BlockletManager extends BaseBlockletManager {
 
     // full deploy
     const { meta } = await this._resolveDownload(cwd, tarFile);
-    const oldBlocklet = await this.state.getBlocklet(meta.did);
+    const oldBlocklet = await states.blocklet.getBlocklet(meta.did);
 
     if (oldBlocklet) {
       if (isInProgress(oldBlocklet.status)) {
@@ -1394,11 +1390,11 @@ class BlockletManager extends BaseBlockletManager {
 
       const childrenMeta = await getChildrenMeta(meta);
       mergeMeta(meta, childrenMeta);
-      const newBlocklet = await this.state.getBlocklet(meta.did);
+      const newBlocklet = await states.blocklet.getBlocklet(meta.did);
       newBlocklet.meta = meta;
       newBlocklet.source = BlockletSource.upload;
       newBlocklet.deployedFrom = `Upload by ${context.user.did}`;
-      newBlocklet.children = await this.state.getChildrenFromMetas(childrenMeta);
+      newBlocklet.children = await states.blocklet.getChildrenFromMetas(childrenMeta);
 
       await validateBlocklet(newBlocklet);
       await this._downloadBlocklet(newBlocklet, oldBlocklet);
@@ -1412,7 +1408,7 @@ class BlockletManager extends BaseBlockletManager {
 
     const childrenMeta = await getChildrenMeta(meta);
     mergeMeta(meta, childrenMeta);
-    const blocklet = await this.state.addBlocklet({
+    const blocklet = await states.blocklet.addBlocklet({
       did: meta.did,
       meta,
       source: BlockletSource.upload,
@@ -1438,7 +1434,7 @@ class BlockletManager extends BaseBlockletManager {
    * @param {object} blocklet object
    */
   async download(did, blocklet) {
-    await this.state.setBlockletStatus(did, BlockletStatus.waiting);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
     this.installQueue.push(
       {
         entity: 'blocklet',
@@ -1456,7 +1452,7 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('did is required');
     }
 
-    const blocklet = await this.state.findOne({ 'meta.did': did }, { meta: 1, status: 1 });
+    const blocklet = await states.blocklet.getBlocklet(did);
     if (!blocklet) {
       return null;
     }
@@ -1465,12 +1461,12 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async prune() {
-    const blocklets = await this.state.getBlocklets();
+    const blocklets = await states.blocklet.getBlocklets();
     await pruneBlockletBundle(blocklets, this.dataDirs.blocklets);
   }
 
   async getLatestBlockletVersion({ did, version }) {
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
     if (!blocklet) {
       throw new Error('the blocklet is not installed');
     }
@@ -1478,7 +1474,7 @@ class BlockletManager extends BaseBlockletManager {
     let versions = this.cachedBlockletVersions.get(did);
 
     if (!versions) {
-      const { blockletRegistryList } = await this.node.read();
+      const { blockletRegistryList } = await states.node.read();
       const tasks = blockletRegistryList.map((registry) =>
         this.registry
           .getBlockletMeta({ did, registryUrl: registry.url })
@@ -1526,7 +1522,7 @@ class BlockletManager extends BaseBlockletManager {
         name: 'refresh-accessible-ip',
         time: '0 */10 * * * *', // 10min
         fn: async () => {
-          const nodeInfo = await this.node.read();
+          const nodeInfo = await states.node.read();
           await refreshAccessibleExternalNodeIp(nodeInfo);
         },
       },
@@ -1541,7 +1537,7 @@ class BlockletManager extends BaseBlockletManager {
         logger.error('sync blocklet status failed', { error: err });
       }
     };
-    const blocklets = await this.state.getBlocklets();
+    const blocklets = await states.blocklet.getBlocklets();
     blocklets.forEach(run);
   }
 
@@ -1553,7 +1549,7 @@ class BlockletManager extends BaseBlockletManager {
     const childrenMeta = await getChildrenMeta(meta);
     mergeMeta(meta, childrenMeta);
     try {
-      const blocklet = await this.state.addBlocklet({
+      const blocklet = await states.blocklet.addBlocklet({
         did: meta.did,
         meta,
         source,
@@ -1567,7 +1563,7 @@ class BlockletManager extends BaseBlockletManager {
 
       logger.info('blocklet added to database', { meta });
 
-      const blocklet1 = await this.state.setBlockletStatus(did, BlockletStatus.waiting);
+      const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
       this.emit(BlockletEvents.added, blocklet1);
 
       // download
@@ -1579,7 +1575,7 @@ class BlockletManager extends BaseBlockletManager {
 
       if (sync) {
         await this.onDownload({ ...downloadParams, throwOnError: true });
-        return this.state.getBlocklet(did);
+        return states.blocklet.getBlocklet(did);
       }
 
       const ticket = this.installQueue.push(
@@ -1595,12 +1591,12 @@ class BlockletManager extends BaseBlockletManager {
         logger.error('failed to install blocklet', { name, did, version, error: err });
         try {
           await this._delExtras(did);
-          await this.state.deleteBlocklet(did);
+          await states.blocklet.deleteBlocklet(did);
         } catch (e) {
           logger.error('failed to remove blocklet on install error', { did: meta.did, error: e });
         }
 
-        this.notification.create({
+        states.notification.create({
           title: 'Blocklet Install Failed',
           description: `Blocklet ${name}@${version} install failed with error: ${err.message || 'queue exception'}`,
           entityType: 'blocklet',
@@ -1612,7 +1608,7 @@ class BlockletManager extends BaseBlockletManager {
       return blocklet1;
     } catch (err) {
       logger.error('failed to install blocklet', { name, did, version, error: err });
-      this.notification.create({
+      states.notification.create({
         title: 'Blocklet Install Failed',
         description: `Blocklet ${name}@${version} install failed with error: ${err.message || 'queue exception'}`,
         entityType: 'blocklet',
@@ -1635,19 +1631,19 @@ class BlockletManager extends BaseBlockletManager {
 
     const { name, version, did } = meta;
 
-    const oldBlocklet = await this.state.getBlocklet(did);
+    const oldBlocklet = await states.blocklet.getBlocklet(did);
 
     // NOTE: 目前的版本移除了降级通道，所以不需要考虑降级通道的情况
     const action = semver.gt(oldBlocklet.meta.version, version) ? 'downgrade' : 'upgrade';
     logger.info(`${action} blocklet`, { did, version });
 
-    const newBlocklet = await this.state.setBlockletStatus(did, BlockletStatus.waiting);
+    const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
     const childrenMeta = await getChildrenMeta(meta);
     mergeMeta(meta, childrenMeta);
     newBlocklet.meta = meta;
     newBlocklet.source = source;
     newBlocklet.deployedFrom = deployedFrom;
-    newBlocklet.children = await this.state.getChildrenFromMetas(childrenMeta);
+    newBlocklet.children = await states.blocklet.getChildrenFromMetas(childrenMeta);
 
     await validateBlocklet(newBlocklet);
 
@@ -1664,7 +1660,7 @@ class BlockletManager extends BaseBlockletManager {
 
     if (sync) {
       await this.onDownload({ ...downloadParams, throwOnError: true });
-      return this.state.getBlocklet(did);
+      return states.blocklet.getBlocklet(did);
     }
 
     const ticket = this.installQueue.push(
@@ -1681,7 +1677,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('queue failed', { entity: 'blocklet', action, did, version, name, error: err });
       await this._rollback(action, did, oldBlocklet);
       this.emit(`blocklet.${action}.failed`, { did, version, err });
-      this.notification.create({
+      states.notification.create({
         title: `Blocklet ${capitalize(action)} Failed`,
         description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message || 'queue exception'}`,
         entityType: 'blocklet',
@@ -1839,14 +1835,14 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // pre install
-      const nodeEnvironments = await this.node.getEnvironments();
+      const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
         hooks.preInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: blocklet.env.appDir,
           did, // root blocklet did
-          notification: this.notification,
+          notification: states.notification,
           context,
         });
       await forEachBlocklet(blocklet, preInstall, { parallel: true });
@@ -1862,17 +1858,17 @@ class BlockletManager extends BaseBlockletManager {
           env: getRuntimeEnvironments(b, nodeEnvironments),
           appDir: blocklet.env.appDir,
           did, // root blocklet did
-          notification: this.notification,
+          notification: states.notification,
           context,
         });
       await forEachBlocklet(blocklet, postInstall, { parallel: true });
 
-      await this.state.setBlockletStatus(did, BlockletStatus.installed);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
       logger.info('blocklet installed', { source, meta });
       this.emit(BlockletEvents.installed, { blocklet, context });
 
-      this.notification.create({
+      states.notification.create({
         title: 'Blocklet Installed',
         description: `Blocklet ${meta.name}@${meta.version} is installed successfully. (Source: ${
           deployedFrom || fromBlockletSource(source)
@@ -1884,13 +1880,13 @@ class BlockletManager extends BaseBlockletManager {
       });
       return blocklet;
     } catch (err) {
-      const { meta } = await this.state.getBlocklet(did);
+      const { meta } = await states.blocklet.getBlocklet(did);
       const { name, version } = meta;
       logger.error('failed to install blocklet', { name, did, version, error: err });
       try {
         await this._rollback('install', did);
         this.emit(BlockletEvents.installFailed, { meta: { did } });
-        this.notification.create({
+        states.notification.create({
           title: 'Blocklet Install Failed',
           description: `Blocklet ${meta.name}@${meta.version} install failed with error: ${err.message}`,
           entityType: 'blocklet',
@@ -1921,20 +1917,20 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       // update state
-      await this.state.upgradeBlocklet({ meta, source, deployedFrom, children });
+      await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
       await this._setConfigs(did);
 
       let blocklet = await this.ensureBlocklet(did);
 
       // pre install
-      const nodeEnvironments = await this.node.getEnvironments();
+      const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
         hooks.preInstall({
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: blocklet.env.appDir,
           did, // root blocklet did
-          notification: this.notification,
+          notification: states.notification,
           context,
         });
       await forEachBlocklet(blocklet, preInstall, { parallel: true });
@@ -1950,7 +1946,7 @@ class BlockletManager extends BaseBlockletManager {
           env: getRuntimeEnvironments(b, nodeEnvironments),
           appDir: b.env.appDir,
           did, // root blocklet did
-          notification: this.notification,
+          notification: states.notification,
           context,
         });
       await forEachBlocklet(blocklet, postInstall, { parallel: true });
@@ -1966,7 +1962,7 @@ class BlockletManager extends BaseBlockletManager {
             env: getRuntimeEnvironments(b, nodeEnvironments),
             appDir: b.env.appDir,
             did: b.meta.did,
-            notification: this.notification,
+            notification: states.notification,
             context,
           });
         }
@@ -1991,7 +1987,7 @@ class BlockletManager extends BaseBlockletManager {
       } else {
         const status =
           oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-        await this.state.setBlockletStatus(did, status);
+        await states.blocklet.setBlockletStatus(did, status);
       }
 
       blocklet = await this.ensureBlocklet(did, context);
@@ -2003,7 +1999,7 @@ class BlockletManager extends BaseBlockletManager {
           downgrade: BlockletEvents.downgraded,
         };
         this.emit(eventNames[action], { blocklet, context });
-        this.notification.create({
+        states.notification.create({
           title: `Blocklet ${capitalize(action)} Success`,
           description: `Blocklet ${name}@${version} ${action} successfully. (Source: ${
             deployedFrom || fromBlockletSource(source)
@@ -2022,7 +2018,7 @@ class BlockletManager extends BaseBlockletManager {
       const b = await this._rollback(action, did, oldBlocklet);
       logger.error(`failed to ${action} blocklet`, { did, version, name, error: err });
       this.emit(BlockletEvents.updated, { blocklet: b });
-      this.notification.create({
+      states.notification.create({
         title: `Blocklet ${capitalize(action)} Failed`,
         description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message}`,
         entityType: 'blocklet',
@@ -2101,14 +2097,14 @@ class BlockletManager extends BaseBlockletManager {
     await fs.move(tarballPath, cachePath, { overwrite: true });
 
     const key = 'blocklet:manager:downloadCache';
-    const cacheList = (await this.cache.get(key)) || [];
+    const cacheList = (await states.cache.get(key)) || [];
     const exist = cacheList.find((x) => x.integrity === integrity);
 
     // update
     if (exist) {
       logger.info('update cache tarFile', { base58: integrity });
       exist.accessAt = Date.now();
-      await this.cache.set(key, cacheList);
+      await states.cache.set(key, cacheList);
       return;
     }
 
@@ -2132,7 +2128,7 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('add cache tarFile', { base58: integrity });
 
     // update
-    await this.cache.set(key, cacheList);
+    await states.cache.set(key, cacheList);
   }
 
   async _getCachedTarFile(integrity) {
@@ -2253,9 +2249,9 @@ class BlockletManager extends BaseBlockletManager {
 
   async _syncPm2Status(pm2Status, did) {
     try {
-      const state = await this.state.getBlocklet(did);
+      const state = await states.blocklet.getBlocklet(did);
       if (state && util.shouldUpdateBlockletStatus(state.status)) {
-        const result = await this.state.setBlockletStatus(did, pm2StatusMap[pm2Status]);
+        const result = await states.blocklet.setBlockletStatus(did, pm2StatusMap[pm2Status]);
         logger.info('sync pm2 status to blocklet', { result });
       }
     } catch (error) {
@@ -2300,8 +2296,7 @@ class BlockletManager extends BaseBlockletManager {
 
     if (['upgrade', 'downgrade'].includes(action)) {
       // rollback blocklet
-      const { _id } = await this.state.getBlocklet(did);
-      const result = await this.state.updateById(_id, { $set: oldBlocklet });
+      const result = await states.blocklet.updateBlocklet(did, oldBlocklet);
       await this._setConfigs(did);
       logger.info('blocklet rollback successfully', { did });
       this.emit(BlockletEvents.updated, { blocklet: result });
@@ -2313,7 +2308,7 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _deleteBlocklet({ did, keepData, keepLogsDir, keepConfigs }, context) {
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
     const { name } = blocklet.meta;
     const dataDir = path.join(this.dataDirs.data, name);
     const logsDir = path.join(this.dataDirs.logs, name);
@@ -2335,7 +2330,7 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
-    const result = await this.state.deleteBlocklet(did);
+    const result = await states.blocklet.deleteBlocklet(did);
     logger.info('blocklet removed successfully', { did });
 
     this.emit(BlockletEvents.removed, { blocklet: result, context });
@@ -2343,20 +2338,20 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   async _setConfigs(did) {
-    const blocklet = await this.state.getBlocklet(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
     const { meta } = blocklet;
-    await this.extras.setConfigs(did, get(meta, 'environments', []));
+    await states.blockletExtras.setConfigs(did, get(meta, 'environments', []));
     for (const child of blocklet.children) {
-      await this.extras.setChildConfigs(did, child.meta.did, get(child.meta, 'environments'));
+      await states.blockletExtras.setChildConfigs(did, child.meta.did, get(child.meta, 'environments'));
     }
   }
 
   async _delExtras(did) {
-    const blocklet = await this.state.getBlocklet(did);
-    await this.extras.delConfigs(did);
-    await this.extras.delSettings(did);
+    const blocklet = await states.blocklet.getBlocklet(did);
+    await states.blockletExtras.delConfigs(did);
+    await states.blockletExtras.delSettings(did);
     for (const child of blocklet.children) {
-      await this.extras.delChildConfigs(did, child.meta.did);
+      await states.blockletExtras.delChildConfigs(did, child.meta.did);
     }
   }
 }

package/lib/migrations/1.6.4-security.js

@@ -7,7 +7,7 @@ const cloneDeep = require('lodash/cloneDeep');
 const security = require('@abtnode/util/lib/security');
 
 module.exports = async ({ states, configFile, dataDir }) => {
-  if (process.env.CI) {
+  if (process.env.CI || process.env.NODE_ENV === 'test') {
     return;
   }
 
@@ -34,8 +34,24 @@ module.exports = async ({ states, configFile, dataDir }) => {
         return c;
       });
 
-      await states.blockletExtras.update({ did: item.did }, { $set: { configs: newConfigs } });
+      const newChildren = cloneDeep(item.children || []).map((x) => {
+        return {
+          ...x,
+          configs: cloneDeep(x.configs || []).map((c) => {
+            if (c.secure) {
+              c.value = security.encrypt(c.value, item.did, fs.readFileSync(file));
+            }
+
+            return c;
+          }),
+        };
+      });
+
+      await states.blockletExtras.update({ did: item.did }, { $set: { configs: newConfigs, children: newChildren } });
     }
+
+    states.node.compactDatafile();
+    states.blockletExtras.compactDatafile();
   } catch (err) {
     console.error(err);
     throw err;

package/lib/migrations/1.6.5-security.js

@@ -0,0 +1,60 @@
+/* eslint-disable no-await-in-loop */
+const fs = require('fs');
+const path = require('path');
+const uniq = require('lodash/uniq');
+const cloneDeep = require('lodash/cloneDeep');
+const security = require('@abtnode/util/lib/security');
+const { forEachBlocklet } = require('@blocklet/meta/lib/util');
+
+module.exports = async ({ states, dataDir }) => {
+  if (process.env.CI || process.env.NODE_ENV === 'test') {
+    return;
+  }
+
+  const file = path.join(dataDir, '.sock');
+  if (fs.existsSync(file) === false) {
+    return;
+  }
+
+  try {
+    const extras = await states.blockletExtras.find();
+    const blocklets = await states.blocklet.find();
+    for (const blocklet of blocklets) {
+      forEachBlocklet(
+        blocklet,
+        (b) => {
+          let configKeys;
+          const extra = extras.find((x) => x.did === blocklet.meta.did);
+          const rootKeys = (extra.configs || []).map((x) => x.key);
+          if (b.meta.did === blocklet.meta.did) {
+            configKeys = rootKeys;
+          } else {
+            const childExtra = (extra.children || []).find((x) => x.did === b.meta.did);
+            const childKeys = childExtra ? childExtra.configs.map((x) => x.key) : [];
+            configKeys = uniq([...rootKeys, ...childKeys]);
+          }
+
+          b.environments = cloneDeep(b.environments || [])
+            .filter((x) => configKeys.includes(x.key) === false)
+            .map((c) => {
+              if (c.key === 'BLOCKLET_APP_SK') {
+                c.value = security.encrypt(c.value, b.meta.did, fs.readFileSync(file));
+              }
+
+              return c;
+            });
+        },
+        { sync: true }
+      );
+
+      await states.blocklet.updateById(blocklet._id, {
+        $set: { environments: blocklet.environments, children: blocklet.children, migratedFrom: '1.6.5' },
+      });
+    }
+
+    states.blocklet.compactDatafile();
+  } catch (err) {
+    console.error(err);
+    throw err;
+  }
+};

package/lib/states/base.js

@@ -191,6 +191,14 @@ class BaseState extends EventEmitter {
   insert(...args) {
     return this.asyncDB.insert(...args);
   }
+
+  compactDatafile() {
+    this.db.persistence.compactDatafile((err) => {
+      if (err) {
+        console.error(`failed to compact datafile: ${this.filename}`, err);
+      }
+    });
+  }
 }
 
 /**

package/lib/states/blocklet.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-async-promise-executor */
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
@@ -5,6 +6,7 @@ const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const detectPort = require('detect-port');
 const Lock = require('@abtnode/util/lib/lock');
+const security = require('@abtnode/util/lib/security');
 const { fixPerson, fixInterfaces } = require('@blocklet/meta/lib/fix');
 const {
   BlockletStatus,
@@ -27,6 +29,40 @@ const getMaxPort = (ports = {}) => Math.max(Object.values(ports).map(Number));
 const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
+const formatBlocklet = (blocklet, phase, dek) => {
+  forEachBlocklet(
+    blocklet,
+    (b) => {
+      if (b.meta) {
+        fixPerson(b.meta);
+        fixInterfaces(b.meta);
+      }
+
+      b.children = b.children || [];
+
+      if (!b.environments || !b.meta || !dek) {
+        return;
+      }
+
+      ['BLOCKLET_APP_SK'].forEach((key) => {
+        const env = b.environments.find((x) => x.key === key);
+        if (!env) {
+          return;
+        }
+        if (phase === 'onUpdate' && env.value.indexOf('0x') === 0) {
+          env.value = security.encrypt(env.value, b.meta.did, dek);
+        }
+        if (phase === 'onRead' && env.value.indexOf('0x') === -1) {
+          env.value = security.decrypt(env.value, b.meta.did, dek);
+        }
+      });
+    },
+    { sync: true }
+  );
+
+  return blocklet;
+};
+
 class BlockletState extends BaseState {
   /**
    * Creates an instance of BlockletState
@@ -48,14 +84,7 @@ class BlockletState extends BaseState {
           return reject(err);
         }
 
-        if (doc) {
-          // TODO: this only exists for backward compatible
-          fixPerson(doc.meta);
-          fixInterfaces(doc.meta);
-          doc.children = doc.children || [];
-        }
-
-        return resolve(doc);
+        return resolve(doc ? formatBlocklet(doc, 'onRead', this.options.dek) : null);
       });
     });
   }
@@ -70,14 +99,7 @@ class BlockletState extends BaseState {
             return reject(err);
           }
 
-          return resolve(
-            docs.filter(Boolean).map((doc) => {
-              // TODO: this only exists for backward compatible
-              fixPerson(doc.meta);
-              fixInterfaces(doc.meta);
-              return doc;
-            })
-          );
+          return resolve(docs.filter(Boolean).map((doc) => formatBlocklet(doc, 'onRead', this.options.dek)));
         });
     });
   }
@@ -114,7 +136,6 @@ class BlockletState extends BaseState {
   } = {}) {
     return this.getBlocklet(did).then(
       (doc) =>
-        // eslint-disable-next-line no-async-promise-executor
         new Promise(async (resolve, reject) => {
           if (doc) {
             reject(new Error('Blocklet already added'));
@@ -165,6 +186,26 @@ class BlockletState extends BaseState {
     );
   }
 
+  updateBlocklet(did, updates) {
+    return this.getBlocklet(did).then(
+      (doc) =>
+        new Promise(async (resolve, reject) => {
+          if (!doc) {
+            reject(new Error('Blocklet does not exist'));
+            return;
+          }
+
+          try {
+            const formatted = formatBlocklet(updates, 'onUpdate', this.options.dek);
+            const newDoc = await this.updateById(doc._id, { $set: formatted });
+            resolve(newDoc);
+          } catch (err) {
+            reject(err);
+          }
+        })
+    );
+  }
+
   upgradeBlocklet({ meta, source, deployedFrom, children } = {}) {
     return this.getBlocklet(meta.did).then(
       (doc) =>

package/lib/util/blocklet.js

@@ -192,7 +192,6 @@ const fillBlockletConfigs = (blocklet, configs) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
-  blocklet.userEnvironments = blocklet.configObj; // deprecated
   blocklet.environmentObj = (blocklet.environments || []).reduce((acc, x) => {
     acc[x.key] = x.value;
     return acc;
@@ -308,6 +307,7 @@ const getRuntimeEnvironments = (blocklet, nodeEnvironments) => {
 
   return {
     ...blocklet.environmentObj,
+    ...blocklet.configObj,
     ...nodeEnvironments,
     ...safeNodeEnvironments,
   };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.4",
+  "version": "1.6.5",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,20 +19,20 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/constant": "1.6.4",
-    "@abtnode/cron": "1.6.4",
-    "@abtnode/logger": "1.6.4",
-    "@abtnode/queue": "1.6.4",
-    "@abtnode/rbac": "1.6.4",
-    "@abtnode/router-provider": "1.6.4",
-    "@abtnode/static-server": "1.6.4",
-    "@abtnode/timemachine": "1.6.4",
-    "@abtnode/util": "1.6.4",
+    "@abtnode/constant": "1.6.5",
+    "@abtnode/cron": "1.6.5",
+    "@abtnode/logger": "1.6.5",
+    "@abtnode/queue": "1.6.5",
+    "@abtnode/rbac": "1.6.5",
+    "@abtnode/router-provider": "1.6.5",
+    "@abtnode/static-server": "1.6.5",
+    "@abtnode/timemachine": "1.6.5",
+    "@abtnode/util": "1.6.5",
     "@arcblock/did": "^1.13.77",
     "@arcblock/event-hub": "1.13.77",
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/vc": "^1.13.77",
-    "@blocklet/meta": "1.6.4",
+    "@blocklet/meta": "1.6.5",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
@@ -73,5 +73,5 @@
     "express": "^4.17.1",
     "jest": "^27.3.1"
   },
-  "gitHead": "1c144cb9fb9a9952bc92f25cabbdb47a378cbd24"
+  "gitHead": "59da906682f8122797a932640aebbad5a30dfcc3"
 }