@abtnode/core 1.17.7-beta-20251227-001958-ea2ba3f5 → 1.17.7-beta-20251229-223813-e1e6c5e3

package/lib/event/index.js

@@ -24,7 +24,7 @@ const { joinURL } = require('ufo');
 const { encode } = require('@abtnode/util/lib/base32');
 const dayjs = require('@abtnode/util/lib/dayjs');
 
-const { isInstanceWorker } = require('@abtnode/util/lib/pm2/is-instance-worker');
+const { isWorkerInstance } = require('@abtnode/util/lib/pm2/is-instance-worker');
 const { isInServerlessMode } = require('@abtnode/util/lib/serverless');
 const { NodeMonitSender } = require('../monitor/node-monit-sender');
 const { isCLI } = require('../util');
@@ -43,12 +43,7 @@ const {
   updateDidDocument,
   updateDidDocumentStateOnly,
 } = require('../util/blocklet');
-const {
-  backupBlockletSites,
-  cleanBlockletSitesBackup,
-  rollbackBlockletSites,
-  routingSnapshotPrefix,
-} = require('./util');
+const { backupBlockletSites, cleanBlockletSitesBackup, rollbackBlockletSites } = require('./util');
 const { ensureBlockletHasMultipleInterfaces } = require('../router/helper');
 const { sendServerlessHeartbeat } = require('../util/launcher');
 
