@abtnode/util 1.16.45-beta-20250620-082630-c0c76051 → 1.16.45-beta-20250624-134945-a23c15fc

package/lib/upload-component.js

@@ -0,0 +1,393 @@
+const path = require('path');
+const fs = require('fs-extra');
+const tar = require('tar');
+const { types } = require('@ocap/mcrypto');
+const { fromRandom } = require('@ocap/wallet');
+const { update: updateMetaFile, read: readMetaFile } = require('@blocklet/meta/lib/file');
+const {
+  BLOCKLET_GROUPS,
+  BLOCKLET_LATEST_SPEC_VERSION,
+  BLOCKLET_DEFAULT_VERSION,
+  BLOCKLET_META_FILE,
+  BLOCKLET_RELEASE_FOLDER_NAME,
+  BLOCKLET_BUNDLE_FOLDER_NAME,
+  BLOCKLET_RELEASE_FILE,
+} = require('@blocklet/constant');
+const { MAX_UPLOAD_FILE_SIZE } = require('@abtnode/constant');
+const { zipToDir } = require('./zip');
+
+const { createRelease } = require('./create-blocklet-release');
+
+const TEMP_DIR_NAME = 'blocklet-upload-tmp';
+const HTML_MIME_TYPE = 'text/html';
+const GZIP_MIME_TYPE = 'application/gzip';
+const ZIP_MIME_TYPE = 'application/zip';
+const ALLOW_UPLOAD_MIME_TYPES = [HTML_MIME_TYPE, GZIP_MIME_TYPE, ZIP_MIME_TYPE];
+
+const maxUploadSize = Number(process.env.MAX_UPLOAD_FILE_SIZE) || MAX_UPLOAD_FILE_SIZE;
+
+const hasHtmlFile = (dir) => {
+  const files = ['index.html', 'index.htm'];
+  return files.some((file) => fs.existsSync(path.join(dir, file)));
+};
+
+/**
+ * 递归检查文件夹中是否存在指定文件
+ * 优先查找当前层级，再递归查找子目录，确保外层优先级最高
+ * @param {string} dir - 要检测的文件夹路径
+ * @param {string[]} filenames - 要查找的文件名数组
+ * @param {string} rootDir - 相对路径的根目录，用于计算相对路径
+ * @param {number} maxDepth - 最大搜索深度，默认为5
+ * @param {number} currentDepth - 当前递归深度，默认为0
+ * @returns {Promise<Object>} 返回找到的文件映射 {filename: relativePath}
+ */
+const checkFileExist = async (dir, filenames = [], rootDir = null, maxDepth = 5, currentDepth = 0) => {
+  if (!dir || !filenames.length) return {};
+
+  const baseDir = rootDir || dir;
+  const result = {};
+
+  try {
+    // 读取当前目录内容
+    const files = await fs.readdir(dir);
+
+    // 串行获取文件统计信息，避免并行操作
+    const stats = [];
+    // eslint-disable-next-line no-await-in-loop
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      // eslint-disable-next-line no-await-in-loop
+      const stat = await fs.stat(fullPath);
+      stats.push({ file, fullPath, stat });
+    }
+
+    // 优先在当前层级查找文件
+    for (const { file, fullPath, stat } of stats) {
+      if (!stat.isDirectory() && filenames.includes(file)) {
+        result[file] = path.relative(baseDir, fullPath);
+      }
+    }
+
+    // 对于未找到的文件，递归查找子目录（但不超过最大深度）
+    const remainingFiles = filenames.filter((name) => !result[name]);
+    if (remainingFiles.length > 0 && currentDepth < maxDepth) {
+      for (const { fullPath, stat } of stats) {
+        if (stat.isDirectory()) {
+          // 串行递归查找，确保操作顺序，传递深度信息
+          // eslint-disable-next-line no-await-in-loop
+          const found = await checkFileExist(fullPath, remainingFiles, baseDir, maxDepth, currentDepth + 1);
+          // 只添加当前结果中不存在的文件（保证外层优先级）
+          Object.keys(found).forEach((key) => {
+            if (!result[key]) {
+              result[key] = found[key];
+            }
+          });
+        }
+      }
+    }
+
+    return result;
+  } catch (error) {
+    return {};
+  }
+};
+
+/**
+ * 根据 index.html 的路径计算入口文件的根目录
+ * @param {string} filePath - index.html 文件的相对路径
+ * @returns {string} 入口文件的根目录路径
+ */
+const getEntryFilePath = (filePath) => {
+  if (
+    !filePath ||
+    !filePath.startsWith(`${BLOCKLET_BUNDLE_FOLDER_NAME}/`) ||
+    !filePath.endsWith('index.html') ||
+    !filePath.endsWith('index.html')
+  ) {
+    return '.';
+  }
+
+  // 提取 bundle/ 后面的路径部分
+  const afterBundle = filePath.split(`${BLOCKLET_BUNDLE_FOLDER_NAME}/`)[1];
+  if (!afterBundle) {
+    return '.';
+  }
+
+  // 获取目录路径（去除文件名）
+  const dirPath = path.dirname(afterBundle);
+  return dirPath === '.' ? '.' : dirPath;
+};
+
+/**
+ * 规范化 bundle 目录结构
+ * 如果解压后只有一个文件夹且不是 bundle，则重命名为 bundle
+ * @param {string} tempDir - 临时目录
+ */
+const normalizeBundleStructure = async (tempDir) => {
+  const allContents = await fs.readdir(tempDir);
+  // 过滤隐藏文件
+  const visibleContents = allContents.filter((item) => !item.startsWith('.'));
+
+  if (visibleContents.length === 1) {
+    const itemPath = path.join(tempDir, visibleContents[0]);
+    const stat = await fs.stat(itemPath);
+
+    if (stat.isDirectory() && visibleContents[0] !== BLOCKLET_BUNDLE_FOLDER_NAME) {
+      const bundlePath = path.join(tempDir, BLOCKLET_BUNDLE_FOLDER_NAME);
+      await fs.move(itemPath, bundlePath);
+    }
+  }
+};
+
+/**
+ * 处理压缩文件（.gz 或 .zip）
+ * @param {string} srcFile - 源文件路径
+ * @param {string} mimetype - 文件类型
+ * @param {string} tempDir - 临时目录
+ * @param {string} destDir - 目标目录
+ * @returns {Promise<string>} index.html 的相对路径
+ */
+const handleArchiveFile = async (srcFile, mimetype, tempDir, destDir) => {
+  // 清空临时目录
+  await fs.emptyDir(tempDir);
+
+  try {
+    // 根据文件类型解压
+    if (mimetype === GZIP_MIME_TYPE) {
+      await tar.x({ file: srcFile, C: tempDir });
+    } else if (mimetype === ZIP_MIME_TYPE) {
+      await zipToDir(srcFile, tempDir);
+    }
+  } catch (err) {
+    throw new Error('Only zip or gz archives are supported as resources.');
+  }
+  // 处理解压后的目录结构
+  await normalizeBundleStructure(tempDir);
+
+  // 检查必要文件
+  const foundFiles = await checkFileExist(tempDir, ['blocklet.yml', 'index.html', 'index.htm']);
+  if (!foundFiles['blocklet.yml'] && !foundFiles['index.html'] && !foundFiles['index.htm']) {
+    throw new Error('Unable to parse the uploaded file, missing blocklet.yml or index.html or index.htm');
+  }
+
+  // 复制文件到目标目录
+  await fs.copy(tempDir, destDir);
+
+  // 如果不是 blocklet 项目，返回 index.html 路径
+  return foundFiles['blocklet.yml'] ? '' : foundFiles['index.html'] || foundFiles['index.htm'];
+};
+
+/**
+ * 处理 HTML 文件
+ * @param {string} srcFile - 源文件路径
+ * @param {string} destDir - 目标目录
+ */
+const handleHtmlFile = async (srcFile, destDir) => {
+  const bundleDir = path.join(destDir, BLOCKLET_BUNDLE_FOLDER_NAME);
+  await fs.ensureDir(bundleDir);
+  await fs.copy(srcFile, path.join(bundleDir, 'index.html'));
+};
+
+/**
+ * 生成 blocklet 元数据文件
+ * @param {string} destDir - 目标目录
+ * @param {string} baseName - 基础名称
+ * @param {string} indexPath - index.html 路径
+ * @param {Object} user - 用户对象
+ */
+const generateBlockletMeta = async (destDir, baseName, indexPath, user) => {
+  // 只有在需要时才生成元数据（HTML文件或有indexPath）
+  if (!indexPath && (await fs.pathExists(path.join(destDir, BLOCKLET_BUNDLE_FOLDER_NAME, BLOCKLET_META_FILE)))) {
+    return; // 已存在 blocklet.yml，无需生成
+  }
+
+  const randomWallet = fromRandom({ role: types.RoleType.ROLE_BLOCKLET });
+  const meta = {
+    name: randomWallet.address,
+    title: baseName.slice(0, 40),
+    description: `${baseName} (uploaded)`,
+    group: BLOCKLET_GROUPS[1], // static
+    publicUrl: '/',
+    main: !indexPath ? '.' : getEntryFilePath(indexPath),
+    author: user?.fullName || user?.email || 'Blocklet',
+    specVersion: BLOCKLET_LATEST_SPEC_VERSION,
+    version: BLOCKLET_DEFAULT_VERSION,
+    logo: 'logo.png',
+    did: randomWallet.address,
+    interfaces: [
+      {
+        type: 'web',
+        name: 'publicUrl',
+        path: '/',
+        prefix: '*',
+        port: 'BLOCKLET_PORT',
+        protocol: 'http',
+        proxyBehavior: 'service',
+      },
+    ],
+  };
+
+  const metaPath = path.join(destDir, BLOCKLET_BUNDLE_FOLDER_NAME, BLOCKLET_META_FILE);
+  await updateMetaFile(metaPath, meta);
+};
+
+/**
+ * 清理临时文件
+ * @param {string} srcFile - 源文件路径
+ * @param {string} tempDir - 临时目录路径
+ */
+const cleanup = async (srcFile, tempDir) => {
+  try {
+    // 串行删除，确保操作完成
+    if (await fs.pathExists(srcFile)) {
+      await fs.remove(srcFile);
+    }
+    if (await fs.pathExists(tempDir)) {
+      await fs.emptyDir(tempDir);
+    }
+  } catch (error) {
+    // 清理失败不影响主流程，只记录错误
+    console.warn('Failed to clean up temporary files:', error.message);
+  }
+};
+
+/**
+ * 处理文件上传的核心逻辑
+ * @param {Object} node - 节点对象
+ * @param {Object} uploadMetadata - 上传文件的元数据
+ * @param {Object} blocklet - Blocklet 对象
+ * @param {Object} user - 用户对象
+ * @returns {Promise<Object>} 处理结果
+ */
+const onUploadComponent = async (node, uploadMetadata, blocklet, user) => {
+  const {
+    id: filename,
+    size,
+    metadata: { filename: originalname, filetype: mimetype },
+  } = uploadMetadata;
+
+  const srcFile = path.join(node.dataDirs.tmp, filename);
+
+  // 验证文件存在性
+  if (!(await fs.pathExists(srcFile))) {
+    throw new Error(`File not found: ${filename}`);
+  }
+
+  // 验证文件类型
+  if (!ALLOW_UPLOAD_MIME_TYPES.includes(mimetype)) {
+    throw new Error(`Unsupported file type: ${mimetype}`);
+  }
+
+  // 验证文件大小
+  if (size > maxUploadSize * 1024 * 1024) {
+    throw new Error(`File size exceeds the limit: ${maxUploadSize}MB`);
+  }
+
+  // 初始化目录结构
+  const tempDir = path.join(node.dataDirs.tmp, TEMP_DIR_NAME);
+  const baseName = path.parse(originalname).name;
+  const destDir = path.join(blocklet.env.dataDir, 'components', baseName);
+
+  await fs.ensureDir(tempDir);
+  await fs.ensureDir(destDir);
+
+  let indexPath = '';
+
+  try {
+    // 根据文件类型处理解压或复制
+    if (mimetype === GZIP_MIME_TYPE || mimetype === ZIP_MIME_TYPE) {
+      indexPath = await handleArchiveFile(srcFile, mimetype, tempDir, destDir);
+    } else if (mimetype === HTML_MIME_TYPE) {
+      await handleHtmlFile(srcFile, destDir);
+    }
+
+    // 生成 blocklet 元数据
+    await generateBlockletMeta(destDir, baseName, indexPath, user);
+
+    // 创建发布包
+    const release = await createRelease(destDir);
+
+    // 清理临时文件
+    // FIXME: 我们使用的上传组件，在上传完成后会验证上传文件是否存在，如果立即清理会在前端显示上传失败
+    // 所以这里需要有一点延迟清理
+    setTimeout(() => {
+      cleanup(srcFile, tempDir);
+    }, 5000);
+
+    const releaseDir = path.join(destDir, BLOCKLET_RELEASE_FOLDER_NAME);
+    return {
+      filename,
+      size,
+      originalname,
+      mimetype,
+      meta: release.meta,
+      inputUrl: `file://${path.join(releaseDir, BLOCKLET_RELEASE_FILE)}`,
+    };
+  } catch (error) {
+    // 出错时清理临时文件
+    cleanup(srcFile, tempDir);
+    throw error;
+  }
+};
+
+/**
+ * 更新组件的 DID，用于覆盖已上传的内容
+ * @param {string} url - 安装包地址（file:// 开头的 blocklet.json 文件地址）
+ * @param {string} did - 要更新的 DID
+ * @returns {Promise<Object>} 更新后的元数据
+ */
+const updateComponentDid = async (url, did) => {
+  if (!url.startsWith('file://')) {
+    throw new Error('URL must start with file://');
+  }
+
+  // 根据 blocklet.json 路径定位 bundle 目录
+  const releaseDir = path.dirname(url.replace('file://', ''));
+  const bundlePath = path.join(releaseDir, '..', BLOCKLET_BUNDLE_FOLDER_NAME);
+  const blockletYmlPath = path.join(bundlePath, BLOCKLET_META_FILE);
+
+  // 串行执行：读取 -> 更新 -> 写入 -> 重新打包
+  const existingMeta = await readMetaFile(blockletYmlPath);
+  if (existingMeta.did !== did) {
+    existingMeta.did = did;
+    await updateMetaFile(blockletYmlPath, existingMeta);
+
+    // 重新创建发布包
+    const release = await createRelease(path.join(bundlePath, '..'));
+    return release.meta;
+  }
+  return existingMeta;
+};
+
+/**
+ * 清空上传的文件
+ * @param {string} url - 安装包地址（file:// 开头的 blocklet.json 文件地址）
+ * @param {string} tempDir - 临时目录路径
+ */
+const removeUploadFile = async (url) => {
+  if (!url.startsWith('file://')) {
+    throw new Error('URL must start with file://');
+  }
+
+  try {
+    const releaseDir = path.dirname(url.replace('file://', ''));
+    // 获取上传的文件夹
+    const componentDir = path.dirname(releaseDir, '..');
+    // 判断是否有这个文件夹，如果有在进行删除
+    if (await fs.pathExists(componentDir)) {
+      await fs.remove(componentDir);
+    }
+  } catch (error) {
+    console.error('removeUploadFile failed', { error });
+    throw error;
+  }
+};
+
+module.exports = {
+  checkFileExist,
+  TEMP_DIR_NAME,
+  onUploadComponent,
+  updateComponentDid,
+  removeUploadFile,
+  hasHtmlFile,
+};

