@cloudbase/manager-node 5.9.4 → 5.10.0

package/lib/deploy/framework.js

@@ -234,9 +234,10 @@ function resolveHostingOutputDir(config, root, readPkgFile = defaultReadPkgFile)
 /**
  * 本地构建单个 hosting 项（仅执行 buildCommand，不安装依赖，不上传）
  *
- * 从 StaticDeployer.runLocalBuild 提炼的纯函数版：不依赖 Environment，
- * 供 CLI 的 tcb app build 与任何需要「只构建不上传」的调用方复用，
- * 避免各端各自复制推断/执行逻辑。buildCommand 为空 → 直接返回 null。
+ * 从原 StaticDeployer.runLocalBuild 提炼的纯函数版（该方法已随「声明式部署只部署
+ * 不构建」一并移除，构建入口只剩这里）：不依赖 Environment，供 CLI 的 tcb app build
+ * 与任何需要「只构建不上传」的调用方复用，避免各端各自复制推断/执行逻辑。
+ * buildCommand 为空 → 直接返回 null。
  *
  * @param config   hosting 项配置（framework/buildCommand/outputDir，root 单独传参）
  * @param root     项目目录（绝对路径）

package/lib/env/index.js

@@ -508,7 +508,8 @@ class EnvService {
             return access_token;
         }
         catch (e) {
-            console.log(e);
+            // 错误信息走 stderr，且保留完整堆栈；stdout 只留给结构化输出
+            console.error(e);
             throw e;
         }
     }

package/lib/error-types.js

@@ -17,5 +17,12 @@ exports.ERROR_TYPES = {
     netError: { code: 'NETWORK_ERROR' },
     apiError: { code: 'API_ERROR' },
     credentialError: { code: 'MISSING_CREDENTIAL' },
-    fileError: { code: 'FILE_READ_ERROR' }
+    fileError: { code: 'FILE_READ_ERROR' },
+    /**
+     * 部署前未找到构建产物（目录不存在或为空）。
+     *
+     * 声明式部署（`tcb deploy`）不执行构建，产物必须由用户先产出；
+     * 这个码让 CLI 侧能稳定映射到非零退出码并给出「先构建」的引导。
+     */
+    buildOutputNotFound: { code: 'BUILD_OUTPUT_NOT_FOUND' }
 };

package/lib/function/index.js

@@ -1978,13 +1978,13 @@ class FunctionService {
             if (!(base64 === null || base64 === void 0 ? void 0 : base64.length)) {
                 (0, error_1.throwInvalidParam)('文件不能为空');
             }
-            console.log(`[${func.name}] 部署方式: ZIP base64 上传`);
+            (0, utils_1.debugLog)(`[${func.name}] 部署方式: ZIP base64 上传`);
             return {
                 ZipFile: base64
             };
         }
         // 默认走 COS 上传（SCF: scf.GetTempCosInfo + COS SDK；CBF: tcb.GetTempCosInfo + PutUrl 直传）
