@abtnode/core 1.16.13 → 1.16.14-beta-0c29907f

package/lib/blocklet/manager/helper/install-application-from-backup.js

@@ -6,6 +6,7 @@ const { forEachBlockletSync, getBlockletAppIdList } = require('@blocklet/meta/li
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 
 const { BLOCKLET_CONFIGURABLE_KEY, BlockletEvents, BlockletStatus } = require('@blocklet/constant');
+const { INSTALL_ACTIONS } = require('@abtnode/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-app-backup');
 
@@ -195,7 +196,7 @@ const installApplicationFromBackup = async ({
   } catch (error) {
     logger.error('installFromBackup failed', { did, error });
 
-    await manager._rollback('install', did);
+    await manager._rollback(INSTALL_ACTIONS.INSTALL, did);
 
     throw error;
   }
@@ -213,7 +214,7 @@ const installApplicationFromBackup = async ({
     } catch (error) {
       logger.error('download blocklet failed', { did, error });
 
-      await manager._rollback('install', did);
+      await manager._rollback(INSTALL_ACTIONS.INSTALL, did);
 
       throw error;
     }
@@ -233,11 +234,11 @@ const installApplicationFromBackup = async ({
       blocklet: { ...blocklet1 },
       skipCheckIntegrity: true,
       context,
-      postAction: 'install',
+      postAction: INSTALL_ACTIONS.INSTALL,
     };
 
     // backup rollback data
-    await manager._rollbackCache.backup({ did, action: 'install' });
+    await manager._rollbackCache.backup({ did, action: INSTALL_ACTIONS.INSTALL });
 
     const ticket = manager.installQueue.push(
       {
@@ -251,7 +252,7 @@ const installApplicationFromBackup = async ({
     ticket.on('failed', async (err) => {
       logger.error('failed to install blocklet', { did, error: err });
       try {
-        await manager._rollback('install', did, {});
+        await manager._rollback(INSTALL_ACTIONS.INSTALL, did, {});
       } catch (e) {
         logger.error('failed to remove blocklet on install error', { did, error: e });
       }
@@ -272,7 +273,7 @@ const installApplicationFromBackup = async ({
     logger.error('failed to install blocklet', { did, error: err });
 
     try {
-      await manager._rollback('install', did, {});
+      await manager._rollback(INSTALL_ACTIONS.INSTALL, did, {});
     } catch (e) {
       logger.error('failed to remove blocklet on install error', { did, error: e });
     }

package/lib/blocklet/manager/helper/install-application-from-general.js

@@ -1,6 +1,6 @@
 const joi = require('joi');
 
-const { BLOCKLET_INSTALL_TYPE, NODE_MODES } = require('@abtnode/constant');
+const { BLOCKLET_INSTALL_TYPE, NODE_MODES, INSTALL_ACTIONS } = require('@abtnode/constant');
 const { BlockletStatus, BlockletEvents, BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-app-general');
@@ -122,7 +122,7 @@ const installApplicationFromGeneral = async ({
     logger.error('failed to create blocklet extras', { did, componentDid, error: err });
 
     try {
-      await manager._rollback('install', did, {});
+      await manager._rollback(INSTALL_ACTIONS.INSTALL, did, {});
     } catch (e) {
       logger.error('failed to remove blocklet on create extras error', { did, componentDid, error: e });
     }
@@ -146,7 +146,7 @@ const installApplicationFromGeneral = async ({
     const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.waiting);
     manager.emit(BlockletEvents.added, blocklet1);
 
-    const action = 'install';
+    const action = INSTALL_ACTIONS.INSTALL;
     const downloadParams = {
       blocklet: { ...blocklet1 },
       context,
@@ -175,7 +175,7 @@ const installApplicationFromGeneral = async ({
         const componentDid = component?.meta?.did;
         logger.error('failed to install blocklet', { did, componentDid, error: err });
         try {
-          await manager._rollback('install', did, {});
+          await manager._rollback(INSTALL_ACTIONS.INSTALL, did, {});
         } catch (e) {
           logger.error('failed to remove blocklet on install error', { did, componentDid, error: e });
         }
@@ -198,7 +198,7 @@ const installApplicationFromGeneral = async ({
     logger.error('failed to install blocklet', { did, componentDid, error: err });
 
     try {
-      await manager._rollback('install', did, {});
+      await manager._rollback(INSTALL_ACTIONS.INSTALL, did, {});
     } catch (e) {
       logger.error('failed to remove blocklet on install error', { did, componentDid, error: e });
     }

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

@@ -5,6 +5,7 @@ const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-
 const { isInProgress } = require('@blocklet/meta/lib/util');
 
 const { BlockletSource, BlockletGroup, fromBlockletStatus } = require('@blocklet/constant');
+const { INSTALL_ACTIONS } = require('@abtnode/constant');
 const {
   parseComponents,
   filterDuplicateComponents,
@@ -96,6 +97,8 @@ const installComponentFromUpload = async ({
     newBlocklet.children.push(newChild);
   }
 
+  const action = index >= 0 ? INSTALL_ACTIONS.UPGRADE_COMPONENT : INSTALL_ACTIONS.INSTALL_COMPONENT;
+
   const { dynamicComponents } = await parseComponents(newChild);
   const newChildren = filterDuplicateComponents(dynamicComponents, newBlocklet.children);
 
@@ -104,7 +107,6 @@ const installComponentFromUpload = async ({
   checkVersionCompatibility(newBlocklet.children);
 
   // backup rollback data
-  const action = 'upgrade';
   await manager._rollbackCache.backup({ did: newBlocklet.meta.did, action, oldBlocklet });
 
   const componentDids = [newChild.meta.did, ...newChildren.map((x) => x.meta.did)];

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

@@ -1,4 +1,3 @@
-const capitalize = require('lodash/capitalize');
 const { sign } = require('@arcblock/jwt');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-component-url');
@@ -8,6 +7,7 @@ const { titleSchema } = require('@blocklet/meta/lib/schema');
 const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
 
 const { BlockletStatus, BlockletEvents, BlockletGroup } = require('@blocklet/constant');
+const { INSTALL_ACTIONS } = require('@abtnode/constant');
 const {
   getBlockletMetaFromUrl,
   parseComponents,
@@ -16,6 +16,7 @@ const {
   checkStructVersion,
   checkVersionCompatibility,
   validateBlocklet,
+  getComponentNamesWithVersion,
 } = require('../../../util/blocklet');
 const StoreUtil = require('../../../util/store');
 const { formatName } = require('../../../util/get-domain-for-blocklet');
@@ -105,7 +106,7 @@ const installComponentFromUrl = async ({
   checkVersionCompatibility(blocklet.children);
 
   const oldBlocklet = await manager._getBlockletForInstallation(rootDid);
-  const action = 'upgrade';
+  const action = index > 0 ? INSTALL_ACTIONS.UPGRADE_COMPONENT : INSTALL_ACTIONS.INSTALL_COMPONENT;
   try {
     // add component to db
     await states.blocklet.addChildren(rootDid, newChildren);
@@ -141,6 +142,7 @@ const installComponentFromUrl = async ({
     oldBlocklet: { ...oldBlocklet },
     blocklet: { ...newBlocklet },
     componentDids,
+    addedComponentDids: componentDids,
     context,
     postAction: action,
   };
@@ -148,6 +150,8 @@ const installComponentFromUrl = async ({
   // backup rollback data
   await manager._rollbackCache.backup({ did: rootDid, action, oldBlocklet });
 
+  logger.info('install component from url', { rootDid, url, mountPoint, sync, componentDids });
+
   if (sync) {
     await manager._downloadAndInstall({ ...downloadParams, throwOnError: true });
     return states.blocklet.getBlocklet(rootDid);
@@ -167,10 +171,23 @@ const installComponentFromUrl = async ({
   ticket.on('failed', async (err) => {
     logger.error('queue failed', { entity: 'blocklet', action, did: rootDid, error: err });
     await manager._rollback(action, rootDid, oldBlocklet);
-    manager.emit(`blocklet.${action}.failed`, { did: rootDid, err });
+
+    const notificationEvent =
+      action === INSTALL_ACTIONS.INSTALL_COMPONENT
+        ? BlockletEvents.componentInstallFailed
+        : BlockletEvents.componentUpgradeFailed;
+    const actionName = action === INSTALL_ACTIONS.INSTALL_COMPONENT ? 'install' : 'upgrade';
+
+    manager.emit(notificationEvent, {
+      blocklet: { ...newBlocklet, componentDids, error: { message: err.message } },
+      context: { ...context, createAuditLog: false },
+    });
+
     manager._createNotification(rootDid, {
-      title: `Blocklet ${capitalize(action)} Failed`,
-      description: `Blocklet ${rootDid} ${action} failed with error: ${err.message || 'queue exception'}`,
+      title: '',
+      description: `${getComponentNamesWithVersion(newBlocklet, componentDids)} ${actionName} failed for ${
+        newBlocklet.meta.title
+      }: ${err.message || 'queue exception'}.`,
       entityType: 'blocklet',
       entityId: rootDid,
       severity: 'error',

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

@@ -1,10 +1,10 @@
 /* eslint-disable no-await-in-loop */
 const cloneDeep = require('lodash/cloneDeep');
-const capitalize = require('lodash/capitalize');
 
 const logger = require('@abtnode/logger')('@abtnode/core:upgrade-component');
 
 const { BlockletStatus, BlockletEvents } = require('@blocklet/constant');
+const { INSTALL_ACTIONS } = require('@abtnode/constant');
 const {
   getUpdateMetaList,
   parseComponents,
@@ -14,6 +14,7 @@ const {
   checkVersionCompatibility,
   validateBlocklet,
   getFixedBundleSource,
+  getComponentNamesWithVersion,
 } = require('../../../util/blocklet');
 
 const check = async ({ did, states }) => {
@@ -83,6 +84,12 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
   const oldBlocklet = await manager._getBlockletForInstallation(did);
   checkStructVersion(oldBlocklet);
 
+  logger.info('upgrade blocklet components', {
+    componentDids,
+    updateId,
+    did,
+  });
+
   // parse children
   let dynamicComponents = [];
   const children = cloneDeep(oldBlocklet.children).map((oldComponent) => {
@@ -102,7 +109,7 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
 
   checkVersionCompatibility(children);
 
-  logger.info('upgrade blocklet children', {
+  logger.info('blocklet components to upgrade', {
     did,
     children: children.map((x) => ({ name: x.meta.name, version: x.meta.version })),
   });
@@ -115,7 +122,7 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
 
   manager.emit(BlockletEvents.statusChange, newBlocklet);
 
-  const action = 'upgrade';
+  const action = INSTALL_ACTIONS.UPGRADE_COMPONENT;
 
   // backup rollback data
   await manager._rollbackCache.backup({ did, action, oldBlocklet });
@@ -138,15 +145,23 @@ const upgrade = async ({ updateId, componentDids, context, states, manager }) =>
   ticket.on('failed', async (err) => {
     logger.error('queue failed', { entity: 'blocklet', action, did, error: err });
     await manager._rollback(action, did, oldBlocklet);
-    manager.emit(`blocklet.${action}.failed`, { did, err });
+
+    manager.emit(BlockletEvents.componentUpgradeFailed, {
+      blocklet: { ...oldBlocklet, componentDids, error: { message: err.message } },
+      context: { ...context, createAuditLog: false },
+    });
+
     manager._createNotification(did, {
-      title: `Blocklet ${capitalize(action)} Failed`,
-      description: `Blocklet ${did} ${action} failed with error: ${err.message || 'queue exception'}`,
+      title: '',
+      description: `${getComponentNamesWithVersion(oldBlocklet, componentDids)} upgrade failed for ${
+        oldBlocklet.meta.title
+      }: ${err.message || 'queue exception'}.`,
       entityType: 'blocklet',
       entityId: did,
       severity: 'error',
     });
   });
+
   return newBlocklet;
 };
 

package/lib/event.js

@@ -233,10 +233,28 @@ module.exports = ({
       } catch (error) {
         logger.error('Failed to createAuditLog for installBlocklet', { error });
       }
-    } else if ([BlockletEvents.upgraded, BlockletEvents.downgraded].includes(eventName)) {
+    } else if ([BlockletEvents.upgraded].includes(eventName)) {
       await handleBlockletUpgrade(eventName, payload);
-
+    } else if ([BlockletEvents.removed, BlockletEvents.dataCleaned].includes(eventName)) {
+      await handleBlockletRemove(eventName, payload);
+    } else if ([BlockletEvents.started].includes(eventName)) {
+      const { publicToStore } = blocklet.settings || {};
+      if (publicToStore) {
+        handleInstanceInStore(blocklet, { publicToStore }).catch((error) => {
+          logger.error('handleInstanceInStore failed', { message: error.message });
+        });
+      }
+    } else if (
+      [
+        BlockletEvents.componentInstalled,
+        BlockletEvents.componentInstallFailed,
+        BlockletEvents.componentUpgradeFailed,
+        BlockletEvents.componentUpgraded,
+      ].includes(eventName)
+    ) {
       if (payload?.context?.createAuditLog !== false) {
+        const resultStatus = [BlockletEvents.componentInstallFailed, BlockletEvents.componentUpgradeFailed].includes(eventName) ? 'failed' : 'success'; // prettier-ignore
+        const action = [BlockletEvents.componentInstalled, BlockletEvents.componentInstallFailed].includes(eventName) ? 'installed' : 'upgraded'; // prettier-ignore
         try {
           await node.createAuditLog({
             action: 'upgradeBlocklet',
@@ -244,37 +262,16 @@ module.exports = ({
               did: blocklet.meta.did,
             },
             context: payload.context || {},
-            result: blocklet,
+            result: {
+              ...blocklet,
+              resultStatus,
+              action,
+            },
           });
         } catch (error) {
-          logger.error('Failed to createAuditLog for upgradeBlocklet', { error });
+          logger.error('Failed to createAuditLog for upgradeBlocklet failed', { error });
         }
       }
-    } else if ([BlockletEvents.removed, BlockletEvents.dataCleaned].includes(eventName)) {
-      await handleBlockletRemove(eventName, payload);
-    } else if ([BlockletEvents.started].includes(eventName)) {
-      const { publicToStore } = blocklet.settings || {};
-      if (publicToStore) {
-        handleInstanceInStore(blocklet, { publicToStore }).catch((error) => {
-          logger.error('handleInstanceInStore failed', { message: error.message });
-        });
-      }
-    } else if ([BlockletEvents.upgradeFailed, BlockletEvents.downgradeFailed].includes(eventName)) {
-      try {
-        await node.createAuditLog({
-          action: 'upgradeBlocklet',
-          args: {
-            did: blocklet.meta.did,
-          },
-          context: payload.context || {},
-          result: {
-            ...blocklet,
-            resultStatus: 'failed',
-          },
-        });
-      } catch (error) {
-        logger.error('Failed to createAuditLog for upgradeBlocklet failed', { error });
-      }
     } else if (BlockletEvents.appDidChanged === eventName) {
       const hash = await takeRoutingSnapshot(
         { message: `${routingSnapshotPrefix(blocklet)}Update blocklet ${blocklet.meta.name} app did`, dryRun: false },
@@ -361,9 +358,6 @@ module.exports = ({
     BlockletEvents.installed,
     BlockletEvents.installFailed,
     BlockletEvents.upgraded,
-    BlockletEvents.upgradeFailed,
-    BlockletEvents.downgraded,
-    BlockletEvents.downgradeFailed,
     BlockletEvents.updated,
     BlockletEvents.statusChange,
     BlockletEvents.removed,
@@ -372,6 +366,12 @@ module.exports = ({
     BlockletEvents.stopped,
     BlockletEvents.appDidChanged,
 
+    BlockletEvents.componentInstalled,
+    BlockletEvents.componentInstallFailed,
+    BlockletEvents.componentUpgraded,
+    BlockletEvents.componentUpgradeFailed,
+    BlockletEvents.componentRemoved,
+
     BlockletEvents.backupProgress,
     BlockletEvents.restoreProgress,
     BlockletEvents.downloadBundleProgress,

package/lib/index.js

@@ -258,6 +258,10 @@ function ABTNode(options) {
     configPublicToStore: blockletManager.configPublicToStore.bind(blockletManager),
     configNavigations: blockletManager.configNavigations.bind(blockletManager),
     configOAuth: blockletManager.configOAuth.bind(blockletManager),
+    joinFederatedLogin: blockletManager.joinFederatedLogin.bind(blockletManager),
+    auditFederatedLogin: blockletManager.auditFederatedLogin.bind(blockletManager),
+    configFederated: blockletManager.configFederated.bind(blockletManager),
+    setFederated: blockletManager.setFederated.bind(blockletManager),
     configNotification: blockletManager.configNotification.bind(blockletManager),
     updateWhoCanAccess: blockletManager.updateWhoCanAccess.bind(blockletManager),
     updateAppSessionConfig: blockletManager.updateAppSessionConfig.bind(blockletManager),

package/lib/states/audit-log.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-async-promise-executor */
 const pick = require('lodash/pick');
 const get = require('lodash/get');
+const uniq = require('lodash/uniq');
 const joinUrl = require('url-join');
 const { getDisplayName } = require('@blocklet/meta/lib/util');
 const { BLOCKLET_SITE_GROUP_SUFFIX, NODE_SERVICES } = require('@abtnode/constant');
@@ -20,20 +21,18 @@ const getServerInfo = (info) => `[${info.name}](${joinUrl(info.routing.adminPath
  * }} info
  * @returns {string}
  */
-const getBlockletInfo = (blocklet, info) => `[${getDisplayName(blocklet)} v${blocklet.meta.version}](${joinUrl(info.routing.adminPath, '/blocklets/', blocklet.meta.did, '/overview')})`; // prettier-ignore
-const expandTeam = async (teamDid, info, node) => {
-  if (!teamDid) {
-    return '';
-  }
+const getBlockletInfo = (blocklet, info) => `[${getDisplayName(blocklet)}](${joinUrl(info.routing.adminPath, '/blocklets/', blocklet.meta.did, '/overview')})`; // prettier-ignore
+const componentOrApplication = (componentDids) => (componentDids?.length ? 'component' : 'application');
+const getComponentNamesWithVersion = (blocklet, componentDids) =>
+  uniq(componentDids || [])
+    .map((x) => {
+      const component = blocklet.children.find((y) => y.meta.did === x);
+      return `${component.meta.title}@${component.meta.version}`;
+    })
+    .join(', ');
+const componentOrApplicationInfo = (app, componentDids) =>
+  `${componentOrApplication(componentDids)} ${getComponentNamesWithVersion(app, componentDids)}`;
 
-  if (teamDid === info.did) {
-    return getServerInfo(info);
-  }
-
-  const { blocklet } = node.states;
-  const doc = await blocklet.getBlocklet(teamDid);
-  return doc ? getBlockletInfo(doc, info) : '';
-};
 const expandSite = async (siteId, info, node) => {
   if (!siteId) {
     return '';
@@ -97,8 +96,7 @@ const expandUser = async (teamDid, userDid, passportId, info, node) => {
  * @return {string} the generated markdown source
  */
 const getLogContent = async (action, args, context, result, info, node) => {
-  const [team, site, [user, passport]] = await Promise.all([
-    expandTeam(args.teamDid, info, node),
+  const [site, [user, passport]] = await Promise.all([
     expandSite(args.id, info, node),
     expandUser(args.teamDid, args.userDid || get(args, 'user.did') || args.ownerDid, args.passportId, info, node),
   ]);
@@ -106,60 +104,56 @@ const getLogContent = async (action, args, context, result, info, node) => {
   switch (action) {
     // blocklets
     case 'installBlocklet':
-      return `installed blocklet ${getBlockletInfo(result, info)} from ${result.deployedFrom}`;
+      return `installed application ${result.meta.title}`;
+    case 'deleteBlocklet':
+      return `removed application ${result.meta.title}`; // prettier-ignore
+    case 'backupBlocklet':
+      return `backup application ${result.meta.title}`; // prettier-ignore
     case 'startBlocklet':
-      return `started blocklet ${getBlockletInfo(result, info)} ${args.reason || ''}`;
+      return `started ${componentOrApplicationInfo(result, args.componentDids)}`;
     case 'restartBlocklet':
-      return `restarted blocklet ${getBlockletInfo(result, info)}`;
+      return `restarted ${componentOrApplicationInfo(result, args.componentDids)}`;
     case 'reloadBlocklet':
-      return `reloaded blocklet ${getBlockletInfo(result, info)}`;
+      return `reloaded ${componentOrApplicationInfo(result, args.componentDids)}`;
     case 'stopBlocklet':
-      return `stopped blocklet ${getBlockletInfo(result, info)}`;
+      return `stopped ${componentOrApplicationInfo(result, args.componentDids)}`;
     case 'resetBlocklet':
-      return `reset blocklet ${getBlockletInfo(result, info)} data and config`;
-    case 'deleteBlocklet':
-      return `removed blocklet ${getBlockletInfo(result, info)} ${args.keepData ? 'but kept its data and config' : 'and its data and config'}`; // prettier-ignore
-    case 'installComponent':
-      return `added component from ${args.file ? 'Upload' : args.url} at **${args.mountPoint}** to ${getBlockletInfo(result, info)}`; // prettier-ignore
-    case 'deleteComponent':
-      return `removed component ${args.did} from blocklet ${getBlockletInfo(result, info)}`;
-    case 'configBlocklet':
-      return `updated following config for blocklet ${getBlockletInfo(result, info)}:\n${args.configs.map(x => `* ${x.key}: ${x.value}`).join('\n')}`; // prettier-ignore
+      return `reset ${componentOrApplicationInfo(result, args.childDid ? [args.childDid] : [])}`;
     case 'upgradeBlocklet':
+      const actionName = result.action || 'upgraded';
       if (result.resultStatus === 'failed') {
-        return `upgrade blocklet failed: ${getBlockletInfo(result, info)}`;
+        return `${actionName} component failed: **${getComponentNamesWithVersion(result, result.componentDids)}**`;
       }
-      return `upgraded blocklet ${getBlockletInfo(result, info)} to v${result.meta.version}`;
+      return `${actionName} component: **${getComponentNamesWithVersion(result, result.componentDids)}**`;
+    case 'deleteComponent':
+      return `removed ${result.deletedComponent.meta.title}@${result.deletedComponent.meta.version} ${ args.keepData !== false ? 'but kept its data and config' : 'and its data and config' }`; // prettier-ignore
+    case 'configBlocklet':
+      return `updated following config for ${args.did?.length > 1 ? componentOrApplicationInfo(result, [args.did[1]]) : 'application'}: ${args.configs.map(x => `* ${x.key}`).join(', ')}`; // prettier-ignore
     case 'backupToSpaces':
       if (args?.success) {
-        return `Backup ${getBlockletInfo(result, info)} to ${
-          args.url
-        } successfully:\n- Backup files have been stored [here](${args.backupUrl})`;
+        return `Backup application to ${args.url} successfully:\n- Backup files have been stored [here](${args.backupUrl})`;
       }
-      return `Backup ${getBlockletInfo(result, info)} to ${
-        args.url
-      } failed:\n- The reason for the error is: <span style='color:red'>${args.errorMessage}</span>`;
-
-    case 'upgradeComponents':
-      return `upgraded components for blocklet ${getBlockletInfo(result, info)}`;
+      return `Backup application to ${args.url} failed:\n- The reason for the error is: <span style='color:red'>${args.errorMessage}</span>`;
     case 'configPublicToStore':
-      if (args.publicToStore) {
-        return `set publicToStore to true for blocklet ${getBlockletInfo(result, info)}`;
-      }
-      return `set publicToStore to false for blocklet ${getBlockletInfo(result, info)}`;
+      return `set publicToStore to ${args.publicToStore ? 'true' : 'false'}`;
     case 'configNavigations':
       // eslint-disable-next-line prettier/prettier
-      return `updated following navigations for blocklet ${getBlockletInfo(result, info)}:\n${args.navigations.map(
+      return `updated following navigations:\n${args.navigations.map(
         (x) => `- ${x.title}: ${x.link}\n`
       )}`;
     case 'configOAuth':
       return `updated following OAuth for blocklet ${getBlockletInfo(result, info)}:\n${args.oauth}`;
+    // TODO: @zhanghan 配置审计日志
+    case 'joinFederatedLogin':
+      return `updated following OAuth for blocklet ${getBlockletInfo(result, info)}:\n${args.oauth}`;
+    case 'auditFederatedLogin':
+      return `updated following OAuth:\n${args.oauth}`;
     case 'configNotification':
-      return `updated following notification setting for blocklet ${getBlockletInfo(result, info)}`;
+      return `updated following notification setting: ${args.notification}`;
     case 'updateComponentTitle':
-      return `update component title to **${args.title}** for blocklet ${getBlockletInfo(result, info)}`;
+      return `update component title to **${args.title}**`;
     case 'updateComponentMountPoint':
-      return `update component mount point to **${args.mountPoint}** for blocklet ${getBlockletInfo(result, info)}`;
+      return `update component mount point to **${args.mountPoint}**`;
     // store
     case 'addBlockletStore':
       return `added blocklet store ${args.url}`;
@@ -173,57 +167,57 @@ const getLogContent = async (action, args, context, result, info, node) => {
     // teams: members/passports
     case 'addUser':
       if (args.passport) {
-        return `${args.reason} and received **${args.passport.name}** passport from ${team}`;
+        return `${args.reason} and received **${args.passport.name}** passport`;
       }
-      return `joined team ${team} by ${args.reason}`;
+      return `joined team by ${args.reason}`;
     case 'updateUser':
-      return `${args.reason} and received **${args.passport.name}** passport from ${team}`;
+      return `${args.reason} and received **${args.passport.name}** passport`;
     case 'connectAccount':
       return `user ${user} connect with account ${args.connectedAccount.provider}: ${args.connectedAccount.did}`;
     case 'switchProfile':
-      return `switched profile to ${args.profile.fullName} for ${team}`;
+      return `switched profile to ${args.profile.fullName}`;
     case 'switchPassport':
-      return `${args.provider} user ${user} switched passport to ${args.passport.name} for ${team}`;
+      return `${args.provider} user ${user} switched passport to ${args.passport.name}`;
     case 'login':
-      return `${args.provider} user ${user} logged in to ${team} with passport ${args.passport.name}`;
+      return `${args.provider} user ${user} logged in with passport ${args.passport.name}`;
     case 'updateWhoCanAccess':
       return `updated access control policy to **${args.whoCanAccess}**`;
     case 'configPassportIssuance':
-      return `${args.enabled ? 'enabled' : 'disabled'} passport issuance for ${team}`;
+      return `${args.enabled ? 'enabled' : 'disabled'} passport issuance`;
     case 'createPassportIssuance':
-      return `issued **${args.name}** passport to ${user} for ${team}, issuance id: ${result.id}`;
+      return `issued **${args.name}** passport to ${user}, issuance id: ${result.id}`;
     case 'processPassportIssuance':
-      return `claimed passport **${args.name}** from ${team}, issuance id: ${args.sessionId}`;
+      return `claimed passport **${args.name}**, issuance id: ${args.sessionId}`;
     case 'revokeUserPassport':
-      return `revoked **${passport}** passport of user ${user} for ${team}`;
+      return `revoked **${passport}** passport of user ${user}`;
     case 'enableUserPassport':
-      return `enabled **${passport}** passport of user ${user} for ${team}`;
+      return `enabled **${passport}** passport of user ${user}`;
     case 'updateUserApproval':
-      return `${args.user.approved ? 'enabled' : 'disabled'} user ${user} for ${team}`;
+      return `${args.user.approved ? 'enabled' : 'disabled'} user ${user}`;
     case 'deletePassportIssuance':
-      return `removed passport issuance ${args.sessionId} from ${team}`;
+      return `removed passport issuance ${args.sessionId}`;
     case 'createMemberInvitation':
-      return `created member invitation(${result.inviteId}: ${args.remark}) with **${args.role}** passport for ${team}`; // prettier-ignore
+      return `created member invitation(${result.inviteId}: ${args.remark}) with **${args.role}** passport`; // prettier-ignore
     case 'deleteInvitation':
-      return `removed unused member invitation(${args.inviteId}) from ${team}`;
+      return `removed unused member invitation(${args.inviteId})`;
     case 'createRole':
-      return `created passport ${args.name}(${args.title}) for ${team}`;
+      return `created passport ${args.name}(${args.title})`;
     case 'updateRole':
-      return `updated passport ${args.role.name}(${args.role.title}) for ${team}`;
+      return `updated passport ${args.role.name}(${args.role.title})`;
     case 'updatePermissionsForRole':
-      return `granted following permissions to passport ${args.roleName} for ${team}: \n${args.grantNames.map(x => `- ${x}`).join('\n')}`; // prettier-ignore
+      return `granted following permissions to passport ${args.roleName}: \n${args.grantNames.map(x => `- ${x}`).join('\n')}`; // prettier-ignore
     case 'configTrustedPassports':
       const trustedPassports = args.trustedPassports || [];
       if (trustedPassports.length === 0) {
-        return `removed all trusted passport issuers for ${team}`;
+        return 'removed all trusted passport issuers';
       }
-      return `updated trusted passport issuers to following for ${team}: \n${trustedPassports.map(x => `- ${x.remark}: ${x.issuerDid}`).join('\n')}`; // prettier-ignore
+      return `updated trusted passport issuers to following: \n${trustedPassports.map(x => `- ${x.remark}: ${x.issuerDid}`).join('\n')}`; // prettier-ignore
     case 'configTrustedFactories':
       const trustedFactories = args.trustedFactories || [];
       if (trustedFactories.length === 0) {
-        return `removed all trusted factories for ${team}`;
+        return 'removed all trusted factories';
       }
-      return `updated trusted factories to following for ${team}: \n${trustedFactories.map(x => `- ${x.remark}: ${x.factoryAddress}`).join('\n')}`; // prettier-ignore
+      return `updated trusted factories to following: \n${trustedFactories.map(x => `- ${x.remark}: ${x.factoryAddress}`).join('\n')}`; // prettier-ignore
     case 'delegateTransferNFT':
       return `${args.owner} ${args.reason}`;
     case 'issuePassportToUser':

package/lib/states/blocklet.js

@@ -508,6 +508,7 @@ class BlockletState extends BaseState {
    * }}
    */
   async setBlockletStatus(did, status, { componentDids } = {}) {
+    logger.info('setBlockletStatus', { did, status, componentDids });
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }

package/lib/states/notification.js

@@ -23,7 +23,7 @@ class NotificationState extends BaseState {
   }
 
   async create(payload) {
-    ['title', 'description'].forEach((x) => {
+    ['description'].forEach((x) => {
       if (!payload[x]) {
         throw new Error(`Invalid notification payload: ${x} is required`);
       }
@@ -40,7 +40,7 @@ class NotificationState extends BaseState {
       severity: payload.severity || 'info',
       read: false,
     });
-    this.emit(EVENTS.NOTIFICATION_CREATE, doc);
+    this.emit(EVENTS.NOTIFICATION_CREATE, { ...payload, ...doc });
     return doc;
   }
 

package/lib/util/blocklet.js

@@ -1811,6 +1811,16 @@ const ensureAppPortsNotOccupied = async ({
   return newBlocklet;
 };
 
+const getComponentNamesWithVersion = (app = {}, componentDids = []) => {
+  const str = uniq(componentDids)
+    .map((x) => {
+      const component = (app.children || []).find((y) => y.meta.did === x);
+      return `${component.meta.title}@${component.meta.version}`;
+    })
+    .join(', ');
+  return str;
+};
+
 module.exports = {
   updateBlockletFallbackLogo,
   forEachBlocklet,
@@ -1873,4 +1883,5 @@ module.exports = {
   getBlockletURLForLauncher,
   exceedRedemptionPeriod,
   ensureAppPortsNotOccupied,
+  getComponentNamesWithVersion,
 };