@cloudbase/manager-node 5.9.0 → 5.9.2

package/.coding-ci-publish-beta.yaml

@@ -138,7 +138,7 @@ stages:
   - task: 生成并同步 changelog
     cmds:
     - plugin: ci_changelog
-      version: 0.12.0
+      version: 1.1.0
       params:
         to_ref: HEAD
         tag_pattern: ^v(\d+\.\d+\.\d+(?:-[\w.]+)?)$
@@ -174,22 +174,22 @@ stages:
         cmds:
         - "bash -lc '\nset -e\nexport NVM_DIR=\"$HOME/.nvm\"\n[ -s \"$NVM_DIR/nvm.sh\"\
           \ ] && . \"$NVM_DIR/nvm.sh\"\nnvm use 22.14.0\necho \"==========================================\"\
-          \necho \"\U0001F4E6 写回插件生成的 changelog 并打 tag v${MANAGER_NODE_VERSION}\"\
-          \necho \"==========================================\"\n# 配置 git\ngit config --global\
-          \ user.email \"cloudbase-ci-bot@tencent.com\"\ngit config --global user.name\
-          \ \"cloudbase-ci-bot\"\n# 切换到 release 分支\ngit fetch origin release/${MANAGER_NODE_VERSION}\n\
+          \necho \"\U0001F4E6 写回插件生成的 changelog 并打 tag v${MANAGER_NODE_VERSION}\"\n\
+          echo \"==========================================\"\n# 配置 git\ngit config\
+          \ --global user.email \"cloudbase-ci-bot@tencent.com\"\ngit config --global\
+          \ user.name \"cloudbase-ci-bot\"\n# 切换到 release 分支\ngit fetch origin release/${MANAGER_NODE_VERSION}\n\
           git checkout release/${MANAGER_NODE_VERSION}\n# 1. 写回插件生成的 changelog（仅 latest\
-          \ 版本）\necho \"\"\necho \"\U0001F4DD Step 1: 写回插件产物到 CHANGELOG.md\"\nif [ \"$RELEASE_TYPE\"\
-          \ = \"latest\" ]; then\n    if [ ! -f \"${QCI_WORKSPACE}/changelog_content.md\"\
+          \ 版本）\necho \"\"\necho \"\U0001F4DD Step 1: 写回插件产物到 CHANGELOG.md\"\nif [\
+          \ \"$RELEASE_TYPE\" = \"latest\" ]; then\n    if [ ! -f \"${QCI_WORKSPACE}/changelog_content.md\"\
           \ ]; then\n        echo \"❌ 插件产物 ${QCI_WORKSPACE}/changelog_content.md 不存在\"\
           \n        exit 1\n    fi\n    cat \"${QCI_WORKSPACE}/changelog_content.md\"\
           \ CHANGELOG.md > CHANGELOG.md.new\n    mv CHANGELOG.md.new CHANGELOG.md\n\
           \    # 2. 提交 changelog\n    echo \"\"\n    echo \"\U0001F4DD Step 2: 提交变更\"\
           \n    git add CHANGELOG.md\n    git commit -m \"docs(release): changelog\
-          \ for v${MANAGER_NODE_VERSION}\" || echo \"没有需要提交的变更\"\nelse\n    echo\
-          \ \"⏭️  RELEASE_TYPE !== latest，跳过 CHANGELOG.md 写回\"\nfi\n# 3. 打 tag\necho\
-          \ \"\"\necho \"\U0001F3F7️  Step 3: 创建 tag v${MANAGER_NODE_VERSION}\"\
-          \ngit tag -a \"v${MANAGER_NODE_VERSION}\" -m \"Release v${MANAGER_NODE_VERSION}\"\
+          \ for v${MANAGER_NODE_VERSION}\" || echo \"没有需要提交的变更\"\nelse\n    echo \"\
+          ⏭️  RELEASE_TYPE !== latest，跳过 CHANGELOG.md 写回\"\nfi\n# 3. 打 tag\necho \"\
+          \"\necho \"\U0001F3F7️  Step 3: 创建 tag v${MANAGER_NODE_VERSION}\"\ngit tag\
+          \ -a \"v${MANAGER_NODE_VERSION}\" -m \"Release v${MANAGER_NODE_VERSION}\"\
           \n# 4. 推送分支和 tag\necho \"\"\necho \"\U0001F680 Step 4: 推送到远程\"\ngit push\
           \ origin release/${MANAGER_NODE_VERSION}\ngit push origin \"v${MANAGER_NODE_VERSION}\"\
           \necho \"\"\necho \"✅ 完成！\"\necho \"   - changelog.md: 已更新\"\necho \"  \
@@ -237,12 +237,19 @@ stages:
   tasks:
   - task: 企微群通知
     cmds:
+    - plugin: cmds
+      params:
+        cmds:
+        - echo "📦 @cloudbase/manager-node v${MANAGER_NODE_VERSION} 发布成功" > ${QCI_WORKSPACE}/wework_message.md
+        - echo "" >> ${QCI_WORKSPACE}/wework_message.md
+        - cat ${QCI_WORKSPACE}/changelog_content.md >> ${QCI_WORKSPACE}/wework_message.md
+        - cat ${QCI_WORKSPACE}/wework_message.md
     - plugin: message_wework_group
       params:
         c_type: text
         env_variable: _WEWORK_GROUP_ID
         mentioned: lucyqzhang;nenneyu
-        content_path: ${QCI_WORKSPACE}/changelog_content.md
+        content_path: ${QCI_WORKSPACE}/wework_message.md
         group_id: ww150005365489083
     if: $RELEASE_TYPE = latest
 version: '2.0'

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [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)
+- 新增发布流水线配置
+
+---
+
 
 ## @cloudbase/manager-node v5.8.8 版本发布 🚀(2026-09-18)
 

package/changelog_content_en.md

@@ -0,0 +1,6 @@
+## [5.9.1] 2026-10-15
+
+- [Added] [TODO: translate] function: CBF 环境支持 PutUrl 直传函数代码包
+- [Added] [TODO: translate] function: 新增流量策略 V2 与版本删除接口，切换 TCB 协议
+- [Fixed] [TODO: translate] error: 补齐新增代码的错误 code，通过 D31 与 code 取值来源守卫
+- [Fixed] [TODO: translate] function: 适配 CBF 环境接口限制并补齐版本/流量与 CBF 集成测试

