@cloudbase/manager-node 5.9.1 → 5.9.3

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [5.9.2] 2026-10-21
+
+- [Fixed] function: COS 上传超时改为连续无进度判定，避免大包被总耗时误杀
+- [Fixed] utils: 解压远程 zip 增加路径穿越防护并支持失败即中止
+## [5.9.1] 2026-10-15
+
+- [Added] function: CBF 环境支持 PutUrl 直传函数代码包
+- [Added] function: 新增流量策略 V2 与版本删除接口，切换 TCB 协议
+- [Fixed] error: 补齐新增代码的错误 code，通过 D31 与 code 取值来源守卫
+- [Fixed] function: 适配 CBF 环境接口限制并补齐版本/流量与 CBF 集成测试
 ## @cloudbase/manager-node v5.9.0 版本发布 🚀(2026-09-28)
 
 - 新增 错误对象契约统一与无 code 抛错清零 + 自造码文档锚点(D5)

package/changelog_content_en.md

@@ -1,16 +1,4 @@
-## [5.9.0] 2026-09-28
+## [5.9.2] 2026-10-21
 
-- [Added] Add `ERROR_TYPES` standard error type table (6 entries) and support `type` option in `CloudBaseError` constructor (decides `code` / `source` with priority and cannot be overridden by caller); helpers now reference `ERROR_TYPES`
-- [Added] error-docs: locate self-made codes by layer registry page (returns `/error-code/<layer>#<lowercase-code>` anchor when `source` is `cli` / `toolbox` / `manager-node`); manager-node soft-fallback whitelist collapsed to layer registry page (`ready: true`)
-- [Added] Unify error object contract and clear no-`code` throws: add `CloudBaseError.toJSON()`, `ErrorSource` union type (with `'toolbox'`), `isCloudBaseError` / `isValidErrorCode`; converge 171 raw `throw new Error` to unified helpers, storage batch delete now carries `code` + `source` + `details`
-- [Added] Upgrade `@cloudbase/toolbox` to `~0.9.0`
-- [Added] Update cloud function and cloud run integration tests: replace fixed sleep with polling wait, unify jest timeout to 10 minutes, add `waitUntil` / `waitForSandboxToolSettled` helpers with fast-fail diagnostics on failed states
-- [Fixed] Fix `function` regression where throw-helper was misused in value position (`reject(throwNetError(...))`) causing Promise to never settle; now construct `new CloudBaseError(msg, { type: ERROR_TYPES.netError })` in value position
-- [Fixed] `error`: `toJSON()` normalizes numeric codes to strings (e.g. `876` ⇒ `"876"`) at output layer while `code` on object stays faithful; `NaN` / `±Infinity` fall back to `ERROR`
-- [Fixed] `error`: add ES5 prototype fallback (`Object.setPrototypeOf(this, CloudBaseError.prototype)`) to avoid lost prototype chain under third-party downlevel compilation
-- [Fixed] Address code review fixes: extract `MODEL_STATUS` constant in `aiModel`; fix `authoration` → `authorization` spelling in `environment` / `cloud-api-request`; use truthy checks in `user` validation; change `error: any` → `unknown` in `function` and use `WeakMap` for idempotency marker; use truthy checks for `customConfiguration` / `DNSConfig` in `sandbox` to avoid null pointer
-- [Fixed] `review`: fix empty `failures[0].id` null pointer when deploy report is inconsistent; narrow `description` with `typeof === 'string'` in `permission`; remove `as any` and tighten `isRetryableError` retry logic in `function`
-- [Fixed] `deploy`: downgrade image `latest` tag from block (`fail`) to hint (`warn`) since platform allows `latest` as suboptimal not mandatory failure
-- [Fixed] `error`: change enterprise image guidance idempotency from `message` text dependency to marker flag to avoid duplicate append after text mutation
-- [Fixed] `error`: governance D14/D15/D16/D22 — pass through TCR permission errors; only retry retryable errors in trigger creation; `waitFunctionActive` tolerates creation-phase `NOT_FOUND`; `toJSON()` emits `stack`
-- [Refactor] `error`: rename throw helpers to `throwXxx` form (e.g. `invalidParam` → `throwInvalidParam`) so call sites signal interruption, 494 sites / 35 files
+- [Fixed] [TODO: translate] function: COS 上传超时改为连续无进度判定，避免大包被总耗时误杀
+- [Fixed] [TODO: translate] utils: 解压远程 zip 增加路径穿越防护并支持失败即中止

package/lib/function/index.js