@@ -66,8 +61,8 @@ module.exports = ({
   ensureBlockletRouting,
   ensureBlockletRoutingForUpgrade,
   removeBlockletRouting,
-  takeRoutingSnapshot,
-  handleRouting,
+  handleBlockletRouting,
+  handleSystemRouting,
   handleBlockletWafChange,
   domainStatus,
   teamAPI,
@@ -100,7 +95,7 @@ module.exports = ({
 
   // Listen events from eventHub and call eventHandler
   [...Object.values(BlockletEvents), ...Object.values(TeamEvents), ...Object.values(EVENTS)].forEach((name) => {
-    if (isInstanceWorker()) {
+    if (isWorkerInstance()) {
       return;
     }
     eventHub.on(name, (data) => {
@@ -140,7 +135,7 @@ module.exports = ({
   });
 
   eventHub.on(EVENTS.NODE_UPDATED, () => {
-    if (isInstanceWorker()) {
+    if (isWorkerInstance()) {
       return;
     }
     logger.info('node update');
@@ -187,7 +182,7 @@ module.exports = ({
     }
   };
 
-  const handleBlockletBlurOrGreenStarted = async (name, { blocklet, componentDids, context }) => {
+  const handleBlockletBlueOrGreenStarted = async (name, { blocklet, componentDids, context }) => {
     try {
       // 只有某些 children 有多个接口时, 才需要更新路由
       const hasMultipleInterfaces = ensureBlockletHasMultipleInterfaces(blocklet, componentDids);
@@ -196,14 +191,10 @@ module.exports = ({
       }
       const changed = await ensureBlockletRouting(blocklet, context);
       if (changed) {
-        const hash = await takeRoutingSnapshot(
-          {
-            message: `${routingSnapshotPrefix(blocklet)}Blur or green start blocklet ${blocklet.meta.name}`,
-            dryRun: false,
-          },
-          context
-        );
-        logger.info('created.url.mapping', { event: name, did: blocklet.meta.did, hash });
+        await handleBlockletRouting({
+          did: blocklet.meta.did,
+          message: 'Blue or green start blocklet',
+        });
         return true;
       }
       return false;
@@ -221,26 +212,49 @@ module.exports = ({
     }
   };
 
+  /**
+   * Handle BlockletEvents.added - set up routing early for DNS warm-up
+   * This is called as soon as blocklet is added to database, before download/install completes
+   */
+  const handleBlockletAdded = async (name, { blocklet, context }) => {
+    try {
+      const changed = await ensureBlockletRouting(blocklet, context);
+      if (changed) {
+        await handleBlockletRouting({
+          did: blocklet.meta.did,
+          message: 'Added blocklet (early routing setup)',
+        });
+        logger.info('early routing setup completed after added', { did: blocklet.meta.did });
+      }
+    } catch (error) {
+      // Non-blocking - don't fail the install if early routing setup fails
+      // It will be retried at installed event
+      logger.error('early routing setup failed after added', { event: name, did: blocklet.meta.did, error });
+    }
+  };
+
   const handleBlockletInstall = async (name, { blocklet, context }) => {
     try {
+      // Routing is already set up at 'added' event, but ensure it's complete
+      // This handles cases where 'added' handler failed or was skipped
       const changed = await ensureBlockletRouting(blocklet, context);
       if (changed) {
-        const hash = await takeRoutingSnapshot(
-          { message: `${routingSnapshotPrefix(blocklet)}Install blocklet ${blocklet.meta.name}`, dryRun: false },
-          context
-        );
-        logger.info('created.url.mapping', { event: name, did: blocklet.meta.did, hash });
+        await handleBlockletRouting({
+          did: blocklet.meta.did,
+          message: 'Install blocklet',
+        });
       }
 
       await teamAPI.refreshBlockletInterfacePermissions(blocklet.meta);
       logger.info('refreshed blocklet interface permissions after installed', { did: blocklet.meta.did });
 
+      // Send full DID document update after install to capture any info populated during installation
+      // The 'added' event sends an early document for DNS warm-up, but some metadata may be incomplete
       try {
-        const nodeInfo = await node.getNodeInfo();
-        await updateDidDocument({ did: blocklet.appPid, nodeInfo, teamManager, states });
+        await updateDidDocument({ did: blocklet.appPid, nodeInfo: await node.getNodeInfo(), teamManager, states });
         logger.info('updated blocklet DID document after install', { did: blocklet.meta.did });
       } catch (error) {
-        logger.error('update blocklet DID document failed after install', { did: blocklet.meta.did, error });
+        logger.error('update blocklet DID document state failed after install', { did: blocklet.meta.did, error });
       }
     } catch (error) {
       logger.error('create.url.mapping.error', { event: name, error });
@@ -262,25 +276,24 @@ module.exports = ({
 
     try {
       const changed = await removeBlockletRouting(blocklet, context);
-
       if (changed) {
-        const hash = await takeRoutingSnapshot(
-          { message: `${routingSnapshotPrefix(blocklet)}Remove blocklet ${blocklet.meta.name}`, dryRun: false },
-          context
-        );
-        logger.info('remove blocklet routing rules', { event: name, did: blocklet.meta.did, hash });
+        await handleBlockletRouting({
+          did: blocklet.meta.did,
+          message: 'Remove blocklet',
+          isRemoval: true,
+        });
+        logger.info('remove blocklet routing rules', { event: name, did: blocklet.meta.did });
       }
     } catch (error) {
       logger.error('remove blocklet routing rules error', { event: name, error });
     }
 
     try {
-      const nodeInfo = await node.getNodeInfo();
       await updateDidDocumentStateOnly({
         did: blocklet.appPid,
         blocklet,
         state: 'deleted',
-        nodeInfo,
+        nodeInfo: await node.getNodeInfo(),
       });
       logger.info('updated blocklet DID document state to deleted', { did: blocklet.meta.did });
     } catch (error) {
@@ -303,11 +316,10 @@ module.exports = ({
 
       const changed = await ensureBlockletRoutingForUpgrade(blocklet, context);
       if (changed) {
-        const hash = await takeRoutingSnapshot(
-          { message: `${routingSnapshotPrefix(blocklet)}Upgrade blocklet ${blocklet.meta.name}`, dryRun: false },
-          context
-        );
-        logger.info('upgrade blocklet routing rules', { event: name, did: blocklet.meta.did, hash });
+        await handleBlockletRouting({
+          did: blocklet.meta.did,
+          message: 'Upgrade blocklet',
+        });
       }
 
       await teamAPI.refreshBlockletInterfacePermissions(blocklet.meta);
@@ -318,7 +330,7 @@ module.exports = ({
     } catch (error) {
       logger.error('upgrade blocklet routing rules error', { event: name, error });
 
-      rollbackBlockletSites({ blocklet, sites, backupFile, takeRoutingSnapshot, context })
+      rollbackBlockletSites({ blocklet, sites, backupFile, handleBlockletRouting, context })
         .then(() => {
           logger.info('rollback blocklet routing rules success', { event: name, did: blocklet.meta.did });
         })
@@ -375,8 +387,11 @@ module.exports = ({
       return;
     }
 
-    if ([BlockletEvents.blurOrGreenStarted].includes(eventName)) {
-      await handleBlockletBlurOrGreenStarted(eventName, payload);
+    if ([BlockletEvents.blueOrGreenStarted].includes(eventName)) {
+      await handleBlockletBlueOrGreenStarted(eventName, payload);
+    } else if ([BlockletEvents.added].includes(eventName)) {
+      // Non-blocking - don't await to avoid slowing down install flow
+      handleBlockletAdded(eventName, payload);
     } else if ([BlockletEvents.installed].includes(eventName)) {
       await handleBlockletInstall(eventName, payload);
 
@@ -425,20 +440,15 @@ module.exports = ({
         }
       }
     } 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 });
+      await handleBlockletRouting({
+        did: blocklet.meta.did,
+        message: 'Update blocklet appDid',
+      });
     } else if (BlockletEvents.spaceConnected === eventName) {
-      nodeState
-        .read()
-        .then((info) => handleRouting(info))
-        .catch((err) => {
-          logger.error('Reload gateway failed on blocklet.connectedSpace', { error: err });
-        });
-      logger.info('Reload gateway after blocklet connected to space', { event: eventName, did: blocklet.appDid });
+      await handleBlockletRouting({
+        did: blocklet.meta.did,
+        message: 'Connect blocklet to DID Spaces',
+      });
     } else if (BlockletEvents.backupProgress === eventName && payload?.completed) {
       try {
         const backupEndpoint = getBackupEndpoint(blocklet?.environments);
@@ -530,30 +540,22 @@ module.exports = ({
         logger.error('monit runtime info failed', { eventName, error });
       }
 
+      // Use state-only update for started/stopped - no need to send full document
       if ([BlockletEvents.started, BlockletEvents.stopped].includes(eventName)) {
-        try {
-          const nodeInfo = await node.getNodeInfo();
-          updateDidDocument({ did: blocklet.appPid, nodeInfo, teamManager, states })
-            .then(() => {
-              logger.info('updated blocklet DID document after state change', {
-                did: blocklet.meta.did,
-                event: eventName,
-              });
-            })
-            .catch((error) => {
-              logger.error('update blocklet DID document failed after state change', {
-                did: blocklet.meta.did,
-                event: eventName,
-                error,
-              });
+        updateDidDocument({ did: blocklet.appPid, nodeInfo: await node.getNodeInfo(), teamManager, states })
+          .then(() => {
+            logger.info(`updated blocklet DID document on ${eventName}`, {
+              did: blocklet.meta.did,
+              event: eventName,
+            });
+          })
+          .catch((error) => {
+            logger.error(`update blocklet DID document failed on ${eventName}`, {
+              did: blocklet.meta.did,
+              event: eventName,
+              error,
             });
-        } catch (error) {
-          logger.error('update blocklet DID document failed after state change', {
-            did: blocklet.meta.did,
-            event: eventName,
-            error,
           });
-        }
       }
     }
 
@@ -683,7 +685,7 @@ module.exports = ({
     BlockletEvents.nftConsumed,
 
     BlockletEvents.configTheme,
-    BlockletEvents.blurOrGreenStarted,
+    BlockletEvents.blueOrGreenStarted,
   ].forEach((eventName) => {
     listen(blockletManager, eventName, handleBlockletEvent);
   });
@@ -742,26 +744,25 @@ module.exports = ({
     onEvent(EVENTS.NODE_UPDATED, { did: nodeInfo.did });
 
     // We need update router on some fields change
-    const fields = ['enableWelcomePage', 'webWalletUrl', 'registerUrl'];
+    const fields = ['enableWelcomePage'];
     const shouldUpdateRouter = fields.some((x) => nodeInfo[x] !== oldInfo[x]);
     if (shouldUpdateRouter) {
-      handleRouting(nodeInfo).catch((err) => {
+      handleSystemRouting({ message: 'Server settings updated' }).catch((err) => {
         logger.error('Handle routing failed on node.updated', { error: err });
       });
     }
   });
 
   listen(nodeState, EVENTS.NODE_MAINTAIN_PROGRESS, onEvent);
-  nodeState.on(EVENTS.RELOAD_GATEWAY, (nodeInfo) => {
-    handleRouting(nodeInfo).catch((err) => {
-      logger.error('Handle routing failed on node.updated', { error: err });
+  nodeState.on(EVENTS.RELOAD_GATEWAY, () => {
+    handleSystemRouting({ message: 'Reload gateway' }).catch((err) => {
+      logger.error('Handle routing failed on reload gateway', { error: err });
     });
   });
 
   routerManager.on(EVENTS.UPDATE_DOMAIN_ALIAS, async (did) => {
     if (did) {
-      const nodeInfo = await node.getNodeInfo();
-      updateDidDocument({ did, nodeInfo, teamManager, states })
+      updateDidDocument({ did, nodeInfo: await node.getNodeInfo(), teamManager, states })
         .then(() => {
           logger.info('Update did document successfully on update domain alias', { did });
         })
@@ -794,6 +795,16 @@ module.exports = ({
 
   listen(securityAPI, BlockletEvents.securityConfigUpdated, onEvent);
 
+  // Refresh router when security config changes to update static serving rules
+  // When access policy changes from/to PUBLIC, nginx config needs to be updated
+  listen(securityAPI, BlockletEvents.securityConfigUpdated, (eventName, data) => {
+    if (daemon) {
+      handleBlockletRouting({ did: data?.did, message: 'Security config changed' }).catch((err) => {
+        logger.error('Failed to refresh router after security config change', { error: err, did: data?.did });
+      });
+    }
+  });
+
   Object.keys(TeamEvents).forEach((key) => {
     listen(teamAPI, TeamEvents[key], onEvent);
   });
@@ -827,7 +838,7 @@ module.exports = ({
   if (daemon) {
     const { handleEventBusEvent } = eventBusHandler({ states, teamManager, teamAPI });
     eventHub.on(EVENT_BUS_EVENT, (data) => {
-      if (isInstanceWorker()) {
+      if (isWorkerInstance()) {
         return null;
       }
       return handleEventBusEvent(data);

package/lib/event/util.js

@@ -1,12 +1,9 @@
 const path = require('path');
 const fs = require('fs');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
-const { BLOCKLET_MODES } = require('@blocklet/constant');
 
 const states = require('../states');
 
-const routingSnapshotPrefix = (blocklet) => (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '[DEV] ' : '');
-
 const backupBlockletSites = async (blocklet) => {
   const sites = await states.site.getSitesByBlocklet(blocklet.meta.did);
   let backupFile = null;
@@ -24,7 +21,7 @@ const backupBlockletSites = async (blocklet) => {
   return { sites, backupFile };
 };
 
-const rollbackBlockletSites = async ({ blocklet, sites, backupFile, takeRoutingSnapshot, context }) => {
+const rollbackBlockletSites = async ({ blocklet, sites, backupFile, handleBlockletRouting }) => {
   try {
     let sitesToRestore = sites;
     logger.info('rollback blocklet sites', { did: blocklet.meta.did, sites, backupFile });
@@ -41,15 +38,13 @@ const rollbackBlockletSites = async ({ blocklet, sites, backupFile, takeRoutingS
     await Promise.all(promises);
     logger.info('rollback blocklet sites rules success to database', { did: blocklet.meta.did, sites, backupFile });
 
-    const hash = await takeRoutingSnapshot(
-      {
-        message: `${routingSnapshotPrefix(blocklet)}Roll back sites rules for blocklet ${blocklet.meta.name}`,
-        dryRun: false,
-      },
-      context
-    );
+    // Trigger router reload after rollback
+    await handleBlockletRouting({
+      did: blocklet.meta.did,
+      message: 'Roll back sites rules',
+    });
 
-    logger.info('rollback blocklet sites success to snapshot', { did: blocklet.meta.did, hash });
+    logger.info('rollback blocklet sites success', { did: blocklet.meta.did });
   } catch (error) {
     logger.error('rollback blocklet sites error', { error, blocklet, sites, backupFile });
   }
@@ -66,7 +61,6 @@ const cleanBlockletSitesBackup = (backupFile) => {
 };
 
 module.exports = {
-  routingSnapshotPrefix,
   backupBlockletSites,
   cleanBlockletSitesBackup,
   rollbackBlockletSites,

package/lib/index.js

@@ -12,8 +12,7 @@ const { listProviders } = require('@abtnode/router-provider');
 const { DEFAULT_CERTIFICATE_EMAIL, EVENTS } = require('@abtnode/constant');
 const { CustomError } = require('@blocklet/error');
 
-const { isInstanceWorker } = require('@abtnode/util/lib/pm2/is-instance-worker');
-const RoutingSnapshot = require('./states/routing-snapshot');
+const { isWorkerInstance } = require('@abtnode/util/lib/pm2/is-instance-worker');
 const BlockletManager = require('./blocklet/manager/disk');
 const RouterManager = require('./router/manager');
 const getRouterHelpers = require('./router/helper');
@@ -276,13 +275,6 @@ function ABTNode(options) {
 
   // 4. init routing manager
   const routerManager = new RouterManager({ certManager, dataDirs });
-  const routingSnapshot = new RoutingSnapshot({
-    baseDir: dataDirs.core,
-    getRoutingData: async () => {
-      const sites = await states.site.getSites();
-      return { sites };
-    },
-  });
 
   const nodeAPI = new NodeAPI(states, options.nodeDid);
   const passportAPI = new PassportAPI({ states, teamManager, nodeAPI, teamDid: options.nodeDid });
@@ -311,18 +303,17 @@ function ABTNode(options) {
 
   const {
     handleBlockletWafChange,
-    handleRouting,
+    handleBlockletRouting,
+    handleSystemRouting,
+    handleAllRouting,
     resetSiteByDid,
-    updateNodeRouting,
-    takeRoutingSnapshot,
     getRoutingSites,
-    getSnapshotSites,
     ensureDashboardRouting,
     ensureBlockletRouting,
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
     getCertificates,
-    getSitesFromSnapshot,
+    getSitesFromState,
     getRoutingCrons,
     ensureWildcardCerts,
     ensureServerlessCerts,
@@ -339,7 +330,6 @@ function ABTNode(options) {
     getGatewayBlacklist,
   } = getRouterHelpers({
     dataDirs,
-    routingSnapshot,
     routerManager,
     blockletManager,
     certManager,
@@ -351,7 +341,7 @@ function ABTNode(options) {
 
   // Generate an on node ready callback
   const onStatesReady = createStateReadyQueue({ states: states.allStates, options, dataDirs });
-  onStatesReady(createStateReadyHandler(routingSnapshot));
+  onStatesReady(createStateReadyHandler());
   const domainStatus = new DomainStatus({ routerManager, states });
 
   const isInitialized = async () => {
@@ -492,10 +482,9 @@ function ABTNode(options) {
     cleanupDirtyMaintainState: states.node.cleanupDirtyMaintainState.bind(states.node),
     updateNodeOwner: states.node.updateNodeOwner.bind(states.node),
     updateNftHolder: states.node.updateNftHolder.bind(states.node),
-    updateNodeRouting,
     isInitialized,
     resetNode: (params, context) =>
-      resetNode({ params, context, blockletManager, routerManager, takeRoutingSnapshot, teamManager, certManager }),
+      resetNode({ params, context, blockletManager, routerManager, handleAllRouting, teamManager, certManager }),
     updateNodeStatus: states.node.updateStatus.bind(states.node),
     resetNodeStatus: states.node.resetStatus.bind(states.node),
 
@@ -727,10 +716,7 @@ function ABTNode(options) {
     deleteRoutingRule,
     getRoutingRuleById: states.site.getRuleById.bind(states.site),
     getRoutingSites: (params, context) => getRoutingSites(params, context, { withDefaultCors: false }),
-    getRoutingSnapshots: routingSnapshot.listSnapshots.bind(routingSnapshot),
-    getSnapshotSites: (params, context) => getSnapshotSites(params, context, { withDefaultCors: false }),
-    takeRoutingSnapshot,
-    getSitesFromSnapshot,
+    getSitesFromState,
     ensureDashboardRouting,
     ensureWildcardCerts,
     ensureServerlessCerts,
@@ -742,7 +728,10 @@ function ABTNode(options) {
 
     getRoutingProviders: () => listProviders(dataDirs.router),
     checkDomains: domainStatus.checkDomainsStatus.bind(domainStatus),
-    handleRouting,
+
+    handleSystemRouting,
+    handleBlockletRouting,
+    handleAllRouting,
 
     certManager,
     updateCertificate: certManager.update.bind(certManager),
@@ -875,8 +864,8 @@ function ABTNode(options) {
     ensureBlockletRouting,
     ensureBlockletRoutingForUpgrade,
     removeBlockletRouting,
-    takeRoutingSnapshot,
-    handleRouting,
+    handleBlockletRouting,
+    handleSystemRouting,
     domainStatus,
     teamAPI,
     nodeAPI,
@@ -894,7 +883,7 @@ function ABTNode(options) {
   const webhook = WebHook({ events, dataDirs, instance });
 
   const initCron = async () => {
-    if (isInstanceWorker()) {
+    if (isWorkerInstance()) {
       return;
     }
     Cron.init({

package/lib/migrations/1.5.0-site.js

@@ -1,6 +1,6 @@
 const { SLOT_FOR_IP_DNS_SITE } = require('@abtnode/constant');
 
-module.exports = async ({ states, node, printInfo }) => {
+module.exports = async ({ states, printInfo }) => {
   printInfo('Migrate ip dns site for blocklet...');
 
   const sites = await states.site.getSites();
@@ -24,11 +24,7 @@ module.exports = async ({ states, node, printInfo }) => {
   }
 
   if (changed) {
-    await node.takeRoutingSnapshot({
-      message: 'Migrate ip dns site for blocklet',
-      dryRun: false,
-      handleRouting: false,
-    });
-    printInfo('Take routing snapshot');
+    // Note: Routing snapshots have been removed
+    printInfo('Migration completed (routing snapshots removed)');
   }
 };

package/lib/migrations/1.5.15-site.js

@@ -57,7 +57,7 @@ const mergeSite = (newSite, oldSite) => {
   });
 };
 
-module.exports = async ({ states, node, printInfo }) => {
+module.exports = async ({ states, printInfo }) => {
   printInfo('Migrate site to 2.0 version for router...\n');
 
   const sites = await states.site.getSites();
@@ -175,11 +175,7 @@ module.exports = async ({ states, node, printInfo }) => {
     printInfo(`Add site to db: ${site.domain}`);
   }
 
-  await node.takeRoutingSnapshot({
-    message: 'Migrate site to 2.0 version for router',
-    dryRun: false,
-    handleRouting: false,
-  });
+  // Note: Routing snapshots have been removed
   printInfo('\n');
-  printInfo('Take routing snapshot');
+  printInfo('Migration completed (routing snapshots removed)');
 };

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

@@ -10,11 +10,17 @@ const { BlockletStatus } = require('@blocklet/constant');
 const defaultLogger = require('@abtnode/logger')('blocklet-runtime-monitor');
 
 const { Op } = require('sequelize');
-const { isInstanceWorker } = require('@abtnode/util/lib/pm2/is-instance-worker');
+const { isWorkerInstance } = require('@abtnode/util/lib/pm2/is-instance-worker');
 const { getRuntimeInfo } = require('../util/blocklet');
 
 const insertThrottleMap = new Map();
 
+const isRuntimeMonitorDisabled = () => {
+  const value = process.env.ABT_NODE_RUNTIME_MONITOR_DISABLED;
+  // Disabled when set to '1' or 'true', enabled when '0', 'false', or unset
+  return value === '1' || value === 'true';
+};
+
 class BlockletRuntimeMonitor extends EventEmitter {
   constructor({ states, logger = defaultLogger } = {}) {
     super();
@@ -29,6 +35,10 @@ class BlockletRuntimeMonitor extends EventEmitter {
   }
 
   async getHistory(blockletDid, hours = 1) {
+    if (isRuntimeMonitorDisabled()) {
+      return [];
+    }
+
     const result = await this.states.runtimeInsight.model.findAll({
       where: {
         did: {
@@ -53,6 +63,10 @@ class BlockletRuntimeMonitor extends EventEmitter {
    * @memberof BlockletRuntimeMonitor
    */
   getRuntimeInfo(blockletDid, componentId = 'app') {
+    if (isRuntimeMonitorDisabled()) {
+      return null;
+    }
+
     if (!this.data[blockletDid]) {
       return null;
     }
@@ -65,11 +79,19 @@ class BlockletRuntimeMonitor extends EventEmitter {
   }
 
   async monit(did) {
+    if (isRuntimeMonitorDisabled()) {
+      return;
+    }
+
     const blocklet = await this.states.blocklet.getBlocklet(did);
     await this._monit(blocklet);
   }
 
   async _monit(blocklet, { addToHistory } = {}) {
+    if (isRuntimeMonitorDisabled()) {
+      return;
+    }
+
     const {
       meta: { did: blockletDid },
       status,
@@ -160,6 +182,10 @@ class BlockletRuntimeMonitor extends EventEmitter {
   }
 
   async monitAll() {
+    if (isRuntimeMonitorDisabled()) {
+      return;
+    }
+
     if (this.inProgress) {
       this.logger.debug('monitoring is in progress');
       return;
@@ -198,11 +224,16 @@ class BlockletRuntimeMonitor extends EventEmitter {
   }
 
   async getBlockletRuntimeInfo(blockletDid) {
-    const blocklets = await this.states.blocklet.getBlocklets();
-    const blocklet = blocklets.find((x) => x.meta.did === blockletDid);
+    if (isRuntimeMonitorDisabled()) {
+      return null;
+    }
 
-    const info = this.getRuntimeInfo(blockletDid);
+    const blocklet = await this.states.blocklet.getBlocklet(blockletDid);
+    if (!blocklet) {
+      return null;
+    }
 
+    const info = this.getRuntimeInfo(blockletDid);
     if (blocklet && !info) {
       await this._monit(blocklet, { addToHistory: false }).catch((err) => {
         this.logger.error('failed to get blocklet runtime info', { error: err });
@@ -217,7 +248,7 @@ class BlockletRuntimeMonitor extends EventEmitter {
   }
 
   _push(blockletDid, value) {
-    if (isInstanceWorker()) {
+    if (isWorkerInstance()) {
       return Promise.resolve();
     }
 
@@ -246,3 +277,4 @@ class BlockletRuntimeMonitor extends EventEmitter {
 }
 
 module.exports.BlockletRuntimeMonitor = BlockletRuntimeMonitor;
+module.exports.isRuntimeMonitorDisabled = isRuntimeMonitorDisabled;