package/changelog_content_zh.md

@@ -0,0 +1,16 @@
+## [5.9.0] 2026-09-28
+
+- [Added] 新增 `ERROR_TYPES` 标准错误类型表（6 条），`CloudBaseError` 构造器支持 `type` 选项（优先决定 `code` / `source` 且不可被调用方覆盖），helper 改引 `ERROR_TYPES`
+- [Added] error-docs：自造码按层登记页定位（`source` 为 `cli` / `toolbox` / `manager-node` 时返回 `/error-code/<layer>#<小写码名>` 锚点），manager-node 软降级白名单收敛为层级登记页（`ready: true`）
+- [Added] 错误对象契约统一与无 `code` 抛错清零：新增 `CloudBaseError.toJSON()`、`ErrorSource` 联合类型（含 `'toolbox'`）、`isCloudBaseError` / `isValidErrorCode` 识别；171 处原生 `throw new Error` 收敛为统一辅助函数，storage 批量删除补 `code` + `source` + `details`
+- [Added] 升级 `@cloudbase/toolbox` 至 `~0.9.0`
+- [Added] 更新云函数与云托管集成测试：轮询等待替代固定 sleep，jest 超时统一抬至 10 分钟，新增 `waitUntil` / `waitForSandboxToolSettled` 等辅助函数并补充失败态快速失败诊断
+- [Fixed] 修复 `function` 模块必抛 helper 误用于值位置（`reject(throwNetError(...))`）导致 Promise 永不 settle 的回归，改为值位置构造 `new CloudBaseError(msg, { type: ERROR_TYPES.netError })`
+- [Fixed] `error`: `toJSON()` 输出层将数值码归一化为字符串（如 `876` ⇒ `"876"`），对象上 `code` 保持保真；`NaN` / `±Infinity` 兜底为 `ERROR`
+- [Fixed] `error`: 补 ES5 原型兜底（`Object.setPrototypeOf(this, CloudBaseError.prototype)`），避免第三方降级编译时丢失原型链
+- [Fixed] 按代码评审修复多处问题：`aiModel` 抽 `MODEL_STATUS` 常量；`environment` / `cloud-api-request` 拼写 `authoration` → `authorization`；`user` 校验改真值判断；`function` 的 `error: any` → `unknown` 并改用 `WeakMap` 缓存幂等标记；`sandbox` 的 `customConfiguration` / `DNSConfig` 改真值判断避免空指针
+- [Fixed] `review`: 响应评审修复 `deploy` 报告不自洽时 `failures[0].id` 空指针；`permission` 的 `description` 改用 `typeof === 'string'` 收窄；`function` 去掉 `as any` 断言并收紧 `isRetryableError` 重试判定
+- [Fixed] `deploy`: 镜像 `latest` 标签由拦截（`fail`）降级为提示（`warn`），平台允许 `latest` 属次优而非必然失败
+- [Fixed] `error`: 企业版镜像排查指引幂等判断由依赖 `message` 文本改为标记位，避免文本被改动后重复追加
+- [Fixed] `error`: 治理 D14/D15/D16/D22 — TCR 权限错误透传上游；触发器创建仅重试可重试错误；`waitFunctionActive` 容忍创建期 `NOT_FOUND`；`toJSON()` 输出 `stack`
+- [Refactor] `error`: 抛错 helper 统一改名为 `throwXxx` 形态（如 `invalidParam` → `throwInvalidParam`），调用点即知会中断，共 494 处 / 35 文件

package/lib/function/index.js

@@ -20,6 +20,14 @@ const error_1 = require("../error");
 const error_types_1 = require("../error-types");
 const utils_1 = require("../utils");
 const constant_1 = require("../constant");
+/**
+ * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境支持的运行环境。
+ *
+ * 服务端目前仅提供 Node.js 24.11；SDK 在 CBF 环境下也以它作为 `createFunction` 的默认 runtime。
+ *
+ * 仅供 SDK 内部使用：CBF 的字段支持范围仍在联调中，暂不作为公开 API 导出。
+ */
+const CBF_ALLOWED_RUNTIMES = ['Nodejs24.11'];
 /**
  * 解析环境变量为布尔值
  * 视 'true'/'1'/'yes'/'on'（大小写不敏感）为 true，
@@ -161,7 +169,7 @@ function formatImageDeploymentErrorMessage(error, imageConfig) {
 // 解析函数配置，换成请求参数（用于 CreateFunction）
 function configToParams(options) {
     var _a, _b, _c;
-    const { func, codeSecret, baseParams = {} } = options;
+    const { func, codeSecret, baseParams = {}, isCbf = false } = options;
     // 白名单：只有这些字段会被透传到 API（大小写不敏感）
     // 参考 SCF API 文档：https://cloud.tencent.com/document/product/583/18586
     // key: 小写用于匹配，value: PascalCase 用于输出
@@ -202,10 +210,12 @@ function configToParams(options) {
         params.InstallDependency = toBooleanString(func.installDependency);
     }
     // 2. L5 配置 - 当不存在时不修改，否则根据 true/false 进行修改
+    // CBF 不接受 SDK 注入的兜底字段：未显式配置时不提交；
+    // 用户显式配置的仍原样下发，由服务端校验并透传报错
     if (func.l5 !== undefined) {
         params.L5Enable = toBooleanString(func.l5);
     }
-    else {
+    else if (!isCbf) {
         params.L5Enable = null;
     }
     // 3. 需要 'TRUE'/'FALSE' 字符串的布尔字段统一处理（大小写不敏感）
@@ -397,6 +407,14 @@ class FunctionService {
     }
     /**
      * 创建云函数
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 默认 runtime 为 `Nodejs24.11`（见 `CBF_ALLOWED_RUNTIMES`）
+     * - 不再注入 `Stamp` / `ClsTopicId` / `ClsLogsetId` 与默认 `Role`
+     * - 不支持定时触发器，内部跳过触发器创建
+     *
+     * 用户显式配置的字段一律原样下发，不支持的字段由服务端报错透传。
+     *
      * @param {ICreateFunctionParam} funcParam
      * @returns {(Promise<IResponseInfo | ICreateFunctionRes>)}
      */
