@abtnode/core 1.16.11-next-069c3537 → 1.16.11-next-3d2b39f7

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,
@@ -66,6 +71,7 @@ const {
   RESTORE_PROGRESS_STATUS,
   CHAIN_PROP_MAP_REVERSE,
 } = require('@blocklet/constant');
+const { consumeServerlessNFT, consumeLauncherSession } = require('../../util/launcher');
 const util = require('../../util');
 const {
   refresh: refreshAccessibleExternalNodeIp,
@@ -80,7 +86,6 @@ const {
   stopBlockletProcess,
   deleteBlockletProcess,
   reloadBlockletProcess,
-  getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   validateBlocklet,
   validateBlockletChainInfo,
@@ -94,7 +99,6 @@ const {
   getBlocklet,
   ensureEnvDefault,
   getConfigFromPreferences,
-  consumeServerlessNFT,
   validateAppConfig,
   checkDuplicateMountPoint,
   validateStore,
@@ -104,6 +108,9 @@ const {
   updateBlockletFallbackLogo,
   ensureAppLogo,
   getBlockletDidDomainList,
+  getProcessState,
+  getBlockletStatus,
+  shouldSkipComponent,
   shouldCleanExpiredBlocklet,
 } = require('../../util/blocklet');
 const states = require('../../states');
@@ -133,7 +140,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');
 
@@ -239,8 +246,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));
     }
   }
 
@@ -427,8 +434,8 @@ class BlockletManager extends BaseBlockletManager {
     return UpgradeComponents.check({ did, states });
   }
 
-  async upgradeComponents({ updateId, selectedComponents: selectedComponentDids }, context = {}) {
-    return UpgradeComponents.upgrade({ updateId, selectedComponentDids, context, states, manager: this });
+  async upgradeComponents({ updateId, selectedComponents: componentDids }, context = {}) {
+    return UpgradeComponents.upgrade({ updateId, componentDids, context, states, manager: this });
   }
 
   async migrateApplicationToStructV2({ did, appSk, context = {} }) {
@@ -445,8 +452,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 });
 
@@ -454,7 +461,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
@@ -507,6 +514,7 @@ class BlockletManager extends BaseBlockletManager {
         nodeEnvironments,
         nodeInfo: await states.node.read(),
         e2eMode,
+        componentDids,
       });
 
       // check blocklet healthy
@@ -516,6 +524,7 @@ class BlockletManager extends BaseBlockletManager {
         context,
         minConsecutiveTime,
         timeout: startTimeout,
+        componentDids,
       };
 
       if (checkHealthImmediately) {
@@ -548,8 +557,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) {
@@ -560,14 +569,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);
     }
@@ -587,11 +596,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;
@@ -600,13 +610,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;
     }
 
@@ -660,18 +675,25 @@ 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 });
 
-    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, {
@@ -687,16 +709,28 @@ 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 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);
 
-    this.emit(BlockletEvents.statusChange, res);
-    return res;
+    if (!componentDids.length) {
+      throw new Error('No running component found');
+    }
+
+    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) {
@@ -755,17 +789,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);
@@ -783,6 +817,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);
@@ -864,6 +908,11 @@ class BlockletManager extends BaseBlockletManager {
       action: `/blocklets/${newBlocklet.meta.did}/components`,
     });
 
+    this.emit(BlockletInternalEvents.componentsUpdated, {
+      appDid: blocklet.appDid,
+      components: getComponentsInternalInfo(newBlocklet),
+    });
+
     return newBlocklet;
   }
 
@@ -922,7 +971,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) {
@@ -935,15 +991,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;
   }
 
@@ -1021,19 +1077,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 });
       }
     }
 
@@ -1046,8 +1101,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);
@@ -1086,7 +1141,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();
@@ -1106,7 +1161,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
@@ -1135,6 +1190,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;
@@ -1311,6 +1373,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);
   }
