@abtnode/core 1.17.8-beta-20260109-075740-5f484e08 → 1.17.8-beta-20260111-112953-aed5ff39

package/lib/blocklet/manager/disk/auth-manager.js

@@ -0,0 +1,68 @@
+const omit = require('lodash/omit');
+const { getConfigs } = require('@blocklet/meta/lib/util-config');
+const { LOGIN_PROVIDER } = require('@blocklet/constant');
+const { getEmailServiceProvider } = require('@abtnode/auth/lib/email');
+
+/**
+ * Migrate blocklet authentication
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Blocklet DID
+ * @returns {Promise<void>}
+ */
+async function migrateBlockletAuthentication(manager, { did }) {
+  const blocklet = await manager.getBlocklet(did);
+  if (blocklet.settings?.authentication) return;
+
+  const authenticationList = [];
+
+  const configs = getConfigs(blocklet, did);
+  const allowWallet = configs.find((x) => x.key === 'DID_CONNECT_ALLOW_WALLET')?.value;
+  if (['1', 'true', undefined, null].includes(allowWallet)) {
+    // 默认是允许使用 wallet
+    authenticationList.push({
+      enabled: true,
+      showQrcode: true,
+      type: 'builtin',
+      provider: LOGIN_PROVIDER.WALLET,
+    });
+  }
+
+  const isEmailServiceEnabled = Boolean(getEmailServiceProvider(blocklet));
+  if (isEmailServiceEnabled) {
+    authenticationList.push({
+      enabled: isEmailServiceEnabled,
+      type: 'builtin',
+      provider: LOGIN_PROVIDER.EMAIL,
+    });
+  }
+
+  // 对旧的数据进行转换，并保存
+  if (blocklet.settings?.oauth) {
+    const oauthList = Object.keys(blocklet.settings?.oauth)
+      .map((key) => ({
+        ...omit(blocklet.settings?.oauth[key], 'order'),
+        type: 'oauth',
+        provider: key,
+      }))
+      .filter((x) => x.enabled === true);
+    authenticationList.push(...oauthList);
+  }
+  authenticationList.push({
+    enabled: true,
+    type: 'builtin',
+    provider: LOGIN_PROVIDER.PASSKEY,
+  });
+  const authentication = authenticationList.reduce((acc, curr, index) => {
+    acc[curr.provider] = {
+      ...omit(curr, ['provider']),
+      order: index,
+    };
+    return acc;
+  }, {});
+  await manager.configAuthentication({ did, authentication: JSON.stringify(authentication) });
+}
+
+module.exports = {
+  migrateBlockletAuthentication,
+};

package/lib/blocklet/manager/disk/backup-manager.js