@@ -405,25 +423,34 @@ class FunctionService {
         const { namespace, backend } = this.getFunctionConfig();
         const { func, functionRootPath, force = false, base64Code, codeSecret, functionPath, deployMode, code } = funcParam;
         const funcName = func.name;
-        const { TopicId, LogsetId } = this.getClsServiceConfig();
+        const isCbf = backend === 'cbf';
+        // EnvId 为两端共用；Stamp / ClsTopicId / ClsLogsetId 与默认 Role 都是 SDK 侧注入的字段，
+        // CBF（云开发云函数）不接受这些参数，一旦下发 CreateFunction 会直接失败（CBF does not
+        // support parameter xxx），故 CBF 下不再注入。用户显式配置的 role 等字段仍经
+        // configToParams 的字段映射原样下发，由服务端校验并透传报错。
         const baseParams = {
-            EnvId: namespace,
-            Stamp: 'MINI_QCBASE',
-            ClsTopicId: TopicId,
-            ClsLogsetId: LogsetId
+            EnvId: namespace
         };
-        // 默认注入 TCB_QcsRole，DISABLE_DEFAULT_TCB_ROLE 为真时跳过（由 func.role 决定或留空）
-        if (!parseEnvBoolean(process.env.DISABLE_DEFAULT_TCB_ROLE)) {
-            baseParams.Role = 'TCB_QcsRole';
+        if (!isCbf) {
+            const { TopicId, LogsetId } = this.getClsServiceConfig();
+            baseParams.Stamp = 'MINI_QCBASE';
+            baseParams.ClsTopicId = TopicId;
+            baseParams.ClsLogsetId = LogsetId;
+            // 默认注入 TCB_QcsRole，DISABLE_DEFAULT_TCB_ROLE 为真时跳过（由 func.role 决定或留空）
+            if (!parseEnvBoolean(process.env.DISABLE_DEFAULT_TCB_ROLE)) {
+                baseParams.Role = 'TCB_QcsRole';
+            }
         }
         const params = configToParams({
             func,
             codeSecret,
-            baseParams
+            baseParams,
+            isCbf
         });
         // 统一走 tcb；默认 runtime 按环境函数后端类型设置
+        // CBF（云开发云函数）目前仅提供 Nodejs24.11（见 CBF_ALLOWED_RUNTIMES）
         if (!func.runtime) {
-            params.Runtime = backend === 'tcb' ? 'Nodejs24.14' : 'Nodejs20.19';
+            params.Runtime = isCbf ? CBF_ALLOWED_RUNTIMES[0] : 'Nodejs20.19';
         }
         const customCode = code;
         const customImageCode = customCode === null || customCode === void 0 ? void 0 : customCode.ImageConfig;
@@ -466,8 +493,10 @@ class FunctionService {
             const res = await this.tcbService.request('CreateFunction', params);
             // 等待函数状态正常
             await this.waitFunctionActive(funcName, codeSecret);
-            // 创建函数触发器、失败自动重试
-            await this.retryCreateTrigger(funcName, func.triggers);
+            // 创建函数触发器、失败自动重试（CBF 不支持定时触发器，跳过）
+            if (!isCbf) {
+                await this.retryCreateTrigger(funcName, func.triggers);
+            }
             // 设置路径，创建云接入路径
             if (func.path) {
                 await this.createAccessPath(funcName, func.path);
@@ -514,8 +543,10 @@ class FunctionService {
                     const configRes = await this.updateFunctionConfig(func);
                     // 等待函数状态正常
                     await this.waitFunctionActive(funcName, codeSecret);
-                    // 3. 创建函数触发器
-                    const triggerRes = await this.retryCreateTrigger(funcName, func.triggers);
+                    // 3. 创建函数触发器（CBF 不支持定时触发器，跳过）
+                    const triggerRes = isCbf
+                        ? null
+                        : await this.retryCreateTrigger(funcName, func.triggers);
                     // 设置路径，创建云接入路径
                     if (func.path) {
                         await this.createAccessPath(funcName, func.path);
@@ -690,18 +721,32 @@ class FunctionService {
     }
     /**
      * 获取云函数详细信息
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 不再注入 `ShowCode`（CBF 不接受该参数），因此也拿不到函数代码内容，
+     *   需要代码请使用 `downloadFunction`
+     * - 不转发 `codeSecret`：CBF 不支持代码保护，若在此下发会掩盖
+     *   `CreateFunction` / `UpdateFunctionCode` 的真实报错
+     *
      * @param {string} name 云函数名称
      * @returns {Promise<Record<string, string>>}
      */
     async getFunctionDetail(name, codeSecret) {
-        const { namespace } = this.getFunctionConfig();
+        const { namespace, backend } = this.getFunctionConfig();
+        const isCbf = backend === 'cbf';
+        // GetFunction 只传 EnvId 即可（SCF 与 CBF 均实测支持），Namespace 属冗余参数，不再下发
         const params = {
             FunctionName: name,
-            ShowCode: 'TRUE',
-            EnvId: namespace,
-            Namespace: namespace
+            EnvId: namespace
         };
-        if (codeSecret) {
+        // ShowCode 是 SDK 侧注入的字段：CBF（云开发云函数）不接受该参数，故 CBF 下不再注入
+        if (!isCbf) {
+            params.ShowCode = 'TRUE';
+        }
+        // CodeSecret（代码保护）在 CBF 下不被支持。该参数由调用方透传进来，
+        // 若在这里下发，用户会先看到指向 GetFunction 的报错，掩盖真正不支持代码保护的
+        // CreateFunction / UpdateFunctionCode，故 CBF 下不转发
+        if (codeSecret && !isCbf) {
             params.CodeSecret = codeSecret;
         }
         const data = await this.tcbService.request('GetFunction', params);
@@ -812,12 +857,21 @@ class FunctionService {
     }
     /**
      * 更新云函数配置
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 不再注入 `ClsTopicId` / `ClsLogsetId`，也不转发 `InstallDependency`
+     * - 环境变量：不传不接受 Key 为空的占位项，清空需提交空数组（传 `envVariables: {}` 即清空）
+     * - 不支持定时触发器：配置里的 `triggers` 会被跳过
+     *
+     * 用户显式配置的字段一律原样下发，不支持的字段由服务端报错透传。
+     *
      * @param {ICloudFunction} func 云函数配置
      * @returns {Promise<IResponseInfo>}
      */
     async updateFunctionConfig(func) {
         var _a, _b, _c;
-        const { namespace } = this.getFunctionConfig();
+        const { namespace, backend } = this.getFunctionConfig();
+        const isCbf = backend === 'cbf';
         // UpdateFunctionConfiguration API 白名单（大小写不敏感）
         // 参考：https://cloud.tencent.com/document/product/583/18580
         // 注意：Runtime, Handler, Code, Type, ProtocolType 只能在 CreateFunction 时指定
@@ -840,14 +894,19 @@ class FunctionService {
             // 注意：dnsCache 需要 'TRUE'/'FALSE' 字符串，在特殊处理阶段处理
             intranetconfig: 'IntranetConfig'
         };
-        const { TopicId, LogsetId } = this.getClsServiceConfig();
         // 构建参数
+        // ClsTopicId / ClsLogsetId 为 SDK 侧注入的字段：CBF（云开发云函数）不接受这两个参数，
+        // 且 UpdateFunctionConfiguration 按请求 JSON 中出现过的 key 生成 FieldMask，
+        // 一旦下发会直接报 FieldMask contains an unsupported field，故 CBF 下不再注入。
         const params = {
             EnvId: namespace,
-            FunctionName: func.name,
-            ClsTopicId: TopicId,
-            ClsLogsetId: LogsetId
+            FunctionName: func.name
         };
+        if (!isCbf) {
+            const { TopicId, LogsetId } = this.getClsServiceConfig();
+            params.ClsTopicId = TopicId;
+            params.ClsLogsetId = LogsetId;
+        }
         // 白名单字段自动转换（大小写不敏感，统一输出 PascalCase）
         for (const key of Object.keys(func)) {
             const lowerKey = key.toLowerCase();
@@ -857,7 +916,11 @@ class FunctionService {
             params[pascalKey] = toPascalCaseKeys(func[key]);
         }
         // 特殊处理：安装依赖标志（仅透传用户显式指定的值）
-        if (func.installDependency !== undefined) {
+        // CBF（云开发云函数）的 UpdateFunctionConfiguration 不接受该参数
+        // （CBF does not support parameter InstallDependency）。它属于「创建 / 更新代码」语义：
+        // SDK 在 createFunction(force=true) 覆盖部署时会把整个 func 透传给本接口，
+        // 若原样下发会让常规覆盖部署直接失败，故 CBF 下不下发
+        if (func.installDependency !== undefined && !isCbf) {
             params.InstallDependency = toBooleanString(func.installDependency);
         }
         // 特殊处理：L5 配置（支持 boolean | string）
@@ -877,13 +940,25 @@ class FunctionService {
             params.Publish = toBooleanString(publishValue);
         }
         // 特殊处理：环境变量
-        if (func.envVariables && Object.keys(func.envVariables).length > 0) {
-            params.Environment = {
-                Variables: Object.keys(func.envVariables).map(key => ({
-                    Key: key,
-                    Value: func.envVariables[key]
-                }))
-            };
+        // - 有变量：原样下发
+        // - 未传 envVariables：不提交，保持云端现有变量不变
+        // - 显式传空对象：CBF（云开发云函数）清空环境变量需提交空数组
+        //   （CBF 不接受 SCF 那套 Key 为空的占位项，会报 Invalid environment variable）
+        if (func.envVariables) {
+            const envKeys = Object.keys(func.envVariables);
+            if (envKeys.length > 0) {
+                params.Environment = {
+                    Variables: envKeys.map(key => ({
+                        Key: key,
+                        Value: func.envVariables[key]
+                    }))
+                };
+            }
+            else if (isCbf) {
+                params.Environment = {
+                    Variables: []
+                };
+            }
         }
         // 特殊处理：VPC 配置
         if (((_a = func === null || func === void 0 ? void 0 : func.vpc) === null || _a === void 0 ? void 0 : _a.subnetId) !== undefined && ((_b = func === null || func === void 0 ? void 0 : func.vpc) === null || _b === void 0 ? void 0 : _b.vpcId) !== undefined) {
@@ -928,7 +1003,8 @@ class FunctionService {
         }
         try {
             // 如果函数配置中包含触发器，则更新触发器
-            if (func.triggers && func.triggers.length > 0) {
+            // CBF（云开发云函数）不支持定时触发器，内部静默跳过（避免无意义的失败告警）
+            if (func.triggers && func.triggers.length > 0 && !isCbf) {
                 try {
                     await this.createFunctionTriggers(func.name, func.triggers);
                 }
@@ -947,6 +1023,11 @@ class FunctionService {
         }
     }
     /**
+     * 更新云函数代码
+     *
+     * `UpdateFunctionCode` 只传 `EnvId` 即可（SCF 与 CBF 均实测支持），不再下发冗余的 `Namespace`。
+     *
+     * 注意：CBF（云开发云函数）不支持 `codeSecret`（代码保护），传入后会由服务端报错。
      *
      * @param {IUpdateFunctionCodeParam} funcParam
      * @returns {Promise<IResponseInfo>}
@@ -961,7 +1042,6 @@ class FunctionService {
             const params = {
                 FunctionName: funcName,
                 EnvId: namespace,
-                Namespace: namespace,
                 Code: {
                     ImageConfig: buildImageConfig(func.imageConfig)
                 }
@@ -1009,7 +1089,6 @@ class FunctionService {
         const params = {
             FunctionName: funcName,
             EnvId: namespace,
-            Namespace: namespace,
             Handler: func.handler || 'index.main',
             InstallDependency: installDependency,
             Code: codeParams
@@ -1156,6 +1235,11 @@ class FunctionService {
     }
     /**
      * 创建云函数触发器
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境不支持定时触发器，
+     * 且该接口走 SCF 后端，对 CBF 的函数会返回「未找到指定的函数」这类误导性报错，
+     * 故 CBF 下直接抛错。内部调用点（`createFunction` / `updateFunctionConfig`）会跳过本方法。
+     *
      * @param {string} name 云函数名称
      * @param {ICloudFunctionTrigger[]} triggers 云函数触发器配置
      * @returns {Promise<IResponseInfo>}
@@ -1163,7 +1247,12 @@ class FunctionService {
     async createFunctionTriggers(name, triggers = []) {
         if (!triggers || !triggers.length)
             return null;
-        const { namespace } = this.getFunctionConfig();
+        const { namespace, backend } = this.getFunctionConfig();
+        // CBF（云开发云函数）不支持定时触发器：不下发到 SCF 后端
+        // （否则会报「未找到指定的函数」，误导用户以为是函数不存在）
+        if (backend === 'cbf') {
+            (0, error_1.throwInvalidParam)(`[${name}] CBF（云开发云函数）环境不支持定时触发器`);
+        }
         const parsedTriggers = triggers.map(item => {
             if (item.type !== 'timer') {
                 (0, error_1.throwInvalidParam)(`不支持的触发器类型 [${item.type}]，目前仅支持定时触发器（timer）！`);
@@ -1206,12 +1295,22 @@ class FunctionService {
     }
     /**
      * 删除云函数触发器
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境不支持定时触发器，
+     * 且该接口走 SCF 后端，对 CBF 的函数会返回「未找到指定的函数」这类误导性报错，
+     * 故 CBF 下直接抛错。
+     *
      * @param {string} name 云函数名称
      * @param {string} triggerName 云函数触发器名称
      * @returns {Promise<IResponseInfo>}
      */
     async deleteFunctionTrigger(name, triggerName) {
-        const { namespace } = this.getFunctionConfig();
+        const { namespace, backend } = this.getFunctionConfig();
+        // CBF（云开发云函数）不支持定时触发器：不下发到 SCF 后端
+        // （否则会报「未找到指定的函数」，误导用户以为是函数不存在）
+        if (backend === 'cbf') {
+            (0, error_1.throwInvalidParam)(`[${name}] CBF（云开发云函数）环境不支持定时触发器`);
+        }
         try {
             return await this.scfService.request('DeleteTrigger', {
                 FunctionName: name,
@@ -1546,10 +1645,10 @@ class FunctionService {
     async publishVersion(publishParams) {
         const { namespace } = this.getFunctionConfig();
         const { functionName: FunctionName, description: Description } = publishParams;
-        return this.scfService.request('PublishVersion', {
+        return this.tcbService.request('PublishVersion', {
             FunctionName,
             Description,
-            Namespace: namespace
+            EnvId: namespace
         });
     }
     /**
@@ -1560,10 +1659,11 @@ class FunctionService {
      */
     async listVersionByFunction(listVersionParams) {
         const { namespace } = this.getFunctionConfig();
-        const { functionName: FunctionName, offset: Offset, limit: Limit, order: Order, orderBy: OrderBy } = listVersionParams;
-        return this.scfService.request('ListVersionByFunction', {
+        const { functionName: FunctionName, searchKey: SearchKey, offset: Offset, limit: Limit, order: Order, orderBy: OrderBy } = listVersionParams;
+        return this.tcbService.request('ListVersionByFunction', {
             FunctionName,
-            Namespace: namespace,
+            EnvId: namespace,
+            SearchKey,
             Offset,
             Limit,
             Order,
@@ -1571,7 +1671,23 @@ class FunctionService {
         });
     }
     /**
-     *
+     * 删除函数指定版本
+     * @param {IDeleteFunctionVersionParams} params
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    async deleteFunctionVersion(params) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, qualifier: Qualifier } = params;
+        return this.tcbService.request('DeleteFunctionVersion', {
+            FunctionName,
+            EnvId: namespace,
+            Qualifier
+        });
+    }
+    /**
+     * 更新函数流量配置（旧版 SCF 协议）
+     * @deprecated 请使用 updateFunctionAliasConfigV2
      * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
      * @returns {Promise<IResponseInfo>}
      * @memberof FunctionService
@@ -1589,7 +1705,24 @@ class FunctionService {
         });
     }
     /**
-     * 查询函数别名详情
+     * 更新函数流量策略（V2，TCB Traffic 协议）
+     * @param {IUpdateFunctionAliasConfigV2} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    async updateFunctionAliasConfigV2(updateVersionConfigParams) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, name: Name, traffic: Traffic } = updateVersionConfigParams;
+        return this.tcbService.request('UpdateAlias', {
+            FunctionName,
+            Name,
+            EnvId: namespace,
+            Traffic
+        });
+    }
+    /**
+     * 查询函数别名详情（旧版 SCF 协议）
+     * @deprecated 请使用 getFunctionAliasV2
      * @param {IGetFunctionAlias} params
      * @returns {Promise<IGetFunctionAliasRes>}
      * @memberof FunctionService
@@ -1604,10 +1737,33 @@ class FunctionService {
         });
     }
     /**
-     * 通过 SCF COS 上传方式（通过 GetTempCosInfo + COS SDK 上传）
-     * 返回 TempCosObjectName 用于创建/更新函数
+     * 查询函数别名详情（V2，TCB Traffic 协议）
+     * @param {IGetFunctionAliasV2} params
+     * @returns {Promise<IGetFunctionAliasResV2>}
+     * @memberof FunctionService
+     */
+    async getFunctionAliasV2(params) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, name: Name } = params;
+        return this.tcbService.request('GetAlias', {
+            FunctionName,
+            Name,
+            EnvId: namespace
+        });
+    }
+    /**
+     * COS 上传方式上传函数代码包，返回 { Key }
+     * - CBF（backend=cbf）：tcb.GetTempCosInfo 获取 PutUrl 直传，Key = 服务端生成的 ObjectKey
+     * - SCF（backend=scf，默认）：scf.GetTempCosInfo + Sign + COS SDK 上传
+     * Key 由 getCodeParams 格式化为 TempCosObjectName 用于创建/更新函数
      */
     async uploadFunctionZipToCos(options, installDependency) {
+        const { backend } = this.getFunctionConfig();
+        // CBF 环境：tcb.GetTempCosInfo + PutUrl 直传
+        if (backend === 'cbf') {
+            return this.uploadFunctionZipViaPutUrl(options, installDependency);
+        }
+        // SCF 环境：保留原链路（scf.GetTempCosInfo + Sign + COS SDK）
         const { func, functionPath, functionRootPath } = options;
         const { env, appId } = this.getFunctionConfig();
         if (!appId) {
@@ -1650,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();
+            }
         });
     }
     /**
@@ -1780,15 +1983,117 @@ class FunctionService {
                 ZipFile: base64
             };
         }
-        // 默认走 COS 上传（GetTempCosInfo + COS SDK）
+        // 默认走 COS 上传（SCF: scf.GetTempCosInfo + COS SDK；CBF: tcb.GetTempCosInfo + PutUrl 直传）
         console.log(`[${func.name}] 部署方式: COS 上传`);
+        const { backend } = this.getFunctionConfig();
         const region = this.environment.cloudBaseContext.region || constant_1.SCF_TEMP_COS.DEFAULT_REGION;
         const result = await this.uploadFunctionZipToCos(options, installDependency);
+        // CBF：ObjectKey 由服务端生成，原样填入（无前导斜杠）；SCF：保持原有 /{Key} 格式
+        if (backend === 'cbf') {
+            return {
+                CosBucketRegion: region,
+                TempCosObjectName: result.Key
+            };
+        }
         return {
             CosBucketRegion: region,
             TempCosObjectName: `/${result.Key}`
         };
     }
+    /**
+     * CBF 环境的临时代码包上传（tcb.GetTempCosInfo + PutUrl 直传）
+     * - 先压缩再取 PutUrl，避免压缩耗时消耗 PutUrl 约 300 秒的有效期
+     * - PutUrl 过期（403）/ 5xx / 网络错误时重新调用 GetTempCosInfo 刷新地址，不复用旧地址（初始 + 重试共 3 次）
+     * - ObjectKey 由服务端生成，多次调用得到不同上传路径，上传成功后原样返回
+     * @private
+     */
+    async uploadFunctionZipViaPutUrl(options, installDependency) {
+        const { func, functionPath, functionRootPath } = options;
+        const { env } = this.getFunctionConfig();
+        // FileName 格式为 `{FunctionName}.zip`，最大 64 字符
+        const fileName = `${func.name}.zip`;
+        if (fileName.length > 64) {
+            (0, error_1.throwInvalidParam)(`[${func.name}] 代码包文件名 ${fileName} 超过 64 字符上限`);
+        }
+        // 1. 本地压缩（云端安装依赖时自动忽略 node_modules 目录，与 SCF 链路一致）
+        const ignore = installDependency === 'TRUE'
+            ? ['node_modules/**/*', 'node_modules', ...(func.ignore || [])]
+            : [...(func.ignore || [])];
+        const packer = new packer_1.FunctionPacker({
+            ignore,
+            codeType: packer_1.CodeType.File,
+            functionPath,
+            name: func.name,
+            root: functionRootPath
+        });
+        const zipFilePath = await packer.compressFiles();
+        try {
+            const maxAttempts = 3;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                // 2. 获取上传信息（每次调用服务端生成新的 PutUrl / ObjectKey）
+                const { PutUrl, ObjectKey } = await this.tcbService.request('GetTempCosInfo', {
+                    EnvId: env,
+                    FileName: fileName
+                });
+                if (!PutUrl || !ObjectKey) {
+                    (0, error_1.throwApiError)(`[${func.name}] GetTempCosInfo 返回数据异常：缺少 PutUrl 或 ObjectKey`);
+                }
+                // 3. 对 PutUrl 直接 HTTP PUT 上传 zip，无需拼接桶域名或 Authorization
+                //    网络错误/超时返回 null，由外层刷新 PutUrl 重试
+                const response = await this.putZipFileToUrl(PutUrl, zipFilePath).catch(e => {
+                    if (attempt === maxAttempts) {
+                        // R3：继承上游错误码（FetchError 自带 ECONNREFUSED / ETIMEDOUT 等）
+                        const errorCode = e.code || e.statusCode || '';
+                        throw new error_1.CloudBaseError(`[${func.name}] COS 上传失败: ${e.message}`, {
+                            code: errorCode,
+                            original: e
+                        });
+                    }
+                    return null;
+                });
+                if (!response) {
+                    continue;
+                }
+                if (response.ok) {
+                    return { Key: ObjectKey };
+                }
+                let errorDetail = '';
+                try {
+                    errorDetail = await response.text();
+                }
+                catch (e) {
+                    // 忽略响应体读取失败
+                }
+                const message = `COS 上传失败: ${response.status} ${response.statusText}${errorDetail ? ` - ${errorDetail}` : ''}`;
+                // 403（PutUrl 过期）/ 5xx 可刷新地址重试；其余 4xx 直接失败
+                const retryable = response.status === 403 || response.status >= 500;
+                if (!retryable || attempt === maxAttempts) {
+                    // HTTP 状态码属平台返回，不作为本层自有码，保留在 message 中
+                    (0, error_1.throwApiError)(message);
+                }
+            }
+            /* istanbul ignore next */
+            (0, error_1.throwApiError)(`[${func.name}] COS 上传失败`);
+        }
+        finally {
+            // 4. 清理临时 zip
+            await packer.clean();
+        }
+    }
+    /**
+     * 对 PutUrl 发起 HTTP PUT 上传 zip 文件（超时 120 秒，支持 http_proxy 代理）
+     * @private
+     */
+    async putZipFileToUrl(putUrl, zipFilePath) {
+        return (0, utils_1.fetchStream)(putUrl, {
+            method: 'PUT',
+            body: fs_1.default.createReadStream(zipFilePath),
+            headers: {
+                'Content-Type': 'application/zip'
+            },
+            timeout: 120000
+        });
+    }
     async createAccessPath(name, path) {
         const access = this.environment.getAccessService();
         try {
@@ -2018,12 +2323,21 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "listVersionByFunction", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], FunctionService.prototype, "deleteFunctionVersion", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "updateFunctionAliasConfig", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], FunctionService.prototype, "updateFunctionAliasConfigV2", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "getFunctionAlias", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], FunctionService.prototype, "getFunctionAliasV2", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "uploadFunctionZipToCos", null);
@@ -2033,6 +2347,9 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "getCodeParams", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], FunctionService.prototype, "uploadFunctionZipViaPutUrl", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], FunctionService.prototype, "createAccessPath", null);

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.0",
+    "version": "5.9.2",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/types/function/index.d.ts

@@ -124,14 +124,30 @@ export interface IPublishVersionRes extends IResponseInfo {
     Handler: string;
     Timeout: number;
     Runtime: string;
-    Namespace: string;
+    EnvId: string;
+    /** @deprecated 请改用 EnvId */
+    Namespace?: string;
 }
 export interface IListFunctionVersionParams {
     functionName: string;
+    /**
+     * 兼容 SCF 的搜索字段。
+     *
+     * 实测仅接受数字型取值（传其它值报 InvalidParameterValue），但服务端**未按它过滤**：
+     * 传存在的版本号与不存在的数字都返回全量版本列表。
+     */
+    searchKey?: string;
     offset?: number;
+    /** 返回数量，默认 20，最大 100（超过报 Offset must be nonnegative and Limit must be between 0 and 100） */
     limit?: number;
-    order?: string;
-    orderBy?: string;
+    /** 排序方向，仅支持 ASC / DESC（传其它值报 Order must be ASC or DESC） */
+    order?: 'ASC' | 'DESC';
+    /** 排序字段，仅支持 AddTime / ModTime（传其它值报 OrderBy must be AddTime or ModTime） */
+    orderBy?: 'AddTime' | 'ModTime';
+}
+export interface IDeleteFunctionVersionParams {
+    functionName: string;
+    qualifier: string;
 }
 export interface IFunctionVersion {
     Version: string;
@@ -170,6 +186,51 @@ export interface IGetFunctionAlias {
     functionName: string;
     name: string;
 }
+export type IFunctionTrafficType = 'FLOW' | 'HEADERS' | 'UNSUPPORTED';
+/**
+ * 可写的流量策略类型：`UNSUPPORTED` 是查询返回的只读兼容态，不可用于 UpdateAlias
+ */
+export type IUpdatableFunctionTrafficType = 'FLOW' | 'HEADERS';
+export interface IFunctionTrafficRule {
+    Version: string;
+    Weight?: number;
+    Key?: string;
+    Value?: string;
+}
+export interface IFunctionTraffic {
+    Type: IFunctionTrafficType | string;
+    DefaultVersion: string;
+    Rules: IFunctionTrafficRule[];
+}
+/** 传入 UpdateAlias 的可写流量策略（`Type` 不含只读的 `UNSUPPORTED`） */
+export interface IUpdatableFunctionTraffic extends Omit<IFunctionTraffic, 'Type'> {
+    Type: IUpdatableFunctionTrafficType;
+}
+export interface IFunctionBackendVersionWeight {
+    Version: string;
+    Weight: number;
+}
+export interface IFunctionBackendVersionMatch {
+    Version: string;
+    Key: string;
+    Method: string;
+    Expression: string;
+}
+export interface IFunctionBackendRoutingConfig {
+    AdditionalVersionWeights: IFunctionBackendVersionWeight[];
+    AdditionVersionMatches: IFunctionBackendVersionMatch[];
+}
+export type ITrafficRule = IFunctionTrafficRule;
+export type ITraffic = IFunctionTraffic;
+export interface IUpdateFunctionAliasConfigV2 {
+    functionName: string;
+    name?: string;
+    traffic: IUpdatableFunctionTraffic;
+}
+export interface IGetFunctionAliasV2 {
+    functionName: string;
+    name?: string;
+}
 export interface IGetFunctionAliasRes extends IResponseInfo {
     FunctionVersion: string;
     Name: string;
@@ -178,6 +239,14 @@ export interface IGetFunctionAliasRes extends IResponseInfo {
     AddTime: string;
     ModTime: string;
 }
+export interface IGetFunctionAliasResV2 extends IResponseInfo {
+    Name: string;
+    FunctionVersion: string;
+    Traffic: IFunctionTraffic;
+    TrafficEditable: boolean;
+    TrafficCompatibilityReason: string;
+    BackendRoutingConfig: IFunctionBackendRoutingConfig;
+}
 export interface IListFunctionOptions {
     limit?: number;
     offset?: number;
@@ -251,6 +320,14 @@ export declare class FunctionService {
     updateFunctionIncrementalCode(funcParam: IUpdateFunctionIncrementalCodeParam): Promise<IResponseInfo>;
     /**
      * 创建云函数
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 默认 runtime 为 `Nodejs24.11`（见 `CBF_ALLOWED_RUNTIMES`）
+     * - 不再注入 `Stamp` / `ClsTopicId` / `ClsLogsetId` 与默认 `Role`
+     * - 不支持定时触发器，内部跳过触发器创建
+     *
+     * 用户显式配置的字段一律原样下发，不支持的字段由服务端报错透传。
+     *
      * @param {ICreateFunctionParam} funcParam
      * @returns {(Promise<IResponseInfo | ICreateFunctionRes>)}
      */
@@ -303,6 +380,13 @@ export declare class FunctionService {
     }): Promise<void>;
     /**
      * 获取云函数详细信息
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 不再注入 `ShowCode`（CBF 不接受该参数），因此也拿不到函数代码内容，
+     *   需要代码请使用 `downloadFunction`
+     * - 不转发 `codeSecret`：CBF 不支持代码保护，若在此下发会掩盖
+     *   `CreateFunction` / `UpdateFunctionCode` 的真实报错
+     *
      * @param {string} name 云函数名称
      * @returns {Promise<Record<string, string>>}
      */
@@ -372,11 +456,24 @@ export declare class FunctionService {
     getCompleteFunctionLogs(_options: IFunctionLogOptionsV2): Promise<IFunctionLogDetailRes[]>;
     /**
      * 更新云函数配置
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境差异：
+     * - 不再注入 `ClsTopicId` / `ClsLogsetId`，也不转发 `InstallDependency`
+     * - 环境变量：不传不接受 Key 为空的占位项，清空需提交空数组（传 `envVariables: {}` 即清空）
+     * - 不支持定时触发器：配置里的 `triggers` 会被跳过
+     *
+     * 用户显式配置的字段一律原样下发，不支持的字段由服务端报错透传。
+     *
      * @param {ICloudFunction} func 云函数配置
      * @returns {Promise<IResponseInfo>}
      */
     updateFunctionConfig(func: ICloudFunction): Promise<IResponseInfo>;
     /**
+     * 更新云函数代码
+     *
+     * `UpdateFunctionCode` 只传 `EnvId` 即可（SCF 与 CBF 均实测支持），不再下发冗余的 `Namespace`。
+     *
+     * 注意：CBF（云开发云函数）不支持 `codeSecret`（代码保护），传入后会由服务端报错。
      *
      * @param {IUpdateFunctionCodeParam} funcParam
      * @returns {Promise<IResponseInfo>}
@@ -428,6 +525,11 @@ export declare class FunctionService {
     copyFunction(name: string, newFunctionName: string, targetEnvId?: string, force?: boolean): Promise<IResponseInfo>;
     /**
      * 创建云函数触发器
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境不支持定时触发器，
+     * 且该接口走 SCF 后端，对 CBF 的函数会返回「未找到指定的函数」这类误导性报错，
+     * 故 CBF 下直接抛错。内部调用点（`createFunction` / `updateFunctionConfig`）会跳过本方法。
+     *
      * @param {string} name 云函数名称
      * @param {ICloudFunctionTrigger[]} triggers 云函数触发器配置
      * @returns {Promise<IResponseInfo>}
@@ -436,6 +538,11 @@ export declare class FunctionService {
     batchCreateTriggers(options: IFunctionBatchOptions): Promise<void>;
     /**
      * 删除云函数触发器
+     *
+     * CBF（云开发云函数，`Functions[0].Backend === 'cbf'`）环境不支持定时触发器，
+     * 且该接口走 SCF 后端，对 CBF 的函数会返回「未找到指定的函数」这类误导性报错，
+     * 故 CBF 下直接抛错。
+     *
      * @param {string} name 云函数名称
      * @param {string} triggerName 云函数触发器名称
      * @returns {Promise<IResponseInfo>}
@@ -505,22 +612,47 @@ export declare class FunctionService {
      */
     listVersionByFunction(listVersionParams: IListFunctionVersionParams): Promise<IFunctionVersionsRes>;
     /**
-     *
+     * 删除函数指定版本
+     * @param {IDeleteFunctionVersionParams} params
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    deleteFunctionVersion(params: IDeleteFunctionVersionParams): Promise<IResponseInfo>;
+    /**
+     * 更新函数流量配置（旧版 SCF 协议）
+     * @deprecated 请使用 updateFunctionAliasConfigV2
      * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
      * @returns {Promise<IResponseInfo>}
      * @memberof FunctionService
      */
     updateFunctionAliasConfig(updateVersionConfigParams: IUpdateFunctionAliasConfig): Promise<IResponseInfo>;
     /**
-     * 查询函数别名详情
+     * 更新函数流量策略（V2，TCB Traffic 协议）
+     * @param {IUpdateFunctionAliasConfigV2} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    updateFunctionAliasConfigV2(updateVersionConfigParams: IUpdateFunctionAliasConfigV2): Promise<IResponseInfo>;
+    /**
+     * 查询函数别名详情（旧版 SCF 协议）
+     * @deprecated 请使用 getFunctionAliasV2
      * @param {IGetFunctionAlias} params
      * @returns {Promise<IGetFunctionAliasRes>}
      * @memberof FunctionService
      */
     getFunctionAlias(params: IGetFunctionAlias): Promise<IGetFunctionAliasRes>;
     /**
-     * 通过 SCF COS 上传方式（通过 GetTempCosInfo + COS SDK 上传）
-     * 返回 TempCosObjectName 用于创建/更新函数
+     * 查询函数别名详情（V2，TCB Traffic 协议）
+     * @param {IGetFunctionAliasV2} params
+     * @returns {Promise<IGetFunctionAliasResV2>}
+     * @memberof FunctionService
+     */
+    getFunctionAliasV2(params: IGetFunctionAliasV2): Promise<IGetFunctionAliasResV2>;
+    /**
+     * COS 上传方式上传函数代码包，返回 { Key }
+     * - CBF（backend=cbf）：tcb.GetTempCosInfo 获取 PutUrl 直传，Key = 服务端生成的 ObjectKey
+     * - SCF（backend=scf，默认）：scf.GetTempCosInfo + Sign + COS SDK 上传
+     * Key 由 getCodeParams 格式化为 TempCosObjectName 用于创建/更新函数
      */
     uploadFunctionZipToCos(options: IFunctionCode, installDependency: 'TRUE' | 'FALSE'): Promise<{
         Key: string;
@@ -542,6 +674,19 @@ export declare class FunctionService {
         TempCosObjectName: string;
         ZipFile?: undefined;
     }>;
+    /**
+     * CBF 环境的临时代码包上传（tcb.GetTempCosInfo + PutUrl 直传）
+     * - 先压缩再取 PutUrl，避免压缩耗时消耗 PutUrl 约 300 秒的有效期
+     * - PutUrl 过期（403）/ 5xx / 网络错误时重新调用 GetTempCosInfo 刷新地址，不复用旧地址（初始 + 重试共 3 次）
+     * - ObjectKey 由服务端生成，多次调用得到不同上传路径，上传成功后原样返回
+     * @private
+     */
+    private uploadFunctionZipViaPutUrl;
+    /**
+     * 对 PutUrl 发起 HTTP PUT 上传 zip 文件（超时 120 秒，支持 http_proxy 代理）
+     * @private
+     */
+    private putZipFileToUrl;
     private createAccessPath;
     private getTempCosInfo;
     /**

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>;
 /**