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

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

@@ -0,0 +1,365 @@
+/* eslint-disable no-await-in-loop */
+/**
+ * Install Utilities Module
+ *
+ * Functions for blocklet installation, verification, and bundle management
+ * Extracted from blocklet.js for better modularity
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+const tar = require('tar');
+const get = require('lodash/get');
+const streamToPromise = require('stream-to-promise');
+const { Throttle } = require('stream-throttle');
+const ssri = require('ssri');
+const diff = require('deep-diff');
+
+const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet:install-utils');
+const formatBackSlash = require('@abtnode/util/lib/format-back-slash');
+const hashFiles = require('@abtnode/util/lib/hash-files');
+const { BLOCKLET_INSTALL_TYPE } = require('@abtnode/constant');
+
+const { BlockletStatus, BlockletSource, fromBlockletStatus } = require('@blocklet/constant');
+const { forEachBlockletSync } = require('@blocklet/meta/lib/util');
+
+/**
+ * Get version scope string with hash for unique directory naming
+ * @param {object} meta - Blocklet meta
+ * @returns {string} Version scope string
+ */
+const getVersionScope = (meta) => {
+  if (meta.dist?.integrity) {
+    const safeHash = meta.dist.integrity
+      .replace('sha512-', '')
+      .slice(0, 8)
+      .replace(/[^a-zA-Z0-9]/g, '');
+    return `${meta.version}-${safeHash}`;
+  }
+
+  return meta.version;
+};
+
+/**
+ * Expand tarball to destination directory
+ * @param {object} options - Options
+ * @param {string} options.source - Source tarball path
+ * @param {string} options.dest - Destination directory
+ * @param {number} options.strip - Number of leading directories to strip (default: 1)
+ * @returns {Promise<string>} Destination path
+ */
+const expandTarball = async ({ source, dest, strip = 1 }) => {
+  logger.info('expand blocklet', { source, dest });
+
+  if (!fs.existsSync(source)) {
+    throw new Error(`Blocklet tarball ${source} does not exist`);
+  }
+
+  fs.mkdirSync(dest, { recursive: true });
+
+  await streamToPromise(
+    fs
+      .createReadStream(source)
+      .pipe(new Throttle({ rate: 1024 * 1024 * 20 })) // 20MB
+      .pipe(tar.x({ C: dest, strip }))
+  );
+
+  return dest;
+};
+
+/**
+ * Verify file integrity using SSRI
+ * @param {object} options - Options
+ * @param {string} options.file - File path
+ * @param {string} options.integrity - Expected integrity hash
+ * @returns {Promise<boolean>} True if valid
+ */
+const verifyIntegrity = async ({ file, integrity: expected }) => {
+  const stream = fs.createReadStream(file);
+  const result = await ssri.checkStream(stream, ssri.parse(expected));
+  logger.debug('verify integrity result', { result });
+  stream.destroy();
+  return true;
+};
+
+/**
+ * Get all app directories from install directory
+ * @param {string} installDir - Installation directory
+ * @returns {Promise<Array<{ key: string, dir: string }>>} App directories
+ */
+const getAppDirs = async (installDir) => {
+  const appDirs = [];
+
+  const getNextLevel = (level, name) => {
+    if (level === 'root') {
+      if (name.startsWith('@')) {
+        return 'scope';
+      }
+      return 'name';
+    }
+    if (level === 'scope') {
+      return 'name';
+    }
+    if (level === 'name') {
+      return 'version';
+    }
+    throw new Error(`Invalid level ${level}`);
+  };
+
+  const fillAppDirs = async (dir, level = 'root') => {
+    if (level === 'version') {
+      appDirs.push({
+        key: formatBackSlash(path.relative(installDir, dir)),
+        dir,
+      });
+
+      return;
+    }
+
+    const nextDirs = [];
+    for (const x of await fs.promises.readdir(dir)) {
+      if (!fs.lstatSync(path.join(dir, x)).isDirectory()) {
+        logger.error('pruneBlockletBundle: invalid file in bundle storage', { dir, file: x });
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      nextDirs.push(x);
+    }
+
+    for (const x of nextDirs) {
+      await fillAppDirs(path.join(dir, x), getNextLevel(level, x));
+    }
+  };
+
+  await fillAppDirs(installDir, 'root');
+
+  return appDirs;
+};
+
+/**
+ * Prune unused blocklet bundles from install directory
+ * @param {object} options - Options
+ * @param {Array} options.blocklets - Current blocklets
+ * @param {string} options.installDir - Installation directory
+ * @param {Array} options.blockletSettings - Blocklet settings with children
+ */
+const pruneBlockletBundle = async ({ blocklets, installDir, blockletSettings }) => {
+  for (const blocklet of blocklets) {
+    if (
+      [
+        BlockletStatus.waiting,
+        BlockletStatus.installing,
+        BlockletStatus.upgrading,
+        BlockletStatus.downloading,
+      ].includes(blocklet.status)
+    ) {
+      logger.info('There are blocklet activities in progress, abort pruning', {
+        bundleName: blocklet.meta.bundleName,
+        status: fromBlockletStatus(blocklet.status),
+      });
+      return;
+    }
+  }
+
+  // blockletMap: { <[scope/]name/version>: true }
+  const blockletMap = {};
+  for (const blocklet of blocklets) {
+    forEachBlockletSync(blocklet, (component) => {
+      blockletMap[`${component.meta.bundleName}/${component.meta.version}`] = true;
+      blockletMap[`${component.meta.bundleName}/${getVersionScope(component.meta)}`] = true;
+    });
+  }
+  for (const setting of blockletSettings) {
+    for (const child of setting.children || []) {
+      if (child.status !== BlockletStatus.deleted) {
+        forEachBlockletSync(child, (component) => {
+          blockletMap[`${component.meta.bundleName}/${component.meta.version}`] = true;
+          blockletMap[`${component.meta.bundleName}/${getVersionScope(component.meta)}`] = true;
+        });
+      }
+    }
+  }
+
+  // fill appDirs
+  let appDirs = [];
+  try {
+    appDirs = await getAppDirs(installDir);
+  } catch (error) {
+    logger.error('fill app dirs failed', { error });
+  }
+
+  const ensureBundleDirRemoved = async (dir) => {
+    const relativeDir = path.relative(installDir, dir);
+    const arr = relativeDir.split(path.sep).filter(Boolean);
+    const { length } = arr;
+    const bundleName = arr[length - 2];
+    const scopeName = length > 2 ? arr[length - 3] : '';
+    const bundleDir = path.join(installDir, scopeName, bundleName);
+    const isDirEmpty = (await fs.promises.readdir(bundleDir)).length === 0;
+    if (isDirEmpty) {
+      logger.info('Remove bundle folder', { bundleDir });
+      await fs.remove(bundleDir);
+    }
+    if (scopeName) {
+      const scopeDir = path.join(installDir, scopeName);
+      const isScopeEmpty = (await fs.promises.readdir(scopeDir)).length === 0;
+      if (isScopeEmpty) {
+        logger.info('Remove scope folder', { scopeDir });
+        await fs.remove(scopeDir);
+      }
+    }
+  };
+
+  // remove trash
+  for (const app of appDirs) {
+    if (!blockletMap[app.key]) {
+      logger.info('Remove app folder', { dir: app.dir });
+      await fs.remove(app.dir);
+      await ensureBundleDirRemoved(app.dir);
+    }
+  }
+
+  logger.info('Blocklet source folder has been pruned');
+};
+
+/**
+ * Get install type from params
+ * @param {object} params - Install params
+ * @returns {string} BLOCKLET_INSTALL_TYPE
+ */
+const getTypeFromInstallParams = (params) => {
+  if (params.type) {
+    if (!Object.values(BLOCKLET_INSTALL_TYPE).includes(params.type)) {
+      throw new Error(`Can only install blocklet from ${Object.values(BLOCKLET_INSTALL_TYPE).join('/')}`);
+    }
+    return params.type;
+  }
+
+  if (params.url) {
+    return BLOCKLET_INSTALL_TYPE.URL;
+  }
+
+  if (params.file) {
+    throw new Error('install from upload is not supported');
+  }
+
+  if (params.did) {
+    return BLOCKLET_INSTALL_TYPE.STORE;
+  }
+
+  if (params.title && params.description) {
+    return BLOCKLET_INSTALL_TYPE.CREATE;
+  }
+
+  throw new Error(`Can only install blocklet from ${Object.values(BLOCKLET_INSTALL_TYPE).join('/')}`);
+};
+
+/**
+ * Get diff files between input files and source directory
+ * @param {Array} inputFiles - Input files with hash
+ * @param {string} sourceDir - Source directory
+ * @returns {Promise<{ addSet: Array, changeSet: Array, deleteSet: Array }>}
+ */
+const getDiffFiles = async (inputFiles, sourceDir) => {
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error(`${sourceDir} does not exist`);
+  }
+
+  const files = inputFiles.reduce((obj, item) => {
+    obj[item.file] = item.hash;
+    return obj;
+  }, {});
+
+  const { files: sourceFiles } = await hashFiles(sourceDir, {
+    filter: (x) => x.indexOf('node_modules') === -1,
+    concurrentHash: 1,
+  });
+
+  const addSet = [];
+  const changeSet = [];
+  const deleteSet = [];
+
+  const diffFiles = diff(sourceFiles, files);
+  if (diffFiles) {
+    diffFiles.forEach((item) => {
+      if (item.kind === 'D') {
+        deleteSet.push(item.path[0]);
+      }
+      if (item.kind === 'E') {
+        changeSet.push(item.path[0]);
+      }
+      if (item.kind === 'N') {
+        addSet.push(item.path[0]);
+      }
+    });
+  }
+
+  return {
+    addSet,
+    changeSet,
+    deleteSet,
+  };
+};
+
+const checkCompatibleOnce = {};
+
+/**
+ * Check compatibility with old blocklets that use blocklet.yml
+ * @param {string} dir - Directory to check
+ * @returns {boolean}
+ */
+const compatibleWithOldBlocklets = (dir) => {
+  if (checkCompatibleOnce[dir] !== undefined) {
+    return checkCompatibleOnce[dir];
+  }
+
+  checkCompatibleOnce[dir] = !!fs.existsSync(path.join(dir, 'blocklet.yml'));
+
+  return checkCompatibleOnce[dir];
+};
+
+/**
+ * Get bundle directory for blocklet
+ * @param {string} installDir - Installation directory
+ * @param {object} meta - Blocklet meta
+ * @returns {string} Bundle directory path
+ */
+const getBundleDir = (installDir, meta) => {
+  const oldDir = path.join(installDir, meta.bundleName || meta.name, meta.version);
+  if (compatibleWithOldBlocklets(oldDir)) {
+    return oldDir;
+  }
+
+  return path.join(installDir, meta.bundleName || meta.name, getVersionScope(meta));
+};
+
+/**
+ * Check if blocklet needs to be downloaded
+ * @param {object} blocklet - New blocklet
+ * @param {object} oldBlocklet - Existing blocklet
+ * @returns {boolean}
+ */
+const needBlockletDownload = (blocklet, oldBlocklet) => {
+  if ([BlockletSource.upload, BlockletSource.local, BlockletSource.custom].includes(blocklet.source)) {
+    return false;
+  }
+
+  if (!get(oldBlocklet, 'meta.dist.integrity')) {
+    return true;
+  }
+
+  return get(oldBlocklet, 'meta.dist.integrity') !== get(blocklet, 'meta.dist.integrity');
+};
+
+module.exports = {
+  getVersionScope,
+  expandTarball,
+  verifyIntegrity,
+  getAppDirs,
+  pruneBlockletBundle,
+  getTypeFromInstallParams,
+  getDiffFiles,
+  compatibleWithOldBlocklets,
+  getBundleDir,
+  needBlockletDownload,
+};

