@cloudbase/manager-node 5.5.6 → 5.5.7-beta.1

package/lib/function/index.js

@@ -192,7 +192,9 @@ function configToParams(options) {
     if ((_c = func === null || func === void 0 ? void 0 : func.layers) === null || _c === void 0 ? void 0 : _c.length) {
         params.Layers = func.layers.map(item => ({
             LayerName: item.name,
-            LayerVersion: item.version
+            // item.version 可能是字符串（如 JSON 配置文件中的 "1" 或模板变量替换结果），
+            // SCF API 要求 LayerVersion 为 int64，需显式转为 number
+            LayerVersion: Number(item.version)
         }));
     }
     // 7. 代码保护
@@ -818,7 +820,9 @@ class FunctionService {
         if ((_c = func === null || func === void 0 ? void 0 : func.layers) === null || _c === void 0 ? void 0 : _c.length) {
             params.Layers = func.layers.map(item => ({
                 LayerName: item.name,
-                LayerVersion: item.version
+                // item.version 可能是字符串（如 JSON 配置文件中的 "1" 或模板变量替换结果），
+                // SCF API 要求 LayerVersion 为 int64，需显式转为 number
+                LayerVersion: Number(item.version)
             }));
         }
         // 特殊处理：HTTP 函数多并发配置（大小写不敏感）

package/lib/storage/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/member-ordering */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -241,27 +242,30 @@ class StorageService {
         getMetadataController.loadTasks(tasks);
         const files = await getMetadataController.run();
         // 对文件上传进行处理
-        const cos = this.getCos(parallel);
-        const uploadFiles = util_1.default.promisify(cos.uploadFiles).bind(cos);
-        const params = {
-            files,
-            SliceSize: BIG_FILE_SIZE,
+        // 构造 files 数组（格式：{ localPath, cloudPath }），传给 uploadFilesCustom
+        const filesForUpload = fileStatsList
+            .filter(stats => !stats.isDir)
+            .map(stats => ({
+            localPath: stats.filePath,
+            cloudPath: stats.cloudFileKey
+        }));
+        // 调用 uploadFilesCustom（智能混合模式：并行→串行）
+        // 不再直接调用 uploadFilesWithRetry（纯并行重试，容易 socket hang up）
+        return this.uploadFilesCustom({
+            files: filesForUpload,
+            bucket,
+            region,
+            ignore: [],
             onProgress,
-            onFileFinish
-        };
-        return this.uploadFilesWithRetry({
-            uploadFiles,
-            options: params,
-            times: retryCount,
-            interval: retryInterval,
-            failedFiles: []
+            onFileFinish,
+            fileId,
+            parallel,
+            retryCount,
+            retryInterval
         });
     }
-    /**
-     * 批量上传文件
-     * @param options
-     */
     async uploadFilesCustom(options) {
+        var _a;
         const { files, bucket, region, ignore, onProgress, onFileFinish, fileId = true, parallel = 20, retryCount = 0, retryInterval = 500 } = options;
         if (!files || !files.length) {
             return;
@@ -275,6 +279,146 @@ class StorageService {
             };
         })
             .filter(item => ((ignore === null || ignore === void 0 ? void 0 : ignore.length) ? !micromatch_1.default.isMatch(item.filePath, ignore) : true));
+        const totalFiles = fileList.length;
+        console.log(`[uploadFiles] 准备上传 ${totalFiles} 个文件`);
+        // 模式 1：完全串行模式（最稳定）
+        if (process.env.COS_UPLOAD_SERIAL === 'true') {
+            console.log(`[uploadFiles] 串行安全模式已启用`);
+            const serialResult = await this.uploadFilesSerial({
+                fileList,
+                bucket,
+                region,
+                fileId,
+                retryCount,
+                retryInterval,
+                onFileFinish
+            });
+            if (serialResult.failedFiles.length > 0) {
+                throw new error_1.CloudBaseError(`[uploadFiles] 串行上传仍失败 (${serialResult.failedFiles.length} 个):\n` +
+                    serialResult.failedFiles.map(f => `- ${f.cloudFileKey}: ${f.error}`).join('\n'), { code: 'HOSTING_DEPLOY_FAILED' });
+            }
+            return {
+                successCount: serialResult.successCount,
+                totalFiles,
+                failedFiles: []
+            };
+        }
+        // 模式 2：智能混合模式（默认）
+        // - 先并行快速上传
+        // - 失败的文件自动走串行重试
+        console.log(`[uploadFiles] 智能混合模式：先并行快速上传，失败文件自动串行重试`);
+        // 第一步：并行上传（分批）
+        const parallelFailedFiles = await this.uploadFilesParallel({
+            fileList,
+            bucket,
+            region,
+            fileId,
+            parallel,
+            retryCount: 0, // 并行阶段不重试，失败后交给串行阶段
+            retryInterval,
+            onFileFinish
+        });
+        // 第二步：串行重试失败的文件
+        if (parallelFailedFiles && parallelFailedFiles.length > 0) {
+            console.warn(`[uploadFiles] 并行阶段 ${parallelFailedFiles.length} 个文件失败，自动切换串行重试...`);
+            const serialResult = await this.uploadFilesSerial({
+                fileList: parallelFailedFiles,
+                bucket,
+                region,
+                fileId: false, // 串行重试不需要再获取 fileId
+                retryCount,
+                retryInterval,
+                onFileFinish
+            });
+            // 检查是否还有失败
+            if (((_a = serialResult === null || serialResult === void 0 ? void 0 : serialResult.failedFiles) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                throw new error_1.CloudBaseError(`[uploadFiles] 串行重试后仍失败 (${serialResult.failedFiles.length} 个):\n` +
+                    serialResult.failedFiles.map(f => `- ${f.cloudFileKey}: ${f.error}`).join('\n'), { code: 'HOSTING_DEPLOY_FAILED' });
+            }
+        }
+        console.log(`[uploadFiles] 全部完成！共处理 ${totalFiles} 个文件`);
+        return {
+            successCount: totalFiles,
+            totalFiles,
+            failedFiles: []
+        };
+    }
+    /**
+     * 串行安全模式：逐文件上传（类似自定义脚本 deploy.js 的方式）
+     * 特点：
+     * - 每个文件独立 HTTP 连接，不会出现 socket hang up
+     * - 单线程串行，稳定性最高
+     * - 适合大规模目录（>1000 文件）或有网络问题的场景
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async uploadFilesSerial(options) {
+        const { fileList, bucket, region, fileId, retryCount, retryInterval, onFileFinish } = options;
+        let uploadedCount = 0;
+        let failedFiles = [];
+        for (let i = 0; i < fileList.length; i++) {
+            const file = fileList[i];
+            let success = false;
+            // 重试机制
+            for (let attempt = 0; attempt <= retryCount; attempt++) {
+                try {
+                    // 每个文件创建新的 COS 实例（确保连接隔离）
+                    const cos = this.getCos(1); // 严格单并发
+                    const putObject = util_1.default.promisify(cos.putObject).bind(cos);
+                    await putObject({
+                        Bucket: bucket,
+                        Region: region,
+                        Key: file.cloudFileKey,
+                        Body: fs_1.default.createReadStream(file.filePath),
+                        ContentLength: fs_1.default.statSync(file.filePath).size,
+                    });
+                    uploadedCount++;
+                    // 显示进度（每 100 个文件或最后 5 个）
+                    if (uploadedCount % 100 === 0 || fileList.length - i <= 5) {
+                        console.log(`[serial-upload] [${uploadedCount}/${fileList.length}] ${file.cloudFileKey}`);
+                    }
+                    success = true;
+                    // 回调成功
+                    if (onFileFinish) {
+                        onFileFinish(null, {}, file);
+                    }
+                    break;
+                }
+                catch (error) {
+                    const isLastAttempt = attempt === retryCount;
+                    if (isLastAttempt) {
+                        console.error(`[serial-upload] [${i + 1}/${fileList.length}] ${file.cloudFileKey}: ${error.message || error.code}`);
+                        // 记录失败的文件
+                        failedFiles.push(Object.assign(Object.assign({}, file), { error: error.message || String(error) }));
+                        // 回调失败
+                        if (onFileFinish) {
+                            onFileFinish(error, null, file);
+                        }
+                    }
+                    else {
+                        // 等待后重试
+                        await new Promise(resolve => { setTimeout(resolve, retryInterval); });
+                    }
+                }
+            }
+        }
+        console.log(`[serial-upload] 完成：成功 ${uploadedCount}/${fileList.length}，失败 ${failedFiles.length}`);
+        return {
+            successCount: uploadedCount,
+            failedFiles
+        };
+    }
+    /**
+     * 并发模式：使用 cos.uploadFiles() 批量上传
+     * 特点：
+     * - 速度快，利用 SDK 内部并行能力
+     * - 分批上传 + 自动刷新凭证
+     * - 适合小规模目录或网络良好的场景
+     *
+     * @returns 失败的文件列表（空的表示全部成功）
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async uploadFilesParallel(options) {
+        const { fileList, bucket, region, fileId, parallel, retryCount, retryInterval, onProgress, onFileFinish } = options;
         // 生成上传文件属性
         const tasks = fileList.map(stats => async () => {
             let cosFileId;
@@ -290,31 +434,89 @@ class StorageService {
                 'x-cos-meta-fileid': cosFileId
             };
         });
-        // 控制请求并发
+        // 控制请求并发（获取 metadata 阶段）
         const asyncTaskController = new parallel_1.AsyncTaskParallelController(parallel, 50);
         asyncTaskController.loadTasks(tasks);
-        fileList = await asyncTaskController.run();
-        const cos = this.getCos(parallel);
-        const uploadFiles = util_1.default.promisify(cos.uploadFiles).bind(cos);
-        const params = {
-            files: fileList,
-            SliceSize: BIG_FILE_SIZE,
-            onProgress,
-            onFileFinish
-        };
-        // return uploadFiles({
-        //     onProgress,
-        //     onFileFinish,
-        //     files: fileList,
-        //     SliceSize: BIG_FILE_SIZE
-        // })
-        return this.uploadFilesWithRetry({
-            uploadFiles,
-            options: params,
-            times: retryCount,
-            interval: retryInterval,
-            failedFiles: []
-        });
+        const processedFileList = await asyncTaskController.run();
+        // 分批上传，避免单次上传时间过长导致 STS 临时凭证过期
+        // 默认每批 500 个文件，可通过环境变量 COS_UPLOAD_BATCH_SIZE 自定义
+        const BATCH_SIZE = process.env.COS_UPLOAD_BATCH_SIZE
+            ? parseInt(process.env.COS_UPLOAD_BATCH_SIZE, 10)
+            : 500;
+        // 收集所有批次失败的文件
+        let allFailedFiles = [];
+        for (let batchStart = 0; batchStart < processedFileList.length; batchStart += BATCH_SIZE) {
+            const batchEnd = Math.min(batchStart + BATCH_SIZE, processedFileList.length);
+            const batchFiles = processedFileList.slice(batchStart, batchEnd);
+            console.log(`[parallel-upload] 正在上传第 ${Math.floor(batchStart / BATCH_SIZE) + 1} 批次 (文件 ${batchStart + 1}-${batchEnd}/${processedFileList.length})`);
+            // 每批次重新获取 COS 实例（刷新 STS 临时凭证）
+            const cos = this.getCos(parallel);
+            const uploadFiles = util_1.default.promisify(cos.uploadFiles).bind(cos);
+            // 跟踪本批次中真正失败的文件（通过 onFileFinish 回调）
+            const batchFailedFiles = [];
+            const batchSuccessFiles = new Set();
+            const params = {
+                files: batchFiles,
+                SliceSize: BIG_FILE_SIZE,
+                onProgress,
+                onFileFinish: (error, result, file) => {
+                    // 空值检查：防止 file 为 null/undefined
+                    if (!file) {
+                        console.warn('[parallel-upload] onFileFinish received null/undefined file');
+                        return;
+                    }
+                    const fileKey = file.Key || file.cloudFileKey;
+                    if (error) {
+                        batchFailedFiles.push({
+                            filePath: file.FilePath || file.filePath,
+                            cloudFileKey: fileKey,
+                            error: error.message || String(error)
+                        });
+                    }
+                    else {
+                        batchSuccessFiles.add(fileKey);
+                    }
+                    // 继续调用用户传入的回调（转换参数格式）
+                    // 注意：cloudFileKey 和 filePath 是 CLI 期望的格式
+                    onFileFinish === null || onFileFinish === void 0 ? void 0 : onFileFinish(error, result, Object.assign(Object.assign({}, file), { cloudFileKey: fileKey, filePath: file.FilePath || file.filePath }));
+                }
+            };
+            try {
+                await this.uploadFilesWithRetry({
+                    uploadFiles,
+                    options: params,
+                    times: retryCount,
+                    interval: retryInterval,
+                    failedFiles: []
+                });
+                console.log(`[parallel-upload] 第 ${Math.floor(batchStart / BATCH_SIZE) + 1} 批次上传成功`);
+            }
+            catch (error) {
+                console.error(`[parallel-upload] 第 ${Math.floor(batchStart / BATCH_SIZE) + 1} 批次上传失败:`, error.message || error.code || error);
+                // 只记录真正失败的文件（通过 onFileFinish 回调跟踪）
+                // 如果 onFileFinish 没有被调用（如 socket hang up），则标记整个批次为失败
+                if (batchFailedFiles.length === 0 && batchSuccessFiles.size === 0) {
+                    // onFileFinish 未被调用，整个批次失败
+                    allFailedFiles.push(...batchFiles.map(f => ({
+                        filePath: f.FilePath || f.filePath,
+                        cloudFileKey: f.Key || f.cloudFileKey,
+                        error: error.message || String(error)
+                    })));
+                }
+                else {
+                    // onFileFinish 已被调用，只记录失败的文件
+                    allFailedFiles.push(...batchFailedFiles);
+                }
+            }
+        }
+        // 返回失败文件列表（不抛异常，让调用方决定是否走串行重试）
+        if (allFailedFiles.length > 0) {
+            console.warn(`[parallel-upload] 共 ${allFailedFiles.length}/${processedFileList.length} 个文件并行上传失败，等待串行重试...`);
+        }
+        else {
+            console.log(`[parallel-upload] 全部 ${processedFileList.length} 个文件并行上传成功`);
+        }
+        return allFailedFiles;
     }
     /**
      * 创建一个空的文件夹
@@ -2506,6 +2708,7 @@ class StorageService {
     }
     /**
      * 获取 COS 配置
+     * @param parallel 并发数量
      */
     getCos(parallel = 20) {
         const internalEndpoint = this.environment.cloudBaseContext.isInternalEndpoint();
@@ -2751,6 +2954,16 @@ __decorate([
 ], StorageService.prototype, "uploadDirectoryCustom", null);
 __decorate([
     (0, utils_1.preLazy)()
+    /**
+     * 上传文件（支持精准重试失败文件）
+     *
+     * 智能混合模式（默认）：
+     * 1. 先并行快速上传（速度快）
+     * 2. 失败的文件自动走串行重试（稳定性高）
+     *
+     * 可选模式：
+     * - COS_UPLOAD_SERIAL=true：完全串行模式（最稳定但慢）
+     */
 ], StorageService.prototype, "uploadFilesCustom", null);
 __decorate([
     (0, utils_1.preLazy)()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "5.5.6",
+    "version": "5.5.7-beta.1",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/scripts/ci/generate-changelog.js

@@ -42,9 +42,17 @@ function getLastTag() {
 
         const currentTag = `v${VERSION}`
         for (const tag of tags) {
-            // 跳过当前版本，找到第一个有效的 semver tag
-            if (tag !== currentTag && /^v?\d+\.\d+\.\d+/.test(tag)) {
-                return tag
+            // 跳过当前版本，找到第一个有效的 semver tag（排除 pre-release，如 v3.5.8-beta.0）
+            // 正则必须以数字结尾（不含 "-"），确保只匹配正式版本 tag
+            if (tag !== currentTag && /^v\d+\.\d+\.\d+$/.test(tag)) {
+                // 确保该 tag 的 commit 是当前分支的祖先（排除 release 分支等未合并到当前分支的 tag）
+                try {
+                    execSync(`git merge-base --is-ancestor ${tag} HEAD`, { encoding: 'utf8' })
+                    return tag
+                } catch {
+                    // tag 不是当前分支的祖先，跳过（如 release 分支的 tag 未合并到 master）
+                    continue
+                }
             }
         }
         return ''
@@ -141,6 +149,9 @@ function shouldFilterEarly(subject, branch) {
     // 3. 分支名就是纯版本号的，如 "2.9.4", "v3.0.1"
     if (/^v?\d+\.\d+(\.\d+)?(-\w+)?$/.test(branch)) return true
 
+    // 4. release 分支的 MR 是发版自动化，不包含用户可见变更
+    if (/^release\//.test(branch)) return true
+
     return false
 }
 
@@ -191,17 +202,15 @@ function parseMR(mergeCommit) {
     // 早期过滤：基于 subject 和分支名
     if (shouldFilterEarly(subject, branch)) return null
 
-    // 优先从 body 中找 conventional commit 描述
+    // 从 body 解析描述和类型
     let type = 'other'
     let scope = ''
     let description = ''
     let breaking = false
 
-    // body 可能有多行，逐行找第一个有意义的 conventional commit 格式
+    // 先尝试从 body 中找 conventional commit
     const bodyLines = body.split('\n').map((l) => l.trim()).filter(Boolean)
     for (const line of bodyLines) {
-        // 跳过分支名本身的重复
-        if (line === branch) continue
         const parsed = parseConventional(line)
         if (parsed) {
             type = parsed.type
@@ -210,28 +219,28 @@ function parseMR(mergeCommit) {
             breaking = parsed.breaking
             break
         }
-        // 如果不是 conventional 格式但也不是分支名，用第一个有意义的行作为描述
-        if (!description && line.length > 3) {
-            description = line
+    }
+
+    // 如果 conventional commit 的描述无效（如 "update v"），回退到分支名生成描述
+    const isGenericDescription = /^(update|udpate)\s*v?|^bump\s*(version|v)?|^\s*$|^v?\d+\.\d+(\.\d+)?$/i.test(description)
+    if (isGenericDescription) {
+        // conventional commit 描述是无效的发版消息，使用分支名生成描述
+        description = branch ? getDescriptionFromBranch(branch) : ''
+        // 如果分支名也无法提供有效描述，用 subject
+        if (!description) {
+            description = subject.replace(/\(merge request !\d+\)$/, '').trim()
         }
     }
 
-    // 如果 body 没有提供有效信息，从分支名推断
+    // 如果 body 中没有 conventional commit，从分支名推断类型
     if (type === 'other' && branch) {
         const inferredType = inferTypeFromBranch(branch)
         if (inferredType) type = inferredType
     }
 
-    if (!description && branch) {
-        description = getDescriptionFromBranch(branch)
-    }
-
-    if (!description) {
-        description = subject
-    }
-
     // 后期过滤：基于解析后的描述内容（过滤 "update v" 等发版 MR）
-    if (shouldFilterByDescription(description, body)) return null
+    // 但如果是 conventional commit 格式（type 不为 'other'），说明是有效 MR，不过滤
+    if (type === 'other' && shouldFilterByDescription(description, body)) return null
 
     // 更智能的分类：描述内容优先于分支名推断
     // 例如 feature/ 分支但描述是"文档内容"的，应归类为 docs
@@ -317,7 +326,8 @@ function generateChangelog(categories) {
 
     // 如果完全没有 MR
     if (!hasContent) {
-        lines.push('- 版本发布')
+        // 不生成默认条目，保持 changelog 干净
+        lines.push('')
     }
 
     lines.push('')

package/types/storage/index.d.ts

@@ -195,11 +195,25 @@ export declare class StorageService {
      * @returns {Promise<void>}
      */
     uploadDirectoryCustom(options: IFileOptions & ICustomOptions): Promise<void>;
+    uploadFilesCustom(options: IFilesOptions & ICustomOptions): Promise<any>;
     /**
-     * 批量上传文件
-     * @param options
+     * 串行安全模式：逐文件上传（类似自定义脚本 deploy.js 的方式）
+     * 特点：
+     * - 每个文件独立 HTTP 连接，不会出现 socket hang up
+     * - 单线程串行，稳定性最高
+     * - 适合大规模目录（>1000 文件）或有网络问题的场景
      */
-    uploadFilesCustom(options: IFilesOptions & ICustomOptions): Promise<any>;
+    private uploadFilesSerial;
+    /**
+     * 并发模式：使用 cos.uploadFiles() 批量上传
+     * 特点：
+     * - 速度快，利用 SDK 内部并行能力
+     * - 分批上传 + 自动刷新凭证
+     * - 适合小规模目录或网络良好的场景
+     *
+     * @returns 失败的文件列表（空的表示全部成功）
+     */
+    private uploadFilesParallel;
     /**
      * 创建一个空的文件夹
      * @param {string} cloudPath
@@ -531,6 +545,7 @@ export declare class StorageService {
     getObjectInfoPublic(options: IGetObjectInfoPublicHttpOptions): Promise<IGetObjectInfoHttpResult>;
     /**
      * 获取 COS 配置
+     * @param parallel 并发数量
      */
     private getCos;
     /**