-        console.log(`[${func.name}] 部署方式: COS 上传`);
+        (0, utils_1.debugLog)(`[${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);

package/lib/hosting/index.js

@@ -17,6 +17,7 @@ const error_1 = require("../error");
 const utils_1 = require("../utils");
 const parallel_1 = require("../utils/parallel");
 const storage_config_1 = require("../utils/storage-config");
+const ignore_1 = require("../utils/ignore");
 const envDomainCache = new Map();
 const HostingStatusMap = {
     init: '初始化中',
@@ -135,6 +136,11 @@ class HostingService {
         const { localPath, cloudPath, entryFiles, files = [], onProgress, onFileFinish, parallel = 20, ignore = ['.DS_Store'], retryCount, retryInterval, verify = false, safe = false, prune = false } = options;
         const { bucket, region, basePath } = await this.getHostingBucket();
         const storageService = await this.environment.getStorageService();
+        // 敏感文件排除在**入口**兜底，不能留给调用方（stbug-cg6I6WXOdb）：
+        // 下方三条分支（一致发布 / 目录 / 单文件）都会把 ignore 继续透传，
+        // 只在某一条分支上补默认清单，就会出现「目录传得上、单文件传得上」的口径分叉。
+        // 用户 ignore 只能追加：`undefined` / `[]` 都不表示「不排除 .env / .git / 私钥」。
+        const effectiveIgnore = (0, ignore_1.mergeArtifactIgnore)(ignore);
         let uploadFiles = Array.isArray(files) ? files : [];
         // localPath 存在，上传文件夹/文件
         if (localPath) {
@@ -153,7 +159,7 @@ class HostingService {
                         onProgress,
                         onFileFinish,
                         fileId: false,
-                        ignore,
+                        ignore: effectiveIgnore,
                         parallel,
                         retryCount,
                         retryInterval,
@@ -172,7 +178,7 @@ class HostingService {
                     onProgress,
                     onFileFinish,
                     fileId: false,
-                    ignore,
+                    ignore: effectiveIgnore,
                     parallel,
                     retryCount,
                     retryInterval,
@@ -189,7 +195,7 @@ class HostingService {
         }
         // 文件上传统一通过批量上传接口
         return storageService.uploadFilesCustom({
-            ignore,
+            ignore: effectiveIgnore,
             parallel,
             onProgress,
             onFileFinish,

package/lib/platform/index.js

@@ -1,8 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlatformService = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
 const error_1 = require("../error");
+const error_types_1 = require("../error-types");
 const utils_1 = require("../utils");
+const cos_upload_1 = require("../utils/cos-upload");
 /**
  * 平台版服务
  * 提供平台版套餐查询、资源用量统计、环境生命周期管理及 HTTP 访问服务路由管理能力
@@ -173,5 +180,277 @@ class PlatformService {
     async describePlatformHttpServiceRoute(params) {
         return this.cloudService.request('DescribePlatformHTTPServiceRoute', Object.assign({}, params));
     }
+    /**
+     * 上传本地错误页文件并创建 HTTP 访问服务自定义错误页配置
+     * 文件上传至平台静态托管桶根目录 error-pages/{PlatformId}/{文件名}，不拼接 BasePath。
+     * 文件名中的空白和括号替换为 -；同名文件会被覆盖。
+     * ResourceType 固定为 STATIC_STORE，ResourceName 固定为 staticstore，RewritePath 自动生成。
+     * 支持一次为多个状态码绑定同一个错误页；同一状态码只允许一个配置，创建前会先查重，
+     * 命中已有配置时直接报错且不上传文件。
+     * 上传失败时不创建规则；创建失败时保留已上传文件，不自动删除或回滚覆盖的对象。
+     * @param {CreateHttpServiceErrorPageParams} params 平台版 ID、状态码列表和本地文件路径
+     * @returns {Promise<CreateHttpServiceErrorPageRes>} 创建成功个数
+     */
+    async createHttpServiceErrorPage(params) {
+        var _a;
+        const { PlatformId, HttpStatusCode, localPath } = params;
+        if (typeof PlatformId !== 'string' || !/^pf-[a-zA-Z0-9-]+$/.test(PlatformId)) {
+            (0, error_1.throwInvalidParam)('PlatformId 必须是有效的平台版 ID');
+        }
+        if (!Array.isArray(HttpStatusCode) ||
+            !HttpStatusCode.length ||
+            HttpStatusCode.some(code => typeof code !== 'string' || !/^[1-5]\d{2}$/.test(code))) {
+            (0, error_1.throwInvalidParam)('HttpStatusCode 必须是非空 HTTP 状态码字符串数组，如 [\'404\', \'403\']');
+        }
+        const statusCodes = Array.from(new Set(HttpStatusCode));
+        // 同一状态码只允许一个配置，先查重，避免重复创建且不白上传文件
+        const { Configs } = await this.describeHttpServiceErrorPage({
+            PlatformId,
+            HttpStatusCode: statusCodes
+        });
+        const occupiedCodes = [];
+        for (const item of Configs !== null && Configs !== void 0 ? Configs : []) {
+            for (const code of (_a = item.HttpStatusCode) !== null && _a !== void 0 ? _a : []) {
+                if (statusCodes.includes(code) && !occupiedCodes.includes(code)) {
+                    occupiedCodes.push(code);
+                }
+            }
+        }
+        if (occupiedCodes.length) {
+            (0, error_1.throwInvalidParam)(`状态码 ${occupiedCodes.join('、')} 已存在错误页配置，请使用 modifyHttpServiceErrorPage 更新`);
+        }
+        const rewritePath = await this.uploadErrorPageFile(PlatformId, localPath);
+        try {
+            return await this.cloudService.request('CreateHTTPServiceErrorPage', {
+                PlatformId,
+                Config: {
+                    HttpStatusCode: statusCodes,
+                    ResourceType: 'STATIC_STORE',
+                    ResourceName: 'staticstore',
+                    RewritePath: rewritePath
+                }
+            });
+        }
+        catch (error) {
+            const message = `错误页文件已上传至 ${rewritePath}，但创建规则失败，文件已保留：${error instanceof Error ? error.message : String(error)}`;
+            throw new error_1.CloudBaseError(message, Object.assign(Object.assign({}, (error instanceof error_1.CloudBaseError
+                ? { code: error.code, source: error.source || undefined, requestId: error.requestId }
+                : { type: error_types_1.ERROR_TYPES.apiError })), { action: 'CreateHTTPServiceErrorPage', original: error instanceof Error ? error : undefined }));
+        }
+    }
+    /**
+     * 更新 HTTP 访问服务自定义错误页配置
+     * 与 ModifyHTTPServiceErrorPage 的入参保持一致：按 Id 更新一条配置，HttpStatusCode 为修改后的完整集合。
+     * 传入 localPath 时上传新文件并以 error-pages/{PlatformId}/{文件名} 作为 RewritePath；
+     * 不传 localPath 时沿用该记录现有文件，仅更新状态码等配置。
+     * 一条记录只对应一份错误页文件，换文件会作用于该记录绑定的全部状态码。
+     * 上传失败时不更新规则；更新失败时保留已上传文件，不自动删除或回滚覆盖的对象。
+     * @param {ModifyHttpServiceErrorPageParams} params 平台版 ID、配置 ID、状态码集合与可选的本地文件路径
+     * @returns {Promise<ModifyHttpServiceErrorPageRes>} 更新成功个数
+     */
+    async modifyHttpServiceErrorPage(params) {
+        var _a;
+        const { PlatformId, Id, HttpStatusCode, localPath } = params;
+        if (typeof PlatformId !== 'string' || !/^pf-[a-zA-Z0-9-]+$/.test(PlatformId)) {
+            (0, error_1.throwInvalidParam)('PlatformId 必须是有效的平台版 ID');
+        }
+        if (!Number.isInteger(Id) || Id <= 0) {
+            (0, error_1.throwInvalidParam)('Id 必须是 describeHttpServiceErrorPage 返回的正整数配置 ID');
+        }
+        if (!Array.isArray(HttpStatusCode) ||
+            !HttpStatusCode.length ||
+            HttpStatusCode.some(code => typeof code !== 'string' || !/^[1-5]\d{2}$/.test(code))) {
+            (0, error_1.throwInvalidParam)('HttpStatusCode 必须是非空 HTTP 状态码字符串数组，如 [\'404\']');
+        }
+        const statusCodes = Array.from(new Set(HttpStatusCode));
+        // 一次查询同时用于取回现有配置（沿用文件、清理旧对象）和校验状态码占用
+        const { Configs } = await this.describeHttpServiceErrorPage({ PlatformId });
+        const target = (Configs !== null && Configs !== void 0 ? Configs : []).find(item => item.Id === Id);
+        const conflictCodes = [];
+        for (const item of Configs !== null && Configs !== void 0 ? Configs : []) {
+            // 同一状态码只允许一个配置，跳过自身记录
+            if (item.Id === Id)
+                continue;
+            for (const code of (_a = item.HttpStatusCode) !== null && _a !== void 0 ? _a : []) {
+                if (statusCodes.includes(code) && !conflictCodes.includes(code)) {
+                    conflictCodes.push(code);
+                }
+            }
+        }
+        if (conflictCodes.length) {
+            (0, error_1.throwInvalidParam)(`状态码 ${conflictCodes.join('、')} 已存在错误页配置，请先删除后再修改`);
+        }
+        let uploadedPath;
+        let config;
+        if (localPath === undefined) {
+            if (!(target === null || target === void 0 ? void 0 : target.RewritePath)) {
+                (0, error_1.throwNotFound)(`Id 为 ${Id} 的错误页配置不存在或缺少 RewritePath，无法沿用原有文件，请传入 localPath 重新上传`);
+            }
+            config = {
+                HttpStatusCode: statusCodes,
+                ResourceType: 'STATIC_STORE',
+                ResourceName: target.ResourceName || 'staticstore',
+                RewritePath: target.RewritePath
+            };
+        }
+        else {
+            uploadedPath = await this.uploadErrorPageFile(PlatformId, localPath);
+            config = {
+                HttpStatusCode: statusCodes,
+                ResourceType: 'STATIC_STORE',
+                ResourceName: 'staticstore',
+                RewritePath: uploadedPath
+            };
+        }
+        try {
+            const result = await this.cloudService.request('ModifyHTTPServiceErrorPage', { PlatformId, Id, Config: config });
+            // 换了文件：异步清理被替换的旧文件
+            if (uploadedPath && (target === null || target === void 0 ? void 0 : target.RewritePath) && target.RewritePath !== uploadedPath) {
+                this.cleanupErrorPageFile(PlatformId, target.RewritePath, Id).catch(() => { });
+            }
+            return result;
+        }
+        catch (error) {
+            if (!uploadedPath) {
+                throw error;
+            }
+            const message = `错误页文件已上传至 ${uploadedPath}，但更新规则失败，文件已保留：${error instanceof Error ? error.message : String(error)}`;
+            throw new error_1.CloudBaseError(message, Object.assign(Object.assign({}, (error instanceof error_1.CloudBaseError
+                ? { code: error.code, source: error.source || undefined, requestId: error.requestId }
+                : { type: error_types_1.ERROR_TYPES.apiError })), { action: 'ModifyHTTPServiceErrorPage', original: error instanceof Error ? error : undefined }));
+        }
+    }
+    /**
+     * 删除 HTTP 访问服务自定义错误页配置
+     * 直接按 Id 整条删除；一条记录可能同时绑定多个状态码（共用同一份静态资源与 Id），
+     * 删除会一并移除这些状态码的映射。
+     * 删除成功后异步清理对应的 COS 文件，清理失败不影响删除结果；
+     * 该文件仍被其他配置引用时不会删除。
+     * @param {DeleteHttpServiceErrorPageParams} params 平台版 ID 与配置 ID
+     * @returns {Promise<DeleteHttpServiceErrorPageRes>} 删除成功个数
+     */
+    async deleteHttpServiceErrorPage(params) {
+        var _a;
+        const { PlatformId, Id } = params;
+        if (typeof PlatformId !== 'string' || !/^pf-[a-zA-Z0-9-]+$/.test(PlatformId)) {
+            (0, error_1.throwInvalidParam)('PlatformId 必须是有效的平台版 ID');
+        }
+        if (!Number.isInteger(Id) || Id <= 0) {
+            (0, error_1.throwInvalidParam)('Id 必须是 describeHttpServiceErrorPage 返回的正整数配置 ID');
+        }
+        // 删除前先取回 RewritePath：删除后配置不可查，届时无法定位待清理的文件
+        let rewritePath;
+        try {
+            const { Configs } = await this.describeHttpServiceErrorPage({ PlatformId });
+            rewritePath = (_a = Configs === null || Configs === void 0 ? void 0 : Configs.find(item => item.Id === Id)) === null || _a === void 0 ? void 0 : _a.RewritePath;
+        }
+        catch (_b) {
+            // 查询失败不阻断删除，仅跳过文件清理
+            rewritePath = undefined;
+        }
+        const result = await this.cloudService.request('DeleteHTTPServiceErrorPage', { PlatformId, Id });
+        if (rewritePath) {
+            this.cleanupErrorPageFile(PlatformId, rewritePath, Id).catch(() => { });
+        }
+        return result;
+    }
+    /**
+     * 查询 HTTP 访问服务自定义错误页配置列表
+     * 平台版能力，通过 PlatformId 指定平台。
+     * 按 HTTP 状态码数组查询已配置的错误页，如 ['404', '403']；不传状态码时返回该平台全部配置。
+     * @param {DescribeHttpServiceErrorPageParams} params 查询参数，包含平台版 ID 及可选的 HTTP 状态码
+     * @returns {Promise<DescribeHttpServiceErrorPageRes>} 错误页配置列表及总条数
+     */
+    async describeHttpServiceErrorPage(params) {
+        return this.cloudService.request('DescribeHTTPServiceErrorPage', Object.assign({}, params));
+    }
+    // ==================== 错误页配置内部方法 ====================
+    /**
+     * 解析平台静态托管桶与地域
+     * 取自 DescribePlatforms 返回的 hosting 资源 Detail，是所有上传与清理操作的前提
+     */
+    async resolveErrorPageHostingBucket(PlatformId) {
+        var _a;
+        const { PlatformList } = await this.describePlatforms({ PlatformIds: [PlatformId] });
+        const platform = PlatformList === null || PlatformList === void 0 ? void 0 : PlatformList.find(item => item.PlatformId === PlatformId);
+        if (!platform) {
+            (0, error_1.throwNotFound)(`未找到平台 ${PlatformId}`);
+        }
+        const hosting = (_a = platform.Resources) === null || _a === void 0 ? void 0 : _a.find(resource => resource.ResType === 'hosting');
+        if (!hosting || hosting.Status !== 0) {
+            (0, error_1.throwApiError)(`平台 ${PlatformId} 的静态托管资源不存在或尚未就绪`);
+        }
+        let detail;
+        try {
+            detail = JSON.parse(hosting.Detail);
+        }
+        catch (_b) {
+            (0, error_1.throwApiError)(`平台 ${PlatformId} 的静态托管资源 Detail 不是有效 JSON`);
+        }
+        if (!detail || typeof detail !== 'object' || Array.isArray(detail)) {
+            (0, error_1.throwApiError)(`平台 ${PlatformId} 的静态托管资源 Detail 格式无效`);
+        }
+        const { Bucket, Region } = detail;
+        if (typeof Bucket !== 'string' ||
+            !/^[a-z0-9][a-z0-9-]*-\d+$/.test(Bucket) ||
+            typeof Region !== 'string' ||
+            !/^[a-z][a-z0-9-]+$/.test(Region)) {
+            (0, error_1.throwApiError)(`平台 ${PlatformId} 的静态托管资源缺少有效的 Bucket 或 Region`);
+        }
+        return { Bucket, Region };
+    }
+    /** 校验本地文件并上传至桶根目录 error-pages/{PlatformId}/{文件名}，返回 RewritePath */
+    async uploadErrorPageFile(PlatformId, localPath) {
+        if (typeof localPath !== 'string' || !localPath.trim()) {
+            (0, error_1.throwInvalidParam)('localPath 必须是本地文件路径');
+        }
+        const filePath = path_1.default.resolve(localPath);
+        const fileName = path_1.default.basename(filePath).replace(/[\s()[\]{}]+/g, '-');
+        // 文件名会直接拼入 COS Key 与 RewritePath，按白名单限制字符集与长度，避免 URL 保留字符和控制字符进入路径
+        if (!/^[\w.\-\u4e00-\u9fa5]{1,128}$/.test(fileName) || fileName === '.' || fileName === '..') {
+            (0, error_1.throwInvalidParam)('错误页文件名只能包含字母、数字、点、下划线、连字符和中文字符，且长度不能超过 128');
+        }
+        let stats;
+        try {
+            stats = await fs_1.promises.stat(filePath);
+            await fs_1.promises.access(filePath, fs_1.constants.R_OK);
+        }
+        catch (error) {
+            (0, error_1.throwFileError)(`无法读取错误页文件 ${filePath}：${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!stats.isFile()) {
+            (0, error_1.throwInvalidParam)('localPath 必须指向普通文件，不能是目录');
+        }
+        const { Bucket, Region } = await this.resolveErrorPageHostingBucket(PlatformId);
+        const key = `error-pages/${PlatformId}/${fileName}`;
+        await (0, cos_upload_1.uploadCosFile)(this.environment, { bucket: Bucket, region: Region, key, localPath: filePath });
+        return `/${key}`;
+    }
+    /**
+     * 静默清理错误页文件：仅允许 error-pages/{PlatformId}/ 前缀；
+     * 清理前确认没有其他配置继续引用该文件，避免误删共用文件或刚上传的新文件；失败不影响主流程
+     */
+    async cleanupErrorPageFile(PlatformId, rewritePath, excludeId) {
+        if (!rewritePath || !rewritePath.startsWith(`/error-pages/${PlatformId}/`)) {
+            return;
+        }
+        try {
+            // 确认没有其他配置继续引用该文件
+            const { Configs } = await this.describeHttpServiceErrorPage({ PlatformId });
+            const referenced = (Configs !== null && Configs !== void 0 ? Configs : []).some(item => { var _a; return item.Id !== excludeId && ((_a = item.RewritePath) !== null && _a !== void 0 ? _a : '') === rewritePath; });
+            if (referenced) {
+                return;
+            }
+            const { Bucket, Region } = await this.resolveErrorPageHostingBucket(PlatformId);
+            await (0, cos_upload_1.deleteCosObject)(this.environment, {
+                bucket: Bucket,
+                region: Region,
+                key: rewritePath.replace(/^\/+/, '')
+            });
+        }
+        catch (_a) {
+            // 清理失败静默
+        }
+    }
 }
 exports.PlatformService = PlatformService;