package/lib/util/blocklet/logo.js

@@ -0,0 +1,57 @@
+/**
+ * Logo Module
+ *
+ * Functions for blocklet logo generation and management
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+
+const { isEthereumDid } = require('@arcblock/did');
+const { toSvg: createDidLogo } = require('@arcblock/did-motif');
+const { createBlockiesSvg } = require('@blocklet/meta/lib/blockies');
+const { BlockletSource } = require('@blocklet/constant');
+
+const { getBundleDir } = require('./install-utils');
+
+/**
+ * Update blocklet fallback logo with DID-based SVG
+ * @param {object} blocklet - Blocklet object with env.dataDir and meta.did
+ */
+const updateBlockletFallbackLogo = async (blocklet) => {
+  if (isEthereumDid(blocklet.meta.did)) {
+    await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createBlockiesSvg(blocklet.meta.did));
+  } else {
+    await fs.writeFile(path.join(blocklet.env.dataDir, 'logo.svg'), createDidLogo(blocklet.meta.did));
+  }
+};
+
+/**
+ * Ensure app logo exists by copying from component if needed
+ * @param {object} blocklet - Blocklet object
+ * @param {string} blockletsDir - Blocklets directory path
+ */
+const ensureAppLogo = async (blocklet, blockletsDir) => {
+  if (!blocklet) {
+    return;
+  }
+
+  if (
+    blocklet.source === BlockletSource.custom &&
+    (blocklet.children || [])[0]?.meta?.logo &&
+    blocklet.children[0].env.appDir
+  ) {
+    const fileName = blocklet.children[0].meta.logo;
+    const src = path.join(blocklet.children[0].env.appDir, fileName);
+    const dist = path.join(getBundleDir(blockletsDir, blocklet.meta), fileName);
+
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dist);
+    }
+  }
+};
+
+module.exports = {
+  updateBlockletFallbackLogo,
+  ensureAppLogo,
+};

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

