@abtnode/core 1.16.11-beta-0ae58a71 → 1.16.11-beta-f74663ac

package/lib/blocklet/manager/disk.js

@@ -38,6 +38,10 @@ const {
   getRolesFromAuthConfig,
   isInProgress,
   isBeforeInstalled,
+  getComponentsInternalInfo,
+  forEachComponentV2,
+  forEachComponentV2Sync,
+  findComponentByIdV2,
 } = require('@blocklet/meta/lib/util');
 const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
@@ -49,6 +53,7 @@ const {
   BlockletStatus,
   BlockletSource,
   BlockletEvents,
+  BlockletInternalEvents,
   BLOCKLET_MODES,
   BlockletGroup,
   fromBlockletStatus,
@@ -68,6 +73,8 @@ const {
   BLOCKLET_CONTROLLER_STATUS,
   SUSPENDED_REASON,
 } = require('@blocklet/constant');
+const isUndefined = require('lodash/isUndefined');
+const { consumeServerlessNFT, consumeLauncherSession } = require('../../util/launcher');
 const util = require('../../util');
 const {
   refresh: refreshAccessibleExternalNodeIp,
@@ -82,7 +89,6 @@ const {
   stopBlockletProcess,
   deleteBlockletProcess,
   reloadBlockletProcess,
-  getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   validateBlocklet,
   validateBlockletChainInfo,
@@ -96,7 +102,6 @@ const {
   getBlocklet,
   ensureEnvDefault,
   getConfigFromPreferences,
-  consumeServerlessNFT,
   validateAppConfig,
   checkDuplicateMountPoint,
   validateStore,
@@ -106,6 +111,9 @@ const {
   updateBlockletFallbackLogo,
   ensureAppLogo,
   getBlockletDidDomainList,
+  getProcessState,
+  getBlockletStatus,
+  shouldSkipComponent,
   exceedRedemptionPeriod,
 } = require('../../util/blocklet');
 const states = require('../../states');
@@ -135,7 +143,7 @@ const { migrateApplicationToStructV2 } = require('./helper/migrate-application-t
 const { getBackupFilesUrlFromEndpoint, getBackupEndpoint } = require('../../util/spaces');
 const { validateAddSpaceGateway, validateUpdateSpaceGateway } = require('../../validators/space-gateway');
 
-const { formatEnvironments, shouldUpdateBlockletStatus, getBlockletMeta, validateOwner } = util;
+const { formatEnvironments, getBlockletMeta, validateOwner } = util;
 
 const statusLock = new Lock('blocklet-status-lock');
 
@@ -241,8 +249,8 @@ class BlockletManager extends BaseBlockletManager {
     this._rollbackCache = new RollbackCache({ dir: this.dataDirs.tmp });
 
     if (daemon) {
-      blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid));
-      blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid));
+      blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid, data.componentDid));
+      blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid, data.componentDid));
     }
   }
 
@@ -402,7 +410,7 @@ class BlockletManager extends BaseBlockletManager {
     throw new Error('Unknown source');
   }
 