package/lib/storage/index.js

@@ -22,6 +22,7 @@ const mime_types_1 = __importDefault(require("mime-types"));
 const cos_nodejs_sdk_v5_1 = __importDefault(require("cos-nodejs-sdk-v5"));
 const utils_1 = require("../utils");
 const error_1 = require("../error");
+const fs_2 = require("../utils/fs");
 const parallel_1 = require("../utils/parallel");
 const storage_config_1 = require("../utils/storage-config");
 const runenv_1 = require("../utils/runenv");
@@ -737,12 +738,27 @@ class StorageService {
                 cloudFileKey: cloudPath
             };
         })
-            .filter(item => ((ignore === null || ignore === void 0 ? void 0 : ignore.length) ? !micromatch_1.default.isMatch(item.filePath, ignore) : true));
+            // `filePath` 是 `path.resolve()` 后的本地绝对路径（hosting 单文件分支塞进
+            // files[].localPath 的就是这种），而 ignore 是「相对业务根目录」的 glob 语义：
+            // micromatch.isMatch('/proj/dist/node_modules/x.js', ['node_modules/**']) 恒为 false。
+            // 只转 `/` 分隔只能救 Windows 上的 `**/xxx` 模式，救不了根锚定的
+            // `node_modules/**` / 裸 `.DS_Store` ⇒ 必须用 isIgnoredPath 统一匹配基准。
+            //
+            // 相对基准取 `cloudFileKey`：ignore 的语义根是「本次上传的根」，
+            // 而 cloudFileKey 正是文件相对于该根的路径（目录分支 = 相对 localPath，
+            // 单文件分支 = 目标文件名）。用它而不是「逐段剥离绝对路径」，
+            // 既让根锚定 pattern 生效，又不会把 `static/**` 放大成任意层级匹配。
+            //
+            // ⚠️ 本函数不追加任何默认清单：`ignore` 传什么就排什么。敏感文件的默认
+            // 排除由**静态托管入口**（HostingService.uploadFiles / StaticDeployer）
+            // 通过 mergeArtifactIgnore 追加后传进来；通用云存储上传是私有桶语义，
+            // 用户可能确实要备份 .env / 配置文件，不能在这里静默丢文件。
+            .filter(item => !(0, fs_2.isIgnoredPath)(item.filePath, ignore, item.cloudFileKey));
         const totalFiles = fileList.length;
