@abtnode/core 1.6.22 → 1.6.25

package/lib/blocklet/manager/disk.js

@@ -92,6 +92,7 @@ const {
   needBlockletDownload,
   verifyPurchase,
 } = require('../../util/blocklet');
+const { parseSourceUrl } = require('../../util/registry');
 const states = require('../../states');
 const BlockletRegistry = require('../registry');
 const BaseBlockletManager = require('./base');
@@ -176,6 +177,9 @@ class BlockletManager extends BaseBlockletManager {
     logger.debug('install blocklet', { params, context });
 
     const source = getSourceFromInstallParams(params);
+    if (typeof context.startImmediately === 'undefined') {
+      context.startImmediately = !!params.startImmediately;
+    }
 
     if (source === BlockletSource.url) {
       return this._installFromUrl({ url: params.url, sync: params.sync }, context);
@@ -673,7 +677,7 @@ class BlockletManager extends BaseBlockletManager {
   /**
    * upgrade blocklet from registry
    */
-  async upgrade({ did, registryUrl }, context) {
+  async upgrade({ did, registryUrl, sync }, context) {
     const blocklet = await states.blocklet.getBlocklet(did);
 
     // TODO: 查看了下目前页面中的升级按钮，都是会传 registryUrl 过来的，这个函数里的逻辑感觉需要在以后做一个简化
@@ -740,6 +744,7 @@ class BlockletManager extends BaseBlockletManager {
       source: BlockletSource.registry,
       deployedFrom: upgradeFromRegistry,
       context,
+      sync,
     });
   }
 
@@ -920,7 +925,6 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const { did, version } = meta;
-    meta.title = `[DEV] ${meta.title || meta.name}`;
 
     const exist = await states.blocklet.getBlocklet(did);
     if (exist) {
@@ -1104,11 +1108,13 @@ class BlockletManager extends BaseBlockletManager {
         blocklet.diskInfo = await getDiskInfo(blocklet, { useFakeDiskInfo: !diskInfo });
 
         try {
-          const app = blocklet.meta.group === BlockletGroup.gateway ? blocklet.children[0].env : blocklet.env;
-          const { appId } = app;
-          blocklet.runtimeInfo = await getRuntimeInfo(appId);
-          if (blocklet.runtimeInfo.status && shouldUpdateBlockletStatus(blocklet.status)) {
-            blocklet.status = statusMap[blocklet.runtimeInfo.status];
+          const app = blocklet.meta.group === BlockletGroup.gateway ? blocklet.children[0] : blocklet;
+          if (app) {
+            const { appId } = app.env;
+            blocklet.runtimeInfo = await getRuntimeInfo(appId);
+            if (blocklet.runtimeInfo.status && shouldUpdateBlockletStatus(blocklet.status)) {
+              blocklet.status = statusMap[blocklet.runtimeInfo.status];
+            }
           }
         } catch (err) {
           if (err.code !== 'BLOCKLET_PROCESS_404') {
@@ -1379,7 +1385,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _installFromStore({ did, registry }, context) {
+  async _installFromStore({ did, registry, sync }, context) {
     logger.debug('start install blocklet', { did });
     if (!isValidDid(did)) {
       throw new Error('Blocklet did is invalid');
@@ -1404,6 +1410,7 @@ class BlockletManager extends BaseBlockletManager {
       meta,
       source: BlockletSource.registry,
       deployedFrom: info.cdnUrl || registryUrl,
+      sync,
       context,
     });
   }
@@ -1411,6 +1418,16 @@ class BlockletManager extends BaseBlockletManager {
   async _installFromUrl({ url, sync }, context) {
     logger.debug('start install blocklet', { url });
 
+    const { inStore, registryUrl, blockletDid } = await parseSourceUrl(url);
+    if (inStore) {
+      const exist = await states.blocklet.getBlocklet(blockletDid);
+      if (exist) {
+        return this.upgrade({ did: blockletDid, registryUrl }, context);
+      }
+
+      return this._installFromStore({ did: blockletDid, registry: registryUrl }, context);
+    }
+
     const meta = await getBlockletMetaFromUrl(url);
 
     if (!meta) {
@@ -2335,7 +2352,7 @@ class BlockletManager extends BaseBlockletManager {
     } catch (err) {
       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.emit(BlockletEvents.updated, b);
       states.notification.create({
         title: `Blocklet ${capitalize(action)} Failed`,
         description: `Blocklet ${name}@${version} ${action} failed with error: ${err.message}`,
@@ -2622,7 +2639,7 @@ class BlockletManager extends BaseBlockletManager {
       const result = await states.blocklet.updateBlocklet(did, oldBlocklet);
       await this._setConfigs(did);
       logger.info('blocklet rollback successfully', { did });
-      this.emit(BlockletEvents.updated, { blocklet: result });
+      this.emit(BlockletEvents.updated, result);
       return result;
     }
 

package/lib/blocklet/registry.js

@@ -1,9 +1,7 @@
-const isBase64 = require('is-base64');
 const { BlockletGroup } = require('@blocklet/meta/lib/constants');
 const joinURL = require('url-join');
 const get = require('lodash/get');
-const pick = require('lodash/pick');
-const { BLOCKLET_STORE_API_PREFIX, BLOCKLET_STORE_META_PATH } = require('@abtnode/constant');
+const { BLOCKLET_STORE_API_PREFIX } = require('@abtnode/constant');
 
 const { name } = require('../../package.json');
 
@@ -15,6 +13,7 @@ const states = require('../states');
 const isRequirementsSatisfied = require('../util/requirement');
 const { fixAndVerifyBlockletMeta } = require('../util/blocklet');
 const { translate } = require('../locales');
+const { validateRegistryURL, getRegistryMeta } = require('../util/registry');
 
 const DEFAULT_REFRESH_INTERVAL = 1 * 60 * 1000;
 const MAX_REFRESH_INTERVAL = 1 * 60 * 1000;
@@ -152,54 +151,8 @@ class BlockletRegistry {
   }
 }
 
-BlockletRegistry.validateRegistryURL = async (registry) => {
-  const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
-  try {
-    const res = await request.get(url);
-    if (Array.isArray(res.data)) {
-      return res.data;
-    }
-
-    logger.error('Blocklet list fetch failed ', { url, data: res.data });
-    throw new Error('blocklet list fetch failed');
-  } catch (error) {
-    logger.error('Blocklet registry refresh failed', { url, error });
-    throw new Error(`Invalid Blocklet Registry URL ${registry}: ${error.message}`);
-  }
-};
-
-BlockletRegistry.getRegistryMeta = async (registry) => {
-  try {
-    const url = joinURL(registry, BLOCKLET_STORE_META_PATH, `?__t__=${Date.now()}`);
-    const { data } = await request.get(url);
-
-    if (!data) {
-      return {};
-    }
+BlockletRegistry.validateRegistryURL = validateRegistryURL;
 
-    const requiredFields = ['name', 'description', 'maintainer'];
-
-    const missingFields = requiredFields.filter((x) => !data[x]);
-    if (missingFields.length > 0) {
-      throw new Error(`the registry missing required information: ${missingFields.join(', ')}`);
-    }
-
-    const result = pick(data, ['id', 'name', 'description', 'maintainer', 'cdnUrl', 'chainHost']);
-    const { logoUrl } = data;
-    if (logoUrl) {
-      if (logoUrl.startsWith('http') === true) {
-        result.logoUrl = logoUrl;
-      } else if (isBase64(logoUrl, { allowMime: true })) {
-        result.logoUrl = logoUrl;
-      } else {
-        result.logoUrl = joinURL(registry, logoUrl);
-      }
-    }
-
-    return result;
-  } catch (err) {
-    throw new Error(`Can not get meta info for registry [${registry}]: ${err.message}`);
-  }
-};
+BlockletRegistry.getRegistryMeta = getRegistryMeta;
 
 module.exports = BlockletRegistry;

package/lib/event.js

@@ -208,6 +208,7 @@ module.exports = ({
   };
 
   events.handleBlockletAdd = handleBlockletAdd;
+  events.handleBlockletUpgrade = handleBlockletUpgrade;
   events.handleBlockletRemove = handleBlockletRemove;
   events.handleServerEvent = handleServerEvent;
   events.onEvent = onEvent;

package/lib/index.js

@@ -35,6 +35,7 @@ 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 } = require('./util');
 
 /**
@@ -148,6 +149,7 @@ function ABTNode(options) {
     getSitesFromSnapshot,
     getRoutingCrons,
     ensureWildcardCerts,
+    getRouterProvider,
   } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager });
 
   const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
@@ -367,6 +369,11 @@ function ABTNode(options) {
 
     // Services
     getServices: (params, context) => getServices({ stringifySchema: true }, context),
+
+    // Utilities: moved here because some deps require native build
+    getSysInfo,
+    getSysInfoEmitter: (interval) => new SysInfoEmitter(interval),
+    getRouterProvider,
   };
 
   const webhook = WebHook({ events, dataDirs, instance });

package/lib/router/helper.js

@@ -9,12 +9,11 @@ const isEqual = require('lodash/isEqual');
 const joinUrl = require('url-join');
 const { getProvider } = require('@abtnode/router-provider');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
-const getTmpDirectory = require('@abtnode/util/lib/get-tmp-directory');
+const getTmpDir = require('@abtnode/util/lib/get-tmp-directory');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const {
   DOMAIN_FOR_DEFAULT_SITE,
   DOMAIN_FOR_IP_SITE_REGEXP,
-  ROUTER_PROVIDER_NONE,
   DOMAIN_FOR_INTERNAL_SITE,
   WELLKNOWN_PATH_PREFIX,
   WELLKNOWN_AUTH_PATH_PREFIX,
@@ -30,6 +29,7 @@ const {
   BLOCKLET_SITE_GROUP_SUFFIX,
   WELLKNOWN_ACME_CHALLENGE_PREFIX,
   WELLKNOWN_DID_RESOLVER_PREFIX,
+  WELLKNOWN_PING_PREFIX,
 } = require('@abtnode/constant');
 const {
   BLOCKLET_DYNAMIC_PATH_PREFIX,
@@ -449,7 +449,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   const hasRuleByPrefix = (site, value) => site.rules.find((x) => x.isProtected && get(x, 'from.pathPrefix') === value);
 
   const downloadCert = async ({ domain, url }) => {
-    const destFolder = getTmpDirectory(path.join(`certificate-${Date.now()}`));
+    const destFolder = getTmpDir(path.join(`certificate-${Date.now()}`));
     try {
       const filename = path.join(destFolder, 'certificate.tar.gz');
       fs.ensureDirSync(destFolder);
@@ -511,11 +511,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
   const updateDashboardCertificates = async () => {
     const info = await nodeState.read();
-    const provider = getProviderFromNodeInfo(info);
-    if (provider === ROUTER_PROVIDER_NONE) {
-      return;
-    }
-
     const https = get(info, 'routing.https', true);
     const ipWildcardDomain = get(info, 'routing.ipWildcardDomain', '');
     const didDomain = info.didDomain;
@@ -597,6 +592,20 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         to: proxyTarget,
       };
 
+      const pingWellknownRule = {
+        isProtected: true,
+        from: { pathPrefix: WELLKNOWN_PING_PREFIX },
+        to: {
+          type: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
+          response: {
+            status: 200,
+            contentType: 'application/javascript',
+            body: "console.log('ping: pong')",
+          },
+          port: info.port,
+        },
+      };
+
       if (site) {
         const didResolverRuleUpdateRes = await upsertSiteRule(
           {
@@ -614,7 +623,15 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
           context
         );
 
-        return didResolverRuleUpdateRes || acmeRuleUpdateRes;
+        const pingRuleRes = await upsertSiteRule(
+          {
+            site,
+            rule: pingWellknownRule,
+          },
+          context
+        );
+
+        return didResolverRuleUpdateRes || acmeRuleUpdateRes || pingRuleRes;
       }
 
       await routerManager.addRoutingSite(
@@ -623,7 +640,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
             domain: DOMAIN_FOR_INTERNAL_SITE,
             port: await getWellknownSitePort(),
             name: NAME_FOR_WELLKNOWN_SITE,
-            rules: [didResolverWellknownRule, acmeChallengeWellknownRule],
+            rules: [didResolverWellknownRule, acmeChallengeWellknownRule, pingWellknownRule],
             isProtected: true,
           },
           skipCheckDynamicBlacklist: true,
@@ -647,12 +664,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    */
   const ensureDashboardRouting = async (context = {}) => {
     const info = await nodeState.read();
-
-    const provider = getProviderFromNodeInfo(info);
-    if (provider === ROUTER_PROVIDER_NONE) {
-      return false;
-    }
-
     const sites = await siteState.getSites();
     let dashboardSite = (sites || []).find((x) => x.domain === DOMAIN_FOR_IP_SITE);
     const updatedResult = [];
@@ -893,6 +904,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * Add system routing rules for blocklet in dashboard site
    *
    * @returns {boolean} if routing changed
+   * TODO: do we still need this?
    */
   const _ensureBlockletRulesForDashboardSite = async (blocklet, sites, nodeInfo, context = {}) => {
     // blocklet level duplication detection
@@ -993,12 +1005,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    */
   const ensureBlockletRouting = async (blocklet, context = {}) => {
     const nodeInfo = await nodeState.read();
-
-    const provider = getProviderFromNodeInfo(nodeInfo);
-    if (provider === ROUTER_PROVIDER_NONE) {
-      return false;
-    }
-
     const hasWebInterface = (blocklet.meta.interfaces || []).some((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
     if (!hasWebInterface) {
       return false;
@@ -1098,12 +1104,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * @returns {boolean} if routing changed
    */
   const ensureBlockletRoutingForUpgrade = async (blocklet, context = {}) => {
-    const nodeInfo = await nodeState.read();
-    const provider = getProviderFromNodeInfo(nodeInfo);
-    if (provider === ROUTER_PROVIDER_NONE) {
-      return false;
-    }
-
     await routerManager.deleteRoutingRulesItemByDid(
       { did: blocklet.meta.did, ruleFilter: (x) => x.isProtected },
       context
@@ -1158,14 +1158,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     return rules.filter((rule) => rule.to.did === did);
   }
 
-  const routers = {}; // we need to keep reference for different router instances
+  const providers = {}; // we need to keep reference for different router instances
   const handleRouting = async (nodeInfo) => {
     const providerName = get(nodeInfo, 'routing.provider', null);
     const httpsEnabled = get(nodeInfo, 'routing.https', true);
     logger.debug('handle routing', { providerName, httpsEnabled });
-    if (providerName === ROUTER_PROVIDER_NONE) {
-      return;
-    }
 
     const Provider = getProvider(providerName);
     const checkResult = await Provider.check({ configDir: dataDirs.router });
@@ -1173,12 +1170,12 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       throw new Error(`${providerName} pre-check failed, ${checkResult.error}`);
     }
 
-    if (routers[providerName]) {
-      await routers[providerName].restart();
+    if (providers[providerName]) {
+      await providers[providerName].reload();
     } else {
-      routers[providerName] = new Router({
+      providers[providerName] = new Router({
         provider: new Provider({
-          configDirectory: path.join(dataDirs.router, providerName),
+          configDir: path.join(dataDirs.router, providerName),
           httpPort: nodeInfo.routing.httpPort || DEFAULT_HTTP_PORT,
           httpsPort: nodeInfo.routing.httpsPort || DEFAULT_HTTPS_PORT,
           cacheDisabled: nodeInfo.mode === NODE_MODES.DEBUG,
@@ -1216,11 +1213,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         },
       });
 
-      certManager.on('cert.added', () => routers[providerName].restart());
-      certManager.on('cert.removed', () => routers[providerName].restart());
-      certManager.on('cert.issued', () => routers[providerName].restart());
+      certManager.on('cert.added', () => providers[providerName].reload());
+      certManager.on('cert.removed', () => providers[providerName].reload());
+      certManager.on('cert.issued', () => providers[providerName].reload());
 
-      await routers[providerName].start();
+      await providers[providerName].start();
     }
   };
 
@@ -1228,8 +1225,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     const info = await nodeState.read();
     const providerName = get(info, 'routing.provider', null);
 
-    if (providerName && routers[providerName] && typeof routers[providerName].rotateLogs === 'function') {
-      await routers[providerName].rotateLogs();
+    if (providerName && providers[providerName] && typeof providers[providerName].rotateLogs === 'function') {
+      await providers[providerName].rotateLogs();
     }
   };
 
@@ -1258,30 +1255,28 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     await handleRouting(result);
 
     if (newProvider !== info.routing.provider) {
-      if (newProvider !== ROUTER_PROVIDER_NONE) {
-        // Ensure we have system sites for daemon
-        await ensureDashboardRouting(context);
-
-        // Ensure we have system rules for blocklets
-        const blocklets = await blockletState.getBlocklets();
-        const ensureBlocklet = async (x) => {
-          const blocklet = await blockletManager.ensureBlocklet(x.meta.did);
-          return ensureBlockletRouting(blocklet, context);
-        };
-        const ensureBlockletResults = await Promise.all(blocklets.map((x) => ensureBlocklet(x)));
+      // Ensure we have system sites for daemon
+      await ensureDashboardRouting(context);
+
+      // Ensure we have system rules for blocklets
+      const blocklets = await blockletState.getBlocklets();
+      const ensureBlocklet = async (x) => {
+        const blocklet = await blockletManager.ensureBlocklet(x.meta.did);
+        return ensureBlockletRouting(blocklet, context);
+      };
+      const ensureBlockletResults = await Promise.all(blocklets.map((x) => ensureBlocklet(x)));
 
-        // We need to take snapshot after system rules ensured
-        if (ensureBlockletResults.filter(Boolean).length) {
-          await takeRoutingSnapshot({ message: `Switch routing engine to ${newProvider}`, dryRun: false }, context);
-          logger.info(`take routing snapshot on switch engine: ${newProvider}`, { ensureBlockletResults });
-        }
+      // We need to take snapshot after system rules ensured
+      if (ensureBlockletResults.filter(Boolean).length) {
+        await takeRoutingSnapshot({ message: `Switch routing engine to ${newProvider}`, dryRun: false }, context);
+        logger.info(`take routing snapshot on switch engine: ${newProvider}`, { ensureBlockletResults });
       }
 
       const Provider = getProvider(info.routing.provider);
       if (Provider) {
         try {
           const providerInstance = new Provider({
-            configDirectory: path.join(dataDirs.router, info.routing.provider),
+            configDir: path.join(dataDirs.router, info.routing.provider),
             httpPort: info.routing.httpPort || DEFAULT_HTTP_PORT,
             httpsPort: info.routing.httpsPort || DEFAULT_HTTPS_PORT,
             cacheDisabled: info.mode === NODE_MODES.DEBUG,
@@ -1424,6 +1419,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     ensureWildcardCerts,
     addWellknownSite,
     upsertSiteRule,
+    getRouterProvider: (name) => providers[name],
 
     getRoutingCrons: () => [
       {

package/lib/router/index.js

@@ -117,12 +117,7 @@ class Router {
   }
 
   async update() {
-    if (!this.provider) {
-      throw new Error('use setProvider() to set provider first');
-    }
-
     logger.info('router: update');
-
     await this.updateRoutingTable();
     await this.provider.reload();
   }
@@ -139,6 +134,12 @@ class Router {
     return this.provider.restart();
   }
 
+  async reload() {
+    logger.info('router: reload');
+    await this.updateRoutingTable();
+    return this.provider.reload();
+  }
+
   stop() {
     logger.info('router: stop');
     return this.provider.stop();
@@ -153,6 +154,10 @@ class Router {
     logger.info('router: rotate logs');
     await this.provider.rotateLogs();
   }
+
+  getLogFilesForToday() {
+    return this.provider.getLogFilesForToday();
+  }
 }
 
 Router.formatSites = (sites = []) => {

package/lib/router/manager.js

@@ -594,8 +594,8 @@ class RouterManager extends EventEmitter {
     // get provider
     const providerName = getProviderFromNodeInfo(info);
     const Provider = getProvider(providerName);
-    const tempPath = path.join(os.tmpdir(), `${providerName}-${Date.now()}`);
-    const provider = new Provider({ configDirectory: tempPath });
+    const tmpDir = path.join(os.tmpdir(), `${providerName}-${Date.now()}`);
+    const provider = new Provider({ configDir: tmpDir });
     const tempRouter = new Router({
       provider,
       getRoutingParams: async () => ({
@@ -610,10 +610,10 @@ class RouterManager extends EventEmitter {
     await tempRouter.updateRoutingTable();
     try {
       await tempRouter.validateConfig();
-      await fse.remove(tempPath);
+      await fse.remove(tmpDir);
     } catch (error) {
       logger.error('validate router config failed', { error, action, data });
-      await fse.remove(tempPath);
+      await fse.remove(tmpDir);
       throw error;
     }
   }

package/lib/states/blocklet.js

@@ -9,6 +9,7 @@ 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 { getDisplayName } = require('@blocklet/meta/lib/util');
 const {
   BlockletStatus,
   BlockletSource,
@@ -25,6 +26,7 @@ const { validateBlockletMeta } = require('../util');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
+const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
 const getMaxPort = (ports = {}) => Math.max(Object.values(ports).map(Number));
 
 const getExternalPortsFromMeta = (meta) =>
@@ -50,10 +52,10 @@ const formatBlocklet = (blocklet, phase, dek) => {
         if (!env) {
           return;
         }
-        if (phase === 'onUpdate' && env.value.indexOf('0x') === 0) {
+        if (phase === 'onUpdate' && isHex(env.value) === true) {
           env.value = security.encrypt(env.value, b.meta.did, dek);
         }
-        if (phase === 'onRead' && env.value.indexOf('0x') === -1) {
+        if (phase === 'onRead' && isHex(env.value) === false) {
           env.value = security.decrypt(env.value, b.meta.did, dek);
         }
       });
@@ -243,20 +245,17 @@ class BlockletState extends BaseState {
             await this.fillChildrenPorts(children, { oldChildren: doc.children, defaultPort: getMaxPort(ports) });
 
             // add to db
-            const newDoc = await this.updateById(doc._id, {
-              $set: {
-                meta: omit(sanitized, ['htmlAst']),
-                source,
-                deployedFrom,
-                children,
-                ports,
-              },
+            const newDoc = await this.updateBlocklet(meta.did, {
+              meta: omit(sanitized, ['htmlAst']),
+              source,
+              deployedFrom,
+              children,
+              ports,
             });
             lock.release();
 
-            const formatted = formatBlocklet(newDoc, 'onRead', this.options.dek);
-            this.emit('upgrade', formatted);
-            resolve(formatted);
+            this.emit('upgrade', newDoc);
+            resolve(newDoc);
           } catch (err) {
             lock.release();
             reject(err);
@@ -446,8 +445,7 @@ class BlockletState extends BaseState {
       return child;
     });
 
-    await this.update(doc._id, { $set: updates });
-    return formatBlocklet({ ...doc, ...updates }, 'onRead', this.options.dek);
+    return this.updateBlocklet(did, updates);
   }
 
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren } = {}) {
@@ -511,7 +509,7 @@ class BlockletState extends BaseState {
       const { meta, mountPoint, sourceUrl = '', source = '', deployedFrom = '' } = child;
 
       if (!mountPoint) {
-        throw new Error(`mountPoint is required when adding component ${meta.title || meta.name}`);
+        throw new Error(`mountPoint is required when adding component ${getDisplayName(child, true)}`);
       }
 
       if (meta.did === parent.meta.did) {
@@ -542,5 +540,6 @@ class BlockletState extends BaseState {
 }
 
 BlockletState.BlockletStatus = BlockletStatus;
+BlockletState.formatBlocklet = formatBlocklet;
 
 module.exports = BlockletState;

package/lib/states/node.js

@@ -6,7 +6,7 @@ const isEmpty = require('lodash/isEmpty');
 const security = require('@abtnode/util/lib/security');
 const { isFromPublicKey } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:node');
-const { ROUTER_PROVIDER_NONE, NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT } = require('@abtnode/constant');
+const { NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
@@ -87,7 +87,7 @@ class NodeState extends BaseState {
           nodeOwner,
           port,
           version,
-          routing = { provider: ROUTER_PROVIDER_NONE },
+          routing = { provider: 'default' },
           docker,
           mode,
           runtimeConfig,

package/lib/states/site.js

@@ -1,4 +1,5 @@
 const logger = require('@abtnode/logger')('@abtnode/core:states:site');
+const { toSlotDomain } = require('@abtnode/router-provider/lib/util');
 
 const BaseState = require('./base');
 
@@ -75,6 +76,14 @@ class SiteState extends BaseState {
 
     return count > 0;
   }
+
+  async findOneByDomain(domain) {
+    // eslint-disable-next-line no-param-reassign
+    domain = toSlotDomain(domain);
+    return this.asyncDB.findOne({
+      $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
+    });
+  }
 }
 
 module.exports = SiteState;

package/lib/util/blocklet.js

@@ -42,7 +42,7 @@ const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
-const { forEachBlocklet, isFreeBlocklet } = require('@blocklet/meta/lib/util');
+const { forEachBlocklet, isFreeBlocklet, getDisplayName } = require('@blocklet/meta/lib/util');
 
 const { validate: validateEngine, get: getEngine } = require('../blocklet/manager/engine');
 
@@ -456,7 +456,7 @@ const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironment
 
       const clusterMode = get(b.meta, 'capabilities.clusterMode', false);
       if (clusterMode && blocklet.mode !== BLOCKLET_MODES.DEVELOPMENT) {
-        const clusterSize = Number(blocklet.configObj.BLOCKLET_CLUSTER_SIZE) || Number.POSITIVE_INFINITY;
+        const clusterSize = Number(blocklet.configObj.BLOCKLET_CLUSTER_SIZE) || +process.env.ABT_NODE_MAX_CLUSTER_SIZE;
         options.execMode = 'cluster';
         options.mergeLogs = true;
         options.instances = Math.min(os.cpus().length, clusterSize);
@@ -1069,7 +1069,7 @@ const checkDuplicateComponents = (dynamicComponents, staticComponents) => {
   if (duplicates.length) {
     throw new Error(
       `Cannot add duplicate component${duplicates.length > 1 ? 's' : ''}: ${duplicates
-        .map((x) => x.meta.title || x.meta.name)
+        .map((x) => getDisplayName(x, true))
         .join(', ')}`
     );
   }

package/lib/util/disk-monitor.js

@@ -1,22 +1,26 @@
-const systeminformation = require('@abtnode/util/lib/sys-info');
 const logger = require('@abtnode/logger')('@abtnode/disk-monitor');
+const info = require('./sysinfo');
 
 const states = require('../states');
 
 /**
- *
- * @param {number} threshold Threshold for disk alarms, percentage
+ * @param {number} threshold Threshold for disk alerts, percentage
  */
 const check = async (threshold) => {
-  const info = await systeminformation.get();
-  const usageRatio = (info.disk.used / info.disk.total) * 100;
-  const usageRationText = `${usageRatio.toFixed(2)}%`;
-  logger.info('monitoring disk usage', { usage: usageRationText, threshold });
+  const { disks } = await info.getSysInfo();
+  for (const disk of disks) {
+    const usageRatio = (disk.used / disk.total) * 100;
+    const usageRatioPercent = `${usageRatio.toFixed(2)}%`;
+    logger.info('check disk usage', { usage: usageRatioPercent, threshold });
 
-  if (usageRatio >= threshold) {
+    if (usageRatio < threshold) {
+      return;
+    }
+
+    // eslint-disable-next-line no-await-in-loop
     await states.notification.create({
       title: 'Disk Usage Alert',
-      description: `More than ${usageRationText} disk space has been used`,
+      description: `More than ${usageRatioPercent} space has been used for disk ${disk.device}, the blocklet server may not function properly.`,
       entityType: 'node',
       severity: 'warning',
       sticky: true,
@@ -30,7 +34,6 @@ const getCron = () => ({
   fn: async () => {
     const nodeInfo = await states.node.read();
     const threshold = nodeInfo.diskAlertThreshold;
-
     await check(threshold);
   },
   options: { runOnInit: true },

package/lib/util/get-domain-for-blocklet.js

@@ -1,5 +1,6 @@
 const slugify = require('slugify');
 const { DEFAULT_IP_DNS_DOMAIN_SUFFIX } = require('@abtnode/constant');
+const md5 = require('@abtnode/util/lib/md5');
 
 const SLOT_FOR_IP_DNS_SITE = '888-888-888-888';
 
@@ -17,7 +18,9 @@ const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
 };
 
 const getDidDomainForBlocklet = ({ name, daemonDid, didDomain }) => {
-  return `${formatName(name)}-${daemonDid.toLowerCase()}.${didDomain}`;
+  const prefix = md5(name).substring(0, 8);
+
+  return `${prefix}-${daemonDid.toLowerCase()}.${didDomain}`;
 };
 
 module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet };

package/lib/util/index.js

@@ -20,7 +20,6 @@ const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/vali
 const { BlockletStatus, BLOCKLET_INTERFACE_WELLKNOWN } = require('@blocklet/meta/lib/constants');
 const {
   StatusCode,
-  ROUTER_PROVIDER_NONE,
   DOMAIN_FOR_DEFAULT_SITE,
   DOMAIN_FOR_IP_SITE,
   DOMAIN_FOR_IP_SITE_REGEXP,
@@ -242,7 +241,7 @@ const getBlockletInterfaces = ({ blocklet, context, nodeInfo, routingRules, node
   return uniqBy(interfaces, 'url');
 };
 
-const isRoutingEnabled = (routing) => !!routing && !!routing.provider && routing.provider !== ROUTER_PROVIDER_NONE;
+const isRoutingEnabled = (routing) => !!routing && !!routing.provider;
 
 const isInProgress = (status) =>
   [
@@ -283,7 +282,7 @@ const asyncExec = (command, options) =>
     });
   });
 
-const getProviderFromNodeInfo = (nodeInfo) => get(nodeInfo, 'routing.provider', null) || ROUTER_PROVIDER_NONE;
+const getProviderFromNodeInfo = (info) => get(info, 'routing.provider', 'default');
 
 const isCLI = () => !process.env.ABT_NODE_SK;
 
@@ -370,9 +369,8 @@ const getBaseUrls = async (node, ips) => {
     return { protocol, port };
   };
 
-  if (info.routing.provider !== ROUTER_PROVIDER_NONE && info.routing.snapshotHash && info.routing.adminPath) {
+  if (info.routing.provider && info.routing.snapshotHash && info.routing.adminPath) {
     const sites = await node.getSitesFromSnapshot();
-
     const { ipWildcardDomain } = info.routing;
     const adminPath = normalizePathPrefix(info.routing.adminPath);
     const tmpHttpPort = getPort(httpPort, DEFAULT_HTTP_PORT);

package/lib/util/registry.js

@@ -0,0 +1,90 @@
+const joinURL = require('url-join');
+const pick = require('lodash/pick');
+const isBase64 = require('is-base64');
+
+const { BLOCKLET_STORE_API_PREFIX, BLOCKLET_STORE_META_PATH } = require('@abtnode/constant');
+
+const { name } = require('../../package.json');
+const logger = require('@abtnode/logger')(`${name}:util:registry`); // eslint-disable-line
+
+const request = require('./request');
+
+const validateRegistryURL = async (registry) => {
+  const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
+  try {
+    const res = await request.get(url);
+    if (Array.isArray(res.data)) {
+      return res.data;
+    }
+
+    logger.error('Blocklet list fetch failed ', { url, data: res.data });
+    throw new Error('blocklet list fetch failed');
+  } catch (error) {
+    logger.error('Blocklet registry refresh failed', { url, error });
+    throw new Error(`Invalid Blocklet Registry URL ${registry}: ${error.message}`);
+  }
+};
+
+const getRegistryMeta = async (registry) => {
+  try {
+    const url = joinURL(registry, BLOCKLET_STORE_META_PATH, `?__t__=${Date.now()}`);
+    const { data } = await request.get(url);
+
+    if (!data) {
+      return {};
+    }
+
+    const requiredFields = ['name', 'description', 'maintainer'];
+
+    const missingFields = requiredFields.filter((x) => !data[x]);
+    if (missingFields.length > 0) {
+      throw new Error(`the registry missing required information: ${missingFields.join(', ')}`);
+    }
+
+    const result = pick(data, ['id', 'name', 'description', 'maintainer', 'cdnUrl', 'chainHost']);
+    const { logoUrl } = data;
+    if (logoUrl) {
+      if (logoUrl.startsWith('http') === true) {
+        result.logoUrl = logoUrl;
+      } else if (isBase64(logoUrl, { allowMime: true })) {
+        result.logoUrl = logoUrl;
+      } else {
+        result.logoUrl = joinURL(registry, logoUrl);
+      }
+    }
+
+    return result;
+  } catch (err) {
+    throw new Error(`Can not get meta info for registry [${registry}]: ${err.message}`);
+  }
+};
+
+const parseSourceUrl = async (url) => {
+  const { origin, pathname } = new URL(url);
+
+  const match = pathname.match(/^\/api\/blocklets\/(\w*)\/blocklet\.json/);
+  if (match) {
+    try {
+      const m = await getRegistryMeta(origin);
+      if (m && m.id) {
+        return {
+          inStore: true,
+          registryUrl: origin,
+          blockletDid: match[1],
+        };
+      }
+    } catch {
+      // meat is not in store, do nothing
+    }
+  }
+
+  return {
+    inStore: false,
+  };
+};
+
+module.exports = {
+  validateRegistryURL,
+  getRegistryMeta,
+  parseSourceUrl,
+};

package/lib/util/service.js

@@ -1,30 +1,15 @@
 const fs = require('fs-extra');
-const { NODE_SERVICES } = require('@abtnode/constant');
-
-const servicesNames = Object.values(NODE_SERVICES);
 
 const getServices = ({ stringifySchema = false } = {}) =>
-  servicesNames
+  ['auth']
     .map((x) => {
-      const service = {};
-
-      // Read service meta
-      try {
-        const packageFile = require.resolve(`${x}/package.json`);
-        const { name, description, version } = fs.readJSONSync(packageFile);
-        service.name = name;
-        service.description = description || name;
-        service.version = version;
-      } catch (err) {
-        return null;
-      }
+      let service;
 
-      // Read service config: optional
       try {
-        const schemaFile = require.resolve(`${x}/api/schema.json`);
-        service.schema = fs.readJSONSync(schemaFile);
+        const metaFile = require.resolve(`@abtnode/blocklet-services/services/${x}/meta.json`);
+        service = fs.readJSONSync(metaFile);
       } catch (err) {
-        service.schema = {};
+        service = {};
       }
 
       if (stringifySchema) {

package/lib/util/sysinfo.js

@@ -0,0 +1,79 @@
+const EventEmitter = require('events');
+const driveList = require('drivelist');
+const si = require('systeminformation');
+const checkDiskSpace = require('check-disk-space').default;
+
+const getSysInfo = async () => {
+  const [info, drives] = await Promise.all([
+    si.get({
+      cpu: 'physicalCores',
+      mem: '*',
+      currentLoad: '*',
+      osInfo: 'platform',
+    }),
+    driveList.list(),
+  ]);
+
+  return {
+    cpu: {
+      ...info.currentLoad,
+      ...info.cpu,
+    },
+    mem: info.mem,
+    os: info.osInfo,
+    disks: await Promise.all(
+      drives
+        .filter((x) => x.isSystem && x.isVirtual === false && x.mountpoints.length)
+        .map(async (x) => {
+          const result = await checkDiskSpace(x.mountpoints[0].path);
+          return {
+            device: x.device,
+            mountPoint: result.diskPath,
+            total: result.size,
+            used: result.size - result.free,
+            free: result.free,
+          };
+        })
+    ),
+  };
+};
+
+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

@@ -39,6 +39,7 @@ const ruleSchema = {
         ROUTING_RULE_TYPES.BLOCKLET,
         ROUTING_RULE_TYPES.REDIRECT,
         ROUTING_RULE_TYPES.GENERAL_PROXY,
+        ROUTING_RULE_TYPES.DIRECT_RESPONSE,
         ROUTING_RULE_TYPES.NONE
       )
       .required(),
@@ -54,6 +55,12 @@ const ruleSchema = {
       .label('interface name')
       .when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }),
     realInterfaceName: Joi.string().label('real interface name'), // child blocklet interface
+    response: Joi.object({ status: Joi.number().required(), contentType: Joi.string(), body: Joi.string().required() })
+      .label('response')
+      .when('type', {
+        is: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
+        then: Joi.required(),
+      }),
   },
 
   // List of services that manipulate the request before the upstream blocklet

package/lib/validators/trusted-passport.js

@@ -8,6 +8,7 @@ const Joi = JOI.extend(didExtension);
 const trustedPassportsSchema = Joi.array().items(
   Joi.object({
     issuerDid: Joi.DID().required(),
+    remark: Joi.string().trim(),
     mappings: Joi.array().items(
       Joi.object({
         from: Joi.object({

package/lib/webhook/index.js

@@ -64,7 +64,7 @@ module.exports = ({ events, dataDirs, instance }) => {
       const webhookList = await webhookState.list();
       const nodeInfo = await nodeState.read();
       const { internal, external } = await IP.get();
-      const baseUrls = await getBaseUrls(instance, [internal, external]);
+      const baseUrls = await getBaseUrls(instance, [external, internal]);
       const senderFns = {};
 
       if (webhookList.length) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.22",
+  "version": "1.6.25",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,34 +19,36 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/certificate-manager": "1.6.22",
-    "@abtnode/constant": "1.6.22",
-    "@abtnode/cron": "1.6.22",
-    "@abtnode/db": "1.6.22",
-    "@abtnode/logger": "1.6.22",
-    "@abtnode/queue": "1.6.22",
-    "@abtnode/rbac": "1.6.22",
-    "@abtnode/router-provider": "1.6.22",
-    "@abtnode/static-server": "1.6.22",
-    "@abtnode/timemachine": "1.6.22",
-    "@abtnode/util": "1.6.22",
-    "@arcblock/did": "^1.14.16",
-    "@arcblock/event-hub": "1.14.16",
+    "@abtnode/certificate-manager": "1.6.25",
+    "@abtnode/constant": "1.6.25",
+    "@abtnode/cron": "1.6.25",
+    "@abtnode/db": "1.6.25",
+    "@abtnode/logger": "1.6.25",
+    "@abtnode/queue": "1.6.25",
+    "@abtnode/rbac": "1.6.25",
+    "@abtnode/router-provider": "1.6.25",
+    "@abtnode/static-server": "1.6.25",
+    "@abtnode/timemachine": "1.6.25",
+    "@abtnode/util": "1.6.25",
+    "@arcblock/did": "^1.14.19",
+    "@arcblock/event-hub": "1.14.19",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "^1.14.16",
-    "@blocklet/meta": "1.6.22",
+    "@arcblock/vc": "^1.14.19",
+    "@blocklet/meta": "1.6.25",
     "@fidm/x509": "^1.2.1",
     "@nedb/core": "^1.2.2",
     "@nedb/multi": "^1.2.2",
-    "@ocap/mcrypto": "^1.14.16",
-    "@ocap/util": "^1.14.16",
-    "@ocap/wallet": "^1.14.16",
+    "@ocap/mcrypto": "^1.14.19",
+    "@ocap/util": "^1.14.19",
+    "@ocap/wallet": "^1.14.19",
     "@slack/webhook": "^5.0.3",
     "axios": "^0.25.0",
     "axon": "^2.0.3",
     "chalk": "^4.0.0",
+    "check-disk-space": "^3.2.0",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.3.0",
+    "drivelist": "^9.2.4",
     "flat": "^5.0.2",
     "fs-extra": "^10.0.0",
     "get-port": "^5.1.1",
@@ -64,6 +66,7 @@
     "ssri": "^8.0.0",
     "stream-throttle": "^0.1.3",
     "stream-to-promise": "^3.0.0",
+    "systeminformation": "^5.11.5",
     "tar": "^6.1.0",
     "unzipper": "^0.10.11",
     "url-join": "^4.0.1",
@@ -75,5 +78,5 @@
     "express": "^4.17.1",
     "jest": "^27.4.5"
   },
-  "gitHead": "18ac52a439dbd04e4ace98d796b6de517503fb14"
+  "gitHead": "bd2ad7d90fbd1b3786702dfca1ab28dcec9a7bc7"
 }