@@ -0,0 +1,288 @@
+const fs = require('fs-extra');
+const path = require('path');
+const merge = require('lodash/merge');
+const isEmpty = require('lodash/isEmpty');
+const { joinURL } = require('ufo');
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:backup');
+const sleep = require('@abtnode/util/lib/sleep');
+const { encode } = require('@abtnode/util/lib/base32');
+const { BACKUPS, DEFAULT_DID_DOMAIN } = require('@abtnode/constant');
+const { BlockletStatus, BlockletEvents, RESTORE_PROGRESS_STATUS } = require('@blocklet/constant');
+
+const states = require('../../../states');
+const { SpacesBackup } = require('../../storage/backup/spaces');
+const { SpacesRestore } = require('../../storage/restore/spaces');
+const {
+  getBackupJobId,
+  getBackupEndpoint,
+  getBackupFilesUrlFromEndpoint,
+  getSpaceNameByEndpoint,
+} = require('../../../util/spaces');
+const { shouldJobBackoff } = require('../../../util');
+const { installApplicationFromBackup } = require('../helper/install-application-from-backup');
+
+/**
+ * Handle backup to spaces
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Blocklet DID
+ * @param {Object} params.context - Context
+ * @param {Object} params.backupState - Backup state
+ * @returns {Promise<void>}
+ */
+async function _onBackupToSpaces(
+  manager,
+  {
+    did,
+    context,
+    backupState = {
+      strategy: BACKUPS.STRATEGY.AUTO,
+    },
+  }
+) {
+  const blocklet = await states.blocklet.getBlocklet(did);
+  const {
+    appDid,
+    meta: { did: appPid },
+  } = blocklet;
+
+  if (shouldJobBackoff()) {
+    const backup = await states.backup.findOne({ appPid }, {}, { createdAt: -1 });
+    const message = 'Backup to spaces is not available when blocklet server is starting.';
+
+    if (backup.status === BACKUPS.STATUS.PROGRESS) {
+      await states.backup.fail(backup.id, {
+        message,
+      });
+    }
+
+    manager.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      completed: true,
+      progress: -1,
+      message,
+      backup,
+      context,
+      blocklet,
+    });
+
+    logger.warn(message);
+    return;
+  }
+
+  const spaceGateways = await manager.getBlockletSpaceGateways({ did });
+  const backupEndpoint = getBackupEndpoint(blocklet.environments);
+  if (isEmpty(spaceGateways) || isEmpty(backupEndpoint)) {
+    logger.warn('Canceled automatic backups because there is no space gateway.', { appPid });
+
+    const jobId = getBackupJobId(did);
+    await manager.backupQueue.delete(jobId);
+    await manager.updateAutoBackup({ did, autoBackup: { enabled: false } }, context);
+
+    return;
+  }
+
+  const {
+    user: { did: userDid, locale },
+  } = context;
+
+  let { referrer } = context;
+  if (isEmpty(referrer)) {
+    // fixes: https://github.com/ArcBlock/did-spaces/issues/908, referrer 在某些情况下会不存在
+    /**
+     * @type {import('@blocklet/server-js').NodeState}
+     */
+    const node = await states.node.read();
+    referrer = joinURL(
+      `https://${encode(node.did)}.${DEFAULT_DID_DOMAIN}`,
+      node.routing.adminPath,
+      `/blocklets/${did}/didSpaces`
+    );
+  }
+
+  const verifyBackup = () => {
+    // @note: 自动备份时,应用停止运行就跳过本次备份
+    if (backupState?.strategy === BACKUPS.STRATEGY.AUTO && blocklet.status === BlockletStatus.stopped) {
+      const message =
+        'Automatic backup is only available to running blocklets, please start your blocklet before enable automatic backup.';
+      logger.error(message, { appPid });
+
+      return message;
+    }
+
+    if (backupState?.strategy === BACKUPS.STRATEGY.AUTO && shouldJobBackoff()) {
+      const message = 'Automatic backup is not available when blocklet server is starting.';
+      logger.error(message, { appPid });
+
+      return message;
+    }
+
+    return null;
+  };
+
+  let backup = await states.backup.findOne({ appPid }, {}, { createdAt: -1 });
+  if (backup?.status !== BACKUPS.STATUS.PROGRESS) {
+    const message = verifyBackup();
+    if (message) {
+      return;
+    }
+
+    // 创建备份记录
+    backup = await states.backup.start({
+      appPid,
+      userDid,
+      strategy: backupState?.strategy,
+      sourceUrl: path.join(manager.dataDirs.tmp, 'backup', appDid),
+      targetName: await getSpaceNameByEndpoint(backupEndpoint, 'DID Space'),
+    });
+  }
+
+  const spacesBackup = new SpacesBackup({ appDid, appPid, event: manager, userDid, referrer, locale, backup });
+  try {
+    const message = verifyBackup();
+    if (message) {
+      throw new Error(message);
+    }
+
+    manager.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      message: 'Start backup...',
+      progress: 10,
+      completed: false,
+    });
+    await states.backup.progress(backup.id, {
+      message: 'Start backup...',
+      progress: 10,
+    });
+    await spacesBackup.backup();
+
+    await states.backup.success(backup.id, {
+      targetUrl: getBackupFilesUrlFromEndpoint(getBackupEndpoint(blocklet?.environments)),
+      metadata: {
+        count: spacesBackup.backupOutput.data?.count,
+        size: spacesBackup.backupOutput.data?.size,
+      },
+    });
+
+    // 备份成功了
+    manager.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      completed: true,
+      progress: 100,
+      backup,
+      context,
+      blocklet,
+    });
+  } catch (error) {
+    // @note: 主动抛出错误表明正在备份中，不做处理
+    if (error.cause?.status === BlockletEvents.backupProgress) {
+      logger.warn(error.message);
+      return;
+    }
+
+    await states.backup.fail(backup.id, {
+      message: error?.message,
+    });
+
+    manager.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      completed: true,
+      progress: -1,
+      message: error?.message,
+      backup,
+      context,
+      blocklet,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Handle restore from spaces
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} params.input - Restore input
+ * @param {Object} params.context - Context
+ * @returns {Promise<void>}
+ */
+async function _onRestoreFromSpaces(manager, { input, context }) {
+  try {
+    if (input.delay) {
+      await sleep(input.delay);
+    }
+
+    manager.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: input.appPid },
+      status: RESTORE_PROGRESS_STATUS.start,
+    });
+
+    const userDid = context.user.did;
+    const spacesRestore = new SpacesRestore({
+      ...input,
+      appPid: input.appPid,
+      event: manager,
+      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 });
+        });
+      }
+    };
+
+    manager.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: input.appPid },
+      status: RESTORE_PROGRESS_STATUS.installing,
+    });
+
+    try {
+      await installApplicationFromBackup({
+        url: `file://${spacesRestore.restoreDir}`,
+        moveDir: true,
+        ...merge(...params),
+        manager,
+        states,
+        controller: input.controller,
+        context: { ...context, startImmediately: true },
+      });
+
+      removeRestoreDir();
+    } catch (error) {
+      console.error(error);
+      removeRestoreDir();
+      throw error;
+    }
+
+    manager.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: input.appPid },
+      status: RESTORE_PROGRESS_STATUS.completed,
+    });
+  } catch (error) {
+    console.error(error);
+
+    manager.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: input.appPid },
+      status: RESTORE_PROGRESS_STATUS.error,
+      message: error.message,
+    });
+
+    throw error;
+  }
+}
+
+module.exports = {
+  _onBackupToSpaces,
+  _onRestoreFromSpaces,
+};

