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

package/lib/blocklet/manager/helper/blue-green-start-blocklet.js

@@ -458,6 +458,11 @@ const blueGreenStartBlocklet = async (
   // 根据情况更新 route table， 会判断只有包含多 interfaces 的 DID 才会更新 route table
   // 如果是蓝绿更新发起的，则不更新 route table，因为蓝绿更新会自动更新 route table
   if (!['true', '1'].includes(process.env.ABT_NODE_DISABLE_BLUE_GREEN) && !ignoreBlockletStartedEvent) {
+    // 检查 blocklet 是否仍然存在（可能在异步执行期间被删除）
+    if (!(await manager.hasBlocklet({ did }))) {
+      logger.warn('skip blueOrGreenStarted event: blocklet no longer exists', { did });
+      return;
+    }
     const latestBlocklet = await manager.getBlocklet(did, { e2eMode });
     manager.emit(BlockletEvents.blueOrGreenStarted, {
       blocklet: latestBlocklet,

package/lib/blocklet/manager/lock.js

@@ -0,0 +1,18 @@
+const { DBCache, getAbtNodeRedisAndSQLiteUrl } = require('@abtnode/db-cache');
+
+const statusLock = new DBCache(() => ({
+  prefix: 'blocklet-status-lock',
+  ttl: 120_000,
+  ...getAbtNodeRedisAndSQLiteUrl(),
+}));
+
+const startLock = new DBCache(() => ({
+  prefix: 'blocklet-start-lock',
+  ttl: process.env.NODE_ENV === 'test' ? 1_000 : 120_000,
+  ...getAbtNodeRedisAndSQLiteUrl(),
+}));
+
+module.exports = {
+  statusLock,
+  startLock,
+};

package/lib/event/index.js

@@ -23,7 +23,7 @@ const {
 const { joinURL } = require('ufo');
 const { encode } = require('@abtnode/util/lib/base32');
 const dayjs = require('@abtnode/util/lib/dayjs');
-
+const { deleteBlockletCache, clearBlockletInfoCache } = require('@abtnode/util/lib/blocklet-cache');
 const { isWorkerInstance } = require('@abtnode/util/lib/pm2/is-instance-worker');
 const { isInServerlessMode } = require('@abtnode/util/lib/serverless');
 const { NodeMonitSender } = require('../monitor/node-monit-sender');
@@ -37,12 +37,8 @@ const { getBackupEndpoint, getBackupFilesUrlFromEndpoint, getDIDSpacesUrlFromEnd
 const { autoBackupHandlerFactory, autoBackupHandler } = require('./auto-backup-handler');
 
 const eventBusHandler = require('../blocklet/webhook/event-bus');
-const {
-  isDevelopmentMode,
-  deleteBlockletCache,
-  updateDidDocument,
-  updateDidDocumentStateOnly,
-} = require('../util/blocklet');
+const { isDevelopmentMode, updateDidDocument, updateDidDocumentStateOnly } = require('../util/blocklet');
+
 const { backupBlockletSites, cleanBlockletSitesBackup, rollbackBlockletSites } = require('./util');
 const { ensureBlockletHasMultipleInterfaces } = require('../router/helper');
 const { sendServerlessHeartbeat } = require('../util/launcher');
@@ -93,7 +89,32 @@ module.exports = ({
     }
   };
 
+  /**
+   * 缓存清除事件列表，所有进程（master + workers）都必须处理
+   * 触发场景：
+   * - blocklet.upgraded: configTheme, blocklet.componentRemoved, blocklet.componentInstalled, installed, removed, spaceConnected
+   * - blocklet.blueOrGreenStarted: started，单个和多个的启动
+   */
+  [
+    BlockletEvents.started,
+    BlockletEvents.updated,
+    BlockletEvents.upgraded,
+    BlockletEvents.blueOrGreenStarted,
+    BlockletEvents.stopped,
+    BlockletEvents.appDidChanged,
+  ].forEach((name) => {
+    eventHub.on(name, (data) => {
+      const did = get(data, 'meta.did');
+      if (did) {
+        logger.info(`delete blocklet cache on ${name}`, { did });
+        deleteBlockletCache(did);
+        clearBlockletInfoCache(did);
+      }
+    });
+  });
+
   // Listen events from eventHub and call eventHandler
+  // Only master/primary process handles full event processing to avoid redundant operations
   [...Object.values(BlockletEvents), ...Object.values(TeamEvents), ...Object.values(EVENTS)].forEach((name) => {
     if (isWorkerInstance()) {
       return;
@@ -111,23 +132,6 @@ module.exports = ({
         });
       }
 
-      // clear blocklet cache
-      if (
-        [
-          BlockletEvents.updated,
-          BlockletEvents.started,
-          BlockletEvents.removed,
-          BlockletEvents.statusChange,
-          BlockletEvents.installed,
-        ].includes(name)
-      ) {
-        const did = get(data, 'meta.did');
-        if (did) {
-          logger.info(`delete blocklet cache on ${name}`, { did });
-          deleteBlockletCache(did);
-        }
-      }
-
       if (typeof eventHandler === 'function') {
         eventHandler({ name, data });
       }

package/lib/util/blocklet/app-utils.js

@@ -0,0 +1,192 @@
+/**
+ * App Utils Module
+ *
+ * Functions for app-level utilities like archive creation, SK utilities, and domain handling
+ * Logo functions moved to ./logo.js
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+const os = require('node:os');
+const get = require('lodash/get');
+const uniq = require('lodash/uniq');
+const createArchive = require('archiver');
+
+const { toAddress } = require('@ocap/util');
+const { getDidDomainForBlocklet } = require('@abtnode/util/lib/get-domain-for-blocklet');
+const { BLOCKLET_CONFIGURABLE_KEY, BLOCKLET_MODES } = require('@blocklet/constant');
+
+const { getSlpDid, shouldEnableSlpDomain, getBlockletKnownAs } = require('./did-document');
+
+// updateBlockletFallbackLogo, ensureAppLogo
+
+/**
+ * Create a zip archive of a data directory
+ * @param {string} dataDir - Directory to archive
+ * @param {string} fileName - Output filename
+ * @returns {Promise<string>} Path to created archive
+ */
+const createDataArchive = (dataDir, fileName) => {
+  const zipPath = path.join(os.tmpdir(), fileName);
+  if (fs.existsSync(zipPath)) {
+    fs.removeSync(zipPath);
+  }
+
+  const archive = createArchive('zip', { zlib: { level: 9 } });
+  const stream = fs.createWriteStream(zipPath);
+
+  return new Promise((resolve, reject) => {
+    archive
+      .directory(dataDir, false)
+      .on('error', (err) => reject(err))
+      .pipe(stream);
+
+    stream.on('close', () => resolve(zipPath));
+    archive.finalize();
+  });
+};
+
+/**
+ * Check if an app SK is currently in use
+ * @param {object} blocklet - Blocklet with environments and migratedFrom
+ * @param {string} appSk - App SK to check
+ * @returns {boolean}
+ */
+const isBlockletAppSkUsed = ({ environments, migratedFrom = [] }, appSk) => {
+  const isUsedInEnv = environments.find((e) => e.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK)?.value === appSk;
+  const isUsedInHistory = migratedFrom.some((x) => x.appSk === appSk);
+  return isUsedInEnv || isUsedInHistory;
+};
+
+/**
+ * Check if the app SK is being rotated
+ * @param {Array} newConfigs - New configuration array
+ * @param {Array} oldConfigs - Old configuration array
+ * @param {string} externalSk - External SK if any
+ * @returns {boolean}
+ */
+const isRotatingAppSk = (newConfigs, oldConfigs, externalSk) => {
+  const newSk = newConfigs.find((x) => BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK === x.key);
+  if (!newSk) {
+    // If no newSk found, we are not rotating the appSk
+    return false;
+  }
+
+  const oldSk = oldConfigs.find((x) => BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_SK === x.key);
+  if (!oldSk) {
+    // If we have no oldSk, we are setting the initial appSk for external managed apps
+    // If we have no oldSk, but we are not external managed apps, we are rotating the appSk
+    return !externalSk;
+  }
+
+  // Otherwise, we must be rotating the appSk
+  // eslint-disable-next-line sonarjs/prefer-single-boolean-return
+  if (oldSk.value !== newSk.value) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ * Get blocklet URL for launcher
+ * @param {object} options - Options
+ * @param {object} options.blocklet - Blocklet object
+ * @param {object} options.nodeInfo - Node info
+ * @returns {string} Blocklet URL
+ */
+const getBlockletURLForLauncher = ({ blocklet, nodeInfo }) => {
+  const enableSlpDomain = shouldEnableSlpDomain(nodeInfo.mode);
+  let didDomain = '';
+  if (enableSlpDomain) {
+    didDomain = getDidDomainForBlocklet({
+      did: getSlpDid(nodeInfo.did, blocklet.appPid),
+      didDomain: nodeInfo.slpDomain,
+    });
+  } else {
+    didDomain = getDidDomainForBlocklet({
+      did: blocklet.appPid,
+      didDomain: nodeInfo.didDomain,
+    });
+  }
+
+  return `https://${didDomain}`;
+};
+
+/**
+ * Get list of DID domains for a blocklet
+ * @param {object} blocklet - Blocklet object
+ * @param {object} nodeInfo - Node info
+ * @returns {Array} Array of domain aliases
+ */
+const getBlockletDidDomainList = (blocklet, nodeInfo) => {
+  const domainAliases = [];
+  const alsoKnownAs = getBlockletKnownAs(blocklet);
+
+  const dids = [blocklet.appPid, blocklet.appDid, ...alsoKnownAs].filter(Boolean).map((did) => toAddress(did));
+
+  uniq(dids).forEach((did) => {
+    const domain = getDidDomainForBlocklet({ did, didDomain: nodeInfo.didDomain });
+
+    domainAliases.push({ value: domain, isProtected: true });
+  });
+
+  const enableSlpDomain = shouldEnableSlpDomain(nodeInfo.mode);
+  if (enableSlpDomain) {
+    const slpDid = getSlpDid(nodeInfo.did, blocklet.appPid);
+    const domain = getDidDomainForBlocklet({ did: slpDid, didDomain: nodeInfo.slpDomain });
+
+    domainAliases.push({ value: domain, isProtected: true });
+  }
+
+  return domainAliases;
+};
+
+/**
+ * Get component names with version for display
+ * @param {object} app - App blocklet
+ * @param {Array} componentDids - Component DIDs
+ * @returns {string} Comma-separated component names with versions
+ */
+const getComponentNamesWithVersion = (app = {}, componentDids = []) => {
+  const str = uniq(componentDids)
+    .map((x) => {
+      const component = (app.children || []).find((y) => y.meta.did === x);
+      return `${component.meta.title}@${component.meta.version}`;
+    })
+    .join(', ');
+  return str;
+};
+
+/**
+ * Check if blocklet is in development mode
+ * @param {import('@blocklet/server-js').BlockletState} blocklet
+ * @returns {boolean}
+ */
+const isDevelopmentMode = (blocklet) => blocklet?.mode === BLOCKLET_MODES.DEVELOPMENT;
+
+/**
+ * Get hook arguments for a blocklet
+ * @param {object} blocklet - Blocklet object
+ * @returns {object} Hook arguments
+ */
+const getHookArgs = (blocklet) => ({
+  output: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '' : path.join(blocklet.env.logsDir, 'output.log'),
+  error: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '' : path.join(blocklet.env.logsDir, 'error.log'),
+  timeout:
+    Math.max(
+      get(blocklet, 'meta.timeout.script', 120),
+      ...(blocklet?.children || []).map((child) => child.meta?.timeout?.script || 0)
+    ) * 1000,
+});
+
+module.exports = {
+  createDataArchive,
+  isBlockletAppSkUsed,
+  isRotatingAppSk,
+  getBlockletURLForLauncher,
+  getBlockletDidDomainList,
+  getComponentNamesWithVersion,
+  isDevelopmentMode,
+  getHookArgs,
+};

package/lib/util/blocklet/blocklet-loader.js

@@ -0,0 +1,258 @@
+/**
+ * Blocklet Loader Module
+ *
+ * Functions for loading blocklet state from database and cache
+ * Handles blocklet retrieval, caching, and bundle expansion
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+const get = require('lodash/get');
+const pick = require('lodash/pick');
+
+const { toAddress } = require('@ocap/util');
+const { isValid: isValidDid } = require('@arcblock/did');
+const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet:blocklet-loader');
+const { DBCache, getAbtNodeRedisAndSQLiteUrl } = require('@abtnode/db-cache');
+const { BLOCKLET_CACHE_TTL } = require('@abtnode/constant');
+const { BLOCKLET_BUNDLE_FILE } = require('@blocklet/constant');
+const { parseOptionalComponents } = require('@blocklet/resolver');
+const { forEachBlockletSync, getComponentName } = require('@blocklet/meta/lib/util');
+const { getComponentProcessId } = require('@blocklet/meta/lib/get-component-process-id');
+
+const { expandBundle } = require('../index');
+const { getComponentDirs, fillBlockletConfigs } = require('./environment');
+const { formatBlockletTheme } = require('./meta-utils');
+
+// Blocklet state cache
+const blockletCache = new DBCache(() => ({
+  prefix: 'blocklet-state',
+  ttl: BLOCKLET_CACHE_TTL,
+  ...getAbtNodeRedisAndSQLiteUrl(),
+}));
+
+/**
+ * Delete blocklet from cache
+ * @param {string} did - Blocklet DID
+ */
+const deleteBlockletCache = async (did) => {
+  await blockletCache.del(did);
+};
+
+/**
+ * Ensure blocklet bundle is expanded
+ * @param {object} _meta - Blocklet meta (unused)
+ * @param {string} appDir - App directory path
+ */
+const ensureBlockletExpanded = async (_meta, appDir) => {
+  const bundlePath = path.join(appDir, BLOCKLET_BUNDLE_FILE);
+  if (fs.existsSync(bundlePath)) {
+    try {
+      const nodeModulesPath = path.join(appDir, 'node_modules');
+      if (fs.existsSync(nodeModulesPath)) {
+        await fs.remove(nodeModulesPath);
+      }
+      await expandBundle(bundlePath, appDir);
+      await fs.remove(bundlePath);
+    } catch (err) {
+      throw new Error(`Failed to expand blocklet bundle: ${err.message}`);
+    }
+  }
+};
+
+/**
+ * Internal function to get blocklet with full state
+ * @param {object} options - Options
+ * @returns {Promise<object>} Blocklet object
+ */
+const _getBlocklet = async ({
+  did,
+  dataDirs,
+  states,
+  e2eMode = false,
+  throwOnNotExist = true,
+  ensureIntegrity = false,
+  getOptionalComponents = false,
+} = {}) => {
+  if (!did) {
+    throw new Error('Blocklet did does not exist');
+  }
+  if (!isValidDid(did)) {
+    logger.error('Blocklet did is invalid', { did });
+    throw new Error('Blocklet did is invalid');
+  }
+
+  if (!dataDirs) {
+    throw new Error('dataDirs does not exist');
+  }
+
+  if (!states) {
+    throw new Error('states does not exist');
+  }
+
+  const blocklet = await states.blocklet.getBlocklet(did);
+  if (!blocklet) {
+    if (throwOnNotExist || ensureIntegrity) {
+      logger.error('can not find blocklet in database by did', { did });
+      throw new Error('can not find blocklet in database by did');
+    }
+    return null;
+  }
+
+  // 优化：并行查询独立数据（只查询一次 extraDoc，然后从内存中同步提取）
+  const [extraDoc, nodeInfo, site] = await Promise.all([
+    states.blockletExtras.getExtraByDid(blocklet.meta.did),
+    states.node.read(),
+    states.site.findOneByBlocklet(blocklet.meta.did),
+  ]);
+
+  // 从 extraDoc 中同步提取 settings（不需要再次查询数据库）
+  const extrasMeta = extraDoc ? pick(extraDoc, ['did', 'meta', 'controller']) : null;
+  const settings = states.blockletExtras.getFromDoc({ doc: extraDoc, dids: [blocklet.meta.did], name: 'settings' });
+
+  // app settings
+  // FIXME: @zhanghan 在 server 开发模式下，使用 `node /workspace/arcblock/blocklet-server/core/cli/tools/dev.js` 运行的 blocklet，blocklet.meta.did 和 blocklet.appPid 是不一致的
+  blocklet.trustedPassports = get(settings, 'trustedPassports') || [];
+  blocklet.trustedFactories = (get(settings, 'trustedFactories') || []).map((x) => {
+    if (!x.passport.ttlPolicy) {
+      x.passport.ttlPolicy = 'never';
+      x.passport.ttl = 0;
+    }
+    if (x.factoryAddress) {
+      x.factoryAddress = toAddress(x.factoryAddress);
+    }
+    return x;
+  });
+  blocklet.enablePassportIssuance = get(settings, 'enablePassportIssuance', true);
+  blocklet.settings = settings || {};
+
+  if (extrasMeta) {
+    blocklet.controller = extrasMeta.controller;
+  }
+
+  blocklet.settings.storeList = blocklet.settings.storeList || [];
+  blocklet.settings.theme = formatBlockletTheme(blocklet.settings.theme);
+  blocklet.settings.languages = blocklet.settings.languages || [];
+
+  // 移除第一个版本中 from 为 tmpl 的导航
+  if (blocklet?.settings?.navigations && Array.isArray(blocklet.settings.navigations)) {
+    blocklet.settings.navigations = (blocklet.settings.navigations || []).filter(
+      (item) => !(item?.parent === '/team' && ['tmpl'].includes(item.from))
+    );
+  }
+
+  (nodeInfo?.blockletRegistryList || []).forEach((store) => {
+    if (!blocklet.settings.storeList.find((x) => x.url === store.url)) {
+      blocklet.settings.storeList.push({
+        ...store,
+        protected: true,
+      });
+    }
+  });
+
+  blocklet.site = site;
+  blocklet.enableDocker = nodeInfo.enableDocker;
+  blocklet.enableDockerNetwork = nodeInfo.enableDockerNetwork;
+
+  // 第一次 forEachBlockletSync：收集所有组件的 dids
+  const componentConfigRequests = [];
+  forEachBlockletSync(blocklet, (component, { ancestors }) => {
+    const dids = [...ancestors.map((x) => x.meta.did), component.meta.did];
+    componentConfigRequests.push({
+      componentDid: component.meta.did,
+      dids,
+    });
+  });
+
+  // 基于缓存文档，为每个组件提取 configs（同步操作，不需要再次查询数据库）
+  const configsMap = new Map();
+  componentConfigRequests.forEach(({ componentDid, dids }) => {
+    const configs = states.blockletExtras.getFromDoc({ doc: extraDoc, dids, name: 'configs' });
+    configsMap.set(componentDid, configs);
+  });
+
+  // 第二次 forEachBlockletSync：填充组件
+  forEachBlockletSync(blocklet, (component, { id, level, ancestors }) => {
+    // component env
+    try {
+      // Validate component has required meta fields for getComponentDirs
+      if (!component.meta) {
+        throw new Error(`Component missing meta field: ${component.meta?.did || id}`);
+      }
+      if (!component.meta.name && !component.meta.bundleName) {
+        throw new Error(
+          `Component missing meta.name and meta.bundleName: ${component.meta.did || id}. ` +
+            'This may indicate a migration issue with blocklet_children table.'
+        );
+      }
+
+      component.env = {
+        id,
+        name: getComponentName(component, ancestors),
+        processId: getComponentProcessId(component, ancestors),
+        ...getComponentDirs(component, {
+          dataDirs,
+          ensure: ensureIntegrity,
+          ancestors,
+          e2eMode: level === 0 ? e2eMode : false,
+        }),
+      };
+    } catch (error) {
+      logger.error('Failed to set component env in _getBlocklet', {
+        componentDid: component.meta?.did,
+        componentName: component.meta?.name,
+        componentBundleName: component.meta?.bundleName,
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
+
+    // component config - 从预取的 configsMap 中获取
+    const configs = configsMap.get(component.meta.did) || [];
+    const rootBlocklet = ancestors.length > 0 ? ancestors[0] : blocklet;
+    fillBlockletConfigs(component, configs, { rootBlocklet, nodeInfo, dataDirs });
+  });
+
+  if (getOptionalComponents) {
+    const optionalComponents = await parseOptionalComponents(blocklet);
+    blocklet.optionalComponents = optionalComponents;
+  } else {
+    blocklet.optionalComponents = [];
+  }
+
+  return blocklet;
+};
+
+/**
+ * Get blocklet with optional caching
+ * @param {object} options - Options
+ * @returns {Promise<object>} Blocklet object
+ */
+const getBlocklet = ({
+  did,
+  ensureIntegrity = false,
+  getOptionalComponents = false,
+  useCache = false,
+  ...rest
+} = {}) => {
+  let cacheKey = '';
+
+  if (useCache) {
+    cacheKey = JSON.stringify({
+      ensureIntegrity,
+      getOptionalComponents,
+    });
+  }
+
+  return blockletCache.autoCacheGroup(did, cacheKey, () => {
+    return _getBlocklet({ did, ensureIntegrity, getOptionalComponents, ...rest });
+  });
+};
+
+module.exports = {
+  blockletCache,
+  deleteBlockletCache,
+  ensureBlockletExpanded,
+  getBlocklet,
+};