-        console.log(`[uploadFiles] 准备上传 ${totalFiles} 个文件`);
+        (0, utils_1.progressLog)(`[uploadFiles] 准备上传 ${totalFiles} 个文件`);
         // 模式 1：完全串行模式（最稳定）
         if (process.env.COS_UPLOAD_SERIAL === 'true') {
-            console.log(`[uploadFiles] 串行安全模式已启用`);
+            (0, utils_1.debugLog)(`[uploadFiles] 串行安全模式已启用`);
             const serialResult = await this.uploadFilesSerial({
                 fileList,
                 bucket,
@@ -766,7 +782,7 @@ class StorageService {
         // 模式 2：智能混合模式（默认）
         // - 先并行快速上传
         // - 失败的文件自动走串行重试
-        console.log(`[uploadFiles] 智能混合模式：先并行快速上传，失败文件自动串行重试`);
+        (0, utils_1.debugLog)(`[uploadFiles] 智能混合模式：先并行快速上传，失败文件自动串行重试`);
         // 第一步：并行上传（分批）
         const parallelFailedFiles = await this.uploadFilesParallel({
             fileList,
@@ -798,7 +814,7 @@ class StorageService {
                     serialResult.failedFiles.map(f => `- ${f.cloudFileKey}: ${f.error}`).join('\n'), { code: 'HOSTING_DEPLOY_FAILED' });
             }
         }
-        console.log(`[uploadFiles] 全部完成！共处理 ${totalFiles} 个文件`);
+        (0, utils_1.progressLog)(`[uploadFiles] 全部完成！共处理 ${totalFiles} 个文件`);
         return {
             successCount: totalFiles,
             totalFiles,
@@ -836,7 +852,7 @@ class StorageService {
                     uploadedCount++;
                     // 显示进度（每 100 个文件或最后 5 个）
                     if (uploadedCount % 100 === 0 || fileList.length - i <= 5) {
-                        console.log(`[serial-upload] [${uploadedCount}/${fileList.length}] ${file.cloudFileKey}`);
+                        (0, utils_1.debugLog)(`[serial-upload] [${uploadedCount}/${fileList.length}] ${file.cloudFileKey}`);
                     }
                     success = true;
                     // 回调成功
@@ -863,7 +879,7 @@ class StorageService {
                 }
             }
         }
-        console.log(`[serial-upload] 完成：成功 ${uploadedCount}/${fileList.length}，失败 ${failedFiles.length}`);
+        (0, utils_1.progressLog)(`[serial-upload] 完成：成功 ${uploadedCount}/${fileList.length}，失败 ${failedFiles.length}`);
         return {
             successCount: uploadedCount,
             failedFiles
@@ -910,7 +926,7 @@ class StorageService {
         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})`);
+            (0, utils_1.progressLog)(`[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);
@@ -954,7 +970,7 @@ class StorageService {
                     interval: retryInterval,
                     failedFiles: []
                 });
-                console.log(`[parallel-upload] 第 ${Math.floor(batchStart / BATCH_SIZE) + 1} 批次上传成功`);
+                (0, utils_1.debugLog)(`[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);
@@ -979,7 +995,7 @@ class StorageService {
             console.warn(`[parallel-upload] 共 ${allFailedFiles.length}/${processedFileList.length} 个文件并行上传失败，等待串行重试...`);
         }
         else {
-            console.log(`[parallel-upload] 全部 ${processedFileList.length} 个文件并行上传成功`);
+            (0, utils_1.debugLog)(`[parallel-upload] 全部 ${processedFileList.length} 个文件并行上传成功`);
         }
         return allFailedFiles;
     }
@@ -1484,10 +1500,17 @@ class StorageService {
                     return files.filter(item => {
                         // 当前文件全路径
                         const fullPath = path_1.default.join(currDir, item);
-                        // 文件相对于传入目录的路径
-                        const fileRelativePath = fullPath.replace(path_1.default.join(dir, path_1.default.sep), '');
-                        // 匹配
-                        return !micromatch_1.default.isMatch(fileRelativePath, ignore);
+                        // 文件相对于传入目录的路径。
+                        // ⚠️ 必须转成 `/` 分隔再交给 micromatch：Windows 下
+                        // `path.join` 产出 `sub\dist\.env`，而 ignore 里的 pattern
+                        // 一律是 `**/.env` 这种 `/` 写法 ⇒ isMatch 恒为 false，
+                        // 整份 ignore 清单失效（静态托管的 `.git` / `.env` / 私钥
+                        // 排除全靠它，失效即公开泄露）。
+                        const fileRelativePath = (0, fs_2.toPosixPath)(fullPath.replace(path_1.default.join(dir, path_1.default.sep), ''));
+                        // 匹配：必须走 matchesIgnorePattern（内部 dot: true），
+                        // 直接 isMatch 会让 `**` 无法穿越 .ssh / .gnupg / .aws 等
+                        // 点目录，目录上传的私钥排除整体失效（stbug-KlBy1JWhvD）
+                        return !(0, fs_2.matchesIgnorePattern)(fileRelativePath, ignore);
                     });
                 }
             });

package/lib/utils/cos-upload.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCosFile = uploadCosFile;
+exports.deleteCosObject = deleteCosObject;
+const cos_nodejs_sdk_v5_1 = __importDefault(require("cos-nodejs-sdk-v5"));
+const mime_types_1 = require("mime-types");
+const constant_1 = require("../constant");
+const error_1 = require("../error");
+const runenv_1 = require("./runenv");
+/** 构造 COS 客户端，凭证、代理与端点配置与 StorageService.getCos 保持一致 */
+function createCosClient(environment) {
+    const { secretId, secretKey, token, proxy } = environment.getAuthConfig();
+    const internalEndpoint = environment.cloudBaseContext.isInternalEndpoint();
+    const config = {
+        FileParallelLimit: 20,
+        SecretId: secretId,
+        SecretKey: secretKey,
+        SecurityToken: token,
+        Proxy: process.env.TCB_COS_PROXY || proxy,
+        Domain: internalEndpoint ? "{Bucket}.cos-internal.{Region}.tencentcos.cn" /* COS_ENDPOINT.INTERNAL */ : "{Bucket}.cos.{Region}.tencentcos.cn" /* COS_ENDPOINT.PUBLIC */
+    };
+    if (constant_1.COS_SDK_PROTOCOL) {
+        config.Protocol = (constant_1.COS_SDK_PROTOCOL.endsWith(':')
+            ? constant_1.COS_SDK_PROTOCOL.toLowerCase()
+            : `${constant_1.COS_SDK_PROTOCOL.toLowerCase()}:`);
+    }
+    if (internalEndpoint) {
+        config.Protocol = 'http:';
+    }
+    if (constant_1.COS_SDK_KEEPALIVE) {
+        // 与 StorageService.getCos 一致：仅 'true' / 'false' 生效，其他取值保持 SDK 默认
+        config.KeepAlive = { true: true, false: false }[constant_1.COS_SDK_KEEPALIVE];
+    }
+    else if ((0, runenv_1.checkIsInScf)()) {
+        config.KeepAlive = false;
+    }
+    return new cos_nodejs_sdk_v5_1.default(config);
+}
+/** 使用当前 SDK 凭证上传单文件，Key 相对于桶根目录，不加载环境信息或拼接 BasePath。 */
+async function uploadCosFile(environment, options) {
+    const cos = createCosClient(environment);
+    const mimeType = (0, mime_types_1.lookup)(options.localPath) || 'application/octet-stream';
+    const result = await cos.uploadFile({
+        Bucket: options.bucket,
+        Region: options.region,
+        Key: options.key,
+        FilePath: options.localPath,
+        StorageClass: 'STANDARD',
+        ContentType: (0, mime_types_1.contentType)(mimeType) || mimeType
+    });
+    if (result.statusCode !== 200) {
+        (0, error_1.throwApiError)(`COS 文件上传失败，状态码：${result.statusCode}`);
+    }
+}
+/** 删除桶根目录下的单个对象，Key 不做任何路径变换。 */
+async function deleteCosObject(environment, options) {
+    const cos = createCosClient(environment);
+    const result = await cos.deleteObject({
+        Bucket: options.bucket,
+        Region: options.region,
+        Key: options.key
+    });
+    if (result.statusCode !== 200 && result.statusCode !== 204) {
+        (0, error_1.throwApiError)(`COS 文件删除失败，状态码：${result.statusCode}`);
+    }
+}