@abtnode/core 1.16.6-beta-4562aa60 → 1.16.6-beta-eaa4d39d

package/lib/api/team.js

@@ -110,6 +110,42 @@ class TeamAPI extends EventEmitter {
 
   // User && Invitation
 
+  async loginUser({ teamDid, user }) {
+    const state = await this.getUserState(teamDid);
+    const nodeInfo = await this.node.read();
+
+    if (user.role === ROLES.OWNER) {
+      if (teamDid !== nodeInfo.did) {
+        throw new Error('Cannot add user of owner role');
+      }
+
+      if (await state.count({ role: ROLES.OWNER })) {
+        throw new Error('The owner already exists');
+      }
+    }
+
+    const { _action, ...doc } = await state.login(user);
+    if (_action === 'update') {
+      logger.info('user updated successfully', { teamDid, userDid: user.did });
+      this.emit(EVENTS.USER_UPDATED, { teamDid, user: doc });
+    } else if (_action === 'add') {
+      if (teamDid === nodeInfo.did && nodeInfo.nodeOwner && user.did !== nodeInfo.nodeOwner.did) {
+        await this.notification.create({
+          title: 'New member join',
+          description: `User with Name (${user.fullName}) and DID (${user.did}) has joined this server`,
+          entityType: 'node',
+          action: '/team/members',
+          entityId: user.did,
+          severity: 'success',
+        });
+      }
+
+      logger.info('user added successfully', { teamDid, userDid: user.did, userPk: user.pk, userName: user.fullName });
+      this.emit(EVENTS.USER_ADDED, { teamDid, user: doc });
+    }
+    return doc;
+  }
+
   async addUser({ teamDid, user }) {
     const state = await this.getUserState(teamDid);
 
@@ -239,10 +275,10 @@ class TeamAPI extends EventEmitter {
     return res;
   }
 
-  async getUser({ teamDid, user }) {
+  async getUser({ teamDid, user, options = {} }) {
     const state = await this.getUserState(teamDid);
 
-    return state.getUser(user.did);
+    return state.getUser(user.did, options);
   }
 
   async getOwner({ teamDid }) {

package/lib/blocklet/manager/disk.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const flat = require('flat');
 const get = require('lodash/get');
+const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const merge = require('lodash/merge');
 const pick = require('lodash/pick');
@@ -61,6 +62,7 @@ const {
   BLOCKLET_META_FILE,
   BLOCKLET_CONFIGURABLE_KEY,
   RESTORE_PROGRESS_STATUS,
+  CHAIN_PROP_MAP_REVERSE,
 } = require('@blocklet/constant');
 const util = require('../../util');
 const {
@@ -79,6 +81,7 @@ const {
   getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   validateBlocklet,
+  validateBlockletChainInfo,
   statusMap,
   pruneBlockletBundle,
   getDiskInfo,
@@ -99,6 +102,8 @@ const {
   checkVersionCompatibility,
   getBlockletKnownAs,
   updateBlockletFallbackLogo,
+  ensureAppLogo,
+  getBlockletDidDomainList,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
@@ -106,7 +111,6 @@ const { get: getEngine } = require('./engine');
 const blockletPm2Events = require('./pm2-events');
 const runMigrationScripts = require('../migration');
 const hooks = require('../hooks');
-const { getDidDomainForBlocklet } = require('../../util/get-domain-for-blocklet');
 const handleInstanceInStore = require('../../util/public-to-store');
 const { BlockletRuntimeMonitor } = require('../../monitor/blocklet-runtime-monitor');
 const getHistoryList = require('../../monitor/get-history-list');
@@ -433,6 +437,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // validate requirement and engine
       await validateBlocklet(blocklet);
+      await validateBlockletChainInfo(blocklet);
 
       if (!hasRunnableComponent(blocklet)) {
         throw new Error('No runnable component found');
@@ -613,7 +618,7 @@ class BlockletManager extends BaseBlockletManager {
    * @memberof BlockletManager
    */
   // eslint-disable-next-line no-unused-vars
-  async restore(input, context) {
+  async restoreBlocklet(input, context) {
     const { from, ...param } = input;
     if (from === 'spaces') {
       return this._restoreFromSpaces(param, context);
@@ -999,7 +1004,6 @@ class BlockletManager extends BaseBlockletManager {
     return getBackupList(this.dataDirs.data);
   }
 
-  // CAUTION: this method currently only support config by blocklet.meta.did
   // eslint-disable-next-line no-unused-vars
   async config({ did, configs: newConfigs, skipHook, skipDidDocument }, context) {
     // todo: skipDidDocument will be deleted
@@ -1091,10 +1095,6 @@ class BlockletManager extends BaseBlockletManager {
       this.emit(BlockletEvents.spaceConnected, blocklet);
     }
 
-    if (willAppDidChange && !skipDidDocument) {
-      await this._updateDidDocument(blocklet);
-    }
-
     // update blocklet meta
     if (blocklet.structVersion && !childDids.length) {
       const changedTitle = newConfigs.find((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_NAME)?.value;
@@ -1113,11 +1113,20 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
+    // chain config
+    await this._ensureAppChainConfig(rootMetaDid, newConfigs);
+
     await this._updateBlockletEnvironment(rootDid);
 
     // response
     const newState = await this.getBlocklet(rootDid);
+
+    if (willAppDidChange && !skipDidDocument) {
+      await this._updateDidDocument(newState);
+    }
+
     this.emit(BlockletEvents.updated, newState);
+
     return newState;
   }
 
@@ -1962,13 +1971,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.info('blocklet installed', { source, did: meta.did });
 
       // logo
-      if (blocklet.source === BlockletSource.custom && blocklet.children[0]?.meta?.logo) {
-        const fileName = blocklet.children[0].meta.logo;
-        const src = path.join(getBundleDir(this.installDir, blocklet.children[0].meta), fileName);
-        const dist = path.join(getBundleDir(this.installDir, blocklet.meta), fileName);
-        await fs.copy(src, dist);
-      }
-
+      await ensureAppLogo(blocklet, this.installDir);
       await updateBlockletFallbackLogo(blocklet);
 
       // Init db
@@ -2275,12 +2278,12 @@ class BlockletManager extends BaseBlockletManager {
       const nodeInfo = await states.node.read();
       const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
       didDocument
-        .disableDNS({ wallet, didRegistryUrl: nodeInfo.didRegistry })
+        .disableBlockletDNS({ appPid: blocklet.appPid, wallet, didRegistryUrl: nodeInfo.didRegistry })
         .then(() => {
-          logger.info(`disabled blocklet ${blocklet.appDid} dns`);
+          logger.info(`disabled blocklet ${blocklet.appPid} dns`);
         })
         .catch((err) => {
-          logger.error(`disable blocklet ${blocklet.appDid} dns failed`, { error: err });
+          logger.error(`disable blocklet ${blocklet.appPid} dns failed`, { error: err });
         });
     }
 
@@ -2346,6 +2349,9 @@ class BlockletManager extends BaseBlockletManager {
 
         // write configs to db
         await states.blockletExtras.setConfigs([...ancestors.map((x) => x.meta.did), b.meta.did], environments);
+
+        // chain config
+        await this._ensureAppChainConfig(blocklet.meta.did, environments, 'name');
       });
     } else {
       const child = blocklet.children.find((x) => x.meta.did === childDid);
@@ -2354,6 +2360,9 @@ class BlockletManager extends BaseBlockletManager {
           [blocklet.meta.did, ...ancestors.map((x) => x.meta.did), b.meta.did],
           [...get(b.meta, 'environments', []), ...getConfigFromPreferences(child)]
         );
+
+        // chain config
+        await this._ensureAppChainConfig(blocklet.meta.did, get(b.meta, 'environments', []), 'name');
       });
     }
   }
@@ -2540,32 +2549,24 @@ class BlockletManager extends BaseBlockletManager {
   async _updateDidDocument(blocklet) {
     const nodeInfo = await states.node.read();
 
-    const { wallet } = getBlockletInfo(
-      {
-        meta: blocklet.meta,
-        environments: [BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK, BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_WALLET_TYPE]
-          .map((key) => ({ key, value: blocklet.configObj[key] }))
-          .filter((x) => x.value),
-      },
-      nodeInfo.sk
-    );
-    const didDomain = getDidDomainForBlocklet({ appPid: blocklet.appPid, didDomain: nodeInfo.didDomain });
-
     const domainAliases = (get(blocklet, 'site.domainAliases') || []).filter(
       (item) => !item.value.endsWith(nodeInfo.didDomain) && !item.value.endsWith('did.staging.arcblock.io') // did.staging.arcblock.io 是旧 did domain, 但主要存在于比较旧的节点中, 需要做兼容
     );
 
-    domainAliases.push({ value: didDomain, isProtected: true });
+    const didDomainList = getBlockletDidDomainList(blocklet, nodeInfo);
+    domainAliases.push(...didDomainList);
 
     //  先更新 routing rule db 中的 domain aliases, 这一步的目的是为了后面用
     await states.site.updateDomainAliasList(blocklet.site.id, domainAliases);
 
     this.emit(BlockletEvents.appDidChanged, blocklet);
 
+    const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+    const alsoKnownAs = getBlockletKnownAs(blocklet);
     await didDocument.updateBlockletDocument({
       wallet,
       appPid: blocklet.appPid,
-      alsoKnownAs: getBlockletKnownAs(blocklet),
+      alsoKnownAs,
       daemonDidDomain: util.getServerDidDomain(nodeInfo),
       didRegistryUrl: nodeInfo.didRegistry,
       domain: nodeInfo.didDomain,
@@ -2603,12 +2604,21 @@ class BlockletManager extends BaseBlockletManager {
   async _backupToSpaces({ blocklet }, context) {
     const userDid = context.user.did;
     const { referrer } = context;
-    const { appDid } = blocklet;
+    const {
+      appDid,
+      meta: { did: appPid },
+    } = blocklet;
 
-    const spacesBackup = new SpacesBackup({ appDid, event: this, userDid, referrer });
-    this.emit(BlockletEvents.backupProgress, { appDid, message: 'Start backup...', progress: 10, completed: false });
+    const spacesBackup = new SpacesBackup({ appDid, appPid, event: this, userDid, referrer });
+    this.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      message: 'Start backup...',
+      progress: 10,
+      completed: false,
+    });
     await spacesBackup.backup();
-    this.emit(BlockletEvents.backupProgress, { appDid, completed: true, progress: 100 });
+    this.emit(BlockletEvents.backupProgress, { appDid, meta: { did: appPid }, completed: true, progress: 100 });
   }
 
   /**
@@ -2634,11 +2644,17 @@ class BlockletManager extends BaseBlockletManager {
       await sleep(input.delay);
     }
 
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.start });
+    const appPid = input.appDid;
+
+    this.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: appPid },
+      status: RESTORE_PROGRESS_STATUS.start,
+    });
 
     const userDid = context.user.did;
 
-    const spacesRestore = new SpacesRestore({ ...input, event: this, userDid, referrer: context.referrer });
+    const spacesRestore = new SpacesRestore({ ...input, appPid, event: this, userDid, referrer: context.referrer });
     const params = await spacesRestore.restore();
 
     const removeRestoreDir = () => {
@@ -2702,6 +2718,21 @@ class BlockletManager extends BaseBlockletManager {
       throw error;
     }
   }
+
+  async _ensureAppChainConfig(metaDid, configs, key = 'key') {
+    const chainConfigs = configs.filter((x) => ['CHAIN_HOST', 'CHAIN_ID', 'CHAIN_TYPE'].includes(x[key]));
+    if (chainConfigs.length) {
+      const items = chainConfigs.map((x) => ({
+        ...omit(x, ['description', 'validation']),
+        [key]: CHAIN_PROP_MAP_REVERSE[x[key]],
+        shared: true,
+        secure: false,
+        required: false,
+        custom: false,
+      }));
+      await states.blockletExtras.setConfigs(metaDid, items);
+    }
+  }
 }
 
 module.exports = BlockletManager;

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

@@ -1,7 +1,7 @@
 const { BlockletStatus, BLOCKLET_MODES, fromBlockletStatus, BlockletSource } = require('@blocklet/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-app-dev');
-const { ensureMeta, updateBlockletFallbackLogo } = require('../../../util/blocklet');
+const { ensureMeta, updateBlockletFallbackLogo, ensureAppLogo } = require('../../../util/blocklet');
 
 /**
  *
@@ -79,10 +79,12 @@ const installApplicationFromDev = async ({ folder, meta, states, manager } = {})
 
   await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
-  blocklet = await manager.getBlocklet(did);
-
+  // logo
+  await ensureAppLogo(blocklet, manager.installDir);
   await updateBlockletFallbackLogo(blocklet);
 
+  blocklet = await manager.getBlocklet(did);
+
   return blocklet;
 };
 

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

@@ -117,6 +117,9 @@ const installComponentFromUrl = async ({
       }
 
       await states.blockletExtras.setConfigs([blocklet.meta.did, newChild.meta.did], configs);
+
+      // chain config
+      await manager._ensureAppChainConfig(blocklet.meta.did, configs);
     }
   } catch (err) {
     logger.error('Add component failed', err);

package/lib/blocklet/storage/backup/spaces.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {{
  *  appDid: string
+ *  appPid: string,
  *  event: import('events').EventEmitter,
  *  userDid: string,
  *  referrer: string,
@@ -147,6 +148,7 @@ class SpacesBackup extends BaseBackup {
   async export() {
     this.input.event.emit(BlockletEvents.backupProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       message: 'Preparing data for backup...',
       progress: 15,
       completed: false,
@@ -156,6 +158,7 @@ class SpacesBackup extends BaseBackup {
 
     this.input.event.emit(BlockletEvents.backupProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       message: 'Data ready, start backup...',
       progress: 20,
       completed: false,
@@ -193,11 +196,12 @@ class SpacesBackup extends BaseBackup {
           // FIXME: @yejianchao 这里需要更完整的黑名单
           return object.name !== '.DS_Store';
         },
-        onProgress: (data) => {
+        onAfterUpload: (data) => {
           logger.info('backup progress', { appDid: this.input.appDid, data });
           const percent = (data.completed * 100) / data.total;
           this.input.event.emit(BlockletEvents.backupProgress, {
             appDid: this.input.appDid,
+            meta: { did: this.input.appDid },
             message: `Uploading file ${basename(data.key)} (${data.completed}/${data.total})`,
             // 0.8 是因为上传文件到 spaces 占进度的 80%，+ 20 是因为需要累加之前的进度
             progress: +Math.ceil(percent * 0.8).toFixed(2) + 20,

package/lib/blocklet/storage/restore/spaces.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {{
  *  appDid: string; // --> appDid
+ *  appPid: string;
  *  endpoint: string;
  *  password: Buffer; // derived from (appSk, appDid)
  *  delegation: string; // from appDid --> serverDid for downloading
@@ -118,10 +119,11 @@ class SpacesRestore extends BaseRestore {
         debug: true,
         concurrency: 32,
         retryCount: 10,
-        onProgress: (data) => {
+        onAfterUpload: (data) => {
           logger.info('restore progress', { appDid: this.input.appDid, data });
           this.input.event.emit(BlockletEvents.restoreProgress, {
             appDid: this.input.appDid,
+            meta: { did: this.input.appPid },
             status: RESTORE_PROGRESS_STATUS.downloading,
             data,
           });
@@ -140,6 +142,7 @@ class SpacesRestore extends BaseRestore {
   async import(params) {
     this.input.event.emit(BlockletEvents.restoreProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       status: RESTORE_PROGRESS_STATUS.importData,
     });
 
@@ -150,6 +153,7 @@ class SpacesRestore extends BaseRestore {
     );
     this.input.event.emit(BlockletEvents.restoreProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       status: RESTORE_PROGRESS_STATUS.importDataSuccess,
     });
   }

package/lib/crons/check-new-version.js

@@ -0,0 +1,68 @@
+/* eslint-disable no-param-reassign */
+const semver = require('semver');
+const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
+const logger = require('@abtnode/logger')('@abtnode/core:maintain');
+
+const states = require('../states');
+
+// eslint-disable-next-line no-unused-vars
+const checkNewVersion = async (params, context) => {
+  try {
+    const info = await states.node.read();
+
+    if (!process.env.ABT_NODE_PACKAGE_NAME) {
+      logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
+      return '';
+    }
+
+    const versions = await listNpmPackageVersion(process.env.ABT_NODE_PACKAGE_NAME, {
+      includePrereleases: !!info.enableBetaRelease,
+    });
+    if (Array.isArray(versions) && versions.length) {
+      const latestVersionStr = versions[0].version;
+      const latestVersion = semver.coerce(latestVersionStr);
+      const currentVersion = semver.coerce(info.version);
+      if (latestVersionStr !== info.version && semver.gte(latestVersion, currentVersion)) {
+        logger.info('New version found for Blocklet Server', {
+          latestVersion: latestVersionStr,
+          currentVersion: info.version,
+          nextVersion: info.nextVersion,
+        });
+        await states.node.updateNodeInfo({ nextVersion: latestVersionStr });
+        await states.notification.create({
+          title: 'Blocklet Server upgrade available',
+          description: 'A new and improved version of blocklet server is now available',
+          entityType: 'node',
+          severity: 'info',
+          sticky: true,
+          action: '/settings/about',
+        });
+
+        return latestVersionStr;
+      }
+    }
+
+    return '';
+  } catch (err) {
+    logger.error('Failed to check new version for Blocklet Server', { error: err });
+  }
+
+  return '';
+};
+
+const getCron = () => ({
+  name: 'check-new-version',
+  time: '0 0 8 * * *', // check every day
+  // time: '0 */5 * * * *', // check every 5 minutes
+  fn: async () => {
+    const info = await states.node.read();
+    if (!info.autoUpgrade) {
+      return;
+    }
+
+    checkNewVersion();
+  },
+  options: { runOnInit: false },
+});
+
+module.exports = { getCron, checkNewVersion };

package/lib/{util/disk-monitor.js → crons/monitor-disk-usage.js}

@@ -1,5 +1,5 @@
 const logger = require('@abtnode/logger')('@abtnode/disk-monitor');
-const info = require('./sysinfo');
+const info = require('../util/sysinfo');
 
 const states = require('../states');
 
@@ -29,7 +29,7 @@ const check = async (threshold) => {
 };
 
 const getCron = () => ({
-  name: 'disk-monitor',
+  name: 'monitor-disk-usage',
   time: '0 5 * * * *', // check every hour
   fn: async () => {
     const nodeInfo = await states.node.read();

package/lib/crons/rotate-pm2-logs/index.js

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+const path = require('path');
+const spawn = require('cross-spawn');
+const { LOG_RETAIN_IN_DAYS } = require('@abtnode/constant');
+
+const getCron = () => ({
+  name: 'rotate-pm2-logs',
+  time: '0 0 * * *', // default : every day at midnight
+  options: { runOnInit: false },
+  fn: async () => {
+    console.info(`Log rotator started on ${new Date().toISOString()}`);
+    const child = spawn('node', [path.join(__dirname, './script.js')], {
+      detached: true,
+      windowsHide: true, // required for Windows
+      cwd: process.cwd(),
+      timeout: 30 * 60 * 1000, // 30 minutes
+      shell: process.env.SHELL || false,
+      stdio: ['ignore', process.stdout, process.stderr],
+      env: {
+        PATH: process.env.PATH,
+        PM2_HOME: process.env.PM2_HOME,
+        COMPRESS: true,
+        RETAIN: LOG_RETAIN_IN_DAYS,
+      },
+    });
+
+    child.on('error', (err) => {
+      console.error('Log rotator errored', err);
+    });
+
+    child.on('close', (code) => {
+      console.info(`Log rotator exited with code ${code} on ${new Date().toISOString()}`);
+    });
+
+    child.unref();
+  },
+});
+
+module.exports = {
+  getCron,
+};

package/lib/crons/rotate-pm2-logs/script.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-console */
+const pm2 = require('@abtnode/util/lib/async-pm2');
+
+const LogRotator = require('../../util/rotator');
+
+const RETAIN = parseInt(process.env.RETAIN || '', 10);
+const COMPRESS = JSON.parse(process.env.COMPRESS || 'false');
+const DATE_FORMAT = process.env.DATE_FORMAT || 'YYYY-MM-DD';
+const { TZ } = process.env;
+
+const logRotate = new LogRotator({ compress: COMPRESS, dateFormat: DATE_FORMAT, tz: TZ, retain: RETAIN });
+
+// register the cron to force rotate file
+console.info('Start rotating pm2 logs...');
+
+// get list of process managed by pm2
+pm2.connect((err) => {
+  if (err) {
+    console.error('Can not connect to pm2 daemon', err);
+    process.exit(1);
+  }
+
+  // eslint-disable-next-line no-shadow
+  pm2.list(async (err, apps) => {
+    if (err) {
+      console.error('Can not list apps from pm2', err);
+      process.exit(1);
+    }
+
+    const appMap = {};
+
+    // force rotate for each app
+    await Promise.allSettled(
+      apps.map((app) => {
+        // if apps instances are multi and one of the instances has rotated, ignore
+        if (app.pm2_env.instances > 1 && appMap[app.name]) {
+          return Promise.resolve(true);
+        }
+
+        appMap[app.name] = app;
+
+        return logRotate
+          .proceedPm2App(app)
+          .then(() => {
+            console.info(`Rotate ${app.name} log files succeed`);
+          })
+          .catch((error) => {
+            console.error(`Rotate ${app.name} log files failed`, { error });
+          });
+      })
+    );
+
+    console.info('Done rotating pm2 logs...');
+    process.exit(0);
+  });
+});

package/lib/index.js

@@ -24,7 +24,9 @@ const IP = require('./util/ip');
 const DomainStatus = require('./util/domain-status');
 const Maintain = require('./util/maintain');
 const resetNode = require('./util/reset-node');
-const DiskMonitor = require('./util/disk-monitor');
+const DiskMonitor = require('./crons/monitor-disk-usage');
+const LogRotator = require('./crons/rotate-pm2-logs');
+const VersionChecker = require('./crons/check-new-version');
 const StoreUtil = require('./util/store');
 const createQueue = require('./util/queue');
 const createEvents = require('./event');
@@ -235,7 +237,7 @@ function ABTNode(options) {
     updateComponentTitle: blockletManager.updateComponentTitle.bind(blockletManager),
     updateComponentMountPoint: blockletManager.updateComponentMountPoint.bind(blockletManager),
     backupBlocklet: blockletManager.backup.bind(blockletManager),
-    restoreBlocklet: blockletManager.restore.bind(blockletManager),
+    restoreBlocklet: blockletManager.restoreBlocklet.bind(blockletManager),
     migrateApplicationToStructV2: blockletManager.migrateApplicationToStructV2.bind(blockletManager),
 
     // For diagnose purpose
@@ -301,6 +303,7 @@ function ABTNode(options) {
     getNodeUsers: () => teamAPI.getUsers({ teamDid: options.nodeDid }),
     getNodeUser: (user) => teamAPI.getUser({ teamDid: options.nodeDid, user }),
     addUser: teamAPI.addUser.bind(teamAPI),
+    loginUser: teamAPI.loginUser.bind(teamAPI),
     removeUser: teamAPI.removeUser.bind(teamAPI),
     updateUser: teamAPI.updateUser.bind(teamAPI),
     updateUserApproval: teamAPI.updateUserApproval.bind(teamAPI),
@@ -402,8 +405,8 @@ function ABTNode(options) {
     markMigrationExecuted: states.migration.markExecuted.bind(states.migration),
 
     // Upgrading
+    checkNodeVersion: VersionChecker.checkNewVersion,
     upgradeNodeVersion: () => Maintain.triggerMaintain({ action: 'upgrade', next: Maintain.resumeMaintain }),
-    checkNodeVersion: Maintain.checkNewVersion,
     restartServer: () => Maintain.triggerMaintain({ action: 'restart', next: Maintain.resumeMaintain }),
     isBeingMaintained: Maintain.isBeingMaintained,
     resumeMaintain: Maintain.resumeMaintain,
@@ -452,10 +455,11 @@ function ABTNode(options) {
       context: { states, events, webhook },
       jobs: [
         IP.cron,
-        Maintain.getCron(),
+        VersionChecker.getCron(),
         ...getRoutingCrons(),
         ...blockletManager.getCrons(),
         DiskMonitor.getCron(),
+        LogRotator.getCron(),
         ...getStateCrons(states),
         ...nodeAPI.getCrons(),
       ],