@cloudbase/manager-node 5.7.0-beta.3 → 5.7.1-beta.0

package/lib/projectValidator/index.js

@@ -1,440 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectValidator = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const toolbox_1 = require("@cloudbase/toolbox");
-class ProjectValidator {
-    async validate(options = {}) {
-        var _a;
-        const cwd = path_1.default.resolve(options.cwd || process.cwd());
-        const errors = [];
-        const warnings = [];
-        const loaded = await this.loadProjectConfig(cwd, {
-            configPath: options.configPath,
-            mode: options.mode,
-            errors,
-        });
-        const version = String(((_a = loaded.rawConfig) === null || _a === void 0 ? void 0 : _a.version) || '2.1');
-        if (loaded.rawConfig) {
-            this.validateSchema(loaded.rawConfig, errors);
-        }
-        if (loaded.config) {
-            this.validateEnvId(cwd, { raw: loaded.rawConfig || {}, resolved: loaded.config }, errors);
-            this.validatePersonalRegistryConfig(loaded.config, errors);
-            const resourceIssues = this.validateResources(cwd, loaded.config);
-            errors.push(...resourceIssues.errors);
-            warnings.push(...resourceIssues.warnings);
-            this.validateConsistency(loaded.config, errors, warnings);
-        }
-        const summary = this.getSummary(loaded.config);
-        return {
-            valid: errors.length === 0,
-            version,
-            errors,
-            warnings,
-            summary,
-        };
-    }
-    async loadProjectConfig(cwd, options) {
-        const { configPath, mode, errors } = options;
-        let filepath = configPath ? path_1.default.resolve(cwd, configPath) : undefined;
-        try {
-            if (!filepath) {
-                const result = await (0, toolbox_1.searchConfig)(cwd);
-                filepath = result === null || result === void 0 ? void 0 : result.filepath;
-            }
-            if (!filepath) {
-                errors.push({
-                    level: 'error',
-                    field: 'cloudbaserc',
-                    message: '未找到 cloudbaserc 配置文件',
-                    fix: '在项目根目录新增 cloudbaserc.json / cloudbaserc.js / cloudbaserc.yaml / cloudbaserc.yml',
-                });
-                return {};
-            }
-            const rawConfig = (await (0, toolbox_1.loadConfig)({ configPath: filepath }));
-            const config = (await toolbox_1.ConfigParser.parseRawConfig(rawConfig || {}, cwd, {
-                mode,
-            }));
-            return {
-                filepath,
-                rawConfig,
-                config,
-            };
-        }
-        catch (e) {
-            errors.push({
-                level: 'error',
-                field: 'cloudbaserc',
-                message: `配置文件解析失败：${this.getErrorMessage(e)}`,
-                fix: '检查 cloudbaserc 配置文件语法是否正确',
-            });
-            return { filepath };
-        }
-    }
-    validateSchema(config, errors) {
-        const result = (0, toolbox_1.validateCloudBaseConfigBySchema)(config, { version: '2.1' });
-        result.errors.forEach((error) => {
-            errors.push({
-                level: 'error',
-                field: this.normalizeSchemaPath(error.dataPath),
-                message: `配置不符合 v2.1 Schema：${error.message}`,
-                fix: `请检查 ${this.normalizeSchemaPath(error.dataPath) || 'cloudbaserc'} 字段`,
-            });
-        });
-    }
-    validateEnvId(cwd, config, errors) {
-        if (this.hasPersonalCloudFunction(config.resolved)) {
-            if (typeof config.raw.envId !== 'string' || !config.raw.envId.trim()) {
-                errors.push({
-                    level: 'error',
-                    field: 'envId',
-                    message: '个人版 TCR 云端构建必须在 cloudbaserc 中显式声明 envId',
-                    fix: '声明 envId: "{{env.ENV_ID}}"，并在 .env* 中设置 ENV_ID',
-                });
-                return;
-            }
-            if (typeof config.resolved.envId !== 'string' || !config.resolved.envId.trim()) {
-                errors.push({
-                    level: 'error',
-                    field: 'envId',
-                    message: '个人版 TCR 云端构建的 envId 未赋值',
-                    fix: '在 .env* 中设置 cloudbaserc 通过 {{env.ENV_ID}} 引用的 ENV_ID',
-                });
-            }
-            return;
-        }
-        if (config.resolved.envId || this.getLinkedEnvId(cwd)) {
-            return;
-        }
-        errors.push({
-            level: 'error',
-            field: 'envId',
-            message: '缺少 envId，且未检测到 .tcb/project.json 关联环境',
-            fix: '在 cloudbaserc 中配置 envId，或先执行环境关联流程',
-        });
-    }
-    /**
-     * 个人版 TCR 的 username/password/namespace 必须在 cloudbaserc 中显式声明。
-     * ConfigParser 已先解析 {{env.*}}，因此这里同时承担缺失 env 值的前置校验。
-     */
-    validatePersonalRegistryConfig(config, errors) {
-        ;
-        (config.functions || []).forEach((func, index) => {
-            var _a;
-            if (!this.isPersonalCloudFunction(func)) {
-                return;
-            }
-            const build = (_a = func.imageConfig) === null || _a === void 0 ? void 0 : _a.build;
-            const namespace = build === null || build === void 0 ? void 0 : build.namespace;
-            if (typeof namespace !== 'string' || !namespace.trim()) {
-                errors.push({
-                    level: 'error',
-                    resource: `functions[${index}]`,
-                    field: 'imageConfig.build.namespace',
-                    message: '个人版 TCR 缺少 namespace，或对应环境变量未赋值',
-                    fix: '声明 namespace: "{{env.TCB_TCR_NAMESPACE}}"，并在 .env* 中设置该变量',
-                });
-            }
-            const credential = build === null || build === void 0 ? void 0 : build.registryCredential;
-            if (!credential || typeof credential !== 'object') {
-                errors.push({
-                    level: 'error',
-                    resource: `functions[${index}]`,
-                    field: 'imageConfig.build.registryCredential',
-                    message: '个人版 TCR 缺少 username/password 凭证声明',
-                    fix: '在 registryCredential 中使用 {{env.TCB_TCR_USERNAME}} 与 {{env.TCB_TCR_PASSWORD}}',
-                });
-                return;
-            }
-            const { username, password } = credential;
-            if (typeof username !== 'string' || !/^\d{5,20}$/.test(username.trim())) {
-                errors.push({
-                    level: 'error',
-                    resource: `functions[${index}]`,
-                    field: 'imageConfig.build.registryCredential.username',
-                    message: '个人版 TCR username 未赋值或不是有效腾讯云账号 ID',
-                    fix: '声明 username: "{{env.TCB_TCR_USERNAME}}"，并在 .env* 中设置该变量',
-                });
-            }
-            if (typeof password !== 'string' || !password || password.length > 16 * 1024) {
-                errors.push({
-                    level: 'error',
-                    resource: `functions[${index}]`,
-                    field: 'imageConfig.build.registryCredential.password',
-                    message: '个人版 TCR password 未赋值或长度不合法',
-                    fix: '声明 password: "{{env.TCB_TCR_PASSWORD}}"，并在 .env* 中设置该变量',
-                });
-            }
-        });
-    }
-    hasPersonalCloudFunction(config) {
-        return (config.functions || []).some((func) => this.isPersonalCloudFunction(func));
-    }
-    isPersonalCloudFunction(func) {
-        var _a;
-        return (func.type === 'HTTP' &&
-            func.buildStrategy === 'cloud' &&
-            ((_a = func.imageConfig) === null || _a === void 0 ? void 0 : _a.imageType) === 'personal');
-    }
-    validateResources(cwd, config) {
-        const errors = [];
-        const warnings = [];
-        const functionRoot = config.functionRoot || './functions';
-        (config.functions || []).forEach((func, index) => {
-            const resource = `functions[${index}]`;
-            const functionDir = path_1.default.resolve(cwd, func.dir || path_1.default.join(functionRoot, func.name));
-            if (!fs_1.default.existsSync(functionDir)) {
-                errors.push({
-                    level: 'error',
-                    resource,
-                    field: 'dir',
-                    message: `函数目录不存在：${path_1.default.relative(cwd, functionDir)}`,
-                    fix: '创建函数目录，或修正 functions[].dir / functionRoot 配置',
-                });
-                return;
-            }
-            const functionType = func.type || 'Event';
-            const buildStrategy = func.buildStrategy || 'zip';
-            if (functionType === 'HTTP' && buildStrategy === 'zip') {
-                const bootstrapPath = path_1.default.join(functionDir, 'scf_bootstrap');
-                if (!fs_1.default.existsSync(bootstrapPath)) {
-                    errors.push({
-                        level: 'error',
-                        resource,
-                        field: 'scf_bootstrap',
-                        message: '缺少 scf_bootstrap 文件（HTTP 函数 zip 部署必须）',
-                        fix: '在函数目录中新增 scf_bootstrap，并确保其具备执行权限',
-                    });
-                }
-            }
-            if (functionType === 'Event') {
-                const handlerFile = `${(func.handler || 'index.main').split('.')[0]}.js`;
-                if (!fs_1.default.existsSync(path_1.default.join(functionDir, handlerFile))) {
-                    warnings.push({
-                        level: 'warning',
-                        resource,
-                        field: 'handler',
-                        message: `未找到入口文件 ${handlerFile}`,
-                        fix: '确认 handler 配置与函数入口文件一致',
-                    });
-                }
-            }
-        });
-        (config.hosting || []).forEach((hosting, index) => {
-            const root = path_1.default.resolve(cwd, hosting.root || '.');
-            if (!fs_1.default.existsSync(root)) {
-                errors.push({
-                    level: 'error',
-                    resource: `hosting[${index}]`,
-                    field: 'root',
-                    message: `静态托管根目录不存在：${path_1.default.relative(cwd, root)}`,
-                    fix: '创建目录，或修正 hosting[].root 配置',
-                });
-            }
-        });
-        if (config.database) {
-            const migrations = config.database.migrations || './cloudbase/migrations';
-            if (path_1.default.isAbsolute(migrations) || migrations.startsWith('/')) {
-                errors.push({
-                    level: 'error',
-                    resource: 'database',
-                    field: 'migrations',
-                    message: 'database.migrations 仅支持相对路径',
-                    fix: '请使用相对路径，例如 ./cloudbase/migrations',
-                });
-            }
-            else {
-                const migrationsDir = path_1.default.resolve(cwd, migrations);
-                if (!fs_1.default.existsSync(migrationsDir)) {
-                    errors.push({
-                        level: 'error',
-                        resource: 'database',
-                        field: 'migrations',
-                        message: `数据库迁移目录不存在：${path_1.default.relative(cwd, migrationsDir)}`,
-                        fix: '创建迁移目录，或修正 database.migrations 配置',
-                    });
-                }
-            }
-        }
-        return { errors, warnings };
-    }
-    validateConsistency(config, errors, warnings = []) {
-        this.validateUniqueNames('functions', config.functions || [], errors);
-        this.validateUniqueNames('hosting', config.hosting || [], errors);
-        this.validateUniqueField('hosting', config.hosting || [], { field: 'deployPath', errors });
-        this.validateGatewayTargets(config, errors);
-        this.validateGatewayPathRewriteConflicts(config, warnings);
-        this.validateHostingSubPathBaseRisks(config, warnings);
-    }
-    /**
-     * 检测 hosting 路由中 enablePathTransmission=true 与自动生成 pathRewrite 的冲突
-     *
-     * hosting 目标未显式配置 pathRewrite 时，部署会自动生成 PathRewrite.Prefix = hosting.deployPath。
-     * 若同时显式开启 enablePathTransmission=true，路径透传会覆盖路径重写，导致请求打到错误的托管路径（404）。
-     */
-    validateGatewayPathRewriteConflicts(config, warnings) {
-        var _a;
-        const hostingMap = new Map((config.hosting || []).map((h) => [h.name, h]));
-        (((_a = config.gateway) === null || _a === void 0 ? void 0 : _a.routes) || []).forEach((route, index) => {
-            var _a, _b, _c;
-            if (!((_a = route.target) === null || _a === void 0 ? void 0 : _a.startsWith('hosting:')))
-                return;
-            // 用户显式配置了 pathRewrite → 无自动重写，无冲突
-            if (((_b = route.pathRewrite) === null || _b === void 0 ? void 0 : _b.prefix) || ((_c = route.pathRewrite) === null || _c === void 0 ? void 0 : _c.staticStorePrefix))
-                return;
-            // 未显式开启透传 → 无冲突
-            if (route.enablePathTransmission !== true)
-                return;
-            const hostingName = route.target.slice('hosting:'.length);
-            const hosting = hostingMap.get(hostingName);
-            // hosting 无 deployPath → 不会自动生成 PathRewrite，不冲突
-            if (!(hosting === null || hosting === void 0 ? void 0 : hosting.deployPath))
-                return;
-            warnings.push({
-                level: 'warning',
-                resource: `gateway.routes[${index}]`,
-                field: 'enablePathTransmission',
-                message: `hosting 路由 ${route.target} 未显式配置 pathRewrite，部署将自动生成 ` +
-                    `PathRewrite.Prefix=${hosting.deployPath}，但 enablePathTransmission=true 会覆盖路径重写，` +
-                    `导致请求打不到托管实际部署路径`,
-                fix: '删除 enablePathTransmission，让自动生成的 pathRewrite 生效；' +
-                    '或显式配置 pathRewrite.prefix 指向托管部署路径',
-            });
-        });
-    }
-    /**
-     * 子路径部署（deployPath !== '/'）下，前端构建产物若仍使用根路径 base（如 Vite 默认 '/'），
-     * 会导致资源请求落到 /assets/* 而非 /{deployPath}/assets/*，出现 404/白屏。
-     *
-     * 这里在“可能存在构建步骤”的 hosting 配置上给出防坑告警。
-     */
-    validateHostingSubPathBaseRisks(config, warnings) {
-        ;
-        (config.hosting || []).forEach((hosting, index) => {
-            const deployPath = typeof hosting.deployPath === 'string' ? hosting.deployPath.trim() : '';
-            if (!deployPath || deployPath === '/')
-                return;
-            const framework = typeof hosting.framework === 'string' ? hosting.framework.trim().toLowerCase() : '';
-            const hasBuildStep = (typeof hosting.buildCommand === 'string' && hosting.buildCommand.trim().length > 0) ||
-                (!!framework && framework !== 'static' && framework !== 'custom');
-            if (!hasBuildStep)
-                return;
-            warnings.push({
-                level: 'warning',
-                resource: `hosting[${index}]`,
-                field: 'deployPath',
-                message: `静态托管部署在子路径 ${deployPath}，请确认前端构建 base 与子路径匹配，` +
-                    `否则资源可能请求到根路径（如 /assets/*）导致 404/白屏`,
-                fix: "建议将前端 base 配置为 './' 或与 deployPath 对齐（例如 '/serviceName/'）",
-            });
-        });
-    }
-    validateUniqueNames(resource, items, errors) {
-        const names = new Map();
-        items.forEach((item, index) => {
-            if (!item.name)
-                return;
-            const prev = names.get(item.name);
-            if (typeof prev === 'number') {
-                errors.push({
-                    level: 'error',
-                    resource: `${resource}[${index}]`,
-                    field: 'name',
-                    message: `${resource} 名称重复：${item.name}`,
-                    fix: `修改 ${resource}[${index}].name，避免与 ${resource}[${prev}].name 重复`,
-                });
-            }
-            else {
-                names.set(item.name, index);
-            }
-        });
-    }
-    validateUniqueField(resource, items, options) {
-        const { field, errors } = options;
-        const values = new Map();
-        items.forEach((item, index) => {
-            const value = item[field];
-            if (!value)
-                return;
-            const prev = values.get(value);
-            if (typeof prev === 'number') {
-                errors.push({
-                    level: 'error',
-                    resource: `${resource}[${index}]`,
-                    field,
-                    message: `${resource}.${field} 配置重复：${value}`,
-                    fix: `修改 ${resource}[${index}].${field}，避免与 ${resource}[${prev}].${field} 重复`,
-                });
-            }
-            else {
-                values.set(value, index);
-            }
-        });
-    }
-    validateGatewayTargets(config, errors) {
-        var _a;
-        const functionNames = new Set((config.functions || []).map((item) => item.name));
-        const hostingNames = new Set((config.hosting || []).map((item) => item.name));
-        (((_a = config.gateway) === null || _a === void 0 ? void 0 : _a.routes) || []).forEach((route, index) => {
-            const [type, name] = route.target.split(':');
-            if ((type === 'function' && !functionNames.has(name)) || (type === 'hosting' && !hostingNames.has(name))) {
-                errors.push({
-                    level: 'error',
-                    resource: `gateway.routes[${index}]`,
-                    field: 'target',
-                    message: `网关目标不存在：${route.target}`,
-                    fix: '确认 gateway.routes[].target 引用了已声明的 function 或 hosting 资源',
-                });
-            }
-        });
-    }
-    getSummary(config) {
-        var _a, _b, _c, _d;
-        return {
-            functions: ((_a = config === null || config === void 0 ? void 0 : config.functions) === null || _a === void 0 ? void 0 : _a.length) || 0,
-            hosting: ((_b = config === null || config === void 0 ? void 0 : config.hosting) === null || _b === void 0 ? void 0 : _b.length) || 0,
-            databases: (config === null || config === void 0 ? void 0 : config.database) ? 1 : 0,
-            gateways: ((_d = (_c = config === null || config === void 0 ? void 0 : config.gateway) === null || _c === void 0 ? void 0 : _c.routes) === null || _d === void 0 ? void 0 : _d.length) || 0,
-        };
-    }
-    getLinkedEnvId(cwd) {
-        const projectPath = path_1.default.join(cwd, '.tcb', 'project.json');
-        if (!fs_1.default.existsSync(projectPath)) {
-            return '';
-        }
-        try {
-            const project = JSON.parse(fs_1.default.readFileSync(projectPath, 'utf8'));
-            return project.envId || project.EnvId || '';
-        }
-        catch (e) {
-            return '';
-        }
-    }
-    normalizeSchemaPath(dataPath) {
-        return dataPath.replace(/^\//, '').replace(/\//g, '.');
-    }
-    getErrorMessage(error) {
-        return (error === null || error === void 0 ? void 0 : error.message) || String(error);
-    }
-}
-exports.ProjectValidator = ProjectValidator;
-__exportStar(require("./types"), exports);

package/lib/projectValidator/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/types/deploy/DatabaseDeployer.d.ts

@@ -1,70 +0,0 @@
-import { Environment } from '../environment';
-import { IPGUserMigrationInput } from '../database/type';
-/** 数据库迁移部署配置（对应 cloudbaserc.json 中的 database 块） */
-export interface IDatabaseDeployConfig {
-    /** 数据库类型（v2.1 schema: 目前仅支持 postgresql） */
-    type: 'postgresql';
-    /** migration SQL 文件目录（相对项目根） */
-    migrations?: string;
-}
-/** Plan 中单条 migration 的状态 */
-export interface IDatabasePlanItem {
-    /** 14位数字时间串 */
-    version: string;
-    /** migration 名称 */
-    name: string;
-    /** pending=待执行；applied=已应用；conflict=冲突 */
-    status: 'pending' | 'applied' | 'conflict';
-    /** 冲突原因（仅 conflict 时有值） */
-    reason?: string;
-}
-/** deploy 返回结果 */
-export interface IDatabaseDeployResult {
-    /** 异步任务 ID（无pending时为空字符串） */
-    taskId: string;
-}
-export declare class DatabaseDeployer {
-    private environment;
-    constructor(environment: Environment);
-    /**
-     * 从本地目录解析 migration 文件列表
-     *
-     * 文件名格式：{14位时间戳}_{小写下划线名称}.sql
-     * 例如：20260526000000_create_users.sql
-     *
-     * 按文件名升序排列（即按版本号从早到晚）
-     */
-    parseMigrationFiles(migrationsDir: string): IPGUserMigrationInput[];
-    /**
-     * 生成部署计划
-     *
-     * 调用 previewPGUserMigrations 获取云端对比结果，
-     * 返回每条migration 的状态（pending / applied / conflict）
-     */
-    plan(config: IDatabaseDeployConfig, cwd: string, envId: string): Promise<IDatabasePlanItem[]>;
-    /**
-     * 执行数据库迁移
-     *
-     * 流程：
-     * 1. 解析本地 migration 文件
-     * 2. 预览确认无冲突（有冲突直接 throw，中断整个部署）
-     * 3. 无 pending 则跳过
-     * 4. 提交 pushPGUserMigrations
-     * 5. 轮询describeTaskResult 等待完成
-     */
-    deploy(config: IDatabaseDeployConfig, cwd: string, envId: string): Promise<IDatabaseDeployResult>;
-    /**
-     * 解析 migrations 目录路径
-     * - 未配置：默认 ./cloudbase/migrations
-     * - 仅允许相对路径（禁止 / 开头）
-     */
-    private resolveMigrationsDir;
-    /**
-     * 校验 database.type（当前仅支持 postgresql）
-     */
-    private assertDatabaseType;
-    /**
-     * 轮询等待异步任务完成
-     */
-    private waitForTask;
-}

package/types/deploy/DeployOrchestrator.d.ts

@@ -1,168 +0,0 @@
-import { Environment } from '../environment';
-/** 可编排的资源类型 */
-export type ResourceType = 'database' | 'functions' | 'app' | 'hosting' | 'gateway';
-/** 声明式部署选项 */
-export interface IDeployOptions {
-    /** 解析后的 cloudbaserc 配置（ConfigParser 输出，含 envOverrides 已应用） */
-    config: Record<string, any>;
-    envId: string;
-    /** 只部署指定类型 */
-    only?: ResourceType[];
-    /** 跳过指定类型 */
-    skip?: ResourceType[];
-    /** dry-run：只输出计划不实际部署 */
-    dryRun?: boolean;
-    /** 项目根目录（默认 process.cwd()） */
-    cwd?: string;
-    /** 已存在资源（函数）的覆盖更新：yes=true 直接放行（AI Agent / CI 场景） */
-    yes?: boolean;
-    /** 已存在资源（函数）的覆盖更新确认回调：返回 true 部署、false 跳过（CLI 注入 autoConfirm） */
-    confirmUpdate?: (item: IDeployPlanItem) => Promise<boolean>;
-    /** 强制云端对比（漂移检测）：忽略本地 state 快照的 skip 判定，强制重新对比/部署 */
-    refresh?: boolean;
-    /** 同类型资源最大并行数，默认 1（串行）。仅作用于同类型连续实例之间，跨类型依赖顺序不变 */
-    concurrency?: number;
-    /** 失败后继续部署其余资源（database 失败仍强制中断） */
-    continueOnError?: boolean;
-    log?: {
-        info?: (msg: string) => void;
-        success?: (msg: string) => void;
-        warn?: (msg: string) => void;
-        error?: (msg: string) => void;
-    };
-}
-/** 部署计划项（资源级） */
-export interface IDeployPlanItem {
-    type: ResourceType;
-    name: string;
-    /** 动作分类：create=新建；update=覆盖更新已有资源；skip=已存在且配置一致；conflict=检测到冲突（需中断）；deploy=直传覆盖（无存在性概念） */
-    status: 'create' | 'update' | 'skip' | 'conflict' | 'deploy';
-    /** 动作说明（用户可读） */
-    action: string;
-    /** 变更字段明细（如 database 迁移聚合、gateway 路由差异等） */
-    changes?: Array<{
-        field: string;
-        from?: string;
-        to?: string;
-    }>;
-    /** hosting 文件级 diff（新增/修改/删除，前 N 条 + 统计） */
-    fileDiff?: {
-        added: string[];
-        modified: string[];
-        deleted: string[];
-        totalChanged: number;
-    };
-    /** 资源级详情子行（dry-run 树状渲染用）：如函数 runtime/构建策略、迁移逐条状态等 */
-    details?: Array<{
-        label: string;
-        value: string;
-    }>;
-}
-/** 部署结果 */
-export interface IDeployResult {
-    plan: IDeployPlanItem[];
-    results: Array<{
-        type: ResourceType;
-        name: string;
-        ok: boolean;
-        url?: string;
-        error?: string;
-        /** 未执行原因：skip=未变更自动跳过；no-confirm=无确认机制保守跳过；skipped-by-user=用户拒绝覆盖 */
-        reason?: 'skip' | 'no-confirm' | 'skipped-by-user';
-    }>;
-}
-/**
- * 声明式部署编排器
- * 顺序：database → functions → app → hosting → gateway
- * 支持 dry-run / only / skip / 幂等重试（database 失败/冲突会中断后续步骤）
- */
-export declare class DeployOrchestrator {
-    private environment;
-    private databaseDeployer;
-    private functionDeployer;
-    private staticDeployer;
-    private gatewayDeployer;
-    constructor(environment: Environment);
-    /**
-     * 计算部署计划（dry-run 输出）
-     */
-    deployPlan(options: IDeployOptions): Promise<IDeployPlanItem[]>;
-    /**
-     * 执行部署
-     *
-     * 编排模型：plan 按「连续相同资源类型」切成 segments，segment 之间严格按
-     * DEPLOY_ORDER 串行；segment 内部按 concurrency 并行执行。失败中断策略：
-     * - 默认 fail-fast：任一资源失败即中断后续（return）
-     * - continueOnError：非 database 资源失败仍继续，最后汇总失败数
-     * - database 失败始终强制中断（无论是否 continueOnError）
-     */
-    deploy(options: IDeployOptions): Promise<IDeployResult>;
-    /**
-     * 将扁平 plan 按「连续相同资源类型」切成有序 segments
-     *
-     * segment 之间保留 DEPLOY_ORDER 依赖顺序（严格串行）；segment 内部为同类型
-     * 多实例，可并行执行。例如 [db, fnA, fnB, hostingX, hostingY, gateway]
-     * → [[db], [fnA, fnB], [hostingX, hostingY], [gateway]]
-     */
-    private segmentPlan;
-    /**
-     * 部署成功后写回本地 state 快照
-     *
-     * - hosting：成功部署/未变更（skip）的项重算产物指纹；失败项保留旧快照
-     * - app：成功部署写 buildAppConfig 快照；skip 复用旧快照
-     * - gateway：保留旧快照（本轮不做路由级实时快照）
-     */
-    private persistState;
-    /**
-     * 构建完整部署计划（按依赖顺序 + only/skip 过滤）
-     *
-     * 通过查询云端状态判定每个资源的动作：
-     * - database：先按迁移文件做 preview，再聚合成单条资源级计划项（pending→create，存在 conflict→conflict，全部 applied→不出现在 plan）
-     * - functions：ListFunctions 判断是否已存在 → create / update（不做本地 hash / 字段 diff）
-     * - app：describeAppInfo 判断是否已存在 → create / update；本地 state 配置一致 → skip
-     * - hosting：本地 state 指纹 diff → 一致 skip（不重新上传）/ 有差异 deploy（带文件级明细）
-     * - gateway：planRoutes 对比云端路由 → create / update / skip（含变更字段明细）
-     * 云端查询失败时降级为保守判定（全 create），不影响 dry-run 展示。
-     */
-    private buildPlan;
-    /**
-     * 按资源类型构建计划（拆分自 buildPlan，控制圈复杂度）
-     */
-    private buildPlanForType;
-    /**
-     * database 计划：preview 聚合成单条资源级计划项
-     */
-    private buildDatabasePlan;
-    /**
-     * app 计划：本地 state 配置一致 → skip；否则按云端存在性 → create / update
-     */
-    private buildAppPlan;
-    /**
-     * hosting 计划：本地 state 指纹 diff → 一致 skip / 有差异 deploy（带文件级明细）
-     */
-    private buildHostingPlans;
-    /**
-     * gateway 计划：planRoutes 对比云端路由 → create / update / skip（含变更字段明细）
-     */
-    private buildGatewayPlans;
-    /**
-     * 查询环境中已存在的函数名集合（查询失败返回空集，降级为全新建判定）
-     */
-    private listExistingFunctionNames;
-    /**
-     * 判断云应用是否已存在（查询失败返回 false，降级为新建判定）
-     */
-    private appExists;
-    /**
-     * 执行单个计划步骤
-     */
-    private executeStep;
-    /** 深比较（JSON 快照语义）：仅用于 app 配置快照等简单对象 */
-    private deepEqual;
-    /** app 配置差异明细（from → to） */
-    private appConfigChanges;
-    /**
-     * 轻量 inline 守卫：配置合法 + 目录存在（validateProject 接线点）
-     */
-    private guardConfig;
-}