@abtnode/core 1.16.21-beta-445a8baa → 1.16.21-beta-2e75c75c

package/lib/api/team.js

@@ -1399,7 +1399,7 @@ class TeamAPI extends EventEmitter {
 
     const userSessions = await state.model.findAll({
       where,
-      attributes: ['id', 'appPid', 'userDid', 'visitorId', 'passportId', 'updatedAt'],
+      attributes: ['id', 'appPid', 'userDid', 'visitorId', 'passportId', 'updatedAt', 'extra'],
       include: {
         model: userState.model,
         as: 'user',
@@ -1442,10 +1442,11 @@ class TeamAPI extends EventEmitter {
    * @param {string} params.lastLoginIp - 记录的 userSession 中当前用户的最后登录 ip
    * @param {string} params.passportId - 记录的 userSession 中当前用户登录所使用的 passportId
    * @param {string} params.status - 记录的 userSession 的状态
+   * @param {Object} params.extra - 记录的 userSession 额外的数据
    * @returns
    */
 
-  async upsertUserSession({ teamDid, appPid, userDid, visitorId, ua, lastLoginIp, passportId, status }) {
+  async upsertUserSession({ teamDid, appPid, userDid, visitorId, ua, lastLoginIp, passportId, status, extra }) {
     if (!userDid) {
       throw new Error('userDid are required');
     }
@@ -1459,13 +1460,14 @@ class TeamAPI extends EventEmitter {
         lastLoginIp,
         appPid,
         passportId,
+        extra,
       });
-      logger.info('insert userSession successfully', { userDid, ua, lastLoginIp, appPid, passportId });
+      logger.info('insert userSession successfully', { userDid, ua, lastLoginIp, appPid, passportId, extra });
     } else {
       const exist = await state.findOne({ userDid, visitorId, appPid });
       if (exist) {
-        [, [data]] = await state.update(exist.id, { ua, lastLoginIp, passportId, status });
-        logger.info('update userSession successfully', { id: exist.id, ua, lastLoginIp, passportId, status });
+        [, [data]] = await state.update(exist.id, { ua, lastLoginIp, passportId, status, extra });
+        logger.info('update userSession successfully', { id: exist.id, ua, lastLoginIp, passportId, status, extra });
       } else {
         data = await state.insert({
           visitorId,
@@ -1474,8 +1476,17 @@ class TeamAPI extends EventEmitter {
           lastLoginIp,
           appPid,
           passportId,
+          extra,
+        });
+        logger.info('insert userSession successfully', {
+          visitorId,
+          userDid,
+          ua,
+          lastLoginIp,
+          appPid,
+          passportId,
+          extra,
         });
-        logger.info('insert userSession successfully', { visitorId, userDid, ua, lastLoginIp, appPid, passportId });
       }
     }
 
@@ -1491,9 +1502,10 @@ class TeamAPI extends EventEmitter {
    * @param {string} params.ua - 同步的 userSession 中当前用户所使用设备的 ua
    * @param {string} params.lastLoginIp - 同步的 userSession 中当前用户的最后登录 ip
    * @param {string} params.passportId - 同步的 userSession 中当前用户登录所使用的 passportId
+   * @param {object} params.extra - 同步的 userSession 中当前用户登录额外的数据
    * @returns
    */
-  async syncUserSession({ teamDid, targetAppPid, userDid, visitorId, ua, lastLoginIp, passportId }) {
+  async syncUserSession({ teamDid, targetAppPid, userDid, visitorId, ua, lastLoginIp, passportId, extra }) {
     if (!targetAppPid) return;
 
     const blocklet = await getBlocklet({ did: teamDid, states: this.states, dataDirs: this.dataDirs });
@@ -1526,6 +1538,7 @@ class TeamAPI extends EventEmitter {
             lastLoginIp,
             appPid,
             passportId,
+            extra,
           };
           await callFederated({
             action: 'sync',
@@ -1543,6 +1556,7 @@ class TeamAPI extends EventEmitter {
             appPid,
             passportId,
             targetSite,
+            extra,
           });
         } catch (err) {
           logger.info(
@@ -1555,6 +1569,7 @@ class TeamAPI extends EventEmitter {
               appPid,
               passportId,
               targetSite,
+              extra,
             },
             err
           );

package/lib/blocklet/manager/disk.js

@@ -30,6 +30,7 @@ const {
   BACKUPS,
   DEFAULT_DID_DOMAIN,
   FEDERATED,
+  CHECK_UPDATE,
 } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
@@ -50,6 +51,7 @@ const {
   findComponentByIdV2,
   isGatewayBlocklet,
   hasStartEngine,
+  getDisplayName,
 } = require('@blocklet/meta/lib/util');
 const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
@@ -96,6 +98,7 @@ const pRetry = require('p-retry');
 const isFunction = require('lodash/isFunction');
 const { encode } = require('@abtnode/util/lib/base32');
 const formatContext = require('@abtnode/util/lib/format-context');
+const md5 = require('@abtnode/util/lib/md5');
 const { consumeServerlessNFT, consumeLauncherSession } = require('../../util/launcher');
 const util = require('../../util');
 const {
@@ -173,6 +176,7 @@ const {
   getBackupEndpoint,
   getSpaceNameByEndpoint,
   getBackupJobId,
+  getCheckUpdateJobId,
 } = require('../../util/spaces');
 const { validateAddSpaceGateway, validateUpdateSpaceGateway } = require('../../validators/space-gateway');
 const { sessionConfigSchema } = require('../../validators/util');
@@ -216,7 +220,16 @@ const pm2StatusMap = {
 const getBlockletEngineNameByPlatform = (blockletMeta) => getBlockletEngine(blockletMeta).interpreter;
 
 class DiskBlockletManager extends BaseBlockletManager {
-  constructor({ dataDirs, startQueue, installQueue, backupQueue, restoreQueue, daemon = false, teamManager }) {
+  constructor({
+    dataDirs,
+    startQueue,
+    installQueue,
+    backupQueue,
+    restoreQueue,
+    checkUpdateQueue,
+    daemon = false,
+    teamManager,
+  }) {
     super();
 
     this.dataDirs = dataDirs;
@@ -228,6 +241,7 @@ class DiskBlockletManager extends BaseBlockletManager {
      */
     this.backupQueue = backupQueue;
     this.restoreQueue = restoreQueue;
+    this.checkUpdateQueue = checkUpdateQueue;
     this.teamManager = teamManager;
 
     if (isFunction(this.backupQueue.on)) {
@@ -271,33 +285,54 @@ class DiskBlockletManager extends BaseBlockletManager {
       blockletPm2Events.on('online', (data) => this._syncPm2Status('online', data.blockletDid, data.componentDid));
       blockletPm2Events.on('stop', (data) => this._syncPm2Status('stop', data.blockletDid, data.componentDid));
     }
+
+    if (isFunction(this.checkUpdateQueue?.on)) {
+      /**
+       *
+       * @param {{
+       *  id: string,
+       *  job: { did: string }
+       * }} param0
+       */
+      const handleCheckUpdateComplete = async ({ id: jobId, job }) => {
+        await this.checkUpdateQueue.delete(jobId);
+        const { did } = job;
+        const checkUpdate = await this.getAutoCheckUpdate({ did });
+        if (checkUpdate?.enabled) {
+          this.checkUpdateQueue.push(job, jobId, true, CHECK_UPDATE.JOB.INTERVAL);
+        }
+      };
+      this.checkUpdateQueue.on('finished', handleCheckUpdateComplete).on('failed', handleCheckUpdateComplete);
+    }
   }
 
   async initialize() {
     await this.ensureAutoBackupJobs();
+    await this.ensureAutoCheckUpdateJobs();
   }
 
-  async ensureAutoBackupJobs() {
-    const blocklets = await states.blockletExtras.find({
-      'settings.autoBackup.enabled': true,
-    });
+  async ensureJobs({ queue, getJobId, find, entity, action, interval, restoreCancelled }) {
+    const blocklets = await states.blockletExtras.find(find);
 
     const info = await states.node.read();
 
     await Promise.all(
       blocklets.map(async (x) => {
         const { did } = x;
-        const jobId = getBackupJobId(did);
-        const job = await this.backupQueue.get(jobId);
+        const jobId = getJobId(did);
+        const job = await queue.get(jobId);
+        if (restoreCancelled) {
+          queue.restoreCancelled(jobId);
+        }
 
         if (job) {
           return;
         }
 
-        this.backupQueue.push(
+        queue.push(
           {
-            entity: 'blocklet',
-            action: 'backupToSpaces',
+            entity,
+            action,
             did,
             context: formatContext({
               user: { did: info.did },
@@ -305,12 +340,40 @@ class DiskBlockletManager extends BaseBlockletManager {
           },
           jobId,
           true,
-          BACKUPS.JOB.INTERVAL
+          interval
         );
       })
     );
   }
 
+  async ensureAutoBackupJobs() {
+    await this.ensureJobs({
+      queue: this.backupQueue,
+      getJobId: getBackupJobId,
+      find: {
+        'settings.autoBackup.enabled': true,
+      },
+      entity: 'blocklet',
+      action: 'backupToSpaces',
+      interval: BACKUPS.JOB.INTERVAL,
+      restoreCancelled: false,
+    });
+  }
+
+  async ensureAutoCheckUpdateJobs() {
+    await this.ensureJobs({
+      queue: this.checkUpdateQueue,
+      getJobId: getCheckUpdateJobId,
+      find: {
+        'settings.autoCheckUpdate.enabled': true,
+      },
+      entity: 'blocklet',
+      action: 'autoCheckUpdate',
+      interval: CHECK_UPDATE.JOB.INTERVAL,
+      restoreCancelled: true,
+    });
+  }
+
   // ============================================================================================
   // Public API for Installing/Upgrading Application or Components
   // ============================================================================================
@@ -1024,6 +1087,7 @@ class DiskBlockletManager extends BaseBlockletManager {
       entityId: newBlocklet.meta.did,
       severity: 'success',
       action: `/blocklets/${newBlocklet.meta.did}/components`,
+      blockletDashboardAction: '/.well-known/service/admin/components',
     });
 
     this.emit(BlockletEvents.componentRemoved, {
@@ -1792,6 +1856,10 @@ class DiskBlockletManager extends BaseBlockletManager {
       if (job.action === 'restoreFromSpaces') {
         await this._onRestoreFromSpaces(job);
       }
+
+      if (job.action === 'autoCheckUpdate') {
+        await this._onCheckForComponentUpdate(job);
+      }
     }
   }
 
@@ -1985,10 +2053,52 @@ class DiskBlockletManager extends BaseBlockletManager {
    */
   async getAutoBackup({ did }) {
     const autoBackup = await states.blockletExtras.getSettings(did, 'autoBackup', { enabled: false });
-
     return autoBackup;
   }
 
+  /**
+   * @description
+   * @param {{
+   *  did: string,
+   *  autoCheckUpdate: import('@abtnode/client').AutoCheckUpdate
+   * }} { did, autoCheckUpdate }
+   * @param {{}} context
+   * @memberof DiskBlockletManager
+   */
+  async updateAutoCheckUpdate({ did, autoCheckUpdate }, context) {
+    /** @type {import('@abtnode/client').AutoCheckUpdate} */
+    const value = { ...autoCheckUpdate };
+    await states.blockletExtras.setSettings(did, { autoCheckUpdate: value });
+    const jobId = getCheckUpdateJobId(did);
+    await this.checkUpdateQueue.delete(jobId);
+
+    logger.info('updateAutoCheckUpdate.$value', value);
+
+    if (value.enabled) {
+      this.checkUpdateQueue.push(
+        {
+          entity: 'blocklet',
+          action: 'autoCheckUpdate',
+          did,
+          context,
+        },
+        jobId,
+        true,
+        CHECK_UPDATE.JOB.DAY_INTERVAL
+      );
+    }
+  }
+
+  /**
+   * @description
+   * @param {import('@abtnode/client').RequestGetAutoCheckUpdateInput} { did }
+   * @return {Promise<import('@abtnode/client').AutoCheckUpdate>}
+   * @memberof DiskBlockletManager
+   */
+  getAutoCheckUpdate({ did }) {
+    return states.blockletExtras.getSettings(did, 'autoCheckUpdate', { enabled: false });
+  }
+
   /**
    * @description
    * @param {{ did: string }} { did }
@@ -2563,6 +2673,176 @@ class DiskBlockletManager extends BaseBlockletManager {
     }
   }
 
+  async _onCheckForComponentUpdate({ did }) {
+    const list = await UpgradeComponents.check({ did, states });
+    if (!list || !list.updateList?.length) {
+      return;
+    }
+    const updateList = list.updateList.map((item) => {
+      return { title: item.meta.title, description: item.meta.description, version: item.meta.version };
+    });
+
+    const checkUpdateMd5 = md5(JSON.stringify(updateList));
+    const oldMd5 = await states.blockletExtras.getSettings(did, 'checkUpdateMd5', '');
+    // notification has been sent, no more
+    if (checkUpdateMd5 === oldMd5) {
+      return;
+    }
+    const blocklet = await this.getBlocklet(did);
+    const firstComponent = updateList[0];
+    const blockletTitle = getDisplayName(blocklet);
+
+    const description = {
+      en: `${blockletTitle} has components with a new version: ${firstComponent.title} ${firstComponent.version} ${
+        updateList.length > 1 ? 'and more...' : '.'
+      }`,
+      zh: `${blockletTitle} 的组件有新版本: ${firstComponent.title} ${updateList.length > 1 ? '等等...' : '.'}`,
+    };
+    const title = {
+      en: `${blockletTitle} has components with a new version`,
+      zh: `${blockletTitle} 的组件有新版本`,
+    };
+    const body = {
+      en: `${blockletTitle} has new versions of the following components:`,
+      zh: `${blockletTitle} 以下组件有新版:`,
+    };
+    const button = {
+      en: 'Upgrade to new version',
+      zh: '升级到新版本',
+    };
+
+    const action = `/blocklets/${did}/components?checkUpdate=1`;
+    const blockletDashboardAction = '/.well-known/service/admin/components?checkUpdate=1';
+    const users = await this.teamManager.getOwnerAndAdminUsers(did, 1);
+    const nodeInfo = await states.node.read();
+    const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+
+    const attachments = [
+      {
+        type: 'section',
+        fields: updateList
+          .slice(0, 3)
+          .map((item) => {
+            return [
+              {
+                type: 'text',
+                data: { type: 'plain', color: '#9397A1', text: item.title },
+              },
+              {
+                type: 'text',
+                data: { type: 'plain', text: item.version },
+              },
+            ];
+          })
+          .flat(),
+      },
+    ];
+
+    try {
+      await this._sendAllMessageToUser({
+        did,
+        blocklet,
+        title,
+        body,
+        button,
+        attachments,
+        description,
+        action,
+        blockletDashboardAction,
+        sender: {
+          appDid: wallet.address,
+          appSk: wallet.secretKey,
+        },
+        users,
+      });
+      await states.blockletExtras.setSettings(did, { checkUpdateMd5 });
+    } catch (err) {
+      logger.error('send checked update email failed', { error: err });
+    }
+  }
+
+  /**
+   * @description send notification to multiple users, and send different notifications according to the user's own language
+   * @param {{
+   * did: string,
+   * blocklet: import('@abtnode/client').BlockletState,
+   * title: {zh: string, en: string},
+   * body: {zh: string, en: string},
+   * button: {zh: string, en: string},
+   * description: {zh: string, en: string},
+   * attachments: Array<import('@abtnode/client').NotificationAttachment>,
+   * action: string,
+   * blockletDashboardAction: string,
+   * sender: { appDid: string, appSk: string },
+   * users: Array<{ did: string, locale: string }>
+   * */
+  async _sendAllMessageToUser({
+    did,
+    blocklet,
+    title,
+    body,
+    button,
+    description,
+    attachments,
+    action,
+    blockletDashboardAction,
+    sender,
+    users,
+  }) {
+    this._createNotification(did, {
+      title: '',
+      description: description.en,
+      entityType: 'blocklet',
+      entityId: did,
+      severity: 'success',
+      action,
+      blockletDashboardAction,
+    });
+
+    const zhUsers = users.filter((x) => x.locale === 'zh');
+    const enUsers = users.filter((x) => x.locale !== 'zh');
+    const url = `http://${getDidDomainForBlocklet({
+      did: blocklet.appPid,
+    })}`;
+    const link = `${url}${blockletDashboardAction}`;
+
+    // send in batches by language
+    if (zhUsers.length) {
+      await sendToUser(
+        zhUsers.map((x) => x.did),
+        {
+          title: title.zh,
+          body: body.zh,
+          attachments,
+          actions: [
+            {
+              name: button.zh,
+              link,
+            },
+          ],
+        },
+        sender
+      );
+    }
+    if (enUsers.length) {
+      await sendToUser(
+        enUsers.map((x) => x.did),
+        {
+          title: title.en,
+          body: body.en,
+          attachments,
+          actions: [
+            {
+              name: button.en,
+              link,
+            },
+          ],
+        },
+        sender
+      );
+    }
+  }
+
   async getBlockletEnvironments(did) {
     const blockletWithEnv = await this.getBlocklet(did);
     const nodeInfo = await states.node.read();
@@ -3427,10 +3707,10 @@ class DiskBlockletManager extends BaseBlockletManager {
       if (!isExternal) {
         await states.notification.create({ ...notification, blockletUrl });
       }
-
       await this.teamManager.createNotification({
         teamDid: did,
         ...notification,
+        action: notification.blockletDashboardAction || notification.action,
         blockletUrl,
       });
     } catch (error) {

package/lib/index.js

@@ -162,6 +162,27 @@ function ABTNode(options) {
     },
   });
 
+  const checkUpdateQueue = createQueue({
+    daemon: options.daemon,
+    model: states.job,
+    name: 'check_update_queue',
+    onJob: async (job) => {
+      // eslint-disable-next-line no-use-before-define
+      if (typeof blockletManager.onJob === 'function') {
+        // eslint-disable-next-line no-use-before-define
+        await blockletManager.onJob(job);
+      }
+    },
+    options: {
+      concurrency,
+      maxRetries: 0,
+      retryDelay: 10000, // retry after 10 seconds
+      maxTimeout: 60 * 1000 * 60, // throw timeout error after 60 minutes
+      id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
+      enableScheduledJob: true,
+    },
+  });
+
   const certManager = new Cert({
     maintainerEmail: DEFAULT_CERTIFICATE_EMAIL,
     dataDir: dataDirs.certManagerModule,
@@ -188,6 +209,7 @@ function ABTNode(options) {
     installQueue,
     backupQueue,
     restoreQueue,
+    checkUpdateQueue,
     daemon: options.daemon,
     teamManager,
   });
@@ -330,6 +352,10 @@ function ABTNode(options) {
     // blocklet backup record
     getBlockletBackups: blockletManager.getBlockletBackups.bind(blockletManager),
 
+    // check update
+    updateAutoCheckUpdate: blockletManager.updateAutoCheckUpdate.bind(blockletManager),
+    getAutoCheckUpdate: blockletManager.getAutoCheckUpdate.bind(blockletManager),
+
     // Store
     getBlockletMeta: StoreUtil.getBlockletMeta,
     getStoreMeta: StoreUtil.getStoreMeta,

package/lib/states/user.js

@@ -235,7 +235,6 @@ class User extends ExtendBase {
     if (isNullOrUndefined(approved) === false) {
       condition.approved = !!approved;
     }
-
     return this.find({ where: condition, include: includeTags ? [this.getTagInclude()] : [] });
   }
 

package/lib/team/manager.js

@@ -7,6 +7,7 @@ const { EventEmitter } = require('events');
 const upperFirst = require('lodash/upperFirst');
 const get = require('lodash/get');
 const pick = require('lodash/pick');
+const { Op } = require('sequelize');
 
 const { createRBAC, MemoryStorage, SequelizeStorage } = require('@abtnode/rbac');
 const logger = require('@abtnode/logger')('@abtnode/core:team:manager');
@@ -453,6 +454,23 @@ class TeamManager extends EventEmitter {
   getPid(did) {
     return this.isNodeTeam(did) ? did : this.states.blocklet.getBlockletMetaDid(did);
   }
+
+  async getOwnerAndAdminUsers(did, approved) {
+    const passportState = await this.getPassportState(did);
+
+    const passorts = await passportState.find({
+      where: { [Op.or]: [{ role: 'owner' }, { role: 'admin' }] },
+      attributes: ['userDid'],
+    });
+    const userDids = passorts.map((d) => d.userDid);
+
+    const userState = await this.getUserState(did);
+    const users = await userState.find({
+      where: { did: userDids, approved },
+      attributes: ['did', 'locale'],
+    });
+    return users;
+  }
 }
 
 module.exports = TeamManager;

package/lib/util/log.js

@@ -87,15 +87,21 @@ class StreamLog {
 }
 
 const createFile = (files) => {
-  Object.values(files).forEach((file) => {
-    if (!fs.existsSync(file)) {
+  files.forEach((file) => {
+    const targetFile = typeof file === 'string' ? file : file.target;
+
+    if (!fs.existsSync(targetFile)) {
       try {
-        const dir = path.dirname(file);
+        const dir = path.dirname(targetFile);
         fs.mkdirSync(dir, { recursive: true });
       } catch (err) {
         // Do nothing
       }
-      fs.writeFileSync(file, '', 'utf8');
+      fs.writeFileSync(targetFile, '', 'utf8');
+    }
+
+    if (file.symbol && !fs.existsSync(file.symbol)) {
+      fs.symlinkSync(targetFile, file.symbol);
     }
   });
 };
@@ -112,25 +118,28 @@ const getLogFiles = async ({ name, node }) => {
   if (name === 'abtnode') {
     const logDir = path.join(node.dataDirs.logs, '_abtnode');
 
-    const info = path.join(logDir, `daemon-${date}.log`);
-    const error = path.join(logDir, `daemon-error-${date}.log`);
+    const infoSymbol = path.join(logDir, 'daemon.log');
+    const infoTarget = path.join(logDir, `daemon-${date}.log`);
+    const errorSymbol = path.join(logDir, 'daemon-error.log');
+    const errorTarget = path.join(logDir, `daemon-error-${date}.log`);
+
     const access = path.join(logDir, 'access.log');
     const stdout = path.join(logDir, 'daemon.stdout.log');
     const stderr = path.join(logDir, 'daemon.stderr.log');
     const pm2 = path.join(process.env.PM2_HOME, 'pm2.log');
 
-    createFile({
-      info,
-      error,
+    createFile([
+      { symbol: infoSymbol, target: infoTarget },
+      { symbol: errorSymbol, target: errorTarget },
       access,
       stdout,
       stderr,
       pm2,
-    });
+    ]);
 
     return {
-      info,
-      error,
+      info: infoSymbol,
+      error: errorSymbol,
       access,
       stdout,
       stderr,
@@ -140,13 +149,22 @@ const getLogFiles = async ({ name, node }) => {
 
   if (name === 'blocklet-services') {
     const logDir = path.join(node.dataDirs.logs, '_abtnode');
-    const info = path.join(logDir, 'service.log');
-    const error = path.join(logDir, 'service-error.log');
+    const infoSymbol = path.join(logDir, 'service.log');
+    const infoTarget = path.join(logDir, `service-${date}.log`);
+    const errorSymbol = path.join(logDir, 'service-error.log');
+    const errorTarget = path.join(logDir, `service-error-${date}.log`);
     const access = path.join(logDir, 'service.access.log');
     const stdout = path.join(logDir, 'service.stdout.log');
     const stderr = path.join(logDir, 'service.stderr.log');
-    createFile({ error, info, access, stdout, stderr });
-    return { error, info, access, stdout, stderr };
+    createFile([
+      { info: infoSymbol, target: infoTarget },
+      { symbol: errorSymbol, target: errorTarget },
+      access,
+      stdout,
+      stderr,
+    ]);
+
+    return { info: infoSymbol, error: errorSymbol, access, stdout, stderr };
   }
 
   if (name.indexOf('blocklet-') === 0) {
@@ -164,23 +182,25 @@ const getLogFiles = async ({ name, node }) => {
     }
 
     const dir = path.join(node.dataDirs.logs, blockletName);
-    const info = path.join(dir, `info-${date}.log`);
-    const error = path.join(dir, `info-error-${date}.log`);
+    const infoSymbol = path.join(dir, 'info.log');
+    const infoTarget = path.join(dir, `info-${date}.log`);
+    const errorSymbol = path.join(dir, 'info-error.log');
+    const errorTarget = path.join(dir, `info-error-${date}.log`);
     const access = path.join(dir, 'access.log');
     const stdout = path.join(dir, 'output.log');
     const stderr = path.join(dir, 'error.log');
 
-    createFile({
-      info,
-      error,
+    createFile([
+      { symbol: infoSymbol, target: infoTarget },
+      { symbol: errorSymbol, target: errorTarget },
       access,
       stdout,
       stderr,
-    });
+    ]);
 
     return {
-      info,
-      error,
+      info: infoSymbol,
+      error: errorSymbol,
       access,
       stdout,
       stderr,
@@ -343,6 +363,7 @@ const createStreamLogManager = ({ onLog, onGetLogFiles }) => {
       // update files
       // push recent 100 log
       const { recent = 100, ...logFiles } = await onGetLogFiles(name);
+
       const changed = await log.setFiles(logFiles);
       logger.info('log stream: added', { name, logFiles });
       log.getRecent(recent, (error, level, data) => {

package/lib/util/spaces.js

@@ -81,10 +81,20 @@ function getBackupJobId(did) {
   return `${did}.backupToSpaces`;
 }
 
+/**
+ * @description
+ * @param {string} did
+ * @return {string}
+ */
+function getCheckUpdateJobId(did) {
+  return `${did}.checkUpdate`;
+}
+
 module.exports = {
   getBackupEndpoint,
   getBackupFilesUrlFromEndpoint,
   getDIDSpacesUrlFromEndpoint,
   getSpaceNameByEndpoint,
   getBackupJobId,
+  getCheckUpdateJobId,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.21-beta-445a8baa",
+  "version": "1.16.21-beta-2e75c75c",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,39 +19,39 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.16.21-beta-445a8baa",
-    "@abtnode/auth": "1.16.21-beta-445a8baa",
-    "@abtnode/certificate-manager": "1.16.21-beta-445a8baa",
-    "@abtnode/constant": "1.16.21-beta-445a8baa",
-    "@abtnode/cron": "1.16.21-beta-445a8baa",
-    "@abtnode/logger": "1.16.21-beta-445a8baa",
-    "@abtnode/models": "1.16.21-beta-445a8baa",
-    "@abtnode/queue": "1.16.21-beta-445a8baa",
-    "@abtnode/rbac": "1.16.21-beta-445a8baa",
-    "@abtnode/router-provider": "1.16.21-beta-445a8baa",
-    "@abtnode/static-server": "1.16.21-beta-445a8baa",
-    "@abtnode/timemachine": "1.16.21-beta-445a8baa",
-    "@abtnode/util": "1.16.21-beta-445a8baa",
-    "@arcblock/did": "1.18.107",
-    "@arcblock/did-auth": "1.18.107",
-    "@arcblock/did-ext": "^1.18.107",
+    "@abtnode/analytics": "1.16.21-beta-2e75c75c",
+    "@abtnode/auth": "1.16.21-beta-2e75c75c",
+    "@abtnode/certificate-manager": "1.16.21-beta-2e75c75c",
+    "@abtnode/constant": "1.16.21-beta-2e75c75c",
+    "@abtnode/cron": "1.16.21-beta-2e75c75c",
+    "@abtnode/logger": "1.16.21-beta-2e75c75c",
+    "@abtnode/models": "1.16.21-beta-2e75c75c",
+    "@abtnode/queue": "1.16.21-beta-2e75c75c",
+    "@abtnode/rbac": "1.16.21-beta-2e75c75c",
+    "@abtnode/router-provider": "1.16.21-beta-2e75c75c",
+    "@abtnode/static-server": "1.16.21-beta-2e75c75c",
+    "@abtnode/timemachine": "1.16.21-beta-2e75c75c",
+    "@abtnode/util": "1.16.21-beta-2e75c75c",
+    "@arcblock/did": "1.18.108",
+    "@arcblock/did-auth": "1.18.108",
+    "@arcblock/did-ext": "^1.18.108",
     "@arcblock/did-motif": "^1.1.13",
-    "@arcblock/did-util": "1.18.107",
-    "@arcblock/event-hub": "1.18.107",
-    "@arcblock/jwt": "^1.18.107",
+    "@arcblock/did-util": "1.18.108",
+    "@arcblock/event-hub": "1.18.108",
+    "@arcblock/jwt": "^1.18.108",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/validator": "^1.18.107",
-    "@arcblock/vc": "1.18.107",
-    "@blocklet/constant": "1.16.21-beta-445a8baa",
-    "@blocklet/env": "1.16.21-beta-445a8baa",
-    "@blocklet/meta": "1.16.21-beta-445a8baa",
-    "@blocklet/resolver": "1.16.21-beta-445a8baa",
-    "@blocklet/sdk": "1.16.21-beta-445a8baa",
-    "@did-space/client": "^0.3.45",
+    "@arcblock/validator": "^1.18.108",
+    "@arcblock/vc": "1.18.108",
+    "@blocklet/constant": "1.16.21-beta-2e75c75c",
+    "@blocklet/env": "1.16.21-beta-2e75c75c",
+    "@blocklet/meta": "1.16.21-beta-2e75c75c",
+    "@blocklet/resolver": "1.16.21-beta-2e75c75c",
+    "@blocklet/sdk": "1.16.21-beta-2e75c75c",
+    "@did-space/client": "^0.3.49",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.107",
-    "@ocap/util": "1.18.107",
-    "@ocap/wallet": "1.18.107",
+    "@ocap/mcrypto": "1.18.108",
+    "@ocap/util": "1.18.108",
+    "@ocap/wallet": "1.18.108",
     "@slack/webhook": "^5.0.4",
     "archiver": "^5.3.1",
     "axios": "^0.27.2",
@@ -102,5 +102,5 @@
     "jest": "^27.5.1",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "7a7ff8be7f424775c3bde0eead773d8e6177fa1a"
+  "gitHead": "1fca0b58e1ed4f7a9bb268829a7c84290a01c89d"
 }