@abtnode/core 1.8.50 → 1.8.52

package/lib/api/node.js

@@ -14,6 +14,14 @@ const IP = require('../util/ip');
 const { validateNodeInfo, validateUpdateGateway } = require('../validators/node');
 const { getAll } = require('../blocklet/manager/engine');
 const { getDelegateState } = require('../util');
+const { NodeRuntimeMonitor } = require('../monitor/node-runtime-monitor');
+const getHistoryList = require('../monitor/get-history-list');
+
+// 10s 上报统计一次
+const MONITOR_RECORD_INTERVAL_SEC = 10;
+
+// 保存当天数据, 每天上报 8640 次
+const MONITOR_HISTORY_LENGTH = 86400 / MONITOR_RECORD_INTERVAL_SEC;
 
 class NodeAPI {
   /**
@@ -24,6 +32,10 @@ class NodeAPI {
     assert.notStrictEqual(state, undefined, 'argument state can not be undefined');
     assert.notStrictEqual(state, null, 'argument state can not be null');
 
+    this.runtimeMonitor = new NodeRuntimeMonitor({
+      historyLength: MONITOR_HISTORY_LENGTH,
+    });
+
     this.state = state;
   }
 
@@ -115,6 +127,32 @@ class NodeAPI {
     const transferV2Delegation = (state.ops || []).find(({ key }) => key === 'fg:t:transfer_v2');
     return { delegated: !!transferV2Delegation };
   }
+
+  // eslint-disable-next-line no-unused-vars
+  getHistory({ hours = 1 } = {}, context) {
+    const history = this.runtimeMonitor.getHistory();
+
+    return getHistoryList({
+      history,
+      hours,
+      recordIntervalSec: MONITOR_RECORD_INTERVAL_SEC,
+      props: ['date', 'cpu', 'mem', 'daemonMem', 'serviceMem', 'dbMem'],
+    });
+  }
+
+  getRealtimeData() {
+    return this.runtimeMonitor.getRealtimeData();
+  }
+
+  getCrons() {
+    return [
+      {
+        name: 'record-node-runtime-info',
+        time: `*/${MONITOR_RECORD_INTERVAL_SEC} * * * * *`,
+        fn: () => this.runtimeMonitor.monit(),
+      },
+    ];
+  }
 }
 
 module.exports = NodeAPI;

package/lib/blocklet/manager/disk.js

@@ -4,7 +4,6 @@ const fs = require('fs-extra');
 const { fileURLToPath } = require('url');
 const path = require('path');
 const flat = require('flat');
-const urlHttp = require('url-http');
 const get = require('lodash/get');
 const pick = require('lodash/pick');
 const cloneDeep = require('lodash/cloneDeep');
@@ -13,8 +12,9 @@ const capitalize = require('lodash/capitalize');
 const { Throttle } = require('stream-throttle');
 const LRU = require('lru-cache');
 const joi = require('joi');
+const isUrl = require('is-url');
 const { isNFTExpired } = require('@abtnode/util/lib/nft');
-const { disableDNS } = require('@abtnode/util/lib/did-document');
+const didDocument = require('@abtnode/util/lib/did-document');
 const { sign } = require('@arcblock/jwt');
 const { isValid: isValidDid } = require('@arcblock/did');
 const { verifyPresentation } = require('@arcblock/vc');
@@ -45,7 +45,6 @@ const {
   forEachBlockletSync,
   forEachChildSync,
   forEachBlocklet,
-  forEachChild,
   getComponentId,
   getComponentBundleId,
   isPreferenceKey,
@@ -112,7 +111,6 @@ const {
   verifyIntegrity,
   pruneBlockletBundle,
   getDiskInfo,
-  getRuntimeInfo,
   getUpdateMetaList,
   getRuntimeEnvironments,
   getSourceFromInstallParams,
@@ -136,9 +134,11 @@ const blockletPm2Events = require('./pm2-events');
 const { getFactoryState } = require('../../util/chain');
 const runMigrationScripts = require('../migration');
 const hooks = require('../hooks');
-const { formatName } = require('../../util/get-domain-for-blocklet');
+const { formatName, getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
 const handleInstanceInStore = require('../../util/public-to-store');
-const { getNFTState } = require('../../util');
+const { getNFTState, getServerDidDomain } = require('../../util');
+const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
+const getHistoryList = require('../../monitor/get-history-list');
 
 const {
   isInProgress,
@@ -194,6 +194,12 @@ const getSkippedProcessIds = ({ newBlocklet, oldBlocklet, context = {} }) => {
 const getBlockletIndex = (meta, controller) =>
   controller ? toExternalBlocklet(meta.name, controller.nftId) : { did: meta.did, name: meta.name };
 
+// 10s 上报统计一次
+const MONITOR_RECORD_INTERVAL_SEC = 10;
+
+// 保存当天数据, 每天上报 8640 次
+const MONITOR_HISTORY_LENGTH = 86400 / MONITOR_RECORD_INTERVAL_SEC;
+
 class BlockletManager extends BaseBlockletManager {
   /**
    * @param {*} dataDirs generate by ../../util:getDataDirs
@@ -225,6 +231,8 @@ class BlockletManager extends BaseBlockletManager {
       maxAge: process.env.NODE_ENV === 'test' ? 500 : 0.5 * 60 * 1000, // cache for 0.5 minute
     });
 
+    this.runtimeMonitor = new BlockletRuntimeMonitor({ historyLength: MONITOR_HISTORY_LENGTH, states });
+
     if (daemon) {
       blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid));
       blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid));
@@ -1037,7 +1045,7 @@ class BlockletManager extends BaseBlockletManager {
             throw new Error(`${x.key} can not be empty`);
           }
 
-          if (!urlHttp(x.value)) {
+          if (!isUrl(x.value)) {
             throw new Error(`${x.key}(${x.value}) is not a valid http address`);
           }
         }
@@ -1065,6 +1073,15 @@ class BlockletManager extends BaseBlockletManager {
 
     // update db
     await states.blockletExtras.setConfigs(dids, newConfigs);
+
+    const isSkOrWalletTypeChanged = newConfigs.find((item) =>
+      [BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK, BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_WALLET_TYPE].includes(item.key)
+    );
+
+    if (isSkOrWalletTypeChanged) {
+      await this._updateDidDocument(blocklet);
+    }
+
     await this.updateBlockletEnvironment(rootDid);
 
     // response
@@ -1486,6 +1503,20 @@ class BlockletManager extends BaseBlockletManager {
     return newBlocklet;
   }
 
+  // eslint-disable-next-line no-unused-vars
+  async getRuntimeHistory({ did, hours }, context) {
+    const metaDid = await states.blocklet.getBlockletMetaDid(did);
+
+    const history = this.runtimeMonitor.getHistory(metaDid);
+
+    return getHistoryList({
+      history,
+      hours,
+      recordIntervalSec: MONITOR_RECORD_INTERVAL_SEC,
+      props: ['date', 'cpu', 'mem'],
+    });
+  }
+
   // ============================================================================================
   // Internal API that are used by public APIs and called from CLI
   // ============================================================================================
@@ -1711,7 +1742,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     try {
-      let blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
+      const blocklet = await this.ensureBlocklet(did, { throwOnNotExist: false });
 
       if (!blocklet) {
         return null;
@@ -1721,7 +1752,18 @@ class BlockletManager extends BaseBlockletManager {
 
       // if from cached data, only use cache data of runtime info (engine, diskInfo, runtimeInfo...)
       if (fromCache) {
-        blocklet = { ...cachedBlocklet, ...blocklet };
+        const cached = {};
+        forEachBlockletSync(cachedBlocklet, (component, { id }) => {
+          cached[id] = component;
+        });
+
+        Object.assign(blocklet, pick(cachedBlocklet, ['appRuntimeInfo', 'diskInfo']));
+
+        forEachBlockletSync(blocklet, (component, { id }) => {
+          if (cached[id]) {
+            Object.assign(component, pick(cached[id], ['runtimeInfo']));
+          }
+        });
       }
 
       // 处理 domainAliases#value SLOT_FOR_IP_DNS_SITE
@@ -1734,45 +1776,23 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       if (!fromCache) {
-        blocklet.engine = getEngine(getBlockletEngineNameByPlatform(blocklet.meta)).describe();
-        blocklet.diskInfo = await getDiskInfo(blocklet, { useFakeDiskInfo: !diskInfo });
+        // app runtime info, app status
+        blocklet.appRuntimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did);
 
-        try {
-          const app = blocklet.meta.group === BlockletGroup.gateway ? blocklet.children[0] : blocklet;
-          if (app) {
-            const { processId } = app.env;
-            blocklet.runtimeInfo = await getRuntimeInfo(processId);
-            if (blocklet.runtimeInfo.status && shouldUpdateBlockletStatus(blocklet.status)) {
-              blocklet.status = statusMap[blocklet.runtimeInfo.status];
-            }
-          }
-        } catch (err) {
-          if (err.code !== 'BLOCKLET_PROCESS_404') {
-            logger.error('failed to construct blocklet runtime info', { did, error: err });
-          }
+        // app disk info, component runtime info, component status, component engine
+        await forEachBlocklet(blocklet, async (component, { level }) => {
+          component.engine = getEngine(getBlockletEngineNameByPlatform(component.meta)).describe();
 
-          if (blocklet.status === BlockletStatus.running) {
-            await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-            blocklet.status = BlockletStatus.stopped;
+          if (level === 0) {
+            component.diskInfo = await getDiskInfo(component, {
+              useFakeDiskInfo: !diskInfo,
+            });
           }
-        }
 
-        await forEachChild(blocklet, async (child) => {
-          child.engine = getEngine(getBlockletEngineNameByPlatform(child.meta)).describe();
-          child.diskInfo = await getDiskInfo(child, {
-            useFakeDiskInfo: !diskInfo,
-          });
-          if (child.meta.group !== BlockletGroup.gateway) {
-            try {
-              child.runtimeInfo = await getRuntimeInfo(child.env.processId);
-              if (child.runtimeInfo.status && shouldUpdateBlockletStatus(child.status)) {
-                child.status = statusMap[child.runtimeInfo.status];
-              }
-            } catch (err) {
-              if (err.code !== 'BLOCKLET_PROCESS_404') {
-                logger.error('failed to construct blocklet runtime info', { did, error: err });
-              }
-            }
+          component.runtimeInfo = this.runtimeMonitor.getRuntimeInfo(blocklet.meta.did, component.env.id);
+
+          if (component.runtimeInfo?.status && shouldUpdateBlockletStatus(component.status)) {
+            component.status = statusMap[component.runtimeInfo.status];
           }
         });
       }
@@ -2639,6 +2659,11 @@ class BlockletManager extends BaseBlockletManager {
         time: '0 */30 * * * *', // 30min
         fn: () => this._deleteExpiredExternalBlocklet(),
       },
+      {
+        name: 'record-blocklet-runtime-history',
+        time: `*/${MONITOR_RECORD_INTERVAL_SEC} * * * * *`, // 10s
+        fn: () => this.runtimeMonitor.monitAll(),
+      },
     ];
   }
 
@@ -3607,7 +3632,8 @@ class BlockletManager extends BaseBlockletManager {
 
     const nodeInfo = await states.node.read();
     const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
-    disableDNS({ wallet, didRegistryUrl: nodeInfo.didRegistry })
+    didDocument
+      .disableDNS({ wallet, didRegistryUrl: nodeInfo.didRegistry })
       .then(() => {
         logger.info(`disabled blocklet ${blocklet.appDid} dns`);
       })
@@ -3623,6 +3649,8 @@ class BlockletManager extends BaseBlockletManager {
       keepRouting = false;
     }
 
+    this.runtimeMonitor.delete(blocklet.meta.did);
+
     this.emit(BlockletEvents.removed, {
       blocklet: result,
       context: {
@@ -3840,6 +3868,50 @@ class BlockletManager extends BaseBlockletManager {
       logger.info('check expired external blocklet failed', { error });
     }
   }
+
+  async _updateDidDocument(blocklet) {
+    const nodeInfo = await states.node.read();
+
+    const { wallet } = getBlockletInfo(
+      {
+        meta: blocklet.meta,
+        environments: [BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK, BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_WALLET_TYPE]
+          .map((key) => ({ key, value: blocklet.configObj[key] }))
+          .filter((x) => x.value),
+      },
+      nodeInfo.sk
+    );
+    const didDomain = getDidDomainForBlocklet({
+      blockletAppDid: wallet.address,
+      didDomain: nodeInfo.didDomain,
+    });
+
+    const domainAliases = (get(blocklet, 'site.domainAliases') || []).filter(
+      (item) => !item.value.endsWith(nodeInfo.didDomain) && !item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
+    );
+
+    domainAliases.push({ value: didDomain, isProtected: true });
+
+    //  先更新 routing rule db 中的 domain aliases, 这一步的目的是为了后面用
+    await states.site.updateDomainAliasList(blocklet.site.id, domainAliases);
+
+    this.emit(BlockletEvents.appDidChanged, blocklet);
+
+    const blockletWithEnv = await this.ensureBlocklet(blocklet.meta.did);
+    const appSystemEnvironments = getAppOverwrittenEnvironments(blockletWithEnv, nodeInfo);
+
+    await didDocument.updateBlockletDocument({
+      wallet,
+      blockletAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
+      daemonDidDomain: getServerDidDomain(nodeInfo),
+      didRegistryUrl: nodeInfo.didRegistry,
+      domain: nodeInfo.didDomain,
+    });
+    logger.info('updated blocklet dns document', {
+      did: blocklet.meta.did,
+      currentAppDid: appSystemEnvironments.BLOCKLET_APP_ID,
+    });
+  }
 }
 
 module.exports = BlockletManager;

package/lib/event.js

@@ -10,7 +10,6 @@ const handleInstanceInStore = require('./util/public-to-store');
 const eventHub =
   process.env.NODE_ENV === 'test' ? require('@arcblock/event-hub/single') : require('@arcblock/event-hub');
 
-const { isCLI } = require('./util');
 const states = require('./states');
 
 const routingSnapshotPrefix = (blocklet) => (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '[DEV] ' : '');
@@ -29,6 +28,7 @@ module.exports = ({
   certManager,
   routerManager,
   node,
+  nodeRuntimeMonitor,
 }) => {
   const notificationState = states.notification;
   const nodeState = states.node;
@@ -36,20 +36,14 @@ module.exports = ({
   const events = new EventEmitter();
   events.setMaxListeners(0);
 
-  // HACK: do not emit any events from CLI
-  if (isCLI() && process.env.NODE_ENV !== 'test') {
-    events.emit = (name) => logger.debug('stopped core state event in CLI', name);
-  }
-
-  // Push events to event hub for other process to consume
-  const originEmit = events.emit.bind(events);
-  events.emit = (name, ...args) => {
-    logger.debug('proxy event to event hub', { name });
-    eventHub.broadcast(name, ...args);
-    originEmit(name, ...args);
+  let eventHandler = null;
+  events.setEventHandler = (handler) => {
+    if (typeof handler === 'function') {
+      eventHandler = handler;
+    }
   };
 
-  // Subscribe events from eventHub and proxy to eventHandler
+  // Listen events from eventHub and call eventHandler
   [...Object.values(BlockletEvents), ...Object.values(EVENTS)].forEach((name) => {
     eventHub.on(name, (data) => {
       if (name === BlockletEvents.removed) {
@@ -63,16 +57,29 @@ module.exports = ({
     });
   });
 
-  let eventHandler = null;
-
+  // Wipe sensitive data
+  // Emit events to event hub
+  // Emit events to node listener
   const onEvent = (name, data) => {
     let safeData = data;
     if (get(data, 'meta.did', '')) {
       safeData = wipeSensitiveData(cloneDeep(data));
     }
+
+    logger.debug('proxy event to event hub', { name });
+    eventHub.broadcast(name, safeData);
     events.emit(name, safeData);
   };
 
+  // Emit events to node listener
+  // Call eventHandler
+  const onInternalEvent = (name, data) => {
+    events.emit(name, data);
+    if (typeof eventHandler === 'function') {
+      eventHandler({ name, data });
+    }
+  };
+
   const handleBlockletAdd = async (name, { blocklet, context }) => {
     try {
       const changed = await ensureBlockletRouting(blocklet, context);
@@ -199,14 +206,11 @@ module.exports = ({
     } else if ([BlockletEvents.removed].includes(eventName)) {
       await handleBlockletRemove(eventName, payload);
     } else if ([BlockletEvents.started].includes(eventName)) {
-      try {
-        const { publicToStore } = blocklet.settings || {};
-        // 如果一个 blocklet 没有设置 publicToStore，启动成功后不应给 store 发请求
-        if (publicToStore) {
-          await handleInstanceInStore(blocklet, { publicToStore });
-        }
-      } catch (error) {
-        logger.error('handleInstanceInStore failed', { error });
+      const { publicToStore } = blocklet.settings || {};
+      if (publicToStore) {
+        handleInstanceInStore(blocklet, { publicToStore }).catch((error) => {
+          logger.error('handleInstanceInStore failed', { message: error.message });
+        });
       }
     } else if ([BlockletEvents.upgradeFailed, BlockletEvents.downgradeFailed].includes(eventName)) {
       try {
@@ -224,6 +228,19 @@ module.exports = ({
       } catch (error) {
         logger.error('Failed to createAuditLog for upgradeBlocklet failed', { error });
       }
+    } else if (BlockletEvents.appDidChanged === eventName) {
+      const hash = await takeRoutingSnapshot(
+        { message: `${routingSnapshotPrefix(blocklet)}Update blocklet ${blocklet.meta.name} app did`, dryRun: false },
+        get(payload, 'context') || {}
+      );
+
+      logger.info('take snapshot after updated blocklet app', { event: eventName, did: blocklet.meta.did, hash });
+    }
+
+    try {
+      await blockletManager.runtimeMonitor.monit(blocklet.meta.did);
+    } catch (error) {
+      logger.error('monit runtime info failed', { error });
     }
 
     if (payload.blocklet && !payload.meta) {
@@ -266,6 +283,7 @@ module.exports = ({
     BlockletEvents.started,
     BlockletEvents.startFailed,
     BlockletEvents.stopped,
+    BlockletEvents.appDidChanged,
   ].forEach((eventName) => {
     listen(blockletManager, eventName, handleBlockletEvent);
   });
@@ -314,11 +332,8 @@ module.exports = ({
 
   listen(routerManager, BlockletEvents.updated, onEvent);
 
-  events.setEventHandler = (handler) => {
-    if (typeof handler === 'function') {
-      eventHandler = handler;
-    }
-  };
+  listen(nodeRuntimeMonitor, EVENTS.NODE_RUNTIME_INFO, onInternalEvent);
+  listen(blockletManager.runtimeMonitor, EVENTS.BLOCKLETS_RUNTIME_INFO, onInternalEvent);
 
   events.handleServerEvent = handleServerEvent;
   events.handleBlockletEvent = handleBlockletEvent;

package/lib/index.js

@@ -30,7 +30,6 @@ const createQueue = require('./queue');
 const createEvents = require('./event');
 const pm2Events = require('./blocklet/manager/pm2-events');
 const { createStateReadyQueue, createStateReadyHandler } = require('./util/ready');
-const { getSysInfo, SysInfoEmitter } = require('./util/sysinfo');
 const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem, getStateCrons } = require('./util');
 
 /**
@@ -227,6 +226,7 @@ function ABTNode(options) {
     hasBlocklet: blockletManager.hasBlocklet.bind(blockletManager),
     updateAllBlockletEnvironment: blockletManager.updateAllBlockletEnvironment.bind(blockletManager),
     setBlockletInitialized: blockletManager.setInitialized.bind(blockletManager),
+    getBlockletRuntimeHistory: blockletManager.getRuntimeHistory.bind(blockletManager),
 
     // Store
     getBlockletMeta: StoreUtil.getBlockletMeta,
@@ -386,9 +386,9 @@ function ABTNode(options) {
       ),
     endSession: (params, context) => states.session.end(params.id, context),
 
-    // Utilities: moved here because some deps require native build
-    getSysInfo,
-    getSysInfoEmitter: (interval) => new SysInfoEmitter(interval),
+    getNodeRuntimeHistory: nodeAPI.getHistory.bind(nodeAPI),
+    getNodeRuntimeInfo: nodeAPI.getRealtimeData.bind(nodeAPI),
+
     getRouterProvider,
   };
 
@@ -405,6 +405,7 @@ function ABTNode(options) {
     certManager,
     routerManager,
     node: instance,
+    nodeRuntimeMonitor: nodeAPI.runtimeMonitor,
   });
 
   const webhook = WebHook({ events, dataDirs, instance });
@@ -419,6 +420,7 @@ function ABTNode(options) {
         ...blockletManager.getCrons(),
         DiskMonitor.getCron(),
         ...getStateCrons(states),
+        ...nodeAPI.getCrons(),
       ],
       onError: (error, name) => {
         states.notification.create({

package/lib/monitor/blocklet-runtime-monitor.js

@@ -0,0 +1,200 @@
+const EventEmitter = require('events');
+
+const cloneDeep = require('lodash/cloneDeep');
+const pLimit = require('p-limit');
+const { forEachBlocklet } = require('@blocklet/meta/lib/util');
+const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
+const { EVENTS } = require('@abtnode/constant');
+const { BlockletStatus, BlockletGroup } = require('@blocklet/constant');
+const defaultLogger = require('@abtnode/logger')('blocklet-runtime-monitor');
+
+const { getRuntimeInfo } = require('../util/blocklet');
+
+// type BlockletHistoryItem = {
+//   date: number;
+//   cpu: number;
+//   mem: number;
+// };
+
+// type History = Array<BlockletHistoryItem>;
+
+// type RuntimeInfo = {
+//   pid: number;
+//   uptime: number;
+//   memoryUsage: number;
+//   cpuUsage: number;
+//   status: string;
+// };
+
+// type ComponentMonitorData = {
+//   runtimeInfo: RuntimeInfo;
+// }
+
+// type AppMonitorData = ComponentMonitorData & {
+//   history: History;
+// }
+
+// type BlockletMonitorData = {
+//   app: AppMonitorData;
+//   [componentId: string]: ComponentMonitorData;
+// }
+
+// type MonitorData = {
+//   [blockletDid: string]: BlockletMonitorData;
+// }
+
+class BlockletRuntimeMonitor extends EventEmitter {
+  constructor({ historyLength = 100, states, logger = defaultLogger } = {}) {
+    super();
+
+    /**
+     * private
+     */
+    this.historyLength = historyLength;
+    this.states = states;
+    this.data = {};
+    this.logger = logger;
+    this.inProgress = false;
+  }
+
+  getHistory(blockletDid) {
+    if (!this.data[blockletDid]) {
+      return [];
+    }
+
+    return this.data[blockletDid].app.history || [];
+  }
+
+  getRuntimeInfo(blockletDid, componentId = 'app') {
+    if (!this.data[blockletDid]) {
+      return null;
+    }
+
+    if (!this.data[blockletDid][componentId]) {
+      return null;
+    }
+
+    return this.data[blockletDid][componentId].runtimeInfo;
+  }
+
+  async monit(did) {
+    const blocklet = await this.states.blocklet.getBlocklet(did);
+    await this._monit(blocklet);
+  }
+
+  async _monit(blocklet, { addToHistory } = {}) {
+    const {
+      meta: { did: blockletDid },
+      status,
+    } = blocklet;
+
+    if (status !== BlockletStatus.running) {
+      if (this.data[blockletDid]) {
+        Object.keys(this.data[blockletDid]).forEach((key) => {
+          delete this.data[blockletDid][key].runtimeInfo;
+        });
+      }
+      return;
+    }
+
+    this.data[blockletDid] = this.data[blockletDid] || {
+      app: {
+        runtimeInfo: {
+          memoryUsage: 0,
+          cpuUsage: 0,
+          pid: -1,
+          uptime: 0,
+          status: '',
+        },
+        history: [],
+      },
+    };
+
+    let appCpu = 0;
+    let appMem = 0;
+
+    await forEachBlocklet(
+      blocklet,
+      async (component, { id: componentId, ancestors }) => {
+        if (component.meta.group !== BlockletGroup.gateway) {
+          const processId = getComponentProcessId(component, ancestors);
+          try {
+            const runtimeInfo = await getRuntimeInfo(processId);
+
+            this.data[blockletDid][componentId] = { runtimeInfo };
+
+            if (!component.mountPoint || component.mountPoint === '/') {
+              this.data[blockletDid].app.runtimeInfo = cloneDeep(runtimeInfo);
+            }
+
+            appCpu += runtimeInfo.cpuUsage || 0;
+            appMem += runtimeInfo.memoryUsage || 0;
+          } catch (err) {
+            this.logger.error('failed to get blocklet runtime info', { processId, error: err });
+          }
+        }
+      },
+      { parallel: true }
+    );
+
+    this.data[blockletDid].app.runtimeInfo.cpuUsage = appCpu;
+    this.data[blockletDid].app.runtimeInfo.memoryUsage = appMem;
+
+    // push to history
+    if (addToHistory) {
+      this._push(blockletDid, { date: Date.now(), cpu: appCpu, mem: appMem });
+    }
+  }
+
+  async monitAll() {
+    if (this.inProgress) {
+      this.logger.error('monitoring is in progress');
+      return;
+    }
+
+    this.inProgress = true;
+
+    try {
+      const blocklets = await this.states.blocklet.getBlocklets();
+
+      const limit = pLimit(5);
+      await Promise.allSettled(
+        blocklets.map((blocklet) =>
+          limit(async () => {
+            await this._monit(blocklet, { addToHistory: true });
+          })
+        )
+      );
+
+      this.inProgress = false;
+
+      // emit event
+      const eventData = [];
+      Object.entries(this.data).forEach(([did, x]) => {
+        Object.entries(x).forEach(([componentId, { runtimeInfo }]) => {
+          if (componentId !== 'app') {
+            eventData.push({ did, componentId, runtimeInfo });
+          }
+        });
+      });
+      this.emit(EVENTS.BLOCKLETS_RUNTIME_INFO, eventData);
+    } catch (error) {
+      this.inProgress = false;
+      this.logger.error('monit blocklet runtime failed', { error });
+    }
+  }
+
+  delete(blockletDid) {
+    delete this.data[blockletDid];
+  }
+
+  _push(blockletDid, value) {
+    const arr = this.data[blockletDid].app.history;
+    arr.push(value);
+    if (arr.length > this.historyLength) {
+      arr.shift();
+    }
+  }
+}
+
+module.exports.BlockletRuntimeMonitor = BlockletRuntimeMonitor;

package/lib/monitor/get-history-list.js

@@ -0,0 +1,37 @@
+const maxBy = require('lodash/maxBy');
+
+const getHistoryList = ({ history, hours, recordIntervalSec, props = [] }) => {
+  if (hours < 1 || hours > 24) {
+    throw new Error('hours should between 1 to 24');
+  }
+  const intHours = Math.floor(hours);
+
+  const nPerHour = (60 / recordIntervalSec) * 60;
+  const n = nPerHour * intHours;
+  const list = history.slice(-n);
+
+  let i = list.length;
+
+  const res = [];
+
+  while (i > 0 && res.length < nPerHour) {
+    const arr = list.slice(Math.max(0, i - intHours), i);
+
+    // 取一段时间的最大值
+    if (props && props.length) {
+      const obj = {};
+      props.forEach((p) => {
+        obj[p] = (maxBy(arr, (x) => x[p]) || {})[p];
+      });
+      res.unshift(obj);
+    } else {
+      res.unshift(Math.max(...arr));
+    }
+
+    i -= intHours;
+  }
+
+  return res;
+};
+
+module.exports = getHistoryList;

package/lib/monitor/node-runtime-monitor.js

@@ -0,0 +1,228 @@
+const EventEmitter = require('events');
+const pick = require('lodash/pick');
+const cloneDeep = require('lodash/cloneDeep');
+
+const { PROCESS_NAME_DAEMON, PROCESS_NAME_PROXY, PROCESS_NAME_SERVICE, EVENTS } = require('@abtnode/constant');
+const defaultLogger = require('@abtnode/logger')('@abtnode/util:node-runtime-info');
+const pm2 = require('@abtnode/util/lib/async-pm2');
+
+const { getSysInfo } = require('../util/sysinfo');
+
+const getProcessInfo = (processId, { returnList } = {}) =>
+  new Promise((resolve, reject) => {
+    pm2.describe(processId, (err, infos) => {
+      if (err) {
+        return reject(err);
+      }
+
+      if (!infos || !infos[0]) {
+        return resolve(null);
+      }
+
+      if (returnList) {
+        return resolve(infos);
+      }
+
+      return resolve(infos[0]);
+    });
+  });
+
+// type RuntimeInfo = {
+//   pid: number;
+//   uptime: number;
+//   memoryUsage: number;
+//   cpuUsage: number;
+//   status: string;
+// };
+
+// type ServiceRuntimeInfo = RuntimeInfo & {
+//   instanceCount: number;
+// };
+
+// type NodeHistoryItem = {
+//   date: number;
+//   cpu: number;
+//   mem: number;
+//   daemonMem: number;
+//   serviceMem: number;
+//   dbMem: number;
+// };
+
+// type History = Array<NodeHistoryItem>;
+
+// type Realtime = {
+//   cpu: {};
+//   mem: {};
+//   os: {};
+//   disks: [];
+//   daemon: RuntimeInfo
+//   service: ServiceRuntimeInfo
+//   db: RuntimeInfo
+
+// type MonitorData = {
+//   realtime: Realtime;
+//   history: History;
+// }
+
+const DEFAULT_DATA = {
+  realtime: {
+    cpu: {},
+    mem: {},
+    os: {},
+    disks: [],
+    daemon: {},
+    service: {},
+    db: {},
+  },
+  history: [],
+};
+
+class NodeRuntimeMonitor extends EventEmitter {
+  constructor({ historyLength = 100, logger = defaultLogger } = {}) {
+    super();
+
+    /**
+     * private
+     */
+    this.historyLength = historyLength;
+    this.logger = logger;
+    this.data = cloneDeep(DEFAULT_DATA);
+    this.inProgress = false;
+  }
+
+  emitRealtimeData() {
+    this.emit(EVENTS.NODE_RUNTIME_INFO, this.getRealtimeData());
+  }
+
+  getRealtimeData() {
+    return this.data.realtime;
+  }
+
+  getHistory() {
+    return this.data.history;
+  }
+
+  async monit() {
+    if (this.inProgress) {
+      this.logger.error('monitoring is in progress');
+      return;
+    }
+
+    this.inProgress = true;
+
+    const date = Date.now();
+    await Promise.allSettled([
+      getSysInfo().catch((error) => {
+        this.logger.error(`failed to getSysInfo: ${error.message}`);
+      }),
+      getProcessInfo(PROCESS_NAME_SERVICE, { returnList: true }).catch((error) => {
+        this.logger.error(`failed to get blocklet-service info: ${error.message}`);
+      }),
+      process.env.NODE_ENV !== 'development'
+        ? getProcessInfo(PROCESS_NAME_DAEMON).catch((error) => {
+            this.logger.error(`failed to get daemon info: ${error.message}`);
+          })
+        : Promise.resolve(),
+      process.env.NODE_ENV !== 'development'
+        ? getProcessInfo(PROCESS_NAME_PROXY).catch((error) => {
+            this.logger.error(`failed to get db info: ${error.message}`);
+          })
+        : Promise.resolve(),
+    ])
+      .then(([{ value: sysInfo }, { value: serviceInfos }, { value: daemonInfo }, { value: dbInfo }]) => {
+        this.inProgress = false;
+
+        const historyItem = {
+          date,
+          cpu: 0,
+          mem: 0,
+          daemonMem: 0,
+          serviceMem: 0,
+          dbMem: 0,
+        };
+
+        if (sysInfo) {
+          Object.assign(this.data.realtime, pick(sysInfo, ['cpu', 'mem', 'os', 'disks']));
+
+          historyItem.cpu = Number(sysInfo.cpu.currentLoad.toFixed(2));
+          historyItem.mem = sysInfo.mem.total - sysInfo.mem.available;
+        }
+
+        if (serviceInfos) {
+          const [proc] = serviceInfos;
+
+          const runtimeInfo = {
+            pid: proc.pid,
+            uptime: proc.pm2_env ? +new Date() - Number(proc.pm2_env.pm_uptime) : 0,
+            // FIXME: 将 services 进程聚合在一起不利于排查问题
+            memoryUsage: serviceInfos.reduce((total, info) => total + info.monit.memory, 0),
+            cpuUsage: serviceInfos.reduce((total, info) => total + info.monit.cpu, 0),
+            status: proc.pm2_env ? proc.pm2_env.status : null,
+            instanceCount: serviceInfos.length,
+          };
+
+          this.data.realtime.service = runtimeInfo;
+
+          historyItem.serviceMem = runtimeInfo.memoryUsage;
+        } else {
+          this.data.realtime.service = {};
+        }
+
+        if (daemonInfo) {
+          const proc = daemonInfo;
+
+          const runtimeInfo = {
+            pid: proc.pid,
+            uptime: proc.pm2_env ? +new Date() - Number(proc.pm2_env.pm_uptime) : 0,
+            memoryUsage: proc.monit.memory,
+            cpuUsage: proc.monit.cpu,
+            status: proc.pm2_env ? proc.pm2_env.status : null,
+          };
+
+          this.data.realtime.daemon = runtimeInfo;
+
+          historyItem.daemonMem = runtimeInfo.memoryUsage;
+        } else {
+          this.data.realtime.daemon = {};
+        }
+
+        if (dbInfo) {
+          const proc = dbInfo;
+
+          const runtimeInfo = {
+            pid: proc.pid,
+            uptime: proc.pm2_env ? +new Date() - Number(proc.pm2_env.pm_uptime) : 0,
+            memoryUsage: proc.monit.memory,
+            cpuUsage: proc.monit.cpu,
+            status: proc.pm2_env ? proc.pm2_env.status : null,
+          };
+
+          this.data.realtime.db = runtimeInfo;
+
+          historyItem.dbMem = runtimeInfo.memoryUsage;
+        } else {
+          this.data.realtime.db = {};
+        }
+
+        this.logger.info('server runtime info', historyItem);
+
+        this._push(historyItem);
+
+        this.emitRealtimeData();
+      })
+      .catch((err) => {
+        this.inProgress = false;
+        this.logger.error(err.message);
+      });
+  }
+
+  _push(value) {
+    const arr = this.data.history;
+    arr.push(value);
+    if (arr.length > this.historyLength) {
+      arr.shift();
+    }
+  }
+}
+
+module.exports.NodeRuntimeMonitor = NodeRuntimeMonitor;

package/lib/router/helper.js

@@ -12,7 +12,6 @@ const { getProvider } = require('@abtnode/router-provider');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const getTmpDir = require('@abtnode/util/lib/get-tmp-directory');
 const downloadFile = require('@abtnode/util/lib/download-file');
-const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
 const { updateBlockletDocument } = require('@abtnode/util/lib/did-document');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 const {
@@ -45,7 +44,13 @@ const {
 
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../package.json').name}:router:helper`);
-const { getProviderFromNodeInfo, getHttpsCertInfo, findInterfacePortByName, getWellknownSitePort } = require('../util');
+const {
+  getProviderFromNodeInfo,
+  getHttpsCertInfo,
+  findInterfacePortByName,
+  getWellknownSitePort,
+  getServerDidDomain,
+} = require('../util');
 const { getIpDnsDomainForBlocklet, getDidDomainForBlocklet } = require('../util/get-domain-for-blocklet');
 const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-accessible-external-node-ip');
 