@@ -1806,28 +1806,75 @@ class FunctionService {
             }
         });
         return new Promise((resolve, reject) => {
-            // 添加超时保护
-            const timeout = setTimeout(() => {
-                packer.clean();
-                // 同上：值位置不能调用必抛 helper
-                reject(new error_1.CloudBaseError(`[${func.name}] COS 上传超时（60秒）`, { type: error_types_1.ERROR_TYPES.netError }));
-            }, 60000);
-            cos.sliceUploadFile(uploadParams, async (err, data) => {
-                clearTimeout(timeout);
-                // 清理临时文件
-                await packer.clean();
-                if (err) {
-                    // 保留完整的错误信息（避免原始错误丢失）
-                    const errorMessage = err.message || err.error || String(err);
-                    const errorCode = err.code || err.statusCode || '';
-                    reject(new error_1.CloudBaseError(`COS 上传失败: ${errorMessage}${errorCode ? ` (${errorCode})` : ''}`, {
-                        code: errorCode
-                    }));
-                }
-                else {
-                    resolve(data);
-                }
-            });
+            // 上传停滞保护：连续 120 秒无进度才判超时（而非总耗时 120 秒）。
+            // 大包在慢网 / 代理下总耗时可能远超 120 秒，只要仍在传输就不应被打断。
+            const STALL_TIMEOUT = 120000;
+            let stallTimer;
+            let taskId;
+            // 超时与上传回调可能先后到达，用 settled 保证只结算一次
+            let settled = false;
+            const clearStallTimer = () => {
+                if (stallTimer)
+                    clearTimeout(stallTimer);
+                stallTimer = undefined;
+            };
+            // 清理临时包；失败不影响主流程，也不能留下浮空 Promise
+            const cleanup = () => packer.clean().catch(() => undefined);
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearStallTimer();
+                fn();
+            };
+            // 每收到一次上传进度就重置计时器
+            const resetStallTimer = () => {
+                clearStallTimer();
+                if (settled)
+                    return;
+                stallTimer = setTimeout(() => {
+                    // cancelTask 只是不再调度后续分片，不会中断已在飞的请求；
+                    // 且取消后 SDK 不再回调，临时包必须在这里自行清理
+                    if (taskId)
+                        cos.cancelTask(taskId);
+                    // 同上：值位置不能调用必抛 helper
+                    settle(() => reject(new error_1.CloudBaseError(`[${func.name}] COS 上传超时（连续 ${STALL_TIMEOUT / 1000} 秒无进度）`, { type: error_types_1.ERROR_TYPES.netError })));
+                    cleanup();
+                }, STALL_TIMEOUT);
+            };
+            resetStallTimer();
+            try {
+                cos.sliceUploadFile(Object.assign(Object.assign({}, uploadParams), { onTaskReady: (id) => {
+                        taskId = id;
+                    }, onProgress: resetStallTimer }), async (err, data) => {
+                    // 已因停滞超时结算过，这里只补一次清理
+                    if (settled) {
+                        cleanup();
+                        return;
+                    }
+                    // 先置位再 await，避免清理期间定时器再次触发
+                    clearStallTimer();
+                    settled = true;
+                    // 清理临时文件
+                    await cleanup();
+                    if (err) {
+                        // 保留完整的错误信息（避免原始错误丢失）
+                        const errorMessage = err.message || err.error || String(err);
+                        const errorCode = err.code || err.statusCode || '';
+                        reject(new error_1.CloudBaseError(`COS 上传失败: ${errorMessage}${errorCode ? ` (${errorCode})` : ''}`, {
+                            code: errorCode
+                        }));
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
+            }
+            catch (e) {
+                // 同步抛错时 Promise 已 reject，但 stallTimer 不会自动清理，需在此收尾
+                settle(() => reject(e));
+                cleanup();
+            }
         });
     }
     /**

package/lib/utils/index.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompleteTimeRange = exports.formatTimeByMs = exports.formatTimeValue = exports.guid6 = void 0;
 exports.compressToZip = compressToZip;
 exports.shouldSkipEntry = shouldSkipEntry;
+exports.safeResolveZipEntryPath = safeResolveZipEntryPath;
 exports.downloadAndExtractRemoteZip = downloadAndExtractRemoteZip;
 exports.upload = upload;
 exports.getRuntime = getRuntime;
@@ -163,12 +164,51 @@ function shouldSkipEntry(entryPath) {
         return false;
     });
 }
+/**
+ * 校验 zip 条目路径，返回解析后的绝对路径
+ *
+ * 条目名来自压缩包本身（不可信），必须确保解析结果仍落在 baseDir 内，
+ * 否则 `../` 之类的条目会跳出目标目录，形成任意文件写入（Zip Slip / CWE-22）。
+ *
+ * @param {string} baseDir 目标根目录（受信任）
+ * @param {string} entryPath 压缩包内的条目路径（不可信）
+ * @returns {string} 校验通过的绝对路径
+ * @throws 条目路径为绝对路径 / 盘符 / UNC，或解析后越出 baseDir 时抛出
+ */
+function safeResolveZipEntryPath(baseDir, entryPath) {
+    if (typeof entryPath !== 'string' || entryPath.length === 0) {
+        throw new Error('zip 条目路径无效');
+    }
+    // 绝对路径、Windows 盘符、UNC 路径一律拒绝
+    if (path_1.default.isAbsolute(entryPath) ||
+        /^[a-zA-Z]:[\\/]/.test(entryPath) ||
+        entryPath.startsWith('\\\\') ||
+        entryPath.startsWith('//')) {
+        throw new Error(`检测到不安全的 zip 条目路径（绝对路径）: ${entryPath}`);
+    }
+    // 统一分隔符并去掉多余的前导分隔符
+    const normalizedEntryPath = entryPath.replace(/\\/g, '/').replace(/^\/+/, '');
+    const resolvedBase = path_1.default.resolve(baseDir);
+    const resolvedTarget = path_1.default.resolve(resolvedBase, normalizedEntryPath);
+    // 用 path.relative 判断是否仍在 baseDir 内：
+    // 越界时一定是 '..' 本身或以 '..' + 路径分隔符开头（不能仅用 '..' 前缀判断，
+    // 否则会误伤 '..gitignore'、'..env/prod.txt' 等以 '..' 开头的合法条目名）；
+    // Windows 跨盘符时 path.relative 会直接返回绝对路径，故 path.isAbsolute 这一判不能省。
+    const relative = path_1.default.relative(resolvedBase, resolvedTarget);
+    if (relative === '') {
+        return resolvedTarget;
+    }
+    if (relative === '..' || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative)) {
+        throw new Error(`检测到不安全的 zip 条目路径（路径穿越）: ${entryPath}`);
+    }
+    return resolvedTarget;
+}
 /**
  * 下载并解压压缩包到指定目录
  * @param {string} downloadUrl 压缩包下载地址
  * @param {string} targetPath 目标路径
  * @returns {Promise<void>}
- * @throws 当下载失败或解压失败时抛出错误
+ * @throws 当下载失败或解压失败时抛出错误；当条目路径越界时抛出错误
  */
 async function downloadAndExtractRemoteZip(downloadUrl, targetPath) {
     const downloadResponse = await (0, http_request_1.fetchStream)(downloadUrl);
@@ -186,22 +226,71 @@ async function downloadAndExtractRemoteZip(downloadUrl, targetPath) {
         let totalEntries = 0; // 总条目数（文件+目录）
         let processedEntries = 0; // 已处理条目数
         let streamEnded = false; // 流是否结束
-        downloadResponse
+        let aborted = false; // 是否已判定失败（置位后剩余条目只丢弃、不再落盘）
+        const pendingWrites = new Set(); // 在途写入
+        let parseStream; // 解析流，失败时用于中止
+        // 统一失败出口：只认第一次失败，并立即中止下载 / 解析 / 在途写入。
+        // 只置标志位不够——已在处理的条目仍会继续写盘，导致 Promise 已 reject
+        // 之后目标目录内容还在变化。
+        const fail = (err) => {
+            var _a;
+            if (aborted)
+                return;
+            aborted = true;
+            try {
+                // body 的类型声明里没有 destroy（实际是 node-fetch 的 Readable），这里按需断言
+                const rawBody = downloadResponse.body;
+                (_a = rawBody === null || rawBody === void 0 ? void 0 : rawBody.destroy) === null || _a === void 0 ? void 0 : _a.call(rawBody); // 下载流存在时中止
+                parseStream === null || parseStream === void 0 ? void 0 : parseStream.destroy(); // 解析流存在时中止
+                pendingWrites.forEach(ws => ws.destroy()); // 在途写入流存在时中止
+                pendingWrites.clear();
+            }
+            catch (_b) {
+                // 中止动作本身的异常不应覆盖原始错误
+            }
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        //  HTTP 响应体 → unzipper.Parse() 这条管道的下游端
+        parseStream = downloadResponse
             .body.pipe(unzipper_1.default.Parse())
-            .on('error', reject)
+            .on('error', fail)
             .on('entry', async (entry) => {
             totalEntries++;
-            // 检查是否应该跳过这个条目
-            if (shouldSkipEntry(entry.path)) {
+            // 检查是否应该跳过这个条目（已判定失败时同样丢弃，避免继续写盘）
+            if (shouldSkipEntry(entry.path) || aborted) {
                 entry.autodrain(); // 丢弃数据流
                 processedEntries++;
                 checkCompletion();
                 return;
             }
-            const filePath = path_1.default.join(dirPath, entry.path);
+            // 条目名来自压缩包（不可信），校验解析结果必须仍在目标目录内
+            let filePath;
+            try {
+                filePath = safeResolveZipEntryPath(dirPath, entry.path);
+            }
+            catch (err) {
+                entry.autodrain();
+                processedEntries++;
+                fail(err);
+                return;
+            }
+            // 仅放行文件/目录两类条目，其余类型（符号链接等）一律丢弃
+            if (entry.type !== 'File' && entry.type !== 'Directory') {
+                entry.autodrain();
+                processedEntries++;
+                checkCompletion();
+                return;
+            }
             try {
                 // 确保父目录存在（处理嵌套目录情况）
                 await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
+                // await 期间可能已失败（aborted），此时不能再开写入流，否则 reject 之后还会写盘
+                if (aborted) {
+                    entry.autodrain();
+                    processedEntries++;
+                    checkCompletion();
+                    return;
+                }
                 // 如果是目录则创建，否则写入文件
                 if (entry.type === 'Directory') {
                     await fs_extra_1.default.ensureDir(filePath);
@@ -209,17 +298,21 @@ async function downloadAndExtractRemoteZip(downloadUrl, targetPath) {
                     checkCompletion();
                 }
                 else {
+                    const writeStream = fs_extra_1.default.createWriteStream(filePath);
+                    pendingWrites.add(writeStream);
                     entry
-                        .pipe(fs_extra_1.default.createWriteStream(filePath))
-                        .on('error', reject)
+                        .pipe(writeStream)
+                        .on('error', fail)
+                        .on('close', () => pendingWrites.delete(writeStream))
                         .on('finish', () => {
+                        pendingWrites.delete(writeStream);
                         processedEntries++;
                         checkCompletion();
                     });
                 }
             }
             catch (err) {
-                reject(err);
+                fail(err);
             }
         })
             .on('close', () => {
@@ -227,6 +320,9 @@ async function downloadAndExtractRemoteZip(downloadUrl, targetPath) {
             checkCompletion();
         });
         function checkCompletion() {
+            // 已失败时 Promise 早已 settle，无需再尝试 resolve
+            if (aborted)
+                return;
             if (streamEnded && totalEntries === processedEntries) {
                 resolve('');
             }

package/package.json

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

package/types/env/type.d.ts

@@ -281,6 +281,7 @@ export interface HTTPServiceRoute {
     PathRewrite?: HTTPServicePathRewrite;
     UpstreamResourceType: 'SCF' | 'CBR' | 'STATIC_STORE' | 'WEB_SCF' | 'LH' | 'STORAGE';
     UpstreamResourceName: string;
+    UpstreamResourceVersion?: string;
     EnableSafeDomain: boolean;
     EnableAuth: boolean;
     EnablePathTransmission: boolean;
@@ -342,6 +343,7 @@ export interface HTTPServiceRouteParam {
     Path: string;
     UpstreamResourceType?: 'SCF' | 'CBR' | 'STATIC_STORE' | 'WEB_SCF' | 'LH' | 'STORAGE';
     UpstreamResourceName?: string;
+    UpstreamResourceVersion?: string;
     PathRewrite?: HTTPServicePathRewrite;
     EnableSafeDomain?: boolean;
     EnableAuth?: boolean;

package/types/utils/index.d.ts

@@ -32,12 +32,24 @@ export declare function compressToZip(option: IZipOption): Promise<unknown>;
      * @returns {boolean} 如果应该跳过则返回 true
      */
 export declare function shouldSkipEntry(entryPath: string): boolean;
+/**
+ * 校验 zip 条目路径，返回解析后的绝对路径
+ *
+ * 条目名来自压缩包本身（不可信），必须确保解析结果仍落在 baseDir 内，
+ * 否则 `../` 之类的条目会跳出目标目录，形成任意文件写入（Zip Slip / CWE-22）。
+ *
+ * @param {string} baseDir 目标根目录（受信任）
+ * @param {string} entryPath 压缩包内的条目路径（不可信）
+ * @returns {string} 校验通过的绝对路径
+ * @throws 条目路径为绝对路径 / 盘符 / UNC，或解析后越出 baseDir 时抛出
+ */
+export declare function safeResolveZipEntryPath(baseDir: string, entryPath: string): string;
 /**
  * 下载并解压压缩包到指定目录
  * @param {string} downloadUrl 压缩包下载地址
  * @param {string} targetPath 目标路径
  * @returns {Promise<void>}
- * @throws 当下载失败或解压失败时抛出错误
+ * @throws 当下载失败或解压失败时抛出错误；当条目路径越界时抛出错误
  */
 export declare function downloadAndExtractRemoteZip(downloadUrl: string, targetPath: string): Promise<void>;
 /**