package/lib/blocklet/manager/disk/cleanup-manager.js

@@ -0,0 +1,157 @@
+const path = require('path');
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:cleanup');
+const { INSTALL_ACTIONS } = require('@abtnode/constant');
+const { BlockletEvents } = require('@blocklet/constant');
+
+const states = require('../../../states');
+const checkDockerRunHistory = require('../../../util/docker/check-docker-run-history');
+const { dockerExecChown } = require('../../../util/docker/docker-exec-chown');
+
+/**
+ * Rollback blocklet installation/upgrade
+ * @param {Object} manager - BlockletManager instance
+ * @param {string} action - install, upgrade, installComponent, upgradeComponent
+ * @param {string} did - Blocklet DID
+ * @param {Object} oldBlocklet - Previous blocklet state
+ * @returns {Promise<Object>}
+ */
+async function _rollback(manager, action, did, oldBlocklet) {
+  if (action === INSTALL_ACTIONS.INSTALL) {
+    const extraState = oldBlocklet?.extraState;
+
+    // rollback blocklet extra state
+    if (extraState) {
+      await states.blockletExtras.update({ did }, extraState);
+    } else {
+      await states.blockletExtras.remove({ did });
+    }
+
+    // remove blocklet state
+    return _deleteBlocklet(manager, { did, keepData: true });
+  }
+
+  if (
+    [
+      INSTALL_ACTIONS.INSTALL_COMPONENT,
+      INSTALL_ACTIONS.UPGRADE_COMPONENT,
+      'upgrade', // for backward compatibility
+    ].includes(action)
+  ) {
+    const { extraState, ...blocklet } = oldBlocklet;
+    // rollback blocklet state
+    const result = await states.blocklet.updateBlocklet(did, blocklet);
+
+    // rollback blocklet extra state
+    await states.blockletExtras.update({ did: blocklet.meta.did }, extraState);
+
+    logger.info('blocklet rollback successfully', { did, action });
+    manager.emit(BlockletEvents.updated, result);
+    return result;
+  }
+
+  logger.error('rollback action is invalid', { action });
+  throw new Error(`rollback action is invalid: ${action}`);
+}
+
+/**
+ * Delete blocklet
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function _deleteBlocklet(manager, { did, keepData, keepLogsDir, keepConfigs }, context) {
+  const blocklet = await states.blocklet.getBlocklet(did);
+  const { name } = blocklet.meta;
+  const cacheDir = path.join(manager.dataDirs.cache, name);
+
+  // Cleanup db
+  await manager.teamManager.deleteTeam(blocklet.meta.did);
+
+  // Cleanup disk storage
+  await _cleanBlockletData(manager, { blocklet, keepData, keepLogsDir, keepConfigs, appCacheDir: cacheDir });
+
+  const result = await states.blocklet.deleteBlocklet(did);
+  logger.info('blocklet removed successfully', { did });
+
+  let keepRouting = true;
+  if (keepData === false || keepConfigs === false) {
+    keepRouting = false;
+  }
+
+  manager.runtimeMonitor.delete(blocklet.meta.did);
+
+  manager.emit(BlockletEvents.removed, {
+    blocklet: result,
+    context: {
+      ...context,
+      keepRouting,
+    },
+  });
+  return blocklet;
+}
+
+/**
+ * Clean blocklet data
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @returns {Promise<void>}
+ */
+async function _cleanBlockletData(manager, { blocklet, keepData, keepLogsDir, keepConfigs, appCacheDir }) {
+  const { name } = blocklet.meta;
+
+  const dataDir = path.join(manager.dataDirs.data, name);
+  const logsDir = path.join(manager.dataDirs.logs, name);
+  const cacheDir = path.join(manager.dataDirs.cache, name);
+  const nodeInfo = await states.node.read();
+  if (checkDockerRunHistory(nodeInfo)) {
+    await dockerExecChown({
+      name: `${blocklet.meta.did}-clean-data`,
+      dirs: [dataDir, logsDir, cacheDir],
+      force: true,
+    });
+  }
+
+  logger.info(`clean blocklet ${blocklet.meta.did} data`, { keepData, keepLogsDir, keepConfigs });
+
+  if (keepData === false) {
+    await manager._safeRemoveDir(blocklet.meta.did, name, [appCacheDir, dataDir, logsDir, cacheDir]);
+    await states.blockletExtras.remove({ did: blocklet.meta.did });
+    logger.info(`removed blocklet ${blocklet.meta.did} extra data`);
+  } else {
+    if (keepLogsDir === false) {
+      await manager._safeRemoveDir(blocklet.meta.did, name, [appCacheDir, logsDir]);
+    } else {
+      await manager._safeRemoveDir(blocklet.meta.did, name, [appCacheDir]);
+    }
+
+    if (keepConfigs === false) {
+      await states.blockletExtras.remove({ did: blocklet.meta.did });
+      logger.info(`removed blocklet ${blocklet.meta.did} extra data`);
+    }
+  }
+}
+
+/**
+ * Get blocklet for installation with extra state
+ * @param {string} did - Blocklet DID
+ * @returns {Promise<Object|null>}
+ */
+async function _getBlockletForInstallation(did) {
+  const blocklet = await states.blocklet.getBlocklet(did, { decryptSk: false });
+  if (!blocklet) {
+    return null;
+  }
+
+  const extraState = await states.blockletExtras.findOne({ did: blocklet.meta.did });
+  blocklet.extraState = extraState;
+
+  return blocklet;
+}
+
+module.exports = {
+  _rollback,
+  _deleteBlocklet,
+  _cleanBlockletData,
+  _getBlockletForInstallation,
+};

