@cloudbase/manager-node 5.8.0-beta.2 → 5.8.1

package/lib/storage/index.js

@@ -10,7 +10,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageService = void 0;
+exports.StorageService = exports.md5File = void 0;
 const fs_1 = __importDefault(require("fs"));
 const util_1 = __importDefault(require("util"));
 const path_1 = __importDefault(require("path"));
@@ -24,12 +24,418 @@ const error_1 = require("../error");
 const parallel_1 = require("../utils/parallel");
 const runenv_1 = require("../utils/runenv");
 const constant_1 = require("../constant");
+const helper_1 = require("./helper");
 const BIG_FILE_SIZE = 5242880; // 5MB 1024*1024*5
+// ===== hosting deploy consistency 相关能力 =====
+/** 默认 MD5 计算并发数 */
+const DEFAULT_MD5_PARALLEL = 20;
+/** 一致性发布备份前缀（用于 diff.removed 排除备份文件） */
+const CONSISTENT_DEPLOY_BACKUP_PREFIX = '.cloudbase-backup/';
+var helper_2 = require("./helper");
+Object.defineProperty(exports, "md5File", { enumerable: true, get: function () { return helper_2.md5File; } });
 class StorageService {
     constructor(environment) {
         this.environment = environment;
         this.tcbService = new utils_1.CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08');
     }
+    // ==================== 一致性发布 相关能力 ====================
+    /**
+     * 获取远端 manifest（默认 Storage 桶）：返回指定前缀下文件的 key / etag / size，
+     * 过滤目录占位对象。prefix 无前导斜杠，空串表示整桶（Hosting 桶请用 getRemoteManifestCustom）。
+     */
+    async getRemoteManifest(prefix) {
+        const { bucket, region } = this.getStorageConfig();
+        return this.getRemoteManifestCustom({
+            prefix,
+            bucket,
+            region
+        });
+    }
+    /**
+     * 获取远端 manifest，支持自定义 Bucket 和 Region。prefix 规则同 getRemoteManifest。
+     */
+    async getRemoteManifestCustom(options) {
+        const fileList = await this.walkCloudDirCustom(options);
+        return fileList
+            .filter(file => file.Key && !file.Key.endsWith('/'))
+            .map(file => ({
+            key: file.Key,
+            etag: String(file.ETag || '').replace(/^"|"$/g, ''),
+            size: Number(file.Size) || 0
+        }));
+    }
+    /**
+     * 生成本地 manifest：计算每个文件的云端 Key、MD5 与 Size。
+     * - filePaths 须来自 walkLocalDir(localPath)，目录不计入
+     * - key = cloudPath + 文件相对路径；cloudPath 为空表示桶根
+     * - MD5 以受控并发计算，避免阻塞事件循环
+     */
+    async buildLocalManifest(options) {
+        const { localPath, cloudPath, filePaths, parallel = DEFAULT_MD5_PARALLEL } = options;
+        const resolvePath = path_1.default.resolve(localPath);
+        const resolveLocalPath = path_1.default.join(resolvePath, path_1.default.sep);
+        const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        controller.loadTasks(filePaths.map(filePath => async () => {
+            const stat = await fs_1.default.promises.stat(filePath);
+            if (stat.isDirectory()) {
+                return null;
+            }
+            const fileKeyPath = filePath.replace(resolveLocalPath, '').replace(/\\/g, '/');
+            const key = path_1.default.join(cloudPath || '', fileKeyPath).replace(/\\/g, '/');
+            return {
+                key,
+                md5: await (0, helper_1.md5File)(filePath),
+                size: stat.size,
+                localPath: filePath
+            };
+        }));
+        const results = await controller.run();
+        const isError = (res) => Object.prototype.toString.call(res) === '[object Error]';
+        const firstError = results.find(isError);
+        if (firstError) {
+            throw new error_1.CloudBaseError(`计算本地文件摘要失败：${firstError.message}`);
+        }
+        return results.filter(res => res !== null);
+    }
+    /**
+     * 计算本地 manifest 与远端 manifest 的差异：
+     * - added：本地有、远端无；overwritten：两边都有；removed：远端有、本地无
+     * - 两份 manifest 的 key 须基于同一 cloudPath（removed 自动排除 .cloudbase-backup/）
+     */
+    diffManifest(localManifest, remoteManifest) {
+        const localKeys = new Set(localManifest.map(item => item.key));
+        const remoteKeys = new Set(remoteManifest.map(item => item.key));
+        const added = [];
+        const overwritten = [];
+        localManifest.forEach(item => {
+            if (remoteKeys.has(item.key)) {
+                overwritten.push(item.key);
+                return;
+            }
+            added.push(item.key);
+        });
+        const removed = remoteManifest
+            .map(item => item.key)
+            .filter(key => !localKeys.has(key) &&
+            !key.replace(/^\/+/, '').startsWith(CONSISTENT_DEPLOY_BACKUP_PREFIX));
+        return {
+            added,
+            overwritten,
+            removed
+        };
+    }
+    /**
+     * 校验远端 manifest 与本地 manifest 是否一致：
+     * - 远端缺失 → missing；ETag 为纯 MD5 → 按 md5 比对；分块上传 ETag → 降级按 size 比对
+     */
+    verifyManifest(localManifest, remoteManifest) {
+        const remoteMap = new Map(remoteManifest.map(item => [item.key, item]));
+        const missing = [];
+        const mismatched = [];
+        const pureMd5EtagRe = /^[a-f0-9]{32}$/i;
+        localManifest.forEach(localItem => {
+            const remoteItem = remoteMap.get(localItem.key);
+            if (!remoteItem) {
+                missing.push(localItem.key);
+                return;
+            }
+            const remoteEtag = String(remoteItem.etag || '').replace(/^"|"$/g, '');
+            const shouldCompareByMd5 = pureMd5EtagRe.test(remoteEtag);
+            if (shouldCompareByMd5) {
+                if (remoteEtag.toLowerCase() !== localItem.md5.toLowerCase()) {
+                    mismatched.push(localItem.key);
+                }
+                return;
+            }
+            if (Number(remoteItem.size) !== Number(localItem.size)) {
+                mismatched.push(localItem.key);
+            }
+        });
+        return {
+            ok: missing.length === 0 && mismatched.length === 0,
+            missing,
+            mismatched
+        };
+    }
+    /**
+     * 将指定前缀下的远端文件服务端复制到备份前缀（不产生下载流量）。
+     * 始终跳过 .cloudbase-backup/ 下的历史备份，避免根目录发布时递归备份。
+     */
+    async backupRemote(options) {
+        const { bucket, region, prefix, backupPrefix, parallel = 20 } = options;
+        // COS 对象 Key 不保留前导斜杠，统一规范化为 .cloudbase-backup/... 形式
+        const normalizedBackupPrefix = backupPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+        const remoteManifest = await this.getRemoteManifestCustom({
+            bucket,
+            region,
+            prefix
+        });
+        // 过滤掉已备份的文件，避免根目录发布时递归备份旧备份，filesToBackup 存的是需要备份的文件
+        const filesToBackup = remoteManifest.filter(item => !item.key.replace(/^\/+/, '').startsWith(CONSISTENT_DEPLOY_BACKUP_PREFIX));
+        if (!filesToBackup.length) {
+            return;
+        }
+        const cos = this.getCos();
+        const putObjectCopy = util_1.default.promisify(cos.putObjectCopy).bind(cos);
+        const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        controller.loadTasks(
+        // 为每个文件创建一个复制任务
+        filesToBackup.map(file => async () => {
+            const destPath = `${normalizedBackupPrefix}/${file.key.replace(/^\/+/, '')}`;
+            // 拼接复制源
+            const copySource = `${bucket}.cos.${region}.myqcloud.com/${encodeURIComponent(file.key)}`;
+            const res = await putObjectCopy({
+                Bucket: bucket,
+                Region: region,
+                Key: destPath,
+                CopySource: copySource
+            });
+            if (res.statusCode !== 200) {
+                throw new error_1.CloudBaseError(`备份文件失败：${file.key}`);
+            }
+            return destPath;
+        }));
+        const results = await controller.run();
+        const isError = (res) => Object.prototype.toString.call(res) === '[object Error]';
+        const firstError = results.find(isError);
+        if (firstError) {
+            throw new error_1.CloudBaseError(`远端备份失败：${firstError.message}`);
+        }
+    }
+    /**
+     * 从备份恢复被覆盖旧文件（服务端复制回原 Key），并删除本次新增文件。
+     * 任一阶段失败都会抛错，由上层决定是否保留备份供人工恢复。
+     */
+    async restoreFromBackup(options) {
+        const { bucket, region, backupPrefix, overwrittenKeys, addedKeys, parallel = 20 } = options;
+        // COS 对象 Key 不保留前导斜杠，与 backupRemote 的规范化规则保持一致
+        const normalizedBackupPrefix = backupPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+        if (overwrittenKeys.length > 0) {
+            const cos = this.getCos();
+            const putObjectCopy = util_1.default.promisify(cos.putObjectCopy).bind(cos);
+            const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+            controller.loadTasks(overwrittenKeys.map(key => async () => {
+                const sourcePath = `${normalizedBackupPrefix}/${key.replace(/^\/+/, '')}`;
+                const copySource = `${bucket}.cos.${region}.myqcloud.com/${encodeURIComponent(sourcePath)}`;
+                const res = await putObjectCopy({
+                    Bucket: bucket,
+                    Region: region,
+                    Key: key,
+                    CopySource: copySource
+                });
+                if (res.statusCode !== 200) {
+                    throw new error_1.CloudBaseError(`恢复备份文件失败：${key}`);
+                }
+                return key;
+            }));
+            const restoreResults = await controller.run();
+            const isError = (res) => Object.prototype.toString.call(res) === '[object Error]';
+            const firstRestoreError = restoreResults.find(isError);
+            if (firstRestoreError) {
+                throw new error_1.CloudBaseError(`从备份恢复远端文件失败：${firstRestoreError.message}`);
+            }
+        }
+        if (addedKeys.length > 0) {
+            await this.deleteFileCustom(addedKeys, bucket, region);
+        }
+    }
+    /**
+     * 删除备份前缀下的全部对象。
+     * 备份目录以 . 开头，内部使用空 Marker 列举，不受默认排除规则影响。
+     */
+    async cleanupBackup(options) {
+        const { bucket, region, backupPrefix } = options;
+        // 备份目录以 . 开头，会被 walkCloudDirCustom 默认 marker='/' 排除，
+        // 必须显式传 marker='' 才能列举到备份对象
+        await this.deleteDirectoryCustom({
+            cloudPath: backupPrefix,
+            bucket,
+            region,
+            marker: ''
+        });
+    }
+    /**
+     * 清理发布后远端残留的冗余文件。
+     * 仅删除 removedKeys 中位于 prefix 范围内的 Key，排除 .cloudbase-backup/；
+     * 单个删除失败记入 failedKeys，不影响其他文件。
+     */
+    async pruneRemote(options) {
+        const { bucket, region, prefix, removedKeys, parallel = 20 } = options;
+        const normalizedPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+        const prefixWithSlash = normalizedPrefix ? `${normalizedPrefix}/` : '';
+        const backupPrefix = CONSISTENT_DEPLOY_BACKUP_PREFIX;
+        const keysToDelete = Array.from(new Set(removedKeys
+            .map(key => String(key || '').replace(/^\/+/, ''))
+            .filter(key => key &&
+            !key.startsWith(backupPrefix) &&
+            (!prefixWithSlash || key.startsWith(prefixWithSlash)) // 限制在 prefix 范围内
+        )));
+        if (!keysToDelete.length) {
+            return { deletedKeys: [], failedKeys: [] };
+        }
+        const cos = this.getCos();
+        const deleteObject = util_1.default.promisify(cos.deleteObject).bind(cos);
+        const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        controller.loadTasks(keysToDelete.map(key => async () => {
+            try {
+                await deleteObject({
+                    Bucket: bucket,
+                    Region: region,
+                    Key: key
+                });
+                return { key };
+            }
+            catch (error) {
+                return {
+                    key,
+                    error: (error === null || error === void 0 ? void 0 : error.message) || String(error)
+                };
+            }
+        }));
+        const results = await controller.run();
+        const deletedKeys = [];
+        const failedKeys = [];
+        results.forEach(result => {
+            if (result && typeof result.error === 'string') {
+                failedKeys.push(result);
+            }
+            else if (result === null || result === void 0 ? void 0 : result.key) {
+                deletedKeys.push(result.key);
+            }
+        });
+        return { deletedKeys, failedKeys };
+    }
+    /**
+     * 一致性目录上传编排（safe、verify、prune）
+     *
+     * 执行流程（按顺序）：
+     * 1. 扫描本地目录，生成 manifest（key/md5/size）
+     * 2. safe 或 prune 开启时：拉取远端快照 manifest，与本地做 diff
+     *    （safe 用 diff 判定回滚范围；prune 用 diff.removed 判定待清理文件）
+     * 3. safe 开启时：将远端文件服务端复制到备份前缀 .cloudbase-backup/<时间戳>/
+     * 4. 执行目录上传（资源文件先传，入口文件 entries 最后传）
+     * 5. verify 开启时：重新拉取远端 manifest，逐文件校验 ETag/MD5 与 size
+     * 6. 上传与校验全部成功后，prune 开启时：删除 diff.removed 中仍冗余的远端文件
+     * 7. 返回 uploadedKeys / verified / backupPrefix / prune 结果
+     *
+     * 失败时的行为：
+     * - 步骤 4/5 失败且 safe 开启：自动从备份回滚（恢复被覆盖文件、删除本次新增
+     *   文件），回滚成功后抛出“已自动回滚”错误，备份保留供人工核查
+     * - 回滚失败：保留备份并在错误信息中给出备份位置，供人工恢复
+     * - 备份一律不由本编排自动清理，均需调用方确认后通过 cleanupBackup 显式删除
+     * - prune 仅在步骤 4/5 全部成功后执行，失败发布绝不会触发远端删除
+     *
+     * ⚠️ 危险参数：prune
+     * prune 会删除云端 cloudPath 前缀下、本次本地构建中不存在的全部文件。
+     * 若调用方误传了错误的 localPath/cloudPath，整目录都会被判定为“冗余”而删除。
+     * 发布成功后备份默认保留、不自动清理：prune 误删的文件可从备份前缀
+     * （.cloudbase-backup/<时间戳>/）人工恢复；调用方确认无误后应通过
+     * cleanupBackup 显式清理备份。调用方（CLI）仍须在开启 prune 前要求用户二次确认。
+     */
+    async uploadDirectoryConsistent(options) {
+        const { localPath, cloudPath = '', bucket, region, ignore, fileId = true, parallel = 20, retryCount = 0, retryInterval = 500, onProgress, onFileFinish, verify = false, safe = false, prune = false, entries } = options;
+        const resolvePath = path_1.default.resolve(localPath);
+        const resolveLocalPath = path_1.default.join(resolvePath, path_1.default.sep);
+        const filePaths = await this.walkLocalDir(resolveLocalPath, ignore);
+        // 生成本地 manifest
+        const localManifest = await this.buildLocalManifest({
+            localPath,
+            cloudPath,
+            filePaths,
+            parallel
+        });
+        let backupPrefix;
+        let diff;
+        if (safe || prune) {
+            const remoteSnapshot = await this.getRemoteManifestCustom({
+                bucket,
+                region,
+                prefix: cloudPath
+            });
+            // 发布前快照同时用于 safe 回滚判定和 prune 待删文件判定。
+            diff = this.diffManifest(localManifest, remoteSnapshot);
+        }
+        if (safe) {
+            // COS 对象 Key 不保留前导斜杠，备份前缀使用 .cloudbase-backup/ 形式
+            backupPrefix = `${CONSISTENT_DEPLOY_BACKUP_PREFIX}${Date.now()}/`;
+            // 备份远端
+            await this.backupRemote({
+                bucket,
+                region,
+                prefix: cloudPath,
+                backupPrefix,
+                parallel
+            });
+        }
+        try {
+            await this.uploadDirectoryCustom({
+                localPath,
+                cloudPath,
+                entryFiles: entries,
+                bucket,
+                region,
+                ignore,
+                fileId,
+                parallel,
+                retryCount,
+                retryInterval,
+                onProgress,
+                onFileFinish
+            });
+            // 上传完成后校验
+            if (verify) {
+                const remoteManifest = await this.getRemoteManifestCustom({
+                    bucket,
+                    region,
+                    prefix: cloudPath
+                });
+                const verifyResult = this.verifyManifest(localManifest, remoteManifest);
+                if (!verifyResult.ok) {
+                    throw new error_1.CloudBaseError(`一致性校验失败：missing=${verifyResult.missing.join(',') || '[]'}; mismatched=${verifyResult.mismatched.join(',') || '[]'}`);
+                }
+            }
+        }
+        catch (error) {
+            if (!safe || !backupPrefix || !diff) {
+                throw error;
+            }
+            // 失败时回滚；备份保留供人工核查，由调用方确认后通过 cleanupBackup 显式清理
+            try {
+                await this.restoreFromBackup({
+                    bucket,
+                    region,
+                    backupPrefix,
+                    overwrittenKeys: diff.overwritten,
+                    addedKeys: diff.added,
+                    parallel
+                });
+            }
+            catch (rollbackError) {
+                throw new error_1.CloudBaseError(`一致性发布失败，且回滚失败，请使用备份人工恢复：${backupPrefix}；原始错误：${error.message}；回滚错误：${rollbackError.message}`);
+            }
+            throw new error_1.CloudBaseError(`一致性发布失败，已自动回滚，备份保留于 ${backupPrefix}，确认无误后可调用 cleanupBackup 清理：${error.message}`);
+        }
+        // 上传与可选校验均成功后才允许清理远端冗余文件。
+        // 删除失败会记录在结果中，不触发已经成功发布内容的回滚。
+        const pruneResult = prune
+            ? await this.pruneRemote({
+                bucket,
+                region,
+                prefix: cloudPath,
+                removedKeys: (diff === null || diff === void 0 ? void 0 : diff.removed) || [],
+                parallel
+            })
+            : undefined;
+        // 发布成功后保留备份：prune 若误删文件，仍可从备份前缀人工恢复。
+        // 备份不由本编排自动清理，调用方确认无误后通过 cleanupBackup 显式删除。
+        return {
+            uploadedKeys: localManifest.map(item => item.key),
+            verified: verify,
+            backupPrefix,
+            prune: pruneResult
+        };
+    }
+    // ==============================================================
     /**
      * 上传文件
      * localPath 为文件夹时，会尝试在文件夹中寻找 cloudPath 中的文件名
@@ -178,7 +584,7 @@ class StorageService {
      * @returns {Promise<void>}
      */
     async uploadDirectoryCustom(options) {
-        const { localPath, cloudPath, bucket, region, onProgress, onFileFinish, ignore, fileId = true, parallel = 20, retryCount = 0, retryInterval = 500 } = options;
+        const { localPath, cloudPath, entryFiles, bucket, region, onProgress, onFileFinish, ignore, fileId = true, parallel = 20, retryCount = 0, retryInterval = 500 } = options;
         // 此处不检查路径是否存在
         // 绝对路径 /var/blog/xxxx
         const resolvePath = path_1.default.resolve(localPath);
@@ -249,10 +655,26 @@ class StorageService {
             localPath: stats.filePath,
             cloudPath: stats.cloudFileKey
         }));
