@abtnode/core 1.16.11-next-a232f5fb → 1.16.11-next-09bc31f8

package/lib/blocklet/manager/helper/install-component-from-dev.js

@@ -56,7 +56,6 @@ const installComponentFromDev = async ({ folder, meta, rootDid, mountPoint, mana
   const newBlocklet = await states.blocklet.getBlocklet(rootDid);
   await validateBlocklet(newBlocklet);
   await manager._downloadBlocklet(newBlocklet);
-  await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.stopped);
 
   // Add Config
   await manager._setConfigsFromMeta(rootDid);

package/lib/blocklet/manager/helper/install-component-from-upload.js

@@ -13,6 +13,7 @@ const {
   ensureMeta,
   checkStructVersion,
   checkVersionCompatibility,
+  getBlockletStatus,
 } = require('../../../util/blocklet');
 const { resolveDownload, resolveDiffDownload, downloadFromUpload } = require('../../downloader/resolve-download');
 
@@ -39,9 +40,10 @@ const installComponentFromUpload = async ({
   // download
   const { tarFile } = await downloadFromUpload(file, { downloadDir: path.join(manager.dataDirs.tmp, 'download') });
 
-  if (isInProgress(oldBlocklet.status)) {
-    logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
-    throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(oldBlocklet.status)}`);
+  const appStatus = getBlockletStatus(oldBlocklet);
+  if (isInProgress(appStatus)) {
+    logger.error(`Can not deploy blocklet when it is ${fromBlockletStatus(appStatus)}`);
+    throw new Error(`Can not deploy blocklet when it is ${fromBlockletStatus(appStatus)}`);
   }
 
   let meta;
@@ -105,6 +107,8 @@ const installComponentFromUpload = async ({
   const action = 'upgrade';
   await manager._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
 
+  const componentDids = [newChild.meta.did, ...newChildren.map((x) => x.meta.did)];
+
   await manager._downloadAndInstall({
     blocklet: newBlocklet,
     oldBlocklet,
@@ -112,7 +116,7 @@ const installComponentFromUpload = async ({
     throwOnError: true,
     postAction: action,
     skipCheckStatusBeforeDownload: true,
-    selectedComponentDids: newChildren.map((x) => x.meta.did),
+    componentDids,
   });
   return manager.getBlocklet(newBlocklet.meta.did);
 };

package/lib/blocklet/manager/helper/install-component-from-url.js

@@ -127,8 +127,10 @@ const installComponentFromUrl = async ({
     throw err;
   }
 
+  const componentDids = [newChild.meta.did, ...newChildren.map((x) => x.meta.did)];
+
   // new blocklet
-  const newBlocklet = await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.waiting);
+  const newBlocklet = await states.blocklet.setBlockletStatus(rootDid, BlockletStatus.waiting, { componentDids });
 
   newBlocklet.children = blocklet.children;
   await validateBlocklet(newBlocklet);
@@ -138,7 +140,7 @@ const installComponentFromUrl = async ({
   const downloadParams = {
     oldBlocklet: { ...oldBlocklet },
     blocklet: { ...newBlocklet },
-    selectedComponentDids: [newChild.meta.did, ...newChildren.map((x) => x.meta.did)],
+    componentDids,
     context,
     postAction: action,
   };

package/lib/blocklet/manager/helper/upgrade-components.js

@@ -73,8 +73,8 @@ const check = async ({ did, states }) => {
   };
 };
 
-const upgrade = async ({ updateId, selectedComponentDids, context, states, manager }) => {
-  if (!selectedComponentDids?.length) {
+const upgrade = async ({ updateId, componentDids, context, states, manager }) => {
+  if (!componentDids?.length) {
     throw new Error('At least one component needs to be selected');
   }
 
@@ -87,7 +87,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   let dynamicComponents = [];
   const children = cloneDeep(oldBlocklet.children).map((oldComponent) => {
     const newComponent = sessionData.children.find((x) => x.meta.did === oldComponent.meta.did);
-    if (newComponent && selectedComponentDids.includes(newComponent.meta.did)) {
+    if (newComponent && componentDids.includes(newComponent.meta.did)) {
       dynamicComponents.push(...(newComponent._dynamicComponents || []));
       delete newComponent._dynamicComponents;
       return newComponent;
@@ -97,8 +97,8 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   dynamicComponents = filterDuplicateComponents(dynamicComponents, children);
   children.push(...dynamicComponents);
 
-  // selectedComponentDids
-  selectedComponentDids.push(...dynamicComponents.map((x) => x.meta.did));
+  // componentDids
+  componentDids.push(...dynamicComponents.map((x) => x.meta.did));
 
   checkVersionCompatibility(children);
 
@@ -108,7 +108,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
   });
 
   // new blocklet
-  const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
+  const newBlocklet = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting, { componentDids });
 
   newBlocklet.children = children;
   await validateBlocklet(newBlocklet);
@@ -128,7 +128,7 @@ const upgrade = async ({ updateId, selectedComponentDids, context, states, manag
       id: did,
       oldBlocklet: { ...oldBlocklet },
       blocklet: { ...newBlocklet },
-      selectedComponentDids: selectedComponentDids || [],
+      componentDids: componentDids || [],
       context,
       postAction: action,
     },

package/lib/blocklet/manager/pm2-events.js

@@ -27,10 +27,10 @@ class BlockletPm2Events extends EventEmitter {
         if (actualPm2Home !== expectedPm2Home) {
           return;
         }
-        const { BLOCKLET_DID: blockletDid } = details.process || {};
-        logger.debug('listen pm2 event', { name, blockletDid });
+        const { BLOCKLET_DID: blockletDid, BLOCKLET_COMPONENT_DID: componentDid } = details.process || {};
+        logger.debug('listen pm2 event', { name, blockletDid, componentDid });
         if (blockletDid) {
-          this.emit(name, { blockletDid });
+          this.emit(name, { blockletDid, componentDid });
         }
       })
       .error((error) => {

package/lib/event.js

@@ -3,7 +3,13 @@ const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
 const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
-const { BLOCKLET_MODES, BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/constant');
+const {
+  BLOCKLET_MODES,
+  BlockletStatus,
+  BlockletSource,
+  BlockletEvents,
+  BlockletInternalEvents,
+} = require('@blocklet/constant');
 const { EVENTS } = require('@abtnode/constant');
 const { NodeMonitSender } = require('./monitor/node-monit-sender');
 const handleInstanceInStore = require('./util/public-to-store');
@@ -375,6 +381,10 @@ module.exports = ({
     listen(blockletManager, eventName, handleBlockletEvent);
   });
 
+  [BlockletInternalEvents.componentsUpdated, BlockletInternalEvents.appConfigChanged].forEach((eventName) => {
+    listen(blockletManager, eventName, onEvent);
+  });
+
   listen(notificationState, EVENTS.NOTIFICATION_CREATE, onEvent);
 
   listen(nodeState, BlockletEvents.purchaseChange, onEvent);

package/lib/index.js

@@ -268,7 +268,6 @@ function ABTNode(options) {
     // For diagnose purpose
     syncBlockletStatus: blockletManager.status.bind(blockletManager),
     ensureBlockletIntegrity: blockletManager.ensureBlocklet.bind(blockletManager),
-    updateBlockletStatus: states.blocklet.setBlockletStatus.bind(states.blocklet),
 
     getBlocklets: blockletManager.list.bind(blockletManager),
     getBlockletsFromBackup: blockletManager.listBackups.bind(blockletManager),

package/lib/migrations/1.16.11-component-status.js

@@ -0,0 +1,22 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update component status...');
+
+  const apps = await states.blocklet.find({});
+
+  for (const app of apps || []) {
+    const appStatus = app.status;
+    let shouldUpdate = false;
+    for (const component of app.children || []) {
+      shouldUpdate = true;
+      component.status = appStatus;
+    }
+
+    if (shouldUpdate) {
+      await states.blocklet.update({ id: app.id }, { $set: { children: app.children } });
+      printInfo(`Blocklet in blocklet.db updated: ${app.meta?.title}. status: ${appStatus}`);
+    }
+  }
+};

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

@@ -116,7 +116,7 @@ class BlockletRuntimeMonitor extends EventEmitter {
     await forEachBlocklet(
       blocklet,
       async (component, { id: componentId, ancestors }) => {
-        if (component.meta.group !== BlockletGroup.gateway) {
+        if (component.meta.group !== BlockletGroup.gateway && component.status === BlockletStatus.running) {
           const processId = getComponentProcessId(component, ancestors);
           try {
             const runtimeInfo = await getRuntimeInfo(processId);
@@ -130,8 +130,13 @@ class BlockletRuntimeMonitor extends EventEmitter {
             appCpu += runtimeInfo.cpuUsage || 0;
             appMem += runtimeInfo.memoryUsage || 0;
           } catch (err) {
-            this.logger.error('failed to get blocklet runtime info', { processId, error: err });
+            // component status in db may not sync with pm2 when server has just started
+            if (err.code !== 'BLOCKLET_PROCESS_404') {
+              this.logger.error('failed to get blocklet runtime info', { processId, error: err });
+            }
           }
+        } else {
+          delete this.data[blockletDid][componentId];
         }
       },
       { parallel: true }

package/lib/states/blocklet.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
+const pick = require('lodash/pick');
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const cloneDeep = require('lodash/cloneDeep');
@@ -13,17 +14,23 @@ const {
   getDisplayName,
   forEachBlocklet,
   forEachBlockletSync,
-  forEachChildSync,
+  forEachComponentV2Sync,
   getBlockletServices,
 } = require('@blocklet/meta/lib/util');
-const { BlockletStatus, BlockletSource, BLOCKLET_MODES, BLOCKLET_DEFAULT_PORT_NAME } = require('@blocklet/constant');
+const {
+  BlockletStatus,
+  BlockletSource,
+  BLOCKLET_MODES,
+  BLOCKLET_DEFAULT_PORT_NAME,
+  BlockletGroup,
+} = require('@blocklet/constant');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet');
 
 const BaseState = require('./base');
 const { checkDuplicateComponents, ensureMeta } = require('../util/blocklet');
-const { validateBlockletMeta } = require('../util/blocklet');
+const { validateBlockletMeta, getBlockletStatus, shouldSkipComponent } = require('../util/blocklet');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
@@ -37,6 +44,10 @@ const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
 const formatBlocklet = (blocklet, phase, dek) => {
+  if (phase === 'onRead') {
+    blocklet.status = getBlockletStatus(blocklet);
+  }
+
   forEachBlockletSync(blocklet, (b) => {
     if (b.meta) {
       fixPerson(b.meta);
@@ -273,6 +284,9 @@ class BlockletState extends BaseState {
 
     const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.config.dek);
     const [, [updated]] = await this.update({ id: doc.id }, { $set: formatted });
+
+    updated.status = getBlockletStatus(updated);
+
     return updated;
   }
 
@@ -480,62 +494,55 @@ class BlockletState extends BaseState {
   }
 
   /**
-   * @param {String} did blocklet did
+   * @param {Did} did blocklet did
    * @param {BlockletStatus} status blocklet status
-   *
-   * children status only different with parent before blocklet installation
-   * @param {Array<componentId>} children
+   * @param {{
+   *   componentDids?: Array<Did>
+   * }}
    */
-  async setBlockletStatus(did, status, { children } = {}) {
+  async setBlockletStatus(did, status, { componentDids } = {}) {
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }
 
     const doc = await this.getBlocklet(did);
-    if (doc.status === status && !children) {
-      return formatBlocklet(doc, 'onRead', this.config.dek);
-    }
 
-    const updates = { status, startedAt: null, stoppedAt: null };
-    if (status === BlockletStatus.running) {
-      updates.startedAt = new Date();
-    }
-    if (status === BlockletStatus.installed) {
-      updates.installedAt = new Date();
+    if (doc.meta?.group === BlockletGroup.gateway && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
-    if (status === BlockletStatus.stopped) {
-      updates.stoppedAt = new Date();
+
+    // for backward compatibility
+    if (!doc.structVersion && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
 
     // update children status
-    forEachChildSync(doc, (child, { id }) => {
-      if (children === 'all') {
-        child.status = status;
+    forEachComponentV2Sync(doc, (component) => {
+      if (component.meta.group === BlockletGroup.gateway) {
         return;
       }
 
-      if (!children) {
-        if (
-          ![
-            BlockletStatus.waiting,
-            BlockletStatus.upgrading,
-            BlockletStatus.installing,
-            BlockletStatus.starting,
-          ].includes(status)
-        ) {
-          child.status = status;
-        }
-
+      if (shouldSkipComponent(component.meta.did, componentDids)) {
         return;
       }
 
-      if (children.includes(id)) {
-        child.status = status;
+      component.status = status;
+      if (status === BlockletStatus.running) {
+        component.startedAt = new Date();
+        component.stoppedAt = null;
+      }
+      if (status === BlockletStatus.stopped) {
+        component.startedAt = null;
+        component.stoppedAt = new Date();
       }
     });
 
-    updates.children = doc.children;
-    return this.updateBlocklet(did, updates);
+    return this.updateBlocklet(did, pick(doc, ['status', 'children']));
+  }
+
+  async setInstalledAt(did) {
+    logger.info('setInstalledAt', { did });
+    return this.updateBlocklet(did, { installedAt: new Date() });
   }
 
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren, returnMaxPort } = {}) {

package/lib/states/node.js

@@ -253,6 +253,7 @@ class NodeState extends BaseState {
   async getEnvironments() {
     return this.read().then((info) => ({
       ABT_NODE: info.version,
+      ABT_NODE_VERSION: info.version,
       ABT_NODE_DID: info.did,
       ABT_NODE_SK: info.sk,
       ABT_NODE_PK: info.pk,

package/lib/util/blocklet.js

@@ -74,6 +74,7 @@ const {
   findWebInterface,
   forEachBlockletSync,
   forEachChildSync,
+  forEachComponentV2Sync,
   isComponentBlocklet,
   getSharedConfigObj,
   getComponentName,
@@ -81,6 +82,8 @@ const {
   getBlockletAppIdList,
   isBeforeInstalled,
   getChainInfo,
+  isInProgress,
+  isRunning,
 } = require('@blocklet/meta/lib/util');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { titleSchema, descriptionSchema, logoSchema } = require('@blocklet/meta/lib/schema');
@@ -368,8 +371,9 @@ const getComponentSystemEnvironments = (blocklet) => {
   }
 
   return {
-    BLOCKLET_REAL_DID: blocklet.env.id,
+    BLOCKLET_REAL_DID: blocklet.env.id, // <appDid>/componentDid> e.g. xxxxx/xxxxx
     BLOCKLET_REAL_NAME: blocklet.env.name,
+    BLOCKLET_COMPONENT_DID: blocklet.meta.did, // component meta did e.g. xxxxxx
     BLOCKLET_DATA_DIR: blocklet.env.dataDir,
     BLOCKLET_LOG_DIR: blocklet.env.logsDir,
     BLOCKLET_CACHE_DIR: blocklet.env.cacheDir,
@@ -501,7 +505,15 @@ const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {
  */
 const startBlockletProcess = async (
   blocklet,
-  { preStart = noop, postStart = noopAsync, nodeEnvironments, nodeInfo, e2eMode, skippedProcessIds = [] } = {}
+  {
+    preStart = noop,
+    postStart = noopAsync,
+    nodeEnvironments,
+    nodeInfo,
+    e2eMode,
+    skippedProcessIds = [],
+    componentDids,
+  } = {}
 ) => {
   if (!blocklet) {
     throw new Error('blocklet should not be empty');
@@ -517,7 +529,12 @@ const startBlockletProcess = async (
       const { appMain, processId, appCwd, logsDir } = b.env;
 
       if (skippedProcessIds.includes(processId)) {
-        logger.info(`skip start process ${processId}`);
+        logger.info(`skip start skipped process ${processId}`);
+        return;
+      }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info(`skip start process not selected: ${b.meta.did}`, { processId });
         return;
       }
 
@@ -618,31 +635,15 @@ const startBlockletProcess = async (
  * Stop all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const stopBlockletProcess = async (blocklet, { preStop = noop, skippedProcessIds = [] } = {}) => {
-  await forEachBlocklet(
-    blocklet,
-    async (b, { ancestors }) => {
-      if (b.meta?.group === BlockletGroup.gateway) {
-        return;
-      }
-
-      if (skippedProcessIds.includes(b.env.processId)) {
-        logger.info(`skip stop process ${b.env.processId}`);
-        return;
-      }
-
-      await preStop(b, { ancestors });
-      await deleteProcess(b.env.processId);
-    },
-    { parallel: true }
-  );
+const stopBlockletProcess = async (blocklet, { preStop = noop, skippedProcessIds = [], componentDids } = {}) => {
+  return deleteBlockletProcess(blocklet, { preDelete: preStop, skippedProcessIds, componentDids });
 };
 
 /**
  * Delete all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProcessIds = [] } = {}) => {
+const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProcessIds = [], componentDids } = {}) => {
   await forEachBlocklet(
     blocklet,
     async (b, { ancestors }) => {
@@ -652,7 +653,12 @@ const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProces
       }
 
       if (skippedProcessIds.includes(b.env.processId)) {
-        logger.info(`skip delete process ${b.env.processId}`);
+        logger.info(`skip delete skipped process ${b.env.processId}`);
+        return;
+      }
+
+      if (shouldSkipComponent(b.meta?.did, componentDids)) {
+        logger.info(`skip delete process not selected: ${b.meta.did}`, { processId: b.env.processId });
         return;
       }
 
@@ -667,52 +673,25 @@ const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProces
  * Reload all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const reloadBlockletProcess = async (blocklet) =>
+const reloadBlockletProcess = async (blocklet, { componentDids } = {}) =>
   forEachBlocklet(
     blocklet,
     async (b) => {
       if (b.meta.group === BlockletGroup.gateway) {
         return;
       }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info(`skip reload process not selected: ${b.meta.did}`, { processId: b.env.processId });
+        return;
+      }
+
       logger.info('reload process', { processId: b.env.processId });
       await reloadProcess(b.env.processId);
     },
     { parallel: false }
   );
 
-const getBlockletStatusFromProcess = async (blocklet) => {
-  const tasks = [];
-  await forEachBlocklet(blocklet, (b) => {
-    if (b.meta.group !== BlockletGroup.gateway) {
-      tasks.push(getProcessState(b.env.processId));
-    }
-  });
-
-  const list = await Promise.all(tasks);
-
-  if (!list.length) {
-    return blocklet.status;
-  }
-
-  return getRootBlockletStatus(list);
-};
-
-/**
- * @param {Array<BlockletStatus>} statusList
- */
-const getRootBlockletStatus = (statusList = []) => {
-  const noRunningStatus = statusList.find((x) => x !== BlockletStatus.running);
-  if (noRunningStatus) {
-    if (statusList.some((x) => x === BlockletStatus.error)) {
-      return BlockletStatus.error;
-    }
-
-    return noRunningStatus;
-  }
-
-  return BlockletStatus.running;
-};
-
 /**
  * @param {*} processId
  * @returns {BlockletStatus}
@@ -900,13 +879,20 @@ const validateBlockletChainInfo = (blocklet) => {
   return chainInfo;
 };
 
-const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout } = {}) => {
+const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout, componentDids } = {}) => {
   await forEachBlocklet(
     blocklet,
     async (b) => {
-      if (b.meta.group !== BlockletGroup.gateway) {
-        await _checkProcessHealthy(b, { minConsecutiveTime, timeout });
+      if (b.meta.group === BlockletGroup.gateway) {
+        return;
+      }
+
+      if (shouldSkipComponent(b.meta.did, componentDids)) {
+        logger.info('skip check component healthy not selected', { id: b.env.id, processId: b.env.processId });
+        return;
       }
+
+      await _checkProcessHealthy(b, { minConsecutiveTime, timeout });
     },
     { parallel: true }
   );
@@ -1902,6 +1888,71 @@ const getBlockletDidDomainList = (blocklet, nodeInfo) => {
   return domainAliases;
 };
 
+const getBlockletStatus = (blocklet) => {
+  const fallbackStatus = BlockletStatus.stopped;
+
+  if (!blocklet) {
+    return fallbackStatus;
+  }
+
+  if (!blocklet.children?.length) {
+    if (blocklet.meta?.group === BlockletGroup.gateway) {
+      return blocklet.status;
+    }
+
+    if (blocklet.status === BlockletStatus.added) {
+      return BlockletStatus.added;
+    }
+
+    // for backward compatibility
+    if (!blocklet.structVersion) {
+      return blocklet.status;
+    }
+
+    return fallbackStatus;
+  }
+
+  let inProgressStatus;
+  let runningStatus;
+  let status;
+
+  forEachComponentV2Sync(blocklet, (component) => {
+    if (component.meta?.group === BlockletGroup.gateway) {
+      return;
+    }
+
+    if (isInProgress(component.status)) {
+      if (!inProgressStatus) {
+        inProgressStatus = component.status;
+      }
+      return;
+    }
+
+    if (isRunning(component.status)) {
+      runningStatus = component.status;
+      return;
+    }
+
+    status = component.status;
+  });
+
+  return inProgressStatus || runningStatus || status;
+};
+
+const shouldSkipComponent = (componentDid, whiteList) => {
+  if (!whiteList || !Array.isArray(whiteList)) {
+    return false;
+  }
+
+  const arr = whiteList.filter(Boolean);
+
+  if (!arr.length) {
+    return false;
+  }
+
+  return !arr.includes(componentDid);
+};
+
 const shouldCleanExpiredBlocklet = (expirationDate) => {
   return dayjs().diff(dayjs(expirationDate), 'day') > EXPIRED_BLOCKLET_DATA_RETENTION_DAYS;
 };
@@ -1924,7 +1975,6 @@ module.exports = {
   stopBlockletProcess,
   deleteBlockletProcess,
   reloadBlockletProcess,
-  getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   getHealthyCheckTimeout,
   getProcessInfo,
@@ -1963,6 +2013,9 @@ module.exports = {
   getFixedBundleSource,
   ensureAppLogo,
   getBlockletDidDomainList,
+  getProcessState,
+  getBlockletStatus,
+  shouldSkipComponent,
   shouldCleanExpiredBlocklet,
   getBlockletURLForLauncher,
 };