@@ -1369,57 +1435,40 @@ 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;
-
-      if ([added, waiting, downloading, installing, installed, upgrading].includes(status)) {
-        return blocklet;
-      }
-
-      const res = await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped);
-      this.emit(BlockletEvents.statusChange, res);
-      return res;
-    };
-
+  async status(did, { forceSync = false, componentDids } = {}) {
     const blocklet = await this.getBlocklet(did);
 
-    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 (!shouldUpdateStatus) {
+    // for backward compatibility
+    if (!blocklet.structVersion) {
       return blocklet;
     }
 
-    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;
-      }
+    await forEachComponentV2(
+      blocklet,
+      async (component) => {
+        if (!forceSync || !isInProgress(component.status)) {
+          return;
+        }
 
-      const status = await getBlockletStatusFromProcess(blocklet);
-      if (blocklet.status !== status) {
-        const res = await states.blocklet.setBlockletStatus(did, status);
-        this.emit(BlockletEvents.statusChange, res);
-        return res;
-      }
+        if (shouldSkipComponent(component.meta.did, componentDids)) {
+          return;
+        }
 
-      return blocklet;
-    } catch (err) {
-      return fastReturnOnForceSync(blocklet);
-    }
+        try {
+          const status = await getProcessState(component.env.processId);
+          if (component.status !== status) {
+            await states.blocklet.setBlockletStatus(did, status, { componentDids: [component.meta.did] });
+          }
+        } catch {
+          // do nothing
+        }
+      },
+      { parallel: true }
+    );
+
+    blocklet.status = getBlockletStatus(blocklet);
+
+    return blocklet;
   }
 
   async refreshListCache() {
@@ -1636,7 +1685,7 @@ class BlockletManager extends BaseBlockletManager {
    *  oldBlocklet: {},
    *  throwOnError: Error,
    *  skipCheckStatusBeforeDownload: boolean,
-   *  selectedComponentDids: Array<did>,
+   *  componentDids: Array<did>,
    * }} params
    * @return {*}
    * @memberof BlockletManager
@@ -1649,7 +1698,7 @@ class BlockletManager extends BaseBlockletManager {
       oldBlocklet,
       throwOnError,
       skipCheckStatusBeforeDownload,
-      selectedComponentDids,
+      componentDids,
       skipCheckIntegrity,
     } = params;
     const { meta } = blocklet;
@@ -1686,8 +1735,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;
         }),
@@ -1758,12 +1807,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);
       }
 
@@ -1777,13 +1826,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) {
@@ -1792,7 +1841,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 });
@@ -1800,6 +1849,7 @@ class BlockletManager extends BaseBlockletManager {
     try {
       const installedBlocklet = await this._installBlocklet({
         did,
+        componentDids,
         context,
         oldBlocklet,
       });
@@ -1807,7 +1857,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 });
         }
@@ -1820,7 +1870,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 });
 
@@ -1828,6 +1878,7 @@ class BlockletManager extends BaseBlockletManager {
       await this._upgradeBlocklet({
         newBlocklet,
         oldBlocklet,
+        componentDids,
         context,
       });
     } catch (err) {
@@ -1835,13 +1886,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;
@@ -1849,10 +1900,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);
@@ -1864,7 +1923,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',
@@ -2256,7 +2315,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);
@@ -2280,7 +2339,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 });
 
@@ -2308,14 +2369,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) {
@@ -2361,7 +2430,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;
 
@@ -2426,11 +2495,11 @@ class BlockletManager extends BaseBlockletManager {
 
       const status =
         oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-      await states.blocklet.setBlockletStatus(did, status, { children: 'all' });
+      await states.blocklet.setBlockletStatus(did, status, { componentDids });
 
       // start new process
       if (oldBlocklet.status === BlockletStatus.running) {
-        await this.start({ did }, context);
+        await this.start({ did, componentDids }, context);
         logger.info('started blocklet for upgrading', { did, version });
       }
 
@@ -2461,6 +2530,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);
@@ -2517,10 +2591,12 @@ 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) => {
         this.emit(BlockletEvents.downloadBundleProgress, { appDid: appDid || did, meta: { did }, ...data });
@@ -2534,16 +2610,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 });
     }
   }