-  async diff({ did, hashFiles, rootDid }) {
+  diff({ did, hashFiles, rootDid }) {
     return diff({ did, hashFiles, rootDid, states, manager: this });
   }
 
@@ -410,7 +418,7 @@ class BlockletManager extends BaseBlockletManager {
    * After the dev function finished, the caller should send a BlockletEvents.installed event to the daemon
    * @returns {Object} blocklet
    */
-  async dev(folder, { rootDid, mountPoint, defaultStoreUrl } = {}) {
+  dev(folder, { rootDid, mountPoint, defaultStoreUrl } = {}) {
     logger.info('dev component', { folder, rootDid, mountPoint });
 
     const meta = getBlockletMeta(folder, { defaultStoreUrl });
@@ -425,15 +433,15 @@ class BlockletManager extends BaseBlockletManager {
     return installComponentFromDev({ folder, meta, rootDid, mountPoint, manager: this, states });
   }
 
-  async checkComponentsForUpdates({ did }) {
+  checkComponentsForUpdates({ did }) {
     return UpgradeComponents.check({ did, states });
   }
 
-  async upgradeComponents({ updateId, selectedComponents: selectedComponentDids }, context = {}) {
-    return UpgradeComponents.upgrade({ updateId, selectedComponentDids, context, states, manager: this });
+  upgradeComponents({ updateId, selectedComponents: componentDids }, context = {}) {
+    return UpgradeComponents.upgrade({ updateId, componentDids, context, states, manager: this });
   }
 
-  async migrateApplicationToStructV2({ did, appSk, context = {} }) {
+  migrateApplicationToStructV2({ did, appSk, context = {} }) {
     return migrateApplicationToStructV2({ did, appSk, context, manager: this, states });
   }
 
@@ -447,8 +455,8 @@ class BlockletManager extends BaseBlockletManager {
     return { did, isInstalled: !!blocklet, isRunning };
   }
 
-  async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false }, context) {
-    logger.info('start blocklet', { did });
+  async start({ did, throwOnError, checkHealthImmediately = false, e2eMode = false, componentDids }, context) {
+    logger.info('start blocklet', { did, componentDids, throwOnError, checkHealthImmediately, e2eMode });
     // should check blocklet integrity
     const blocklet = await this.ensureBlocklet(did, { e2eMode });
 
@@ -458,7 +466,7 @@ class BlockletManager extends BaseBlockletManager {
       // blocklet may be manually stopped durning starting
       // so error message would not be sent if blocklet is stopped
       // so we need update status first
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.starting, { componentDids });
       blocklet.status = BlockletStatus.starting;
 
       // validate requirement and engine
@@ -511,6 +519,7 @@ class BlockletManager extends BaseBlockletManager {
         nodeEnvironments,
         nodeInfo: await states.node.read(),
         e2eMode,
+        componentDids,
       });
 
       // check blocklet healthy
@@ -520,6 +529,7 @@ class BlockletManager extends BaseBlockletManager {
         context,
         minConsecutiveTime,
         timeout: startTimeout,
+        componentDids,
       };
 
       if (checkHealthImmediately) {
@@ -552,8 +562,8 @@ class BlockletManager extends BaseBlockletManager {
         severity: 'error',
       });
 
-      await this.deleteProcess({ did });
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
+      await this.deleteProcess({ did, componentDids });
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
       this.emit(BlockletEvents.startFailed, { ...res, error: { message: error.message } });
 
       if (throwOnError) {
@@ -564,14 +574,14 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async stop({ did, updateStatus = true, silent = false }, context) {
-    logger.info('stop blocklet', { did });
+  async stop({ did, updateStatus = true, silent = false, componentDids }, context) {
+    logger.info('stop blocklet', { did, componentDids, updateStatus, silent });
 
     const blocklet = await this.getBlocklet(did);
     const { processId } = blocklet.env;
 
     if (updateStatus) {
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids });
       blocklet.status = BlockletStatus.stopping;
       this.emit(BlockletEvents.statusChange, blocklet);
     }
@@ -591,11 +601,12 @@ class BlockletManager extends BaseBlockletManager {
             silent,
             ...getHooksOutputFiles(b),
           }),
+        componentDids,
       });
     } catch (error) {
       logger.error('Failed to stop blocklet', { error, did });
       if (updateStatus) {
-        const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
+        const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
         this.emit(BlockletEvents.statusChange, res);
       }
       throw error;
@@ -604,13 +615,18 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('blocklet stopped successfully', { processId, did });
 
     if (updateStatus) {
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids });
       // send notification to websocket channel
       this.emit(BlockletEvents.statusChange, res);
 
       // send notification to wallet
       this.emit(BlockletEvents.stopped, res);
 
+      this.emit(BlockletInternalEvents.componentsUpdated, {
+        appDid: blocklet.appDid,
+        components: getComponentsInternalInfo(res),
+      });
+
       return res;
     }
 
@@ -640,13 +656,23 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   /**
-   * FIXME: @linchen support cancel
    * @param {import('@abtnode/client').RequestRestoreBlockletInput} input
    * @memberof BlockletManager
    */
-  // eslint-disable-next-line no-unused-vars
   async restoreBlocklet(input, context) {
     const { from, ...param } = input;
+
+    if (input.overwrite) {
+      try {
+        const blocklet = await this.getBlocklet(input.appPid);
+        if (blocklet) {
+          await this.delete({ did: input.appPid, keepData: false, keepLogsDir: false, keepConfigs: false }, context);
+        }
+      } catch (error) {
+        logger.error('Failed to delete blocklet', { error, did: input.appPid });
+      }
+    }
+
     if (from === 'spaces') {
       return this._restoreFromSpaces(param, context);
     }
@@ -664,22 +690,26 @@ class BlockletManager extends BaseBlockletManager {
    * @param {Record<string, any>} context
    * @returns {import('@abtnode/client').BlockletState}
    */
-  async restart({ did }, context) {
+  async restart({ did, componentDids }, context) {
     logger.info('restart blocklet', { did });
-
     const blocklet = await this.getBlocklet(did);
-
     await this.checkControllerStatus(blocklet, 'restart');
-
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
+    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping, { componentDids });
     const result = await states.blocklet.getBlocklet(did);
     this.emit(BlockletEvents.statusChange, result);
 
-    const ticket = this.startQueue.push({ entity: 'blocklet', action: 'restart', id: did, did, context });
+    const ticket = this.startQueue.push({
+      entity: 'blocklet',
+      action: 'restart',
+      id: did,
+      did,
+      componentDids,
+      context,
+    });
     ticket.on('failed', async (err) => {
       logger.error('failed to restart blocklet', { did, error: err });
 
-      const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
+      const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids });
       this.emit(BlockletEvents.statusChange, state);
 
       this._createNotification(did, {
@@ -695,18 +725,29 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   // eslint-disable-next-line no-unused-vars
-  async reload({ did }, context) {
+  async reload({ did, componentDids: list }, context) {
     const blocklet = await this.getBlocklet(did);
-
     await this.checkControllerStatus(blocklet, 'reload');
 
-    await states.blocklet.setBlockletStatus(did, BlockletStatus.stopping);
-    await reloadBlockletProcess(blocklet);
-    const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.running);
-    logger.info('blocklet reload successfully', { did });
+    const componentDids = (blocklet.children || [])
+      .filter((x) => x.status === BlockletStatus.running)
+      .filter((x) => !shouldSkipComponent(x.meta.did, list))
+      .map((x) => x.meta.did);
+
+    if (!componentDids.length) {
+      throw new Error('No running component found');
+    }
 
-    this.emit(BlockletEvents.statusChange, res);
-    return res;
+    try {
+      await reloadBlockletProcess(blocklet, { componentDids });
+      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.running, { componentDids });
+      logger.info('blocklet reload successfully', { did, componentDids });
+      this.emit(BlockletEvents.statusChange, res);
+      return res;
+    } catch (error) {
+      logger.error('Failed to reload blocklet', { error, did, componentDids });
+      throw error;
+    }
   }
 
   async delete({ did, keepData, keepLogsDir, keepConfigs }, context) {
@@ -765,17 +806,17 @@ class BlockletManager extends BaseBlockletManager {
 
     const blocklet = await this.getBlocklet(did);
 
-    if (isInProgress(blocklet.status || blocklet.status === BlockletStatus.running)) {
-      throw new Error('Cannot reset when blocklet is in progress');
-    }
+    if (!childDid) {
+      if (isInProgress(blocklet.status || blocklet.status === BlockletStatus.running)) {
+        throw new Error('Cannot reset when blocklet is in progress');
+      }
 
-    try {
-      await this.deleteProcess({ did }, context);
-    } catch {
-      // do nothing
-    }
+      try {
+        await this.deleteProcess({ did }, context);
+      } catch {
+        // do nothing
+      }
 
-    if (!childDid) {
       // Cleanup disk storage
       const { cacheDir, logsDir, dataDir } = blocklet.env;
       fs.removeSync(cacheDir);
@@ -793,6 +834,16 @@ class BlockletManager extends BaseBlockletManager {
         throw new Error('Child does not exist');
       }
 
+      if (isInProgress(child.status || child.status === BlockletStatus.running)) {
+        throw new Error('Cannot reset when component is in progress');
+      }
+
+      try {
+        await this.deleteProcess({ did, componentDids: [child.meta.did] }, context);
+      } catch {
+        // do nothing
+      }
+
       // Cleanup disk storage
       const { cacheDir, logsDir, dataDir } = child.env;
       fs.removeSync(cacheDir);
@@ -874,6 +925,11 @@ class BlockletManager extends BaseBlockletManager {
       action: `/blocklets/${newBlocklet.meta.did}/components`,
     });
 
+    this.emit(BlockletInternalEvents.componentsUpdated, {
+      appDid: blocklet.appDid,
+      components: getComponentsInternalInfo(newBlocklet),
+    });
+
     return newBlocklet;
   }
 
@@ -932,7 +988,14 @@ class BlockletManager extends BaseBlockletManager {
         // fallback blocklet status to error
         const blocklet = await states.blocklet.getBlocklet(inputDid);
         if (blocklet) {
-          await states.blocklet.setBlockletStatus(blocklet.meta.did, BlockletStatus.error);
+          const componentDids = [];
+          forEachComponentV2Sync(blocklet, (x) => {
+            if ([BlockletStatus.waiting, BlockletStatus.downloading].includes(x.status)) {
+              componentDids.push(x.meta.did);
+            }
+          });
+
+          await states.blocklet.setBlockletStatus(blocklet.meta.did, BlockletStatus.error, { componentDids });
         }
         statusLock.release();
       } catch (err) {
@@ -945,15 +1008,15 @@ class BlockletManager extends BaseBlockletManager {
   }
 
   // eslint-disable-next-line no-unused-vars
-  async deleteProcess({ did }, context) {
+  async deleteProcess({ did, componentDids }, context) {
     const blocklet = await this.getBlocklet(did);
 
-    logger.info('delete blocklet process', { did });
+    logger.info('delete blocklet process', { did, componentDids });
 
-    await deleteBlockletProcess(blocklet, context);
+    await deleteBlockletProcess(blocklet, { ...context, componentDids });
 
-    const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-    logger.info('blocklet process deleted successfully', { did });
+    const result = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids });
+    logger.info('blocklet process deleted successfully', { did, componentDids });
     return result;
   }
 
@@ -996,22 +1059,9 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async list({ includeRuntimeInfo = true, query, filter } = {}, context) {
+  async list({ includeRuntimeInfo = true, query } = {}, context) {
     const condition = { ...flat(query || {}) };
-    if (filter === 'external-only') {
-      condition.controller = {
-        $exists: true,
-      };
-    }
-
-    if (filter === 'external-excluded') {
-      condition.controller = {
-        $exists: false,
-      };
-    }
-
     const blocklets = await states.blocklet.getBlocklets(condition);
-
     if (includeRuntimeInfo) {
       return this._attachBlockletListRuntimeInfo({ blocklets }, context);
     }
@@ -1019,7 +1069,7 @@ class BlockletManager extends BaseBlockletManager {
     return blocklets;
   }
 
-  async listBackups() {
+  listBackups() {
     return getBackupList(this.dataDirs.data);
   }
 
@@ -1031,19 +1081,18 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     const tmpDids = Array.isArray(did) ? did : [did];
-    const [rootDid, ...childDids] = tmpDids;
+    const [rootDid, childDid] = tmpDids;
     const rootMetaDid = await states.blocklet.getBlockletMetaDid(rootDid);
-    const dids = [rootMetaDid, ...childDids];
 
-    logger.info('config blocklet', { dids });
+    logger.info('config blocklet', { rootDid, rootMetaDid, childDid });
 
     const ancestors = [];
     let blocklet = await this.getBlocklet(rootDid);
-    for (const childDid of childDids) {
+    if (childDid) {
       ancestors.push(blocklet);
       blocklet = blocklet.children.find((x) => x.meta.did === childDid);
       if (!blocklet) {
-        throw new Error('Child blocklet does not exist', { dids });
+        throw new Error('Child blocklet does not exist', { rootDid, childDid });
       }
     }
 
@@ -1056,8 +1105,8 @@ class BlockletManager extends BaseBlockletManager {
         await environmentNameSchema.validateAsync(x.key);
       } else if (BLOCKLET_CONFIGURABLE_KEY[x.key] && x.key.startsWith('BLOCKLET_')) {
         // app key
-        if (childDids.length) {
-          logger.error(`Cannot set ${x.key} to child blocklet`, [dids]);
+        if (childDid) {
+          logger.error(`Cannot set ${x.key} to child blocklet`, { rootDid, childDid });
           throw new Error(`Cannot set ${x.key} to child blocklet`);
         }
         await validateAppConfig(x, states);
@@ -1096,7 +1145,7 @@ class BlockletManager extends BaseBlockletManager {
     Object.assign(blocklet.configObj, configObj);
 
     // update db
-    await states.blockletExtras.setConfigs(dids, newConfigs);
+    await states.blockletExtras.setConfigs([rootMetaDid, childDid].filter(Boolean), newConfigs);
 
     if (willAppSkChange) {
       const info = await states.node.read();
@@ -1116,7 +1165,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // update blocklet meta
-    if (blocklet.structVersion && !childDids.length) {
+    if (blocklet.structVersion && !childDid) {
       const changedTitle = newConfigs.find((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_NAME)?.value;
       const changedDescription = newConfigs.find(
         (x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_DESCRIPTION
@@ -1145,6 +1194,13 @@ class BlockletManager extends BaseBlockletManager {
       await this._updateDidDocument(newState);
     }
 
+    if (!childDid && !newConfigs.some((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK)) {
+      this.emit(BlockletInternalEvents.appConfigChanged, {
+        appDid: newState.appDid,
+        configs: newConfigs.map((x) => ({ key: x.key, value: x.value })),
+      });
+    }
+
     this.emit(BlockletEvents.updated, newState);
 
     return newState;
@@ -1321,6 +1377,10 @@ class BlockletManager extends BaseBlockletManager {
     await states.blocklet.updateBlocklet(rootDid, { mountPoint: blocklet.mountPoint, children: blocklet.children });
 
     this.emit(BlockletEvents.upgraded, { blocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
+    this.emit(BlockletInternalEvents.componentsUpdated, {
+      appDid: blocklet.appDid,
+      components: getComponentsInternalInfo(blocklet),
+    });
 
     return this.getBlocklet(rootDid);
   }
@@ -1339,15 +1399,15 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
-  async ensureBlocklet(did, opts = {}) {
+  ensureBlocklet(did, opts = {}) {
     return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: true });
   }
 
-  async getBlocklet(did, opts = {}) {
+  getBlocklet(did, opts = {}) {
     return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
   }
 
-  async hasBlocklet({ did }) {
+  hasBlocklet({ did }) {
     return states.blocklet.hasBlocklet(did);
   }
 
@@ -1379,60 +1439,77 @@ class BlockletManager extends BaseBlockletManager {
     return this.getBlocklet(did);
   }
 
-  async status(did, { forceSync = false } = {}) {
-    const fastReturnOnForceSync = async (blocklet = {}) => {
-      const { status } = blocklet;
-      const { added, waiting, downloading, installing, installed, upgrading } = BlockletStatus;
+  async status(did, { forceSync = false, componentDids } = {}) {
+    const blocklet = await this.getBlocklet(did);
 
-      if ([added, waiting, downloading, installing, installed, upgrading].includes(status)) {
-        return blocklet;
-      }
+    // for backward compatibility
+    if (!blocklet.structVersion) {
+      return blocklet;
+    }
 
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-      this.emit(BlockletEvents.statusChange, res);
-      return res;
+    // {Record<BlockletStatus, Array<Did>>}
+    const updates = new Map();
+    const addToUpdates = (componentDid, status) => {
+      if (updates.has(status)) {
+        updates.get(status).push(componentDid);
+      } else {
+        updates.set(status, [componentDid]);
+      }
     };
 
-    const blocklet = await this.getBlocklet(did);
+    await forEachComponentV2(
+      blocklet,
+      async (component) => {
+        if (!forceSync && !util.shouldUpdateBlockletStatus(component.status)) {
+          return;
+        }
 
-    let shouldUpdateStatus = forceSync || shouldUpdateBlockletStatus(blocklet.status);
-    if (isInProgress(blocklet.status)) {
-      const uptime = Date.now() - new Date(blocklet.updatedAt).getTime();
-      // FIXME @linchen 在彻底修复 blocklet status 稳定性之后, uptime check 应该去掉. 如果 hook 执行时间很长, uptime check 会影响 hook 执行过程中的 blocklet status
-      if (uptime > 120 * 1000) {
-        shouldUpdateStatus = true;
-      }
-    }
+        if (shouldSkipComponent(component.meta.did, componentDids)) {
+          return;
+        }
 
-    if (!shouldUpdateStatus) {
-      return blocklet;
-    }
+        try {
+          const status = await getProcessState(component.env.processId);
+          const oldStatus = component.status;
+          if (component.status !== status) {
+            component.status = status;
+            addToUpdates(component.meta.did, status);
+            logger.info('will sync status from pm2', { did, status, oldStatus, componentDid: component.meta.did });
+          }
+        } catch {
+          if (
+            ![
+              BlockletStatus.added,
+              BlockletStatus.waiting,
+              BlockletStatus.downloading,
+              BlockletStatus.installing,
+              BlockletStatus.installed,
+              BlockletStatus.upgrading,
+            ].includes(component.status)
+          ) {
+            const status = BlockletStatus.stopped;
+            component.status = status;
+            addToUpdates(component.meta.did, status);
+          }
+        }
+      },
+      { parallel: true }
+    );
 
-    try {
-      if (
-        blocklet.meta?.group === BlockletGroup.gateway &&
-        !blocklet.children?.length &&
-        isInProgress(blocklet.status)
-      ) {
-        const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-        this.emit(BlockletEvents.statusChange, res);
-        return res;
+    // iterate updates
+    if (updates.size > 0) {
+      for (const [status, dids] of updates) {
+        logger.info('sync status from pm2', { did, status, componentDids: dids });
+        await states.blocklet.setBlockletStatus(did, status, { componentDids: dids });
       }
+    }
 
-      const status = await getBlockletStatusFromProcess(blocklet);
-      if (blocklet.status !== status) {
-        const res = await states.blocklet.setBlockletStatus(did, status);
-        this.emit(BlockletEvents.statusChange, res);
-        return res;
-      }
+    blocklet.status = getBlockletStatus(blocklet);
 
-      return blocklet;
-    } catch (err) {
-      return fastReturnOnForceSync(blocklet);
-    }
+    return blocklet;
   }
 
-  async refreshListCache() {
+  refreshListCache() {
     this.list({ useCache: false }).catch((err) => {
       logger.error('refresh blocklet list failed', { error: err });
     });
@@ -1496,6 +1573,7 @@ class BlockletManager extends BaseBlockletManager {
         name: 'sync-blocklet-status',
         time: '*/60 * * * * *', // 60s
         fn: this._syncBlockletStatus.bind(this),
+        options: { runOnInit: false },
       },
       {
         name: 'sync-blocklet-list',
@@ -1565,14 +1643,20 @@ class BlockletManager extends BaseBlockletManager {
 
   /**
    * @description
-   * @param {import('@abtnode/client').RequestAddBlockletSpaceGatewayInput} { did, spaceGateway }
+   * @param {import('@abtnode/client').RequestAddBlockletSpaceGatewayInput} { did, spaceGatewayDid }
    * @return {Promise<void>}
    * @memberof BlockletManager
    */
-  async deleteBlockletSpaceGateway({ did, url }) {
+  async deleteBlockletSpaceGateway({ did, spaceGatewayDid }) {
     const spaceGateways = await this.getBlockletSpaceGateways({ did });
 
-    const latestSpaceGateways = spaceGateways.filter((s) => s?.url !== url);
+    const latestSpaceGateways = spaceGateways.filter((s) => {
+      if (spaceGatewayDid) {
+        return s?.did !== spaceGatewayDid;
+      }
+      // note: 兼容性处理，所有没有 did 的 spaceGateway 统一会被删除
+      return !isUndefined(s?.did);
+    });
 
     await states.blockletExtras.setSettings(did, { spaceGateways: latestSpaceGateways });
   }
@@ -1627,7 +1711,7 @@ class BlockletManager extends BaseBlockletManager {
    * @return {Promise<Array<import('@abtnode/client').Backup>>}
    * @memberof BlockletManager
    */
-  async getBlockletBackups({ did }) {
+  getBlockletBackups({ did }) {
     return states.backup.getBlockletBackups({ did });
   }
 
@@ -1653,7 +1737,7 @@ class BlockletManager extends BaseBlockletManager {
    *  oldBlocklet: {},
    *  throwOnError: Error,
    *  skipCheckStatusBeforeDownload: boolean,
-   *  selectedComponentDids: Array<did>,
+   *  componentDids: Array<did>,
    * }} params
    * @return {*}
    * @memberof BlockletManager
@@ -1666,7 +1750,7 @@ class BlockletManager extends BaseBlockletManager {
       oldBlocklet,
       throwOnError,
       skipCheckStatusBeforeDownload,
-      selectedComponentDids,
+      componentDids,
       skipCheckIntegrity,
     } = params;
     const { meta } = blocklet;
@@ -1703,8 +1787,8 @@ class BlockletManager extends BaseBlockletManager {
       const blockletForDownload = {
         ...blocklet,
         children: (blocklet.children || []).filter((x) => {
-          if (selectedComponentDids?.length) {
-            return selectedComponentDids.includes(x.meta.did);
+          if (componentDids?.length) {
+            return componentDids.includes(x.meta.did);
           }
           return x;
         }),
@@ -1775,12 +1859,12 @@ class BlockletManager extends BaseBlockletManager {
       }
 
       if (postAction === 'install') {
-        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.installing);
+        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.installing, { componentDids });
         this.emit(BlockletEvents.statusChange, state);
       }
 
       if (postAction === 'upgrade') {
-        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading);
+        const state = await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading, { componentDids });
         this.emit(BlockletEvents.statusChange, state);
       }
 
@@ -1794,13 +1878,13 @@ class BlockletManager extends BaseBlockletManager {
     try {
       // install blocklet
       if (postAction === 'install') {
-        await this._onInstall({ blocklet, context, oldBlocklet });
+        await this._onInstall({ blocklet, componentDids, context, oldBlocklet });
         return;
       }
 
       // upgrade blocklet
       if (postAction === 'upgrade') {
-        await this._onUpgrade({ oldBlocklet, newBlocklet: blocklet, context });
+        await this._onUpgrade({ oldBlocklet, componentDids, newBlocklet: blocklet, context });
       }
     } catch (error) {
       if (throwOnError) {
@@ -1809,7 +1893,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _onInstall({ blocklet, context, oldBlocklet }) {
+  async _onInstall({ blocklet, componentDids, context, oldBlocklet }) {
     const { meta } = blocklet;
     const { did, version } = meta;
     logger.info('do install blocklet', { did, version });
@@ -1817,6 +1901,7 @@ class BlockletManager extends BaseBlockletManager {
     try {
       const installedBlocklet = await this._installBlocklet({
         did,
+        componentDids,
         context,
         oldBlocklet,
       });
@@ -1824,7 +1909,7 @@ class BlockletManager extends BaseBlockletManager {
       if (context.startImmediately && installedBlocklet?.settings.initialized) {
         try {
           logger.info('start blocklet after installed', { did });
-          await this.start({ did, checkHealthImmediately: true });
+          await this.start({ did, checkHealthImmediately: true, componentDids });
         } catch (error) {
           logger.warn('attempt to start immediately failed', { did, error });
         }
@@ -1837,7 +1922,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _onUpgrade({ oldBlocklet, newBlocklet, context }) {
+  async _onUpgrade({ oldBlocklet, newBlocklet, componentDids, context }) {
     const { version, did } = newBlocklet.meta;
     logger.info('do upgrade blocklet', { did, version });
 
@@ -1845,6 +1930,7 @@ class BlockletManager extends BaseBlockletManager {
       await this._upgradeBlocklet({
         newBlocklet,
         oldBlocklet,
+        componentDids,
         context,
       });
     } catch (err) {
@@ -1852,13 +1938,13 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _onRestart({ did, context }) {
-    await this.stop({ did, updateStatus: false }, context);
-    await this.start({ did }, context);
+  async _onRestart({ did, componentDids, context }) {
+    await this.stop({ did, componentDids, updateStatus: false }, context);
+    await this.start({ did, componentDids }, context);
   }
 
   async _onCheckIfStarted(jobInfo, { throwOnError } = {}) {
-    const { did, context, minConsecutiveTime = 5000, timeout } = jobInfo;
+    const { did, context, minConsecutiveTime = 5000, timeout, componentDids } = jobInfo;
     const blocklet = await this.getBlocklet(did);
 
     const { meta } = blocklet;
@@ -1866,10 +1952,18 @@ class BlockletManager extends BaseBlockletManager {
 
     try {
       // healthy check
-      await checkBlockletProcessHealthy(blocklet, { minConsecutiveTime, timeout });
+      await checkBlockletProcessHealthy(blocklet, { minConsecutiveTime, timeout, componentDids });
 
       // update blocklet status after healthy check
-      const res = await this.status(did, { forceSync: true });
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.running, { componentDids });
+
+      const res = await this.getBlocklet(did);
+
+      this.emit(BlockletInternalEvents.componentsUpdated, {
+        appDid: blocklet.appDid,
+        components: getComponentsInternalInfo(res),
+      });
+
       this.emit(BlockletEvents.started, res);
     } catch (error) {
       const status = await states.blocklet.getBlockletStatus(did);
@@ -1881,7 +1975,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.error('check blocklet if started failed', { did, name, context, timeout, error });
 
       await this.deleteProcess({ did }, context);
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.error);
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, { componentDids });
 
       this._createNotification(did, {
         title: 'Blocklet Start Failed',
@@ -2273,7 +2367,7 @@ class BlockletManager extends BaseBlockletManager {
    * @param {string} opt.did
    * @param {object} opt.context
    */
-  async _installBlocklet({ did, oldBlocklet, context, createNotification = true }) {
+  async _installBlocklet({ did, oldBlocklet, componentDids, context, createNotification = true }) {
     try {
       // should ensure blocklet integrity
       let blocklet = await this.ensureBlocklet(did);
@@ -2297,7 +2391,9 @@ class BlockletManager extends BaseBlockletManager {
       // post install
       await this._runPostInstallHook(blocklet, context);
 
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
+      await states.blocklet.setInstalledAt(did);
+
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.installed, { componentDids });
       blocklet = await this.getBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
 
@@ -2325,14 +2421,22 @@ class BlockletManager extends BaseBlockletManager {
         });
       }
 
-      if (blocklet?.controller?.nftId && process.env.NODE_ENV !== 'test') {
-        const nodeInfo = await states.node.read();
-        await consumeServerlessNFT({ nftId: blocklet.controller.nftId, nodeInfo, blocklet });
-        await states.blockletExtras.updateByDid(did, {
-          controller: { ...blocklet.controller, consumedAt: new Date().toISOString() },
-        });
+      if (blocklet.controller && process.env.NODE_ENV !== 'test') {
+        let isNFTConsumed = false;
+        if (blocklet.controller.launcherSessionId && blocklet.controller.launcherUrl) {
+          await consumeLauncherSession({ params: blocklet.controller, blocklet });
+          isNFTConsumed = true;
+        } else if (blocklet.controller.nftId) {
+          await consumeServerlessNFT({ nftId: blocklet.controller.nftId, blocklet });
+          isNFTConsumed = true;
+        }
 
-        this.emit(BlockletEvents.nftConsumed, { blocklet, context });
+        if (isNFTConsumed) {
+          await states.blockletExtras.updateByDid(did, {
+            controller: { ...blocklet.controller, consumedAt: new Date().toISOString() },
+          });
+          this.emit(BlockletEvents.nftConsumed, { blocklet, context });
+        }
       }
 
       if (createNotification) {
@@ -2378,7 +2482,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async _upgradeBlocklet({ newBlocklet, oldBlocklet, context = {} }) {
+  async _upgradeBlocklet({ newBlocklet, oldBlocklet, componentDids, context = {} }) {
     const { meta, source, deployedFrom, children } = newBlocklet;
     const { did, version, name, title } = meta;
 
@@ -2401,6 +2505,8 @@ class BlockletManager extends BaseBlockletManager {
 
       // update state
       await states.blocklet.upgradeBlocklet({ meta, source, deployedFrom, children });
+      // ensure component status is upgrading
+      await states.blocklet.setBlockletStatus(did, BlockletStatus.upgrading, { componentDids });
       await this._setConfigsFromMeta(did);
 
       // should ensure blocklet integrity
@@ -2441,14 +2547,14 @@ class BlockletManager extends BaseBlockletManager {
 
       logger.info('updated blocklet for upgrading', { did, version, source, name });
 
-      const status =
-        oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-      await states.blocklet.setBlockletStatus(did, status, { children: 'all' });
-
-      // start new process
       if (oldBlocklet.status === BlockletStatus.running) {
-        await this.start({ did }, context);
+        // start new process
+        await this.start({ did, componentDids }, context);
         logger.info('started blocklet for upgrading', { did, version });
+      } else {
+        const status =
+          oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
+        await states.blocklet.setBlockletStatus(did, status, { componentDids });
       }
 
       blocklet = await this.getBlocklet(did, context);
@@ -2478,6 +2584,11 @@ class BlockletManager extends BaseBlockletManager {
 
       await this._rollbackCache.remove({ did: blocklet.meta.did });
 
+      this.emit(BlockletInternalEvents.componentsUpdated, {
+        appDid: blocklet.appDid,
+        components: getComponentsInternalInfo(blocklet),
+      });
+
       return blocklet;
     } catch (err) {
       const b = await this._rollback('upgrade', did, oldBlocklet);
@@ -2524,7 +2635,7 @@ class BlockletManager extends BaseBlockletManager {
    * @return {*}
    * @memberof BlockletManager
    */
-  async _downloadBlocklet(blocklet, context = {}) {
+  _downloadBlocklet(blocklet, context = {}) {
     const {
       appDid,
       meta: { did },
@@ -2534,12 +2645,14 @@ class BlockletManager extends BaseBlockletManager {
       ...context,
       preDownload: async ({ downloadComponentIds }) => {
         // update children status
-        const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
-          children: downloadComponentIds,
-        });
-        this.emit(BlockletEvents.statusChange, blocklet1);
+        if (downloadComponentIds?.length) {
+          const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
+            componentDids: downloadComponentIds,
+          });
+          this.emit(BlockletEvents.statusChange, blocklet1);
+        }
       },
-      onProgress: async (data) => {
+      onProgress: (data) => {
         this.emit(BlockletEvents.downloadBundleProgress, { appDid: appDid || did, meta: { did }, ...data });
       },
       postDownload: async ({ isCancelled }) => {
@@ -2551,16 +2664,17 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
-  async _syncPm2Status(pm2Status, did) {
+  async _syncPm2Status(pm2Status, did, componentDid) {
     try {
-      const state = await states.blocklet.getBlocklet(did);
-      if (state && util.shouldUpdateBlockletStatus(state.status)) {
+      const blocklet = await states.blocklet.getBlocklet(did);
+      const component = findComponentByIdV2(blocklet, componentDid);
+      if (component && util.shouldUpdateBlockletStatus(component.status)) {
         const newStatus = pm2StatusMap[pm2Status];
-        await states.blocklet.setBlockletStatus(did, newStatus);
-        logger.info('sync pm2 status to blocklet', { did, pm2Status, newStatus });
+        await states.blocklet.setBlockletStatus(did, newStatus, { componentDids: [componentDid] });
+        logger.info('sync pm2 status to blocklet', { did, componentDid, pm2Status, newStatus });
       }
     } catch (error) {
-      logger.error('sync pm2 status to blocklet failed', { did, pm2Status, error });
+      logger.error('sync pm2 status to blocklet failed', { did, componentDid, pm2Status, error });
     }
   }