@abtnode/core 1.17.8-beta-20260108-224855-28496abb → 1.17.8-beta-20260111-112953-aed5ff39

package/lib/util/blocklet/config-manager.js

@@ -0,0 +1,232 @@
+/**
+ * Configuration Manager Module
+ *
+ * Functions for managing blocklet configurations, preferences, and pack settings
+ * Extracted from blocklet.js for better modularity
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+
+const {
+  BlockletGroup,
+  BLOCKLET_PREFERENCE_FILE,
+  BLOCKLET_PREFERENCE_PREFIX,
+  BLOCKLET_RESOURCE_DIR,
+} = require('@blocklet/constant');
+const { isEnvShareable } = require('@blocklet/meta/lib/util');
+
+const { APP_CONFIG_IMAGE_KEYS } = require('../index');
+
+/**
+ * Helper to convert preference schema properties to config format
+ * @param {object} properties - Schema properties
+ * @param {Array} result - Result array to populate
+ */
+const fromProperty2Config = (properties = {}, result) => {
+  Object.keys(properties).forEach((key) => {
+    const prop = properties[key];
+    if (prop.properties && ['ArrayTable', 'ArrayCards'].includes(prop['x-component']) === false) {
+      fromProperty2Config(prop.properties, result);
+    } else if (prop['x-decorator'] === 'FormItem') {
+      const secure = prop['x-component'] === 'Password';
+      result.push({
+        default: prop.default || '',
+        description: prop.title || key,
+        name: `${BLOCKLET_PREFERENCE_PREFIX}${key}`,
+        required: prop.required || false,
+        secure,
+        // eslint-disable-next-line no-nested-ternary
+        shared: secure ? false : typeof prop.shared === 'undefined' ? true : prop.shared,
+      });
+    }
+  });
+};
+
+/**
+ * Get config from blocklet preferences schema file
+ * @param {object} blocklet - Blocklet object with env.appDir
+ * @returns {Array} Array of config objects
+ */
+const getConfigFromPreferences = (blocklet) => {
+  const result = [];
+  const schemaFile = path.join(blocklet.env.appDir, BLOCKLET_PREFERENCE_FILE);
+  if (fs.existsSync(schemaFile)) {
+    try {
+      const schema = JSON.parse(fs.readFileSync(schemaFile, 'utf8'));
+      fromProperty2Config(schema.schema?.properties, result);
+    } catch {
+      // do nothing
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Get app configs from component that should be shared
+ * @param {object} meta - Component meta
+ * @param {Array} configsInApp - Configs already in app
+ * @param {Array} configsInComponent - Configs in component
+ * @returns {Array} Array of shared config objects
+ */
+const getAppConfigsFromComponent = (meta, configsInApp = [], configsInComponent = []) => {
+  const configs = [];
+  for (const configInMeta of meta?.environments || []) {
+    if (isEnvShareable(configInMeta)) {
+      const configInApp = (configsInApp || []).find((x) => x.key === configInMeta.name);
+      if (!configInApp) {
+        const configInComponent = configsInComponent.find((y) => y.key === configInMeta.name);
+        if (configInComponent && isEnvShareable(configInComponent)) {
+          configs.push(configInComponent);
+        }
+      }
+    }
+  }
+  return configs;
+};
+
+/**
+ * Separate configs into shared and self configs
+ * @param {Array} configs - Input configs
+ * @param {Array} oldConfigs - Existing configs
+ * @returns {{ sharedConfigs: Array, selfConfigs: Array }}
+ */
+const getConfigsFromInput = (configs = [], oldConfigs = []) => {
+  const sharedConfigs = [];
+  const selfConfigs = [];
+
+  configs.forEach((config) => {
+    const oldConfig = oldConfigs.find((y) => y.key === config.key);
+    if (!config.key.startsWith(BLOCKLET_PREFERENCE_PREFIX) && (isEnvShareable(config) || isEnvShareable(oldConfig))) {
+      sharedConfigs.push(config);
+    } else {
+      selfConfigs.push(config);
+    }
+  });
+
+  return { sharedConfigs, selfConfigs };
+};
+
+/**
+ * Remove app configs if no component uses them
+ * @param {Array} componentConfigs - Configs from removed component
+ * @param {object} app - App blocklet
+ * @param {object} blockletExtraState - Blocklet extra state manager
+ */
+const removeAppConfigsFromComponent = async (componentConfigs, app, blockletExtraState) => {
+  const appConfigs = app.configs || [];
+  const remainedConfigs = [].concat(...(app.children || []).map((x) => x.configs || []));
+  const removedAppConfigs = [];
+
+  componentConfigs.forEach((config) => {
+    const appConfig = appConfigs.find((x) => x.key === config.key);
+    if (
+      appConfig &&
+      !appConfig.custom &&
+      !(app.meta.environments || []).find((x) => x.name === config.key) &&
+      !remainedConfigs.find((x) => x.key === config.key && isEnvShareable(x))
+    ) {
+      removedAppConfigs.push({ key: appConfig.key, value: undefined });
+    }
+  });
+
+  if (removedAppConfigs.length) {
+    await blockletExtraState.setConfigs(app.meta.did, removedAppConfigs);
+  }
+};
+
+/**
+ * Get pack component from app children
+ * @param {object} app - App blocklet
+ * @returns {object|undefined} Pack component
+ */
+const getPackComponent = (app) => {
+  return (app?.children || []).find((x) => x.meta.group === BlockletGroup.pack);
+};
+
+/**
+ * Get pack config from pack component
+ * @param {object} app - App blocklet
+ * @returns {object|null} Pack config or null
+ */
+const getPackConfig = (app) => {
+  const packComponent = getPackComponent(app);
+  if (!packComponent) {
+    return null;
+  }
+
+  const resource = (packComponent.meta.resource?.bundles || []).find(
+    (x) => x.did === packComponent.meta.did && x.type === 'config'
+  );
+
+  if (!resource) {
+    return null;
+  }
+
+  const { appDir } = packComponent.env;
+  const configFile = path.join(appDir, BLOCKLET_RESOURCE_DIR, resource.did, resource.type, 'config.json');
+
+  if (!fs.existsSync(configFile)) {
+    return null;
+  }
+
+  return fs.readJSON(configFile);
+};
+
+/**
+ * Copy pack images from pack dir to app data dir
+ * @param {object} options - Options
+ * @param {string} options.appDataDir - App data directory
+ * @param {string} options.packDir - Pack directory
+ * @param {object} options.packConfig - Pack config with navigations and configObj
+ */
+const copyPackImages = async ({ appDataDir, packDir, packConfig = {} }) => {
+  const mediaDir = path.join(appDataDir, 'media', 'blocklet-service');
+  const { navigations = [], configObj = {} } = packConfig;
+  await fs.ensureDir(mediaDir);
+
+  // Filter bottom navigation items with icons
+  const bottomNavItems = navigations.filter((item) => {
+    const sections = Array.isArray(item.section) ? item.section : [item.section];
+    return sections.includes('bottomNavigation') && item.icon;
+  });
+
+  // Copy tabbar navigation icons
+  if (bottomNavItems.length > 0) {
+    await Promise.all(
+      bottomNavItems.map(async (item) => {
+        const iconFileName = path.basename(item.icon);
+        const iconInImages = path.join(packDir, 'images', iconFileName);
+
+        if (fs.existsSync(iconInImages)) {
+          await fs.copy(iconInImages, path.join(mediaDir, iconFileName));
+        }
+      })
+    );
+  }
+
+  // Copy brand-related images
+  await Promise.all(
+    APP_CONFIG_IMAGE_KEYS.map(async (key) => {
+      const value = configObj[key];
+      if (value) {
+        const imgFile = path.join(packDir, 'images', value);
+        if (fs.existsSync(imgFile)) {
+          await fs.copy(imgFile, path.join(appDataDir, value));
+        }
+      }
+    })
+  );
+};
+
+module.exports = {
+  fromProperty2Config,
+  getConfigFromPreferences,
+  getAppConfigsFromComponent,
+  getConfigsFromInput,
+  removeAppConfigsFromComponent,
+  getPackComponent,
+  getPackConfig,
+  copyPackImages,
+};

package/lib/util/blocklet/did-document.js

@@ -0,0 +1,240 @@
+/**
+ * DID Document Module
+ *
+ * Functions for managing blocklet DID documents
+ * Extracted from blocklet.js for better modularity
+ */
+
+const isEmpty = require('lodash/isEmpty');
+
+const { toDid, toBuffer } = require('@ocap/util');
+const { fromPublicKey } = require('@ocap/wallet');
+const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet:did-document');
+const { isCustomDomain } = require('@abtnode/util/lib/url-evaluation');
+const { isInServerlessMode } = require('@abtnode/util/lib/serverless');
+const md5 = require('@abtnode/util/lib/md5');
+const didDocument = require('@abtnode/util/lib/did-document');
+const { SLOT_FOR_IP_DNS_SITE } = require('@abtnode/constant');
+const { BLOCKLET_CONFIGURABLE_KEY, fromBlockletStatus } = require('@blocklet/constant');
+const { getBlockletInfo } = require('@blocklet/meta/lib/info');
+const { fixAvatar } = require('@blocklet/sdk/lib/util/user');
+
+const { getServerDidDomain, replaceDomainSlot } = require('../index');
+const { getFromCache: getAccessibleExternalNodeIp } = require('../get-accessible-external-node-ip');
+
+/**
+ * Check if SLP domain should be enabled based on mode
+ * @param {string} mode - Node mode
+ * @returns {boolean}
+ */
+const shouldEnableSlpDomain = (mode) => {
+  if (process.env.ABT_NODE_ENABLE_SLP_DOMAIN === 'true') {
+    return true;
+  }
+
+  if (process.env.ABT_NODE_ENABLE_SLP_DOMAIN === 'false') {
+    return false;
+  }
+
+  return isInServerlessMode({ mode });
+};
+
+/**
+ * Get SLP DID from server DID and app permanent ID
+ * @param {string} serverDid - Server DID
+ * @param {string} appPid - App permanent ID
+ * @returns {string} SLP DID address
+ */
+const getSlpDid = (serverDid, appPid) => {
+  if (!serverDid || !appPid) {
+    throw new Error('serverDid and appPid is required');
+  }
+
+  const buffer = Buffer.concat([toBuffer(serverDid), toBuffer(appPid)]);
+  const md5Str = md5(buffer);
+
+  const wallet = fromPublicKey(md5Str);
+  return wallet.address;
+};
+
+/**
+ * Get blocklet known as (alias DIDs)
+ * @param {object} blocklet - Blocklet object
+ * @returns {string[]} Array of DIDs
+ */
+const getBlockletKnownAs = (blocklet) => {
+  const alsoKnownAs = [blocklet.appDid];
+  if (Array.isArray(blocklet.migratedFrom)) {
+    blocklet.migratedFrom.filter((x) => x.appDid !== blocklet.appPid).forEach((x) => alsoKnownAs.push(x.appDid));
+  }
+
+  return alsoKnownAs.filter(Boolean).map(toDid);
+};
+
+/**
+ * Publish DID document for a blocklet
+ * @param {object} options - Options
+ * @param {object} options.blocklet - Blocklet object
+ * @param {object} options.ownerInfo - Owner info
+ * @param {object} options.nodeInfo - Node info
+ */
+// eslint-disable-next-line require-await
+const publishDidDocument = async ({ blocklet, ownerInfo, nodeInfo }) => {
+  const alsoKnownAs = getBlockletKnownAs(blocklet);
+  logger.debug('updateDidDocument blocklet info', { blocklet });
+
+  const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+  const { mode, did: serverDid } = nodeInfo;
+
+  let slpDid = null;
+  const enableSlpDomain = shouldEnableSlpDomain(mode);
+  if (enableSlpDomain) {
+    slpDid = getSlpDid(serverDid, blocklet.appPid);
+
+    if (alsoKnownAs.indexOf(slpDid) === -1) {
+      alsoKnownAs.push(toDid(slpDid));
+    }
+  }
+
+  logger.info('update did document', {
+    blockletDid: blocklet.meta.did,
+    alsoKnownAs,
+    slpDid,
+    daemonDidDomain: getServerDidDomain(nodeInfo),
+    didRegistryUrl: nodeInfo.didRegistry,
+    domain: nodeInfo.didDomain,
+    slpDomain: nodeInfo.slpDomain,
+  });
+
+  const name = blocklet.meta?.title || blocklet.meta?.name;
+  const state = fromBlockletStatus(blocklet.status);
+
+  let launcher;
+  if (!isEmpty(blocklet.controller)) {
+    launcher = {
+      did: toDid(blocklet.controller.did || nodeInfo.registerInfo.appPid), // 目前 controller 没有 launcher 的元信息, 默认在 nodeInfo 中存储
+      name: blocklet.controller.launcherName || nodeInfo.registerInfo.appName || '',
+      url: blocklet.controller.launcherUrl || nodeInfo.registerInfo.appUrl || '',
+      userDid: toDid(blocklet.controller.nftOwner),
+    };
+  }
+
+  const isPrimaryDomain = (d) => {
+    const appUrl = blocklet.environments.find((x) => x.key === BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_URL)?.value;
+    try {
+      const url = new URL(appUrl);
+      return url.hostname === d;
+    } catch (error) {
+      logger.error('failed to get primary domain', { error, domain: d, appUrl });
+      return false;
+    }
+  };
+
+  const domains = await Promise.all(
+    (blocklet.site?.domainAliases || []).map(async (item) => {
+      let type = isCustomDomain(item.value) ? 'custom' : 'internal';
+      // 如果域名是 appUrl，则设置为 primary
+      if (isPrimaryDomain(item.value)) {
+        type = 'primary';
+      }
+
+      if (item.value.includes(SLOT_FOR_IP_DNS_SITE)) {
+        const nodeIp = await getAccessibleExternalNodeIp();
+        item.value = replaceDomainSlot({ domain: item.value, nodeIp });
+      }
+
+      return {
+        type,
+        host: item.value,
+        url: `https://${item.value}`,
+        source: 'dnsRecords', // 固定为 dnsRecords
+      };
+    })
+  );
+
+  let owner;
+  if (ownerInfo) {
+    owner = {
+      did: toDid(ownerInfo.did),
+      name: ownerInfo.fullName,
+      avatar: fixAvatar(ownerInfo.avatar),
+    };
+  }
+
+  return didDocument.updateBlockletDocument({
+    blocklet,
+    wallet,
+    alsoKnownAs,
+    slpDid,
+    daemonDidDomain: getServerDidDomain(nodeInfo),
+    didRegistryUrl: nodeInfo.didRegistry,
+    domain: nodeInfo.didDomain,
+    slpDomain: nodeInfo.slpDomain,
+    serverDid,
+    blockletServerVersion: nodeInfo.version,
+    name,
+    state,
+    owner,
+    launcher,
+    domains,
+  });
+};
+
+/**
+ * Update DID document for a blocklet
+ * @param {object} options - Options
+ * @param {string} options.did - Blocklet DID
+ * @param {object} options.nodeInfo - Node info
+ * @param {object} options.teamManager - Team manager
+ * @param {object} options.states - State managers
+ */
+const updateDidDocument = async ({ did, nodeInfo, teamManager, states }) => {
+  const blocklet = await states.blocklet.getBlocklet(did);
+  const blockletExtra = await states.blockletExtras.findOne({ did });
+
+  blocklet.site = await states.site.findOneByBlocklet(did);
+  blocklet.settings = await states.blockletExtras.getSettings(did);
+  blocklet.controller = blockletExtra?.controller;
+
+  const ownerDid = blocklet.settings?.owner?.did;
+  let ownerInfo;
+  if (ownerDid) {
+    logger.info('get owner info', { ownerDid, teamDid: blocklet.appPid });
+    const userState = await teamManager.getUserState(blocklet.appPid);
+    ownerInfo = await userState.getUser(ownerDid);
+  }
+
+  return publishDidDocument({ blocklet, ownerInfo, nodeInfo });
+};
+
+/**
+ * Update DID document state only (e.g., to 'deleted') without fetching from database
+ * Used when blocklet is being removed and database data may not be available
+ * @param {object} options - Options
+ * @param {string} options.did - Blocklet DID
+ * @param {object} options.blocklet - Blocklet object
+ * @param {string} options.state - New state
+ * @param {object} options.nodeInfo - Node info
+ */
+const updateDidDocumentStateOnly = ({ did, blocklet, state, nodeInfo }) => {
+  logger.debug('update did document state only', { did, state });
+
+  const { wallet } = getBlockletInfo(blocklet, nodeInfo.sk);
+
+  return didDocument.updateBlockletStateOnly({
+    did,
+    state,
+    didRegistryUrl: nodeInfo.didRegistry,
+    wallet,
+    blockletServerVersion: nodeInfo.version,
+  });
+};
+
+module.exports = {
+  shouldEnableSlpDomain,
+  getSlpDid,
+  getBlockletKnownAs,
+  publishDidDocument,
+  updateDidDocument,
+  updateDidDocumentStateOnly,
+};