package/lib/blocklet/manager/disk/component-manager.js

@@ -0,0 +1,83 @@
+const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager:component');
+const { BlockletGroup, BlockletEvents, BlockletInternalEvents, BlockletStatus } = require('@blocklet/constant');
+const { updateMountPointSchema } = require('@blocklet/meta/lib/schema');
+const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
+
+const states = require('../../../states');
+const { checkDuplicateMountPoint } = require('../../../util/blocklet');
+
+/**
+ * Update component mount point
+ * @param {Object} manager - BlockletManager instance
+ * @param {Object} params
+ * @param {string} params.did - Component DID
+ * @param {string} params.rootDid - Root blocklet DID
+ * @param {string} params.mountPoint - New mount point
+ * @param {Object} context - Context
+ * @returns {Promise<Object>}
+ */
+async function updateComponentMountPoint(manager, { did, rootDid: inputRootDid, mountPoint: tmpMountPoint }, context) {
+  const mountPoint = await updateMountPointSchema.validateAsync(tmpMountPoint);
+
+  const blocklet = await states.blocklet.getBlocklet(inputRootDid);
+
+  if (!blocklet) {
+    throw new Error('blocklet does not exist');
+  }
+
+  const rootDid = blocklet.meta.did;
+
+  const isRootComponent = !did;
+
+  const component = isRootComponent ? blocklet : blocklet.children.find((x) => x.meta.did === did);
+  if (!component) {
+    throw new Error('component does not exist');
+  }
+
+  if (isRootComponent && component.group === BlockletGroup.gateway) {
+    throw new Error('cannot update mountPoint of gateway blocklet');
+  }
+
+  checkDuplicateMountPoint(blocklet, mountPoint);
+
+  component.mountPoint = mountPoint;
+
+  await states.blocklet.updateBlocklet(rootDid, { mountPoint: blocklet.mountPoint, children: blocklet.children });
+
+  manager.emit(BlockletEvents.upgraded, { blocklet, context: { ...context, createAuditLog: false } }); // trigger router refresh
+  manager.emit(BlockletInternalEvents.componentUpdated, {
+    appDid: blocklet.appDid,
+    components: getComponentsInternalInfo(blocklet).filter((x) => x.did === component.meta.did),
+  });
+  manager.configSynchronizer.throttledSyncAppConfig(blocklet.meta.did);
+
+  // Restart blocklet if it's running to pick up the new mount point
+  // Only restart the component that was modified (did)
+  if (!isRootComponent && did) {
+    const updatedBlocklet = await manager.getBlocklet(rootDid);
+    const updatedComponent = updatedBlocklet.children.find((x) => x.meta.did === did);
+
+    if (
+      updatedComponent &&
+      (updatedComponent.status === BlockletStatus.running || updatedComponent.greenStatus === BlockletStatus.running)
+    ) {
+      try {
+        await manager.restart({ did: rootDid, componentDids: [did], operator: context?.user?.did }, context);
+        logger.info('restarted blocklet after mount point update', { rootDid, componentDid: did });
+      } catch (error) {
+        logger.error('failed to restart blocklet after mount point update', {
+          rootDid,
+          componentDid: did,
+          error,
+        });
+        // Don't throw error - mount point update succeeded, restart failure is logged but doesn't block the operation
+      }
+    }
+  }
+
+  return manager.getBlocklet(rootDid);
+}
+
+module.exports = {
+  updateComponentMountPoint,
+};