+        const { resourceFiles, entryUploadFiles } = (0, helper_1.splitEntryUploadFiles)(filesForUpload, entryFiles);
         // 调用 uploadFilesCustom（智能混合模式：并行→串行）
         // 不再直接调用 uploadFilesWithRetry（纯并行重试，容易 socket hang up）
+        // 第一阶段先上传资源文件；这里必须 await，确保入口文件不会与资源文件混传。
+        // 如果资源组上传失败，会直接中断，第二阶段不会开始。
+        await this.uploadFilesCustom({
+            files: resourceFiles,
+            bucket,
+            region,
+            ignore: [],
+            onProgress,
+            onFileFinish,
+            fileId,
+            parallel,
+            retryCount,
+            retryInterval
+        });
+        // 第二阶段再上传入口文件（默认各级 index.html），避免入口文件先于其依赖资源对外可见。
         return this.uploadFilesCustom({
-            files: filesForUpload,
+            files: entryUploadFiles,
             bucket,
             region,
             ignore: [],
@@ -781,7 +1203,7 @@ class StorageService {
      * @returns {Promise<void>}
      */
     async deleteDirectoryCustom(options) {
-        const { cloudPath, bucket, region } = options;
+        const { cloudPath, bucket, region, marker } = options;
         const key = this.getCloudKey(cloudPath);
         const cos = this.getCos();
         const deleteMultipleObject = util_1.default.promisify(cos.deleteMultipleObject).bind(cos);
@@ -789,7 +1211,8 @@ class StorageService {
         const files = await this.walkCloudDirCustom({
             bucket,
             region,
-            prefix: key
+            prefix: key,
+            marker
         });
         // 文件为空时，不能调用删除接口
         if (!files.length) {
@@ -2936,6 +3359,27 @@ class StorageService {
     }
 }
 exports.StorageService = StorageService;
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "getRemoteManifest", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "getRemoteManifestCustom", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "backupRemote", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "restoreFromBackup", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "cleanupBackup", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "pruneRemote", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "uploadDirectoryConsistent", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "uploadFile", null);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "5.8.0-beta.2",
+    "version": "5.8.1",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {
@@ -42,7 +42,7 @@
     },
     "dependencies": {
         "@cloudbase/signature-nodejs": "^1.0.0",
-        "@cloudbase/toolbox": "^0.8.3-beta.2",
+        "@cloudbase/toolbox": "~0.8.3",
         "@cloudbase/database": "^0.6.2",
         "archiver": "^3.1.1",
         "cos-nodejs-sdk-v5": "^2.14.0",

package/types/env/index.d.ts

@@ -1,6 +1,6 @@
 import { Environment } from '../environment';
 import { IResponseInfo, AuthDomain, EnvInfo, LoginConfigItem, ICheckTcbServiceRes, ICreatePostpayRes, EnvBillingInfoItem, PriceResult } from '../interfaces';
-import { CalculatePackageCreatePriceParams, CalculatePackageRenewPriceParams, CalculatePackageModifyPriceParams, DescribeHttpServiceRouteParams, DescribeHttpServiceRouteRes, CreateHttpServiceRouteParams, CreateHttpServiceRouteRes, ModifyHttpServiceRouteParams, ModifyHttpServiceRouteRes, DeleteHttpServiceRouteParams, DeleteHttpServiceRouteRes, BindCustomDomainParams, BindCustomDomainRes, DeleteCustomDomainParams, DeleteCustomDomainRes } from './type';
+import { CalculatePackageCreatePriceParams, CalculatePackageRenewPriceParams, CalculatePackageModifyPriceParams, DescribeHttpServiceRouteParams, DescribeHttpServiceRouteRes, VerifyHttpServiceRouteParams, VerifyHttpServiceRouteRes, CreateHttpServiceRouteParams, CreateHttpServiceRouteRes, ModifyHttpServiceRouteParams, ModifyHttpServiceRouteRes, DeleteHttpServiceRouteParams, DeleteHttpServiceRouteRes, BindCustomDomainParams, BindCustomDomainRes, DeleteCustomDomainParams, DeleteCustomDomainRes, DescribeCertificatesParams, DescribeCertificatesRes } from './type';
 import { CreateBillingDealParams, CreateEnvParams, BaasPackageInfo, DescribeBaasPackageListParams, ModifyEnvPlanParams, RenewEnvParams, DestroyEnvParams, DescribeEnvsParams, DescribeEnvInfoParams, DescribeEnvInfoResponse, DescribeEnvAccountCircleParams, DescribeEnvAccountCircleRes, DescribeCreditsUsageDetailParams, EnvPkgCreditsUsage } from '../interfaces/tcb.interface';
 type SOURCE = 'miniapp' | 'qcloud';
 interface IDeleteDomainRes {
@@ -559,6 +559,7 @@ export declare class EnvService {
     private envType?;
     private commonService;
     private billingService;
+    private certificateCloudService;
     private tokenCache;
     constructor(environment: Environment);
     /**
@@ -882,12 +883,27 @@ export declare class EnvService {
         Usages: EnvPkgCreditsUsage[];
         RequestId: string;
     }>;
+    /**
+     * 获取当前凭证有权限访问的 SSL 证书列表。
+     *
+     * 证书用于自定义域名 HTTPS 配置，本接口不依赖 CloudBase 环境信息。
+     * @param {DescribeCertificatesParams} params 查询参数
+     * @returns {Promise<DescribeCertificatesRes>}
+     */
+    describeCertificates(params?: DescribeCertificatesParams): Promise<DescribeCertificatesRes>;
     /**
      * 查询HTTP访问服务域名路由信息
      * @param {DescribeHttpServiceRouteParams} params 查询参数
      * @returns {Promise<DescribeHttpServiceRouteRes>}
      */
     describeHttpServiceRoute(params: DescribeHttpServiceRouteParams): Promise<DescribeHttpServiceRouteRes>;
+    /**
+     * 校验HTTP访问服务域名路由
+     * 此操作为只读预检，不会创建任何资源。
+     * @param {VerifyHttpServiceRouteParams} params 校验参数
+     * @returns {Promise<VerifyHttpServiceRouteRes>}
+     */
+    verifyHttpServiceRoute(params: VerifyHttpServiceRouteParams): Promise<VerifyHttpServiceRouteRes>;
     /**
      * 创建HTTP访问服务域名路由
      * @param {CreateHttpServiceRouteParams} params 创建参数