@abtnode/core 1.17.7-beta-20251225-073259-cb6ecf68 → 1.17.7-beta-20251229-085620-84f09930

package/lib/states/node.js

@@ -200,16 +200,6 @@ class NodeState extends BaseState {
     return doc;
   }
 
-  async updateNodeRouting(entity = {}) {
-    if (isEmpty(entity)) {
-      throw new CustomError(400, 'empty entity');
-    }
-    const nodeInfo = await this.updateNodeInfo({ routing: entity });
-    this.emit(EVENTS.ROUTING_UPDATED, nodeInfo);
-
-    return nodeInfo;
-  }
-
   cleanupDirtyMaintainState() {
     return this.read().then((doc) => {
       if (doc.nextVersion && semver.lte(doc.nextVersion, doc.version)) {

package/lib/states/site.js

@@ -1,4 +1,6 @@
 const logger = require('@abtnode/logger')('@abtnode/core:states:site');
+const { Op, Sequelize } = require('sequelize');
+const { BLOCKLET_SITE_GROUP_SUFFIX } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 const { getBlockletDomainGroupName } = require('../util/router');
@@ -46,6 +48,17 @@ class SiteState extends BaseState {
     return SiteState.renameIdFiledName(result);
   }
 
+  async getSystemSites() {
+    const result = await this.find({
+      where: {
+        domain: {
+          [Op.notLike]: `%${BLOCKLET_SITE_GROUP_SUFFIX}`,
+        },
+      },
+    });
+    return SiteState.renameIdFiledName(result);
+  }
+
   async getSitesByBlocklet(did) {
     const sites = await this.getSites();
     return sites.filter((x) => x.rules.some((r) => r.to?.did === did));
@@ -74,14 +87,84 @@ class SiteState extends BaseState {
     return site.rules.find((x) => x.id === id);
   }
 
+  /**
+   * Check if domain exists as primary domain or alias
+   * Optimized: O(1) for primary domain, efficient DB query for alias
+   * - PostgreSQL: Uses jsonb @> operator (can leverage GIN index)
+   * - SQLite: Uses json_each and json_extract for reliable array element search
+   */
   async domainExists(domain) {
-    const sites = await this.getSites();
-    return sites.some((x) => x.domain === domain || x.domainAliases.some((y) => y.value === domain));
+    // Fast path: check if domain is a primary domain (indexed query)
+    const byPrimaryDomain = await this.findOne({ domain });
+    if (byPrimaryDomain) {
+      return true;
+    }
+
+    const dialect = this.model.sequelize.getDialect();
+    if (dialect === 'postgres') {
+      // PostgreSQL: Use jsonb @> operator for efficient array containment check
+      // This can leverage GIN index on domainAliases if available
+      // Use JSON.stringify to safely construct JSON, then escape single quotes for SQL
+      const searchJson = JSON.stringify([{ value: domain }]).replace(/'/g, "''");
+      const count = await this.count({
+        where: Sequelize.literal(`"domainAliases" @> '${searchJson}'::jsonb`),
+      });
+      return count > 0;
+    }
+
+    // SQLite: Use json_each and json_extract for reliable array element search
+    // This avoids issues with JSON formatting/spacing in LIKE queries
+    const escapedDomain = domain.replace(/'/g, "''");
+    const count = await this.count({
+      where: Sequelize.literal(`
+        EXISTS (
+          SELECT 1 FROM json_each("domainAliases")
+          WHERE json_extract(value, '$.value') = '${escapedDomain}'
+        )
+      `),
+    });
+
+    return count > 0;
   }
 
+  /**
+   * Find site by domain alias
+   * Optimized: O(1) for primary domain, efficient DB query for alias
+   * - PostgreSQL: Uses jsonb @> operator (can leverage GIN index)
+   * - SQLite: Uses json_each and json_extract for reliable array element search
+   */
   async findByDomainAlias(domain) {
-    const sites = await this.getSites();
-    return sites.find((x) => x.domainAliases.some((y) => y.value === domain));
+    // Fast path: check if it's actually a primary domain
+    const byPrimaryDomain = await this.findOne({ domain });
+    if (byPrimaryDomain) {
+      return byPrimaryDomain;
+    }
+
+    const dialect = this.model.sequelize.getDialect();
+    if (dialect === 'postgres') {
+      // PostgreSQL: Use jsonb @> operator for efficient array containment check
+      // This can leverage GIN index on domainAliases if available
+      // Use JSON.stringify to safely construct JSON, then escape single quotes for SQL
+      const searchJson = JSON.stringify([{ value: domain }]).replace(/'/g, "''");
+      const sites = await this.find({
+        where: Sequelize.literal(`"domainAliases" @> '${searchJson}'::jsonb`),
+      });
+      return sites[0] || null;
+    }
+
+    // SQLite: Use json_each and json_extract for reliable array element search
+    // This avoids issues with JSON formatting/spacing in LIKE queries
+    const escapedDomain = domain.replace(/'/g, "''");
+    const sites = await this.find({
+      where: Sequelize.literal(`
+        EXISTS (
+          SELECT 1 FROM json_each("domainAliases")
+          WHERE json_extract(value, '$.value') = '${escapedDomain}'
+        )
+      `),
+    });
+
+    return sites[0] || null;
   }
 
   findOneByBlocklet(did) {

package/lib/team/manager.js

@@ -118,25 +118,6 @@ class TeamManager extends EventEmitter {
   }
 
   async init() {
-    // listen blocklet state
-    ['add', 'upgrade'].forEach((event) => {
-      this.states.blocklet.on(event, ({ meta: { did } }) => {
-        this.cache[did] = getDefaultTeamState();
-      });
-    });
-
-    // init blocklet
-    this.states.blocklet
-      .getBlocklets()
-      .then((blocklets) => {
-        blocklets.forEach(({ meta: { did } }) => {
-          this.cache[did] = getDefaultTeamState();
-        });
-      })
-      .catch((error) => {
-        logger.error('get blocklets failed', error);
-      });
-
     // init server
     this.cache[this.nodeDid] = getDefaultTeamState();
     logger.info('init node team manager', { nodeDid: this.nodeDid });
@@ -347,7 +328,7 @@ class TeamManager extends EventEmitter {
       }
     }
 
-    const domains = await getDomainsByDid(isServices ? teamDid : this.nodeDid);
+    const domains = await getDomainsByDid(isServices ? teamDid : this.nodeDid, this);
     const customDomains = domains.filter((d) => isCustomDomain(d));
 
     // 优先显示自定义域名
@@ -1035,7 +1016,7 @@ class TeamManager extends EventEmitter {
     const dbPath = await this.getDataFileByDid(did);
     logger.info('initDatabase', { did, dbPath });
     try {
-      await doSchemaMigration(dbPath, 'blocklet');
+      await doSchemaMigration(dbPath, 'blocklet', false, `blocklet:${did}`);
     } catch (error) {
       // This error is not fatal, just log it, will happen when there are multiple service processes
       logger.error('initDatabase failed', { did, dbPath, error });

package/lib/util/blocklet.js

@@ -25,6 +25,7 @@ const isUrl = require('is-url');
 const semver = require('semver');
 const { chainInfo: chainInfoSchema } = require('@arcblock/did-connect-js/lib/schema');
 
+const { types } = require('@ocap/mcrypto');
 const { urlPathFriendly } = require('@blocklet/meta/lib/url-path-friendly');
 const { fromSecretKey, fromPublicKey } = require('@ocap/wallet');
 const { toHex, isHex, toDid, toAddress, toBuffer } = require('@ocap/util');
@@ -65,7 +66,7 @@ const { getComponentApiKey } = require('@abtnode/util/lib/blocklet');
 const { toSvg: createDidLogo } = require('@arcblock/did-motif');
 const { createBlockiesSvg } = require('@blocklet/meta/lib/blockies');
 const formatName = require('@abtnode/util/lib/format-name');
-const { hasMountPoint } = require('@blocklet/meta/lib/engine');
+const { hasMountPoint, getBlockletEngine } = require('@blocklet/meta/lib/engine');
 const { fixAvatar } = require('@blocklet/sdk/lib/util/user');
 
 const SCRIPT_ENGINES_WHITE_LIST = ['npm', 'npx', 'pnpm', 'yarn'];
@@ -87,9 +88,9 @@ const {
   BLOCKLET_TENANT_MODES,
   PROJECT,
   BLOCKLET_INTERFACE_TYPE_DOCKER,
+  STATIC_SERVER_ENGINE_DID,
 } = require('@blocklet/constant');
 const { validateBlockletEntry } = require('@blocklet/meta/lib/entry');
-const { getBlockletEngine } = require('@blocklet/meta/lib/engine');
 const { getBlockletInfo } = require('@blocklet/meta/lib/info');
 const { getApplicationWallet: getBlockletWallet } = require('@blocklet/meta/lib/wallet');
 const {
@@ -360,7 +361,7 @@ const getComponentStartEngine = (component, { e2eMode = false } = {}) => {
   const cwd = appDir;
 
   // get app dirs
-  const { main, group } = component.meta;
+  const { group } = component.meta;
 
   let startFromDevEntry = '';
   if (component.mode === BLOCKLET_MODES.DEVELOPMENT && component.meta.scripts) {
@@ -386,9 +387,6 @@ const getComponentStartEngine = (component, { e2eMode = false } = {}) => {
   } else if (group === 'dapp') {
     script = blockletEngineInfo.source || BLOCKLET_ENTRY_FILE;
     args = blockletEngineInfo.args || [];
-  } else if (group === 'static') {
-    script = require.resolve('@abtnode/static-server');
-    environmentObj.BLOCKLET_MAIN_DIR = path.join(appDir, main);
   }
 
   if (component.mode !== BLOCKLET_MODES.DEVELOPMENT) {
@@ -1116,6 +1114,16 @@ const deleteBlockletProcess = async (
       if (!hasStartEngine(b.meta)) {
         return;
       }
+
+      // Skip deleting static-server engine processes since they were never started
+      if (b.meta?.group === 'static') {
+        return;
+      }
+      const engine = getBlockletEngine(b.meta);
+      if (engine.interpreter === 'blocklet' && engine.source?.name === STATIC_SERVER_ENGINE_DID) {
+        return;
+      }
+
       await preDelete(b, { ancestors });
       if (isStopGreenAndBlue) {
         // eslint-disable-next-line no-use-before-define
@@ -1150,6 +1158,15 @@ const reloadBlockletProcess = (blocklet, { componentDids } = {}) =>
         return;
       }
 
+      // Skip reloading static-server engine processes since they were never started
+      if (b.meta?.group === 'static') {
+        return;
+      }
+      const engine = getBlockletEngine(b.meta);
+      if (engine.interpreter === 'blocklet' && engine.source?.name === STATIC_SERVER_ENGINE_DID) {
+        return;
+      }
+
       // eslint-disable-next-line no-use-before-define
       await reloadProcess(b.env.processId);
       logger.info('done reload process', { processId: b.env.processId });
@@ -2244,19 +2261,20 @@ const validateAppConfig = async (config, states) => {
 
   if (x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK) {
     if (x.value) {
+      let wallet;
       try {
-        fromSecretKey(x.value);
+        wallet = fromSecretKey(x.value, { role: types.RoleType.ROLE_APPLICATION });
       } catch {
         try {
-          fromSecretKey(x.value, 'eth');
+          wallet = fromSecretKey(x.value, 'eth');
         } catch {
           throw new Error('Invalid custom blocklet secret key');
         }
       }
 
       // Ensure sk is not used by existing blocklets, otherwise we may encounter appDid collision
-      const blocklets = await states.blocklet.getBlocklets({});
-      if (blocklets.some((b) => isBlockletAppSkUsed(b, x.value))) {
+      const exist = await states.blocklet.hasBlocklet(wallet.address);
+      if (exist) {
         throw new Error('Invalid custom blocklet secret key: already used by existing blocklet');
       }
     } else {
@@ -2380,14 +2398,18 @@ const checkDuplicateAppSk = async ({ sk, did, states }) => {
     appSk = wallet.secretKey;
   }
 
-  const blocklets = await states.blocklet.getBlocklets({});
-  const others = did ? blocklets.filter((b) => b.meta.did !== did) : blocklets;
-
-  const exist = others.find((b) => {
-    const item = (b.environments || []).find((e) => e.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK);
-    return item?.value === toHex(appSk);
-  });
+  let wallet;
+  try {
+    wallet = fromSecretKey(appSk, { role: types.RoleType.ROLE_APPLICATION });
+  } catch {
+    try {
+      wallet = fromSecretKey(appSk, 'eth');
+    } catch {
+      throw new Error('Invalid custom blocklet secret key');
+    }
+  }
 
+  const exist = await states.blocklet.hasBlocklet(wallet.address);
   if (exist) {
     throw new Error(`blocklet secret key already used by ${exist.meta.title || exist.meta.name}`);
   }
@@ -2434,6 +2456,21 @@ const validateStore = (nodeInfo, storeUrl) => {
   }
 
   const storeUrlObj = new URL(storeUrl);
+
+  // Check trusted blocklet sources from environment variable first
+  const trustedSources = process.env.ABT_NODE_TRUSTED_SOURCES;
+  if (trustedSources) {
+    const trustedHosts = trustedSources
+      .split(',')
+      .map((url) => url.trim())
+      .filter(Boolean)
+      .map((url) => new URL(url).host);
+
+    if (trustedHosts.includes(storeUrlObj.host)) {
+      return;
+    }
+  }
+
   const registerUrlObj = new URL(nodeInfo.registerUrl);
 
   // 信任 Launcher 打包的应用
@@ -2804,7 +2841,7 @@ const publishDidDocument = async ({ blocklet, ownerInfo, nodeInfo }) => {
   const name = blocklet.meta?.title || blocklet.meta?.name;
   const state = fromBlockletStatus(blocklet.status);
 
-  let launcher = null;
+  let launcher;
   if (!isEmpty(blocklet.controller)) {
     launcher = {
       did: toDid(blocklet.controller.did || nodeInfo.registerInfo.appPid), // 目前 controller 没有 launcher 的元信息, 默认在 nodeInfo 中存储
@@ -2847,11 +2884,14 @@ const publishDidDocument = async ({ blocklet, ownerInfo, nodeInfo }) => {
     })
   );
 
-  const owner = {
-    did: toDid(ownerInfo.did),
-    name: ownerInfo.fullName,
-    avatar: fixAvatar(ownerInfo.avatar),
-  };
+  let owner;
+  if (ownerInfo) {
+    owner = {
+      did: toDid(ownerInfo.did),
+      name: ownerInfo.fullName,
+      avatar: fixAvatar(ownerInfo.avatar),
+    };
+  }
 
   return didDocument.updateBlockletDocument({
     blocklet,
@@ -2878,21 +2918,15 @@ const updateDidDocument = async ({ did, nodeInfo, teamManager, states }) => {
 
   blocklet.site = await states.site.findOneByBlocklet(did);
   blocklet.settings = await states.blockletExtras.getSettings(did);
-  blocklet.controller = blockletExtra.controller;
-
-  logger.debug('update did document', { blocklet });
+  blocklet.controller = blockletExtra?.controller;
 
-  const ownerDid = blocklet.settings.owner.did;
-  logger.info('get owner info', { ownerDid, teamDid: blocklet.appPid });
-  const userState = await teamManager.getUserState(blocklet.appPid);
-  const ownerInfo = await userState.getUser(ownerDid);
-
-  logger.info('got user info', {
-    owner: ownerInfo,
-    blockletDid: blocklet.meta.did,
-    ownerDid,
-    teamDid: blocklet.appPid,
-  });
+  const ownerDid = blocklet.settings?.owner?.did;
+  let ownerInfo;
+  if (ownerDid) {
+    logger.info('get owner info', { ownerDid, teamDid: blocklet.appPid });
+    const userState = await teamManager.getUserState(blocklet.appPid);
+    ownerInfo = await userState.getUser(ownerDid);
+  }
 
   return publishDidDocument({ blocklet, ownerInfo, nodeInfo });
 };

package/lib/util/get-accessible-external-node-ip.js

@@ -9,7 +9,8 @@ const getNodeDomain = (ip) => (ip ? DEFAULT_IP_DOMAIN.replace(/^\*/, ip.replace(
 let cache = null;
 let cacheAt = 0;
 let cacheMissCount = 0;
-const cacheMissTTL = 1000 * 60 * 10; // 10 minutes
+let pendingFetch = null; // Prevents concurrent fetches
+const cacheMissTTL = 1000 * 60 * 30; // 30 minutes
 
 const timeout = process.env.NODE_ENV === 'test' ? 500 : 5000;
 
@@ -40,19 +41,22 @@ const checkConnected = async ({ ip, nodeInfo }) => {
  */
 const fetch = async (nodeInfo) => {
   const { external, internal } = await getIp();
-  logger.info('refresh external ip:', external);
-
   if ([external, internal].includes(cache)) {
+    logger.info('reuse cached accessible ip:', { cache });
     return cache;
   }
 
+  logger.info('refresh accessible ip:', { external, internal, cache });
+
   // prefer external ip
   try {
     if (external) {
       await checkConnected({ ip: external, nodeInfo });
       cache = external;
+      logger.info('cache external ip as accessible ip', { external });
     }
-  } catch {
+  } catch (err) {
+    logger.error('failed to check external ip', { external, error: err });
     cacheMissCount += 1;
     cache = null;
   }
@@ -63,8 +67,10 @@ const fetch = async (nodeInfo) => {
       if (internal) {
         await checkConnected({ ip: internal, nodeInfo });
         cache = internal;
+        logger.info('cache internal ip as accessible ip', { internal });
       }
-    } catch {
+    } catch (err) {
+      logger.error('failed to check internal ip', { internal, error: err });
       cacheMissCount += 1;
       cache = null;
     }
@@ -86,7 +92,16 @@ module.exports.getFromCache = (nodeInfo) => {
     return cache;
   }
   if (nodeInfo) {
-    return cache || fetch(nodeInfo);
+    if (cache) {
+      return cache;
+    }
+    // Use pending promise to prevent concurrent fetches
+    if (!pendingFetch) {
+      pendingFetch = fetch(nodeInfo).finally(() => {
+        pendingFetch = null;
+      });
+    }
+    return pendingFetch;
   }
   return cache;
 };

package/lib/util/index.js

@@ -29,10 +29,10 @@ const {
   DEFAULT_HTTPS_PORT,
   SLOT_FOR_IP_DNS_SITE,
   BLOCKLET_SITE_GROUP_SUFFIX,
+  DEFAULT_WELLKNOWN_PORT,
 } = require('@abtnode/constant');
 const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
 
-const DEFAULT_WELLKNOWN_PORT = 8088;
 const APP_CONFIG_IMAGE_KEYS = [
   BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_LOGO_FAVICON,
   BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPLASH_PORTRAIT,
@@ -219,8 +219,8 @@ const getBaseUrls = async (node, ips) => {
     return { protocol, port };
   };
 
-  if (info.routing.provider && info.routing.snapshotHash && info.routing.adminPath) {
-    const sites = await node.getSitesFromSnapshot();
+  if (info.routing.provider && info.routing.adminPath) {
+    const sites = await node.getSitesFromState('system');
     const { ipWildcardDomain } = info.routing;
     const adminPath = normalizePathPrefix(info.routing.adminPath);
     const tmpHttpPort = getPort(httpPort, DEFAULT_HTTP_PORT);

package/lib/util/ip.js

@@ -8,6 +8,8 @@ const { promisify } = require('util');
 const lookup = promisify(dns.lookup);
 
 let cache = null;
+let pendingFetch = null; // Prevents concurrent fetches
+
 const fetch = async (args = {}) => {
   try {
     const start = Date.now();
@@ -21,7 +23,19 @@ const fetch = async (args = {}) => {
   return cache;
 };
 
-const get = (args) => cache || fetch(args);
+const get = (args) => {
+  if (cache) {
+    return cache;
+  }
+  // Use pending promise to prevent concurrent fetches
+  if (!pendingFetch) {
+    pendingFetch = fetch(args).finally(() => {
+      pendingFetch = null;
+    });
+  }
+  return pendingFetch;
+};
+
 const cron = {
   name: 'refetch-ip',
   time: '0 */30 * * * *', // refetch every 30 minutes

package/lib/util/launcher.js

@@ -166,17 +166,16 @@ const getCpuUtilization = async () => {
 
 const getComponentsAggregate = async () => {
   try {
-    const list = await states.blocklet.getBlocklets();
+    // Use efficient SQL GROUP BY COUNT instead of loading all children into memory
+    // This is O(1) memory vs O(n) for the old implementation
+    const { total, counts: statusCounts } = await states.blockletChild.getStatusCounts();
+
+    // Convert numeric status keys to string keys using fromBlockletStatus
     const counts = {};
-    let total = 0;
-    list.forEach((b) => {
-      const children = Array.isArray(b.children) ? b.children : [];
-      children.forEach((child) => {
-        const key = fromBlockletStatus(child.status) || 'unknown';
-        counts[key] = (counts[key] || 0) + 1;
-        total += 1;
-      });
-    });
+    for (const [status, count] of Object.entries(statusCounts)) {
+      const key = fromBlockletStatus(Number(status)) || 'unknown';
+      counts[key] = (counts[key] || 0) + count;
+    }
 
     return { total, counts };
   } catch (error) {
@@ -660,7 +659,7 @@ const launchBlockletByLauncher = async (node, extraParams, context) => {
 };
 
 const launchBlockletWithoutWallet = async (node, extraParams, context) => {
-  logger.debug('launchBlockletWithoutWallet', { extraParams, context });
+  logger.info('launchBlockletWithoutWallet start', { extraParams });
 
   extraParams.locale = context.locale || 'en';
 
@@ -679,6 +678,7 @@ const launchBlockletWithoutWallet = async (node, extraParams, context) => {
           description,
         },
       };
+  logger.info('launchBlockletWithoutWallet meta fetched', { blocklet });
 
   if (!blocklet) {
     throw new Error('Blocklet not found');

package/lib/util/ready.js

@@ -3,18 +3,11 @@ const logger = require('@abtnode/logger')('@abtnode/core:ready');
 const chalk = require('chalk');
 
 const createStateReadyHandler =
-  (routingSnapshot) =>
-  async ({ states, options }) => {
-    const snapshotHash = await routingSnapshot.init();
-
+  () =>
+  ({ states, options }) => {
     return states.node
       .read()
       .then(async (state) => {
-        if (snapshotHash && !state.routing.snapshotHash) {
-          logger.info('set snapshot hash because its empty');
-          await states.node.updateNodeRouting({ ...state.routing, snapshotHash });
-        }
-
         // Set default sender/receiver for notification center
         states.notification.setDefaultSender(state.did);
         if (state.nodeOwner) {

package/lib/util/reset-node.js

@@ -62,7 +62,8 @@ const resetDirs = () => {
 
 /* istanbul ignore next */
 const resetBlocklets = async ({ context, blockletManager }) => {
-  const blocklets = await blockletManager.list({ includeRuntimeInfo: false }, context);
+  const result = await blockletManager.list({ includeRuntimeInfo: false }, context);
+  const blocklets = result.blocklets || [];
   for (let i = 0; i < blocklets.length; i++) {
     const blocklet = blocklets[i];
     // eslint-disable-next-line no-await-in-loop
@@ -75,7 +76,7 @@ const resetBlocklets = async ({ context, blockletManager }) => {
 };
 
 /* istanbul ignore next */
-const resetSites = async ({ context, routerManager, takeRoutingSnapshot }) => {
+const resetSites = async ({ context, routerManager, handleAllRouting }) => {
   const sites = await states.site.getSites();
   for (let i = 0; i < sites.length; i++) {
     const site = sites[i];
@@ -87,7 +88,7 @@ const resetSites = async ({ context, routerManager, takeRoutingSnapshot }) => {
     }
   }
 
-  const hash = await takeRoutingSnapshot({ message: 'reset routing sites for test', dryRun: false }, context);
+  const hash = await handleAllRouting({ message: 'reset routing sites for test' });
   logger.info('reset routing sites', { hash });
 };
 
@@ -153,7 +154,7 @@ module.exports = async ({
   context,
   blockletManager,
   routerManager,
-  takeRoutingSnapshot,
+  handleAllRouting,
   teamManager,
   certManager,
 }) => {
@@ -192,7 +193,7 @@ module.exports = async ({
         context,
         blockletManager,
         routerManager,
-        takeRoutingSnapshot,
+        handleAllRouting,
         teamManager,
         certManager,
       });

package/lib/validators/router.js

@@ -103,9 +103,6 @@ const ruleSchema = {
     )
     .optional()
     .default([]),
-
-  // root blocklet ruleId
-  groupId: Joi.string(),
 };
 
 const corsSchema = Joi.array()

package/lib/webhook/sender/api/index.js

@@ -38,6 +38,11 @@ class APISender extends BaseSender {
   }
 
   async sendNotification(url, notification) {
+    if (process.env.NODE_ENV === 'test') {
+      return {
+        text: 'ok',
+      };
+    }
     try {
       const res = await axios.post(url, notification, { timeout: 10000 });
       return { text: res.statusText, code: res.status };