package/lib/zip.js

@@ -0,0 +1,43 @@
+const archiver = require('archiver');
+const { ensureDirSync, existsSync, removeSync, createWriteStream } = require('fs-extra');
+const { dirname } = require('path');
+const StreamZip = require('node-stream-zip');
+
+/**
+ *
+ *
+ * @param {string} source ~/abc/ 通常是一个文件夹
+ * @param {string} target abc.zip 压缩包的名称
+ * @return {*}
+ */
+function dirToZip(source, target) {
+  return new Promise((resolve, reject) => {
+    ensureDirSync(dirname(target));
+
+    if (existsSync(target)) {
+      removeSync(target);
+    }
+
+    const output = createWriteStream(target);
+    const archive = archiver('zip', { level: 9 });
+    archive.on('error', (err) => reject(err));
+    output.on('close', () => resolve());
+
+    archive.directory(source, false);
+
+    archive.pipe(output);
+    archive.finalize();
+  });
+}
+
+async function zipToDir(source, target) {
+  // eslint-disable-next-line new-cap
+  const zip = new StreamZip.async({ file: source });
+  await zip.extract(null, target);
+  await zip.close();
+}
+
+module.exports = {
+  dirToZip,
+  zipToDir,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.45-beta-20250620-082630-c0c76051",
+  "version": "1.16.45-beta-20250624-134945-a23c15fc",
   "description": "ArcBlock's JavaScript utility",
   "main": "lib/index.js",
   "files": [
@@ -18,13 +18,13 @@
   "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/constant": "1.16.45-beta-20250620-082630-c0c76051",
-    "@abtnode/db-cache": "1.16.45-beta-20250620-082630-c0c76051",
+    "@abtnode/constant": "1.16.45-beta-20250624-134945-a23c15fc",
+    "@abtnode/db-cache": "1.16.45-beta-20250624-134945-a23c15fc",
     "@arcblock/did": "1.20.14",
     "@arcblock/pm2": "^5.4.0",
-    "@blocklet/constant": "1.16.45-beta-20250620-082630-c0c76051",
+    "@blocklet/constant": "1.16.45-beta-20250624-134945-a23c15fc",
     "@blocklet/error": "^0.2.5",
-    "@blocklet/meta": "1.16.45-beta-20250620-082630-c0c76051",
+    "@blocklet/meta": "1.16.45-beta-20250624-134945-a23c15fc",
     "@blocklet/xss": "^0.1.36",
     "@ocap/client": "1.20.14",
     "@ocap/mcrypto": "1.20.14",
@@ -58,6 +58,7 @@
     "lodash": "^4.17.21",
     "minimatch": "^9.0.4",
     "multiformats": "9.9.0",
+    "node-stream-zip": "^1.15.0",
     "npm-packlist": "^7.0.4",
     "p-retry": "^4.6.2",
     "p-wait-for": "^3.2.0",
@@ -88,5 +89,5 @@
     "fs-extra": "^11.2.0",
     "jest": "^29.7.0"
   },
-  "gitHead": "70151f84be54392ce491a1f40976e533286d06b8"
+  "gitHead": "3b56a1dbe3fea9df0d6b644a1821afae9b376ee8"
 }