@@ -573,7 +578,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       (item) => !item.value.endsWith(ipWildcardDomain) && !item.value.endsWith(info.didDomain)
     );
 
-    const didDomain = `${encodeBase32(info.did)}.${info.didDomain}`;
+    const didDomain = getServerDidDomain(info);
     const dashboardAliasDomains = [
       { value: ipWildcardDomain, isProtected: true },
       { value: didDomain, isProtected: true },
@@ -668,7 +673,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       updateBlockletDocument({
         wallet,
         blockletAppDid: blocklet.appDid,
-        daemonDidDomain: `${encodeBase32(nodeInfo.did)}.${nodeInfo.didDomain}`,
+        daemonDidDomain: getServerDidDomain(nodeInfo),
         didRegistryUrl: nodeInfo.didRegistry,
         domain: nodeInfo.didDomain,
       })

package/lib/states/blocklet.js

@@ -106,6 +106,22 @@ class BlockletState extends BaseState {
     });
   }
 
+  getBlockletMetaDid(did) {
+    return new Promise((resolve, reject) => {
+      if (!did) {
+        resolve(null);
+      }
+
+      this.findOne({ $or: [{ 'meta.did': did }, { appDid: did }] }, (err, doc) => {
+        if (err) {
+          return reject(err);
+        }
+
+        return resolve(doc ? doc.meta.did : null);
+      });
+    });
+  }
+
   async isExternalBlocklet(did) {
     if (!did) {
       return false;

package/lib/states/site.js

@@ -3,6 +3,7 @@ const { toSlotDomain } = require('@abtnode/router-provider/lib/util');
 
 const BaseState = require('./base');
 const { getBlockletDomainGroupName } = require('../util/router');
+const { validateUpdateDomainAliases } = require('../validators/router');
 
 class SiteState extends BaseState {
   constructor(baseDir, config = {}) {
@@ -83,6 +84,12 @@ class SiteState extends BaseState {
     const site = await this.findOneByBlocklet(did);
     return site.domainAliases.map((x) => x.value).filter(Boolean);
   }
+
+  async updateDomainAliasList(id, domainAliases) {
+    await validateUpdateDomainAliases(domainAliases);
+
+    return super.update({ _id: id }, { $set: { domainAliases } });
+  }
 }
 
 module.exports = SiteState;

package/lib/states/user.js

@@ -1,6 +1,8 @@
 const pickBy = require('lodash/pickBy');
+const escapeStringRegexp = require('escape-string-regexp');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:user');
+const { isValid } = require('@arcblock/did');
 const { PASSPORT_STATUS } = require('@abtnode/constant');
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
@@ -98,7 +100,17 @@ class User extends BaseState {
     }
 
     if (search) {
-      queryParam.$or = [{ fullName: search }, { did: search }];
+      if (search.length > 50) {
+        throw new Error('the length of search text should not more than 50');
+      }
+
+      if (isValid(search)) {
+        queryParam.did = search;
+      } else {
+        const reg = new RegExp(escapeStringRegexp(search), 'i');
+
+        queryParam.fullName = { $regex: reg };
+      }
     }
 
     if (role && role !== '$all') {

package/lib/util/blocklet.js

@@ -78,7 +78,13 @@ const { validate: validateEngine, get: getEngine } = require('../blocklet/manage
 
 const isRequirementsSatisfied = require('./requirement');
 const { getDidDomainForBlocklet } = require('./get-domain-for-blocklet');
-const { isBeforeInstalled, expandBundle, findInterfacePortByName, validateBlockletMeta } = require('./index');
+const {
+  isBeforeInstalled,
+  expandBundle,
+  findInterfacePortByName,
+  validateBlockletMeta,
+  prettyURL,
+} = require('./index');
 
 const getComponentConfig = (meta) => meta.components || meta.children;
 
@@ -274,9 +280,12 @@ const getAppSystemEnvironments = (blocklet, nodeInfo) => {
   let appUrl = '';
 
   const domainAliases = get(blocklet, 'site.domainAliases') || [];
-  const didDomainAlias = domainAliases.find((item) => item.value.endsWith(nodeInfo.didDomain));
+  const didDomainAlias = domainAliases.find(
+    (item) => item.value.endsWith(nodeInfo.didDomain) || item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
+  );
+
   if (didDomainAlias) {
-    appUrl = domainAliases.value;
+    appUrl = prettyURL(didDomainAlias.value, true);
   } else {
     appUrl = `https://${getDidDomainForBlocklet({
       blockletAppDid: appId,

package/lib/util/index.js

@@ -14,6 +14,7 @@ const getPortLib = require('get-port');
 const v8 = require('v8');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
 const axios = require('@abtnode/util/lib/axios');
+const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
 const parseBlockletMeta = require('@blocklet/meta/lib/parse');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
 const { BlockletStatus } = require('@blocklet/constant');
@@ -437,6 +438,20 @@ const getNFTState = async (chainHost, nftId) => {
   return state;
 };
 
+const getServerDidDomain = (nodeInfo) => `${encodeBase32(nodeInfo.did)}.${nodeInfo.didDomain}`;
+
+const prettyURL = (url, isHttps = true) => {
+  if (typeof url !== 'string') {
+    return url;
+  }
+
+  if (url.toLowerCase().startsWith('http')) {
+    return url;
+  }
+
+  return isHttps ? `https://${url}` : `http://${url}`;
+};
+
 const lib = {
   validateOwner,
   getProviderFromNodeInfo,
@@ -472,6 +487,8 @@ const lib = {
   getStateCrons,
   getDelegateState,
   getNFTState,
+  getServerDidDomain,
+  prettyURL,
 };
 
 module.exports = lib;

package/lib/util/sysinfo.js

@@ -1,4 +1,3 @@
-const EventEmitter = require('events');
 const maxBy = require('lodash/maxBy');
 const SysInfo = require('systeminformation');
 
@@ -42,42 +41,4 @@ const getSysInfo = async () => {
   };
 };
 
-class SysInfoEmitter extends EventEmitter {
-  constructor(interval = 3000) {
-    super();
-    this.timer = null;
-    this.polling = false;
-    this.interval = interval;
-  }
-
-  startPolling() {
-    if (this.polling) {
-      return;
-    }
-
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-
-    this.polling = true;
-    this.timer = setInterval(() => {
-      getSysInfo().then((info) => {
-        if (info) {
-          this.emit('info', info);
-        }
-      });
-    }, this.interval);
-  }
-
-  stopPolling() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-      this.polling = false;
-    }
-  }
-}
-
 module.exports.getSysInfo = getSysInfo;
-module.exports.SysInfoEmitter = SysInfoEmitter;

package/lib/validators/router.js

@@ -96,6 +96,15 @@ const addDomainAlias = Joi.alternatives()
   )
   .required();
 
+const domainAliases = Joi.array().items(
+  Joi.object({
+    value: addDomainAlias,
+    isProtected: Joi.boolean(),
+  })
+);
+
+const updateAliases = domainAliases.required();
+
 const addSiteSchema = Joi.object({
   domain: Joi.alternatives()
     .try(
@@ -105,12 +114,7 @@ const addSiteSchema = Joi.object({
     )
     .required()
     .messages(domainMessages),
-  domainAliases: Joi.array().items(
-    Joi.object({
-      value: addDomainAlias,
-      isProtected: Joi.boolean(),
-    })
-  ),
+  domainAliases,
   isProtected: Joi.boolean(),
   rules: Joi.array().items(ruleJoiSchema),
   corsAllowedOrigins: corsSchema,
@@ -148,10 +152,14 @@ const validateUpdateSite = (entity, context) => updateSite.validateAsync(entity,
 const validateAddRule = (entity, context) => addRuleSchema.validateAsync(entity, getMultipleLangParams(context));
 const validateEditRule = (entity, context) => editRuleSchema.validateAsync(entity, getMultipleLangParams(context));
 
+const validateUpdateDomainAliases = (entity, context) =>
+  updateAliases.validateAsync(entity, getMultipleLangParams(context));
+
 module.exports = {
   validateAddRule,
   validateAddSite,
   validateEditRule,
   validateAddDomainAlias,
   validateUpdateSite,
+  validateUpdateDomainAliases,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.50",
+  "version": "1.8.52",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,38 +19,39 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.8.50",
-    "@abtnode/certificate-manager": "1.8.50",
-    "@abtnode/constant": "1.8.50",
-    "@abtnode/cron": "1.8.50",
-    "@abtnode/db": "1.8.50",
-    "@abtnode/logger": "1.8.50",
-    "@abtnode/queue": "1.8.50",
-    "@abtnode/rbac": "1.8.50",
-    "@abtnode/router-provider": "1.8.50",
-    "@abtnode/static-server": "1.8.50",
-    "@abtnode/timemachine": "1.8.50",
-    "@abtnode/util": "1.8.50",
-    "@arcblock/did": "1.18.32",
+    "@abtnode/auth": "1.8.52",
+    "@abtnode/certificate-manager": "1.8.52",
+    "@abtnode/constant": "1.8.52",
+    "@abtnode/cron": "1.8.52",
+    "@abtnode/db": "1.8.52",
+    "@abtnode/logger": "1.8.52",
+    "@abtnode/queue": "1.8.52",
+    "@abtnode/rbac": "1.8.52",
+    "@abtnode/router-provider": "1.8.52",
+    "@abtnode/static-server": "1.8.52",
+    "@abtnode/timemachine": "1.8.52",
+    "@abtnode/util": "1.8.52",
+    "@arcblock/did": "1.18.34",
     "@arcblock/did-motif": "^1.1.10",
-    "@arcblock/did-util": "1.18.32",
-    "@arcblock/event-hub": "1.18.32",
-    "@arcblock/jwt": "^1.18.32",
+    "@arcblock/did-util": "1.18.34",
+    "@arcblock/event-hub": "1.18.34",
+    "@arcblock/jwt": "^1.18.34",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "1.18.32",
-    "@blocklet/constant": "1.8.50",
-    "@blocklet/meta": "1.8.50",
-    "@blocklet/sdk": "1.8.50",
+    "@arcblock/vc": "1.18.34",
+    "@blocklet/constant": "1.8.52",
+    "@blocklet/meta": "1.8.52",
+    "@blocklet/sdk": "1.8.52",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.32",
-    "@ocap/util": "1.18.32",
-    "@ocap/wallet": "1.18.32",
+    "@ocap/mcrypto": "1.18.34",
+    "@ocap/util": "1.18.34",
+    "@ocap/wallet": "1.18.34",
     "@slack/webhook": "^5.0.4",
     "axios": "^0.27.2",
     "axon": "^2.0.3",
     "chalk": "^4.1.2",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.5.1",
+    "escape-string-regexp": "^4.0.0",
     "flat": "^5.0.2",
     "fs-extra": "^10.1.0",
     "get-port": "^5.1.1",
@@ -61,6 +62,7 @@
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "lru-cache": "^6.0.0",
+    "p-limit": "^3.1.0",
     "pm2": "^5.2.0",
     "semver": "^7.3.8",
     "shelljs": "^0.8.5",
@@ -72,7 +74,6 @@
     "tar": "^6.1.11",
     "ua-parser-js": "^1.0.2",
     "unzipper": "^0.10.11",
-    "url-http": "^1.0.7",
     "url-join": "^4.0.1",
     "uuid": "7.0.3"
   },
@@ -82,5 +83,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "7f3ccb957659a6791b93b6fc4fbcbbd2c42f1efd"
+  "gitHead": "80217320b7cbd8c815172f8a985584586c32e858"
 }