@@ -0,0 +1,269 @@
+/**
+ * Meta Utils Module
+ *
+ * Functions for managing blocklet metadata, themes, and status utilities
+ * Extracted from blocklet.js for better modularity
+ */
+
+const cloneDeep = require('lodash/cloneDeep');
+const mergeWith = require('lodash/mergeWith');
+const semver = require('semver');
+
+const { BLOCKLET_THEME_LIGHT, BLOCKLET_THEME_DARK } = require('@blocklet/theme');
+const { getComponentConfig } = require('@blocklet/resolver');
+const { BlockletStatus, BlockletGroup, BlockletSource } = require('@blocklet/constant');
+const {
+  forEachChildSync,
+  findWebInterface,
+  forEachComponentV2Sync,
+  isInProgress,
+  isRunning,
+} = require('@blocklet/meta/lib/util');
+
+/**
+ * Format blocklet theme configuration
+ * @param {object} rawTheme - Raw theme configuration
+ * @returns {object} Formatted theme configuration
+ */
+const formatBlockletTheme = (rawTheme) => {
+  let themeConfig = {};
+
+  if (rawTheme) {
+    if (Array.isArray(rawTheme.concepts) && rawTheme.currentConceptId) {
+      const concept = rawTheme.concepts.find((x) => x.id === rawTheme.currentConceptId);
+      themeConfig = {
+        ...concept.themeConfig,
+        prefer: concept.prefer,
+        name: concept.name,
+      };
+    } else {
+      // 兼容旧数据
+      themeConfig = {
+        light: rawTheme.light || {},
+        dark: rawTheme.dark || {},
+        common: rawTheme.common || {},
+        prefer: rawTheme.prefer || 'system',
+        name: rawTheme.name || 'Default',
+      };
+    }
+  }
+
+  const result = mergeWith(
+    // 至少提供 palette 色板值（客户端会使用）
+    cloneDeep({
+      light: { palette: BLOCKLET_THEME_LIGHT.palette },
+      dark: { palette: BLOCKLET_THEME_DARK.palette },
+      prefer: 'system',
+    }),
+    themeConfig,
+    // 数组值直接替换
+    (_, srcValue) => {
+      if (Array.isArray(srcValue)) {
+        return srcValue;
+      }
+      return undefined;
+    }
+  );
+
+  // 保留原始数据，用于 settings 保存
+  Object.defineProperty(result, 'raw', {
+    value: rawTheme,
+    enumerable: false,
+    writable: false,
+  });
+
+  return result;
+};
+
+/**
+ * merge services
+ * from meta.children[].mountPoints[].services, meta.children[].services
+ * to childrenMeta[].interfaces[].services
+ *
+ * @param {array<child>|object{children:array}} source e.g. [<config>] or { children: [<config>] }
+ * @param {array<meta|{meta}>} childrenMeta e.g. [<meta>] or [{ meta: <meta> }]
+ */
+const mergeMeta = (source, childrenMeta = []) => {
+  // configMap
+  const configMap = {};
+  (Array.isArray(source) ? source : getComponentConfig(source) || []).forEach((x) => {
+    configMap[x.name] = x;
+  });
+
+  // merge service from config to child meta
+  childrenMeta.forEach((child) => {
+    const childMeta = child.meta || child;
+    const config = configMap[childMeta.name];
+    if (!config) {
+      return;
+    }
+
+    (config.mountPoints || []).forEach((mountPoint) => {
+      if (!mountPoint.services) {
+        return;
+      }
+
+      const childInterface = childMeta.interfaces.find((y) => y.name === mountPoint.child.interfaceName);
+      if (childInterface) {
+        // merge
+        const services = childInterface.services || [];
+        mountPoint.services.forEach((x) => {
+          const index = services.findIndex((y) => y.name === x.name);
+          if (index >= 0) {
+            services.splice(index, 1, x);
+          } else {
+            services.push(x);
+          }
+        });
+        childInterface.services = services;
+      }
+    });
+
+    if (config.services) {
+      const childInterface = findWebInterface(childMeta);
+      if (childInterface) {
+        // merge
+        const services = childInterface.services || [];
+        config.services.forEach((x) => {
+          const index = services.findIndex((y) => y.name === x.name);
+          if (index >= 0) {
+            services.splice(index, 1, x);
+          } else {
+            services.push(x);
+          }
+        });
+        childInterface.services = services;
+      }
+    }
+  });
+};
+
+/**
+ * Get list of components that need updates based on version comparison
+ * @param {object} oldBlocklet - Old blocklet state
+ * @param {object} newBlocklet - New blocklet state
+ * @returns {Array} Array of {id, meta} for components needing update
+ */
+const getUpdateMetaList = (oldBlocklet = {}, newBlocklet = {}) => {
+  const oldMap = {};
+  forEachChildSync(oldBlocklet, (b, { id }) => {
+    if (b.bundleSource) {
+      oldMap[id] = b.meta.version;
+    }
+  });
+
+  const res = [];
+
+  forEachChildSync(newBlocklet, (b, { id }) => {
+    if ((b.bundleSource && semver.gt(b.meta.version, oldMap[id])) || process.env.TEST_UPDATE_ALL_BLOCKLET === 'true') {
+      res.push({ id, meta: b.meta });
+    }
+  });
+
+  return res;
+};
+
+/**
+ * Get fixed bundle source from component
+ * @param {object} component - Component object
+ * @returns {object|null} Bundle source object or null
+ */
+const getFixedBundleSource = (component) => {
+  if (!component) {
+    return null;
+  }
+
+  if (component.bundleSource) {
+    return component.bundleSource;
+  }
+
+  const { source, deployedFrom, meta: { bundleName } = {} } = component;
+
+  if (!deployedFrom) {
+    return null;
+  }
+
+  if (source === BlockletSource.registry && bundleName) {
+    return {
+      store: deployedFrom,
+      name: bundleName,
+      version: 'latest',
+    };
+  }
+
+  if (source === BlockletSource.url) {
+    return {
+      url: deployedFrom,
+    };
+  }
+
+  return null;
+};
+
+/**
+ * Get computed status of a blocklet based on its components
+ * @param {object} blocklet - Blocklet object
+ * @returns {string} Computed status
+ */
+const getBlockletStatus = (blocklet) => {
+  const fallbackStatus = BlockletStatus.stopped;
+
+  if (!blocklet) {
+    return fallbackStatus;
+  }
+
+  if (!blocklet.children?.length) {
+    if (blocklet.meta?.group === BlockletGroup.gateway) {
+      return blocklet.status;
+    }
+
+    if (blocklet.status === BlockletStatus.added) {
+      return BlockletStatus.added;
+    }
+
+    // for backward compatibility
+    if (!blocklet.structVersion) {
+      return blocklet.status;
+    }
+
+    return fallbackStatus;
+  }
+
+  let inProgressStatus;
+  let runningStatus;
+  let status;
+
+  forEachComponentV2Sync(blocklet, (component) => {
+    if (component.meta?.group === BlockletGroup.gateway) {
+      return;
+    }
+
+    if (isInProgress(component.status)) {
+      if (!inProgressStatus) {
+        inProgressStatus = component.status;
+      }
+      return;
+    }
+
+    if (isRunning(component.status) || isRunning(component.greenStatus)) {
+      runningStatus = BlockletStatus.running;
+      return;
+    }
+
+    if (status === BlockletStatus.stopped) {
+      return;
+    }
+
+    status = component.status;
+  });
+
+  return inProgressStatus || runningStatus || status;
+};
+
+module.exports = {
+  formatBlockletTheme,
+  mergeMeta,
+  getUpdateMetaList,
+  getFixedBundleSource,
+  getBlockletStatus,
+};