@abtnode/core 1.16.7 → 1.16.8-beta-0c0c5eb2

package/lib/blocklet/manager/disk.js

@@ -128,6 +128,8 @@ const UpgradeComponents = require('./helper/upgrade-components');
 const BlockletDownloader = require('../downloader/blocklet-downloader');
 const RollbackCache = require('./helper/rollback-cache');
 const { migrateApplicationToStructV2 } = require('./helper/migrate-application-to-struct-v2');
+const { getBackupFilesUrlFromEndpoint, getDIDSpaceBackupEndpoint } = require('../../util/spaces');
+const { validateAddSpaceGateway, validateUpdateSpaceGateway } = require('../../validators/space-gateway');
 
 const { formatEnvironments, shouldUpdateBlockletStatus, getBlockletMeta, validateOwner } = util;
 
@@ -195,9 +197,19 @@ const MONITOR_HISTORY_LENGTH = 86400 / MONITOR_RECORD_INTERVAL_SEC;
 
 class BlockletManager extends BaseBlockletManager {
   /**
-   * @param {*} dataDirs generate by ../../util:getDataDirs
+   * Creates an instance of BlockletManager.
+   * @param {{
+   *  dataDirs: ReturnType<typeof import('../../util/index').getDataDirs>,
+   *  startQueue: ReturnType<typeof import('../../util/queue')>,
+   *  installQueue: ReturnType<typeof import('../../util/queue')>,
+   *  backupQueue: ReturnType<typeof import('../../util/queue')>,
+   *  restoreQueue: ReturnType<typeof import('../../util/queue')>,
+   *  daemon: boolean
+   *  teamManager: import('../../team/manager.js')
+   * }} { dataDirs, startQueue, installQueue, backupQueue, restoreQueue, daemon = false, teamManager }
+   * @memberof BlockletManager
    */
-  constructor({ dataDirs, startQueue, installQueue, backupQueue, daemon = false, teamManager }) {
+  constructor({ dataDirs, startQueue, installQueue, backupQueue, restoreQueue, daemon = false, teamManager }) {
     super();
 
     this.dataDirs = dataDirs;
@@ -205,6 +217,7 @@ class BlockletManager extends BaseBlockletManager {
     this.startQueue = startQueue;
     this.installQueue = installQueue;
     this.backupQueue = backupQueue;
+    this.restoreQueue = restoreQueue;
     this.teamManager = teamManager;
 
     // cached installed blocklets for performance
@@ -607,7 +620,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     if (to === 'spaces') {
-      return this._backupToSpaces({ blocklet }, context);
+      return this._backupToSpaces({ blocklet, context });
     }
 
     if (to === 'disk') {
@@ -1097,7 +1110,7 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // Reload nginx to make sure did-space can embed content from this app
-    if (newConfigs.find((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACE_ENDPOINT)?.value) {
+    if (newConfigs.find((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT)?.value) {
       this.emit(BlockletEvents.spaceConnected, blocklet);
     }
 
@@ -1222,6 +1235,7 @@ class BlockletManager extends BaseBlockletManager {
     return newState;
   }
 
+  // TODO: this method can be removed if title is not changed anymore
   async updateComponentTitle({ did, rootDid: inputRootDid, title }) {
     await titleSchema.validateAsync(title);
 
@@ -1367,6 +1381,16 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     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;
+      }
+
       const status = await getBlockletStatusFromProcess(blocklet);
       if (blocklet.status !== status) {
         const res = await states.blocklet.setBlockletStatus(did, status);
@@ -1406,6 +1430,15 @@ class BlockletManager extends BaseBlockletManager {
     });
   }
 
+  /**
+   * @description
+   * @param {{
+   *  entity: string;
+   *  action: string;
+   *  id: string;
+   * }} job
+   * @memberof BlockletManager
+   */
   async onJob(job) {
     if (job.entity === 'blocklet') {
       if (job.action === 'download') {
@@ -1418,6 +1451,14 @@ class BlockletManager extends BaseBlockletManager {
       if (job.action === 'check_if_started') {
         await this._onCheckIfStarted(job);
       }
+
+      if (job.action === 'backupToSpaces') {
+        await this._onBackupToSpaces(job);
+      }
+
+      if (job.action === 'restoreFromSpaces') {
+        await this._onRestoreFromSpaces(job);
+      }
     }
   }
 
@@ -1461,6 +1502,100 @@ class BlockletManager extends BaseBlockletManager {
     ];
   }
 
+  /**
+   * @description
+   * @param {{
+   *  did: import('@abtnode/client').RequestAddBlockletSpaceGatewayInput,
+   *  spaceGateway: import('@abtnode/client').SpaceGateway
+   * }} { did, spaceGateway }
+   * @return {Promise<void>}
+   * @memberof BlockletManager
+   */
+  async addBlockletSpaceGateway({ did, spaceGateway }) {
+    const spaceGateways = await this.getBlockletSpaceGateways({ did });
+
+    const { error, value } = validateAddSpaceGateway.validate(spaceGateway, {
+      stripUnknown: true,
+      allowUnknown: true,
+    });
+
+    if (error) {
+      throw error;
+    }
+
+    spaceGateways.push(value);
+
+    await states.blockletExtras.setSettings(did, { spaceGateways });
+  }
+
+  /**
+   * @description
+   * @param {import('@abtnode/client').RequestAddBlockletSpaceGatewayInput} { did, spaceGateway }
+   * @return {Promise<void>}
+   * @memberof BlockletManager
+   */
+  async deleteBlockletSpaceGateway({ did, url }) {
+    const spaceGateways = await this.getBlockletSpaceGateways({ did });
+
+    const latestSpaceGateways = spaceGateways.filter((s) => s?.url !== url);
+
+    await states.blockletExtras.setSettings(did, { spaceGateways: latestSpaceGateways });
+  }
+
+  /**
+   * @description
+   * @param {{
+   *  did: string,
+   *  where: import('@abtnode/client').SpaceGateway
+   *  spaceGateway: import('@abtnode/client').SpaceGateway
+   * }} { did, spaceGateway }
+   * @return {Promise<void>}
+   * @memberof BlockletManager
+   */
+  async updateBlockletSpaceGateway({ did, where, spaceGateway }) {
+    const { error, value } = validateUpdateSpaceGateway.validate(spaceGateway, {
+      stripUnknown: true,
+      allowUnknown: true,
+    });
+
+    if (error) {
+      throw error;
+    }
+
+    const spaceGateways = await this.getBlockletSpaceGateways({ did });
+
+    for (const s of spaceGateways) {
+      if (s.url === where?.url) {
+        Object.assign(s, value);
+        break;
+      }
+    }
+
+    await states.blockletExtras.setSettings(did, { spaceGateways });
+  }
+
+  /**
+   * @description
+   * @param {{ did: string }} { did }
+   * @return {Promise<Array<import('@abtnode/client').SpaceGateway>>}
+   * @memberof BlockletManager
+   */
+  async getBlockletSpaceGateways({ did }) {
+    const spaceGateways = await states.blockletExtras.getSettings(did, 'spaceGateways', []);
+
+    return spaceGateways;
+  }
+
+  /**
+   * @description
+   * @param {{ did: string }} { did }
+   * @return {Promise<Array<import('@abtnode/client').Backup>>}
+   * @memberof BlockletManager
+   */
+  async getBlockletBackups({ did }) {
+    return states.backup.getBlockletBackups({ did });
+  }
+
   // ============================================================================================
   // Private API that are used by self of helper function
   // ============================================================================================
@@ -1721,6 +1856,127 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
+  /**
+   * FIXME: @wangshijun create audit log for this
+   * @param {{
+   *  blocklet: import('@abtnode/client').BlockletState,
+   *  context: {
+   *    referrer: string;
+   *    user: {
+   *      did: string;
+   *    }
+   *  }
+   * }} { blocklet, context }
+   * @memberof BlockletManager
+   */
+  async _onBackupToSpaces({ blocklet, context, backup }) {
+    const {
+      referrer,
+      user: { did: userDid },
+    } = context;
+    const {
+      appDid,
+      meta: { did: appPid },
+    } = blocklet;
+
+    try {
+      const spacesBackup = new SpacesBackup({ appDid, appPid, event: this, userDid, referrer, locale: 'en' });
+      this.emit(BlockletEvents.backupProgress, {
+        appDid,
+        meta: { did: appPid },
+        message: 'Start backup...',
+        progress: 10,
+        completed: false,
+      });
+      await spacesBackup.backup();
+
+      await states.backup.success(backup._id, {
+        targetUrl: getBackupFilesUrlFromEndpoint(getDIDSpaceBackupEndpoint(blocklet?.environments)),
+      });
+
+      // 备份成功了
+      this.emit(BlockletEvents.backupProgress, { appDid, meta: { did: appPid }, completed: true, progress: 100 });
+    } catch (error) {
+      await states.backup.fail(backup._id, {
+        message: error?.message,
+      });
+      this.emit(BlockletEvents.backupProgress, {
+        appDid,
+        meta: { did: appPid },
+        completed: true,
+        progress: -1,
+        message: error?.message,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * FIXME: @linchen support cancel
+   * FIXME: @wangshijun create audit log for this
+   * @param {{
+   *  input: import('@abtnode/client').RequestRestoreBlockletInput,
+   *  context: Record<string, string>,
+   * }} {input, context}
+   * @memberof BlockletManager
+   */
+  // eslint-disable-next-line no-unused-vars
+  async _onRestoreFromSpaces({ input, context }) {
+    if (input.delay) {
+      await sleep(input.delay);
+    }
+
+    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, appPid, event: this, userDid, referrer: context.referrer });
+    const params = await spacesRestore.restore();
+
+    const removeRestoreDir = () => {
+      if (fs.existsSync(spacesRestore.restoreDir)) {
+        fs.remove(spacesRestore.restoreDir).catch((err) => {
+          logger.error('failed to remove restore dir', { error: err, dir: spacesRestore.restoreDir });
+        });
+      }
+    };
+
+    this.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: appPid },
+      status: RESTORE_PROGRESS_STATUS.installing,
+    });
+
+    try {
+      await installApplicationFromBackup({
+        url: `file://${spacesRestore.restoreDir}`,
+        moveDir: true,
+        ...merge(...params),
+        manager: this,
+        states,
+        controller: input.controller,
+        context: { ...context, startImmediately: true },
+      });
+
+      removeRestoreDir();
+    } catch (error) {
+      removeRestoreDir();
+      throw error;
+    }
+
+    this.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: appPid },
+      status: RESTORE_PROGRESS_STATUS.completed,
+    });
+  }
+
   async _updateBlockletEnvironment(did) {
     const blockletWithEnv = await this.getBlocklet(did);
     const blocklet = await states.blocklet.getBlocklet(did);
@@ -2641,28 +2897,45 @@ class BlockletManager extends BaseBlockletManager {
 
   /**
    * FIXME: @wangshijun create audit log for this
-   * @param {import('@abtnode/client').BlockletState} blocklet
+   * @param {{
+   *  blocklet: import('@abtnode/client').BlockletState,
+   *  context: {
+   *    referrer: string;
+   *    user: {
+   *      did: string;
+   *    }
+   *  }
+   * }} { blocklet, context }
    * @memberof BlockletManager
    */
   // eslint-disable-next-line no-unused-vars
-  async _backupToSpaces({ blocklet }, context) {
-    const userDid = context.user.did;
-    const { referrer } = context;
+  async _backupToSpaces({ blocklet, context }) {
+    const {
+      user: { did: userDid },
+    } = context;
     const {
       appDid,
       meta: { did: appPid },
     } = blocklet;
 
-    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,
+    const backup = await states.backup.start({
+      appPid,
+      userDid,
+      strategy: 1,
+      sourceUrl: path.join(this.dataDirs.tmp, 'backup', appDid),
     });
-    await spacesBackup.backup();
-    this.emit(BlockletEvents.backupProgress, { appDid, meta: { did: appPid }, completed: true, progress: 100 });
+
+    this.backupQueue.push(
+      {
+        entity: 'blocklet',
+        action: 'backupToSpaces',
+        id: appDid,
+        blocklet,
+        context,
+        backup,
+      },
+      appDid
+    );
   }
 
   /**
@@ -2690,45 +2963,16 @@ class BlockletManager extends BaseBlockletManager {
 
     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, appPid, event: this, userDid, referrer: context.referrer });
-    const params = await spacesRestore.restore();
-
-    const removeRestoreDir = () => {
-      if (fs.existsSync(spacesRestore.restoreDir)) {
-        fs.remove(spacesRestore.restoreDir).catch((err) => {
-          logger.error('failed to remove restore dir', { error: err, dir: spacesRestore.restoreDir });
-        });
-      }
-    };
-
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.installing });
-
-    try {
-      await installApplicationFromBackup({
-        url: `file://${spacesRestore.restoreDir}`,
-        moveDir: true,
-        ...merge(...params),
-        manager: this,
-        states,
-        controller: input.controller,
-        context: { ...context, startImmediately: true },
-      });
-
-      removeRestoreDir();
-    } catch (error) {
-      removeRestoreDir();
-      throw error;
-    }
-
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.completed });
+    this.restoreQueue.push(
+      {
+        entity: 'blocklet',
+        action: 'restoreFromSpaces',
+        id: appPid,
+        input,
+        context,
+      },
+      appPid
+    );
   }
 
   async _restoreFromDisk(input) {

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

@@ -5,6 +5,7 @@
  *  event: import('events').EventEmitter,
  *  userDid: string,
  *  referrer: string,
+ *  locale: 'zh' | 'en',
  * }} SpaceBackupInput
  *
  * @typedef {{
@@ -18,7 +19,7 @@
 const { isValid } = require('@arcblock/did');
 const { BLOCKLET_CONFIGURABLE_KEY, BlockletEvents } = require('@blocklet/constant');
 const { SpaceClient, BackupBlockletCommand } = require('@did-space/client');
-const { ensureDirSync } = require('fs-extra');
+const { ensureDirSync, existsSync, remove } = require('fs-extra');
 const { isEmpty } = require('lodash');
 const { join, basename } = require('path');
 const { getAppName, getAppDescription } = require('@blocklet/meta/lib/util');
@@ -33,6 +34,7 @@ const { BlockletExtrasBackup } = require('./blocklet-extras');
 const { BlockletsBackup } = require('./blocklets');
 const { DataBackup } = require('./data');
 const { RoutingRuleBackup } = require('./routing-rule');
+const { translate } = require('../../../locales');
 
 class SpacesBackup extends BaseBackup {
   /**
@@ -70,7 +72,7 @@ class SpacesBackup extends BaseBackup {
    * @type {string}
    * @memberof SpacesBackup
    */
-  spaceEndpoint;
+  spaceBackupEndpoint;
 
   /**
    *
@@ -123,6 +125,7 @@ class SpacesBackup extends BaseBackup {
     await this.initialize();
     await this.export();
     await this.syncToSpaces();
+    await this.destroy();
   }
 
   async initialize() {
@@ -135,10 +138,10 @@ class SpacesBackup extends BaseBackup {
     this.backupDir = join(this.serverDir, 'tmp/backup', this.blocklet.appDid);
     ensureDirSync(this.backupDir);
 
-    this.spaceEndpoint = this.blocklet.environments.find(
-      (e) => e.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACE_ENDPOINT
+    this.spaceBackupEndpoint = this.blocklet.environments.find(
+      (e) => e.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT
     )?.value;
-    if (isEmpty(this.spaceEndpoint)) {
+    if (isEmpty(this.spaceBackupEndpoint)) {
       throw new Error('spaceEndpoint cannot be empty');
     }
 
@@ -173,12 +176,12 @@ class SpacesBackup extends BaseBackup {
     const serverDid = node.did;
 
     const spaceClient = new SpaceClient({
-      endpoint: this.spaceEndpoint,
+      endpoint: this.spaceBackupEndpoint,
       wallet: this.securityContext.signer,
       delegation: this.securityContext.delegation,
     });
 
-    const { errorCount, message } = await spaceClient.send(
+    const { errorCount, message, statusCode } = await spaceClient.send(
       new BackupBlockletCommand({
         appDid: this.blocklet.appDid,
         appName: getAppName(this.blocklet),
@@ -204,7 +207,7 @@ class SpacesBackup extends BaseBackup {
             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,
+            progress: +Math.floor(percent * 0.8).toFixed(2) + 20,
             completed: false,
           });
         },
@@ -212,7 +215,20 @@ class SpacesBackup extends BaseBackup {
     );
 
     if (errorCount !== 0) {
-      throw new Error(`Sync to spaces encountered error: ${message}`);
+      const { locale } = this.input;
+      // @FIXME: get locale @jianchao
+      if (statusCode === 403) {
+        throw new Error(
+          `${translate(locale, 'backup.space.error.title')}: ${translate(locale, 'backup.space.error.forbidden')}`
+        );
+      }
+      throw new Error(`${translate(locale, 'backup.space.error.title')}: ${message}`);
+    }
+  }
+
+  async destroy() {
+    if (existsSync(this.backupDir)) {
+      await remove(this.backupDir);
     }
   }
 }

package/lib/event.js

@@ -1,7 +1,7 @@
 const get = require('lodash/get');
 const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
-const { wipeSensitiveData, isBeforeInstalled } = require('@blocklet/meta/lib/util');
+const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
 const { BLOCKLET_MODES, BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/constant');
 const { EVENTS } = require('@abtnode/constant');
@@ -262,15 +262,9 @@ module.exports = ({
     }
 
     if (
-      [
-        BlockletEvents.started,
-        BlockletEvents.startFailed,
-        BlockletEvents.stopped,
-        BlockletEvents.reloaded,
-        BlockletEvents.statusChange,
-      ].includes(eventName) &&
-      blocklet.status &&
-      !isBeforeInstalled(blocklet.status)
+      [BlockletEvents.started, BlockletEvents.startFailed, BlockletEvents.stopped, BlockletEvents.reloaded].includes(
+        eventName
+      )
     ) {
       try {
         await blockletManager.runtimeMonitor.monit(blocklet.meta.did);

package/lib/index.js

@@ -118,9 +118,29 @@ function ABTNode(options) {
     },
     options: {
       concurrency,
-      maxRetries: 3,
+      // 备份自带重试机制
+      maxRetries: 0,
       retryDelay: 10000, // retry after 10 seconds
-      maxTimeout: 60 * 1000 * 30, // throw timeout error after 30 minutes
+      maxTimeout: 60 * 1000 * 60, // throw timeout error after 60 minutes
+      id: (job) => (job ? md5(`${job.entity}-${job.action}-${job.id}`) : ''),
+    },
+  });
+
+  const restoreQueue = createQueue({
+    daemon: options.daemon,
+    name: 'restore_queue',
+    dataDir: dataDirs.core,
+    onJob: async (job) => {
+      if (typeof blockletManager.onJob === 'function') {
+        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}`) : ''),
     },
   });
@@ -151,6 +171,7 @@ function ABTNode(options) {
     startQueue,
     installQueue,
     backupQueue,
+    restoreQueue,
     daemon: options.daemon,
     teamManager,
   });
@@ -255,6 +276,15 @@ function ABTNode(options) {
     updateBlockletOwner: blockletManager.updateOwner.bind(blockletManager),
     getBlockletRuntimeHistory: blockletManager.getRuntimeHistory.bind(blockletManager),
 
+    // blocklet spaces gateways
+    addBlockletSpaceGateway: blockletManager.addBlockletSpaceGateway.bind(blockletManager),
+    deleteBlockletSpaceGateway: blockletManager.deleteBlockletSpaceGateway.bind(blockletManager),
+    updateBlockletSpaceGateway: blockletManager.updateBlockletSpaceGateway.bind(blockletManager),
+    getBlockletSpaceGateways: blockletManager.getBlockletSpaceGateways.bind(blockletManager),
+
+    // blocklet backup record
+    getBlockletBackups: blockletManager.getBlockletBackups.bind(blockletManager),
+
     // Store
     getBlockletMeta: StoreUtil.getBlockletMeta,
     getStoreMeta: StoreUtil.getStoreMeta,

package/lib/locales/en.js

@@ -4,4 +4,13 @@ module.exports = flat({
   registry: {
     getListError: 'Get Blocklet list from registry "{registryUrl}" failed.',
   },
+  backup: {
+    space: {
+      error: {
+        title: 'Backup to spaces encountered error',
+        forbidden:
+          'You do not have permission to perform the backup, try restoring the application license on DID Spaces or reconnect to DID Spaces and try again',
+      },
+    },
+  },
 });

package/lib/locales/index.js

@@ -10,6 +10,13 @@ const replace = (template, data) =>
   template.replace(/{(\w*)}/g, (_, key) => (Object.prototype.hasOwnProperty.call(data, key) ? data[key] : ''));
 
 module.exports = {
+  /**
+   *
+   * @param {'zh' | 'en'} locale
+   * @param {string} key
+   * @param {Record<string, string>} data
+   * @returns {string}
+   */
   translate: (locale, key, data) => {
     if (tranlations.has(locale)) {
       return replace(tranlations.get(locale)[key], data);

package/lib/locales/zh.js

@@ -4,4 +4,12 @@ module.exports = flat({
   registry: {
     getListError: '从 "{registryUrl}" 源获取 Blocklet 列表失败.',
   },
+  backup: {
+    space: {
+      error: {
+        title: '备份到 Spaces 发生错误',
+        forbidden: '你还没有权限执行备份操作，请尝试在 DID Spaces 上恢复应用授权或者重新连接 DID Spaces 后重试',
+      },
+    },
+  },
 });

package/lib/migrations/1.16.8-component-title.js

@@ -0,0 +1,66 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+const blocklets = {
+  z8ia4e5vAeDsQEE2P26bQqz9oWR1Lxg9qUMaV: 'Static Demo',
+  z8iZyVVn6XsvcuiYhtdw3GoasMbtqR9BjvJz3: 'Blockchain Explorer',
+  z8iZqkCjLP6TZpR12tT3jESWxB8SGzNsx8nZa: 'NFT Store',
+  z8ia1WEiBZ7hxURf6LwH21Wpg99vophFwSJdu: 'Discuss Kit',
+  z8ia5AUWNBoc5Jw6Zf2ru97W1y6PZVFiFa7h9: 'Coming Soon Page',
+  z8iZiDFg3vkkrPwsiba1TLXy3H9XHzFERsP8o: 'Pages Kit',
+  z8iZscGk6ohCejHEiX16C7apdFC7JrPYD1J4Z: 'Virtual Gift Card',
+  z8ia2birZzhjbXqKnxPUUivmqErdsf3724tr6: 'NFT Maker',
+  z8ia1ieY5KhEC4LMRETzS5nUwD7PvAND8qkfX: 'NFT Blender',
+  z8iZqeUACK955YaBWqEd8aKg3tTki1GpvE2Wu: 'ArcBridge Node',
+  z8ia29UsENBg6tLZUKi2HABj38Cw1LmHZocbQ: 'Blocklet Store',
+  z8ia2KGe3icfgRcVc9C1qCbWTBbpP2TrfPu7T: 'FS Chain Manager',
+  z8ia3xzq2tMq8CRHfaXj1BTYJyYnEcHbqP8cJ: 'AI Kit',
+  z8iZvmERrWxqReWe1HZmkAaZvFeRpkXutfKDk: 'NFT Marketplace',
+  z8iZpnScvjjeeyYZQoHSdXm4GQTqcfTTGkyPP: 'DID Wallet',
+  z8iZrihfHTTBCBpDqCzrjFer5jop383b5hdPh: 'DID Spaces Enterprise',
+  z8ia1mAXo8ZE7ytGF36L5uBf9kD2kenhqFGp9: 'Image Bin',
+  z8iZu6GDcVFaSsT7LjrBJC9uAfM6HKyQaCD9U: 'Tower Blocks',
+  z8iZyhourKXqn8JKHbFcQDqWoAMsR6ZEi5nCW: 'Mine Sweeper',
+  z8ia48jeqzdNhr9smse1tQCmt72G5PnSZaTax: 'MultiSig Vault',
+  z8iZngXotuUXxsm6imc7naUUy1G5ycVs7A34H: 'Uptime Kuma',
+  z8iZvMrKPa7qy2nxfrKremuSm8bE9Wb9Tu2NA: 'AI Assistant',
+  z8ia2kJi2hdqASNBZzRiWQaZ8vshaxgQS67EW: 'DID Spaces Personal',
+  z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB: 'AI Studio',
+  z8iZxVUfZZBPpLhVov5YqsaorNX9F2vKAKeMc: 'Excalidraw',
+  z8iZoLRKRXHzqdJ2vFZEi4H5UXT9ADsurxZRK: 'Tweet Token',
+  z8ia5gwZog5Ut4TfUJP4k82fXKQN8iWZp2bfG: 'Token Prize Pool',
+  z8iZorY6mvb5tZrxXTqhBmwu89xjEEazrgT3t: 'Meilisearch',
+  z8iZy4P83i6AgnNdNUexsh2kBcsDHoqcwPavn: 'DID Pay',
+  z8iZqTiD6tFwEub6t685e3dj18Ekbo8xvqBSV: 'Vote',
+  z8iZkFBbrVQxZHvcWWB3Sa2TrfGmSeFz9MSU7: 'Server Launcher',
+  z8iZhW61syFGfgMGDm7ttbDATUf4zbNrzxfJG: 'Blocklet Launcher',
+  z8iZqxnmW2i3AbgmjuFki1J6KE8e5i5zBWB9k: 'Nostr Verifier',
+  z8iZwyBfqwNcGbLCiUnFAQLEzT8sJd2TSjbM2: 'Static Demo',
+  z8iZva6oERHPw7qveUwTBKcY8DqUUtcXheBX8: 'Form Builder',
+  z8iZrdP3XNxaqzcHqTRewE3BdJiCfeMfNLzTc: 'AD Kit',
+  z8ia2XJkmoZDwRBYzrvLqeZAHWz38Ptrz51xf: 'Tweet Assistant',
+  z8ia2YJVK83HuwqykTVVe61mtNWEWeR6kVERi: 'aistro',
+  z8ia5nxBkFetpK1BzaumvDStQiKyAuHdymnoh: 'Wait Genie',
+};
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update component title...');
+
+  const apps = await states.blocklet.find({});
+
+  for (const app of apps || []) {
+    let shouldUpdate = false;
+    for (const component of app.children || []) {
+      const title = blocklets[component?.meta?.bundleDid];
+      if (component?.meta && title && title !== component.meta.title) {
+        component.meta.title = title;
+        shouldUpdate = true;
+      }
+    }
+
+    if (shouldUpdate) {
+      await states.blocklet.update({ _id: app._id }, { $set: { children: app.children } });
+      printInfo(`Blocklet in blocklet.db updated: ${app.meta?.title}`);
+    }
+  }
+};

package/lib/monitor/blocklet-runtime-monitor.js

@@ -91,7 +91,7 @@ class BlockletRuntimeMonitor extends EventEmitter {
     if (status !== BlockletStatus.running) {
       if (this.data[blockletDid]) {
         Object.keys(this.data[blockletDid]).forEach((key) => {
-          delete this.data[blockletDid][key].runtimeInfo;
+          this.data[blockletDid][key].runtimeInfo = {};
         });
       }
       return;

package/lib/router/helper.js

@@ -117,6 +117,14 @@ const attachRuntimeDomainAliases = async ({ sites = [], context = {}, node }) =>
   });
 };
 
+/**
+ * @description
+ * @param {{
+ *  corsAllowedOrigins: Array<string>;
+ * }} site
+ * @param {string} rawUrl
+ * @return {void}
+ */
 const addCorsToSite = (site, rawUrl) => {
   if (!site || !rawUrl) {
     return;
@@ -374,12 +382,18 @@ const ensureCorsForWebWallet = async (sites) => {
   return sites;
 };
 
+/**
+ * @description
+ * @param {Array<any>} [sites=[]]
+ * @param {Array<import('@abtnode/client').BlockletState>} blocklets
+ * @return {Promise<any>}
+ */
 const ensureCorsForDidSpace = async (sites = [], blocklets) => {
   return sites.map((site) => {
     const blocklet = blocklets.find((x) => x.meta.did === site.blockletDid);
     if (blocklet) {
       const endpoint = blocklet.environments.find(
-        (x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SPACE_ENDPOINT
+        (x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT
       );
       if (endpoint && isUrl(endpoint.value)) {
         addCorsToSite(site, endpoint.value);

package/lib/states/audit-log.js

@@ -272,6 +272,11 @@ const getLogContent = async (action, args, context, result, info, node) => {
   }
 };
 
+/**
+ * @description 获取日志的种类
+ * @param {string} action
+ * @return {Promise<'blocklet' | 'team' | 'security' | 'integrations' | 'server' | 'certificates' | 'gateway' | ''>}
+ */
 const getLogCategory = (action) => {
   switch (action) {
     // blocklets
@@ -294,7 +299,7 @@ const getLogCategory = (action) => {
     case 'updateComponentMountPoint':
       return 'blocklet';
 
-    // store
+    // store，此处应该返回 server
     case 'addBlockletStore':
     case 'deleteBlockletStore':
     case 'selectBlockletStore':
@@ -449,7 +454,7 @@ class AuditLogState extends BaseState {
         const data = await this.insert({
           scope: getScope(args) || info.did, // server or blocklet did
           action,
-          category: await getLogCategory(action, args, context, result, info, node),
+          category: await getLogCategory(action),
           content: (await getLogContent(action, args, context, result, info, node)).trim(),
           actor: pick(user.actual || user, ['did', 'fullName', 'role']),
           extra: args,

package/lib/states/backup.js

@@ -0,0 +1,177 @@
+/**
+ * @typedef{{
+    appPid: string; // 此处建议使用 appPid
+    userDid: string;
+    strategy?: 0 | 1; 
+
+    sourceUrl: string; 
+    
+    target?: "Spaces" | 'Local'; 
+    targetUrl?: string; 
+
+    createdAt: string;
+    updatedAt?: string;
+    status?: 0 | 1; 
+    message?: string;
+ * }} Backup
+ */
+
+const { Joi } = require('@arcblock/validator');
+const BaseState = require('./base');
+const { validateBackupSuccess, validateBackupFail, validateBackupStart } = require('../validators/backup.js');
+
+const validateBackup = Joi.object({
+  appPid: Joi.DID(),
+  userDid: Joi.DID(),
+  // 备份策略: 0 表示自动，1 表示手动，建议使用常量
+  strategy: Joi.number().valid(0, 1).default(0).optional(),
+
+  // 形如, /User/allen/blocklet-server/data/discuss-kit
+  sourceUrl: Joi.string().required(),
+
+  // 备份文件存储在哪？本地还是 spaces 的那个位置？
+  // 如果存储在 Spaces, 形如: https://bbqaw5mgxc6fnihrwqcejcxvukkdgkk4anwxwk5msvm.did.abtnet.io/app/space/zNKhe8jwgNZX2z7ZUfwNddNECxSe3wyg7VtS
+  // 如果存储在 Local，形如: /User/allen/discuss-kit
+  target: Joi.string().valid('Spaces', 'Local').optional().default('Spaces'),
+  targetUrl: Joi.string().optional().allow('').default(''),
+
+  createdAt: Joi.string()
+    .optional()
+    .default(() => new Date().toISOString()),
+  updatedAt: Joi.string().optional().default('').allow(''),
+
+  // 0 表示成功了，建议使用常量表示，默认是 1 表示错误的
+  status: Joi.number().optional().allow(null),
+  // 发生错误的时候可以用来存储错误下信息
+  message: Joi.string().optional().default('').allow(''),
+});
+
+/**
+ * @description
+ * @class BackupState
+ */
+class BackupState extends BaseState {
+  constructor(baseDir, config = {}) {
+    super(baseDir, {
+      filename: 'backup.db',
+      ...config,
+    });
+  }
+
+  /**
+   * @description
+   * @param {Pick<Backup, 'appPid' | 'userDid' | 'strategy' | 'sourceUrl' | 'target'>} backup
+   * @return {Promise<Backup & {_id: string}>}
+   * @memberof BackupState
+   */
+  async start(backup) {
+    const { error, value } = validateBackupStart.validate(backup, {
+      stripUnknown: true,
+      allowUnknown: true,
+    });
+
+    if (error) {
+      throw error;
+    }
+
+    return this.create({
+      ...value,
+    });
+  }
+
+  /**
+   * @description
+   * @param {string} id
+   * @param {Pick<Backup, 'targetUrl'>} successBackupInfo
+   * @return {PromiseLike<import('@nedb/core').UpdateResult<Backup>>}
+   * @memberof BackupState
+   */
+  async success(id, successBackupInfo) {
+    const { error, value } = validateBackupSuccess.validate(successBackupInfo, {
+      stripUnknown: true,
+      allowUnknown: true,
+    });
+
+    if (error) {
+      throw error;
+    }
+
+    return this.update(
+      { _id: id },
+      {
+        $set: {
+          ...value,
+          status: 0,
+          updatedAt: new Date().toISOString(),
+        },
+      }
+    );
+  }
+
+  /**
+   * @description
+   * @param {string} id
+   * @param {Pick<Backup, 'message'>} errorBackupInfo
+   * @return {PromiseLike<import('@nedb/core').UpdateResult<Backup>>}
+   * @memberof BackupState
+   */
+  async fail(id, errorBackupInfo) {
+    const { error, value } = validateBackupFail.validate(errorBackupInfo, {
+      stripUnknown: true,
+      allowUnknown: true,
+    });
+
+    if (error) {
+      throw error;
+    }
+
+    return this.update(
+      { _id: id },
+      {
+        $set: {
+          ...value,
+          status: 1,
+          updatedAt: new Date().toISOString(),
+        },
+      }
+    );
+  }
+
+  /**
+   * @description
+   * @param {Backup} backup
+   * @return {Promise<Backup & {_id: string}>}
+   * @memberof BackupState
+   */
+  async create(backup) {
+    const { error, value } = validateBackup.validate(backup, {
+      allowUnknown: true,
+      stripUnknown: true,
+    });
+
+    if (error) {
+      throw new Error(error.message);
+    }
+
+    return this.insert(value);
+  }
+
+  /**
+   * @description
+   * @param {{ did: string }} { did }
+   * @return {Promise<Array<import('@abtnode/client').Backup>>}
+   */
+  async getBlockletBackups({ did }) {
+    const backups = await this.cursor({
+      appPid: did,
+    })
+      .sort({
+        updatedAt: -1,
+      })
+      .exec();
+
+    return backups ?? [];
+  }
+}
+
+module.exports = BackupState;

package/lib/states/blocklet-extras.js

@@ -91,6 +91,12 @@ class BlockletExtrasState extends BaseState {
     this.generateExtraFns();
   }
 
+  /**
+   * @description
+   * @param {string} did
+   * @return {Promise<number>}
+   * @memberof BlockletExtrasState
+   */
   delete(did) {
     return this.remove({ did });
   }

package/lib/states/index.js

@@ -11,6 +11,7 @@ const SessionState = require('./session');
 const ExtrasState = require('./blocklet-extras');
 const CacheState = require('./cache');
 const AuditLogState = require('./audit-log');
+const BackupState = require('./backup');
 
 const init = (dataDirs, config) => {
   const notificationState = new NotificationState(dataDirs.core, config);
@@ -25,6 +26,7 @@ const init = (dataDirs, config) => {
   const extrasState = new ExtrasState(dataDirs.core, config);
   const cacheState = new CacheState(dataDirs.core, config);
   const auditLogState = new AuditLogState(dataDirs.core, config);
+  const backupState = new BackupState(dataDirs.core, config);
 
   return {
     node: nodeState,
@@ -39,6 +41,7 @@ const init = (dataDirs, config) => {
     blockletExtras: extrasState,
     cache: cacheState,
     auditLog: auditLogState,
+    backup: backupState,
   };
 };
 

package/lib/states/user.js

@@ -7,7 +7,6 @@ const { isValid } = require('@arcblock/did');
 const { PASSPORT_STATUS } = require('@abtnode/constant');
 const { upsertToPassports } = require('@abtnode/auth/lib/passport');
 const { fromAppDid } = require('@arcblock/did-ext');
-const { types } = require('@arcblock/did');
 
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
@@ -400,7 +399,7 @@ class User extends BaseState {
           sourceProvider = 'wallet';
           connectedAccounts.forEach((account) => {
             if (account.id && blockletSk) {
-              const accountWallet = fromAppDid(account.id, blockletSk, types.RoleType.ROLE_ACCOUNT);
+              const accountWallet = fromAppDid(account.id, blockletSk);
               account.did = accountWallet.address;
               account.pk = accountWallet.publicKey;
               account.firstLoginAt = account.firstLoginAt || new Date().toISOString();

package/lib/util/blocklet.js

@@ -543,7 +543,8 @@ const startBlockletProcess = async (
         namespace: 'blocklets',
         name: processId,
         cwd: appCwd,
-        time: true,
+        // FIXME @linchen [] does not work, so use () here
+        log_date_format: '(YYYY-MM-DD HH:mm:ss)',
         output: path.join(logsDir, 'output.log'),
         error: path.join(logsDir, 'error.log'),
         wait_ready: process.env.NODE_ENV !== 'test',
@@ -1699,6 +1700,16 @@ const validateAppConfig = async (config, states) => {
       throw new Error(`${x.key}(${x.value}) is not a valid http address`);
     }
   }
+
+  if (x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT) {
+    if (isEmpty(x.value)) {
+      throw new Error(`${x.key} can not be empty`);
+    }
+
+    if (!isUrl(x.value)) {
+      throw new Error(`${x.key}(${x.value}) is not a valid http address`);
+    }
+  }
 };
 
 const checkDuplicateAppSk = async ({ sk, did, states }) => {

package/lib/util/queue.js

@@ -1,6 +1,24 @@
 const path = require('path');
 const createQueue = require('@abtnode/queue');
 
+/**
+ *
+ * @typedef {
+ *  EventEmitter & {
+ *    store: JobStore;
+ *    push: (...args: {
+ *      job: any;
+ *      jobId: string;
+ *      persist: boolean;
+ *      delay: number;
+ *    }) => EventEmitter;
+ *    get: (id: string) => Promise<any>;
+ *    cancel: (id: string) => Promise<...>;
+ *    options: {}
+ *  }
+ * } Queue
+ */
+
 /**
  *
  * @param {Object} Options
@@ -14,6 +32,7 @@ const createQueue = require('@abtnode/queue');
  * @param {number} Options.options.maxRetries [param=1] number of max retries, default 1
  * @param {number} Options.options.maxTimeout [param=86400000] max timeout, in ms, default 86400000ms(1d)
  * @param {number} Options.options.retryDelay [param=0] retry delay, in ms, default 0ms
+ * @returns {Queue}
  */
 module.exports = ({ name, dataDir, onJob, daemon = false, options = {} }) => {
   if (daemon) {

package/lib/util/spaces.js

@@ -0,0 +1,39 @@
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const isEmpty = require('lodash/isEmpty');
+const joinUrl = require('url-join');
+
+/**
+ * @description
+ * @param {import('@abtnode/client').ConfigEntry[]} configs
+ * @return {string | null}
+ */
+const getDIDSpaceBackupEndpoint = (configs) => {
+  return (
+    configs?.find((config) => config.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT)?.value || null
+  );
+};
+
+/**
+ * @FIXME 希望之后放在 sdk 中 @jianchao
+ * @description
+ * @param {string} endpoint
+ * @returns {string}
+ */
+function getBackupFilesUrlFromEndpoint(endpoint) {
+  if (isEmpty(endpoint)) {
+    throw new Error(`Endpoint(${endpoint}) cannot be empty`);
+  }
+
+  const prefix = endpoint.replace(/\/api\/space\/.+/, '');
+
+  const strArray = endpoint.replace(/\/$/, '').split('/');
+  const spaceDid = strArray.at(-4);
+  const appDid = strArray.at(-2);
+
+  return joinUrl(prefix, 'space', spaceDid, 'apps', appDid, 'explorer', `?key=/apps/${appDid}/.did-objects/${appDid}/`);
+}
+
+module.exports = {
+  getDIDSpaceBackupEndpoint,
+  getBackupFilesUrlFromEndpoint,
+};

package/lib/validators/backup.js

@@ -0,0 +1,24 @@
+const { Joi } = require('@arcblock/validator');
+
+const validateBackupStart = Joi.object({
+  appPid: Joi.DID().required(),
+  userDid: Joi.DID().required(),
+  strategy: Joi.number().valid(0, 1).optional().default(0),
+
+  sourceUrl: Joi.string().required(),
+  target: Joi.string().valid('Spaces', 'Local').optional().default('Spaces'),
+});
+
+const validateBackupSuccess = Joi.object({
+  targetUrl: Joi.string().required(),
+});
+
+const validateBackupFail = Joi.object({
+  message: Joi.string().required(),
+});
+
+module.exports = {
+  validateBackupStart,
+  validateBackupSuccess,
+  validateBackupFail,
+};

package/lib/validators/space-gateway.js

@@ -0,0 +1,30 @@
+const { Joi } = require('@arcblock/validator');
+
+const validateAddSpaceGateway = Joi.object({
+  url: Joi.string()
+    .uri({ scheme: ['http', 'https'] })
+    .required(),
+  name: Joi.string().required(),
+  protected: Joi.boolean().optional().allow(null),
+  endpoint: Joi.string()
+    .uri({ scheme: ['http', 'https'] })
+    .optional()
+    .allow(''),
+});
+
+const validateUpdateSpaceGateway = Joi.object({
+  url: Joi.string()
+    .uri({ scheme: ['http', 'https'] })
+    .required(),
+  name: Joi.string().optional().allow(''),
+  protected: Joi.boolean().optional().allow(null),
+  endpoint: Joi.string()
+    .uri({ scheme: ['http', 'https'] })
+    .optional()
+    .allow(''),
+});
+
+module.exports = {
+  validateAddSpaceGateway,
+  validateUpdateSpaceGateway,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.7",
+  "version": "1.16.8-beta-0c0c5eb2",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,18 +19,18 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.16.7",
-    "@abtnode/certificate-manager": "1.16.7",
-    "@abtnode/constant": "1.16.7",
-    "@abtnode/cron": "1.16.7",
-    "@abtnode/db": "1.16.7",
-    "@abtnode/logger": "1.16.7",
-    "@abtnode/queue": "1.16.7",
-    "@abtnode/rbac": "1.16.7",
-    "@abtnode/router-provider": "1.16.7",
-    "@abtnode/static-server": "1.16.7",
-    "@abtnode/timemachine": "1.16.7",
-    "@abtnode/util": "1.16.7",
+    "@abtnode/auth": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/certificate-manager": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/constant": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/cron": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/db": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/logger": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/queue": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/rbac": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/router-provider": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/static-server": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/timemachine": "1.16.8-beta-0c0c5eb2",
+    "@abtnode/util": "1.16.8-beta-0c0c5eb2",
     "@arcblock/did": "1.18.78",
     "@arcblock/did-auth": "1.18.78",
     "@arcblock/did-ext": "^1.18.78",
@@ -39,10 +39,11 @@
     "@arcblock/event-hub": "1.18.78",
     "@arcblock/jwt": "^1.18.78",
     "@arcblock/pm2-events": "^0.0.5",
+    "@arcblock/validator": "^1.18.77",
     "@arcblock/vc": "1.18.78",
-    "@blocklet/constant": "1.16.7",
-    "@blocklet/meta": "1.16.7",
-    "@blocklet/sdk": "1.16.7",
+    "@blocklet/constant": "1.16.8-beta-0c0c5eb2",
+    "@blocklet/meta": "1.16.8-beta-0c0c5eb2",
+    "@blocklet/sdk": "1.16.8-beta-0c0c5eb2",
     "@did-space/client": "^0.2.90",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.78",
@@ -93,5 +94,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "dadd7bfa319e2ee5144bdccb6e280ffe4b8d2679"
+  "gitHead": "0d8ec3154caf670770284dbdabc61a5f4e8b205f"
 }