@cloudbase/manager-node 5.7.1-beta.0 → 5.8.0-beta.0

package/lib/deploy/DeployOrchestrator.js

@@ -0,0 +1,645 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployOrchestrator = void 0;
+const path_1 = __importDefault(require("path"));
+const error_1 = require("../error");
+const DatabaseDeployer_1 = require("./DatabaseDeployer");
+const FunctionDeployer_1 = require("./FunctionDeployer");
+const StaticDeployer_1 = require("./StaticDeployer");
+const GatewayDeployer_1 = require("./GatewayDeployer");
+const StateStore_1 = require("./StateStore");
+const framework_1 = require("./framework");
+const parallel_1 = require("../utils/parallel");
+/** 部署顺序（按依赖：database 最先，函数依赖新 Schema；gateway 最后，依赖函数/hosting） */
+const DEPLOY_ORDER = ['database', 'functions', 'app', 'hosting', 'gateway'];
+/**
+ * 声明式部署编排器
+ * 顺序：database → functions → app → hosting → gateway
+ * 支持 dry-run / only / skip / 幂等重试（database 失败/冲突会中断后续步骤）
+ */
+class DeployOrchestrator {
+    constructor(environment) {
+        this.environment = environment;
+        this.databaseDeployer = new DatabaseDeployer_1.DatabaseDeployer(environment);
+        this.functionDeployer = new FunctionDeployer_1.FunctionDeployer(environment);
+        this.staticDeployer = new StaticDeployer_1.StaticDeployer(environment);
+        this.gatewayDeployer = new GatewayDeployer_1.GatewayDeployer(environment);
+    }
+    /**
+     * 计算部署计划（dry-run 输出）
+     */
+    async deployPlan(options) {
+        return this.buildPlan(options.config, options);
+    }
+    /**
+     * 执行部署
+     *
+     * 编排模型：plan 按「连续相同资源类型」切成 segments，segment 之间严格按
+     * DEPLOY_ORDER 串行；segment 内部按 concurrency 并行执行。失败中断策略：
+     * - 默认 fail-fast：任一资源失败即中断后续（return）
+     * - continueOnError：非 database 资源失败仍继续，最后汇总失败数
+     * - database 失败始终强制中断（无论是否 continueOnError）
+     */
+    async deploy(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const { config, envId, dryRun, cwd = process.cwd(), log, concurrency = 1, continueOnError = false } = options;
+        // 1. 轻量 inline 守卫（validateProject 未接入时的兜底）
+        this.guardConfig(config);
+        const plan = await this.buildPlan(config, options);
+        if (dryRun) {
+            (_a = log === null || log === void 0 ? void 0 : log.info) === null || _a === void 0 ? void 0 : _a.call(log, 'dry-run 模式，仅输出部署计划');
+            return { plan, results: [] };
+        }
+        const results = [];
+        // 按连续相同 type 切段：段间串行（依赖顺序），段内并行
+        const segments = this.segmentPlan(plan);
+        // gateway 段强制串行：executeStep 的 gateway 分支部署 config.gateway.routes 全部路由
+        // （逐路由 plan item 仅用于展示 diff），并发执行会对同一批路由发起重复全量部署（竞态 create/modify 路由、bindCustomDomain）
+        const globalLimit = Math.max(1, Math.min(Number(concurrency) || 1, 20));
+        try {
+            for (const segment of segments) {
+                // 段内并行度：gateway 段固定 1（全量部署语义）；其余段用全局 concurrency
+                const limit = ((_b = segment[0]) === null || _b === void 0 ? void 0 : _b.type) === 'gateway' ? 1 : globalLimit;
+                // 段内预判定（顺序执行，保留交互/冲突中断语义）
+                const toExecute = [];
+                let segmentFailed = false;
+                let segmentDbFailed = false;
+                for (const item of segment) {
+                    // skip：产物/配置未变更，静默跳过（不执行、不询问）
+                    if (item.status === 'skip') {
+                        (_c = log === null || log === void 0 ? void 0 : log.info) === null || _c === void 0 ? void 0 : _c.call(log, `[${item.type}] ${item.name}: ${item.action}`);
+                        results.push({ type: item.type, name: item.name, ok: true, reason: 'skip' });
+                        continue;
+                    }
+                    (_d = log === null || log === void 0 ? void 0 : log.info) === null || _d === void 0 ? void 0 : _d.call(log, `[${item.type}] ${item.name}: ${item.action}`);
+                    // conflict：数据库迁移冲突 → 中断整个部署（后续资源可能依赖新 Schema）
+                    if (item.status === 'conflict') {
+                        const message = '检测到冲突，已中断部署';
+                        (_e = log === null || log === void 0 ? void 0 : log.error) === null || _e === void 0 ? void 0 : _e.call(log, `[${item.type}] ${item.name} ${message}`);
+                        results.push({ type: item.type, name: item.name, ok: false, error: message });
+                        if (item.type === 'database') {
+                            return { plan, results };
+                        }
+                        segmentFailed = true;
+                        continue;
+                    }
+                    // 覆盖确认：仅函数已存在（update）时触发，对齐 tcb fn deploy 的 FunctionConflictChecker 语义
+                    // yes=true 直接放行；注入 confirmUpdate 按回调决定；两者都无 → 保守跳过（no-confirm）
+                    if (item.type === 'functions' && item.status === 'update') {
+                        let confirmed = false;
+                        if (options.yes) {
+                            confirmed = true;
+                        }
+                        else if (options.confirmUpdate) {
+                            confirmed = await options.confirmUpdate(item);
+                        }
+                        if (!confirmed) {
+                            const reason = options.confirmUpdate
+                                ? 'skipped-by-user'
+                                : 'no-confirm';
+                            (_f = log === null || log === void 0 ? void 0 : log.warn) === null || _f === void 0 ? void 0 : _f.call(log, `[${item.type}] ${item.name} 跳过覆盖更新（${reason}）`);
+                            results.push({ type: item.type, name: item.name, ok: false, reason });
+                            continue;
+                        }
+                    }
+                    toExecute.push(item);
+                }
+                if (toExecute.length === 0) {
+                    // 段内无实际执行项：若本段已因 conflict 标记失败且 fail-fast，则中断
+                    if (segmentFailed && !continueOnError) {
+                        return { plan, results };
+                    }
+                    continue;
+                }
+                // 段内并行执行
+                const controller = new parallel_1.AsyncTaskParallelController(limit);
+                const tasks = toExecute.map((item) => async () => {
+                    var _a, _b, _c, _d, _e;
+                    try {
+                        const stepResult = await this.executeStep({ item, config, envId, cwd });
+                        results.push({ type: item.type, name: item.name, ok: true, url: stepResult });
+                    }
+                    catch (e) {
+                        const message = (e === null || e === void 0 ? void 0 : e.message) || String(e);
+                        const requestId = (e === null || e === void 0 ? void 0 : e.requestId) ||
+                            (e === null || e === void 0 ? void 0 : e.RequestId) ||
+                            ((_a = e === null || e === void 0 ? void 0 : e.original) === null || _a === void 0 ? void 0 : _a.requestId) ||
+                            ((_b = e === null || e === void 0 ? void 0 : e.original) === null || _b === void 0 ? void 0 : _b.RequestId) ||
+                            ((_c = e === null || e === void 0 ? void 0 : e.response) === null || _c === void 0 ? void 0 : _c.requestId) ||
+                            ((_d = e === null || e === void 0 ? void 0 : e.response) === null || _d === void 0 ? void 0 : _d.RequestId);
+                        (_e = log === null || log === void 0 ? void 0 : log.error) === null || _e === void 0 ? void 0 : _e.call(log, `[${item.type}] ${item.name} 部署失败: ${message}`);
+                        results.push(Object.assign({ type: item.type, name: item.name, ok: false, error: message }, (requestId ? { requestId } : {})));
+                        segmentFailed = true;
+                        if (item.type === 'database') {
+                            segmentDbFailed = true;
+                        }
+                    }
+                });
+                controller.loadTasks(tasks);
+                await controller.run();
+                // 段内失败中断决策
+                if (segmentFailed) {
+                    if (segmentDbFailed) {
+                        (_g = log === null || log === void 0 ? void 0 : log.error) === null || _g === void 0 ? void 0 : _g.call(log, '数据库迁移失败，中断部署');
+                        return { plan, results };
+                    }
+                    if (!continueOnError) {
+                        (_h = log === null || log === void 0 ? void 0 : log.error) === null || _h === void 0 ? void 0 : _h.call(log, '存在资源部署失败，中断部署');
+                        return { plan, results };
+                    }
+                }
+            }
+        }
+        finally {
+            // 无论部署全部成功还是 fail-fast 中断，都将已成功资源的状态快照落盘
+            // （失败资源保留旧快照，下次 diff 仍会检测到差异）；快照写入失败不影响部署结果
+            if (!dryRun) {
+                try {
+                    await this.persistState({ config, plan, results, cwd });
+                }
+                catch (e) {
+                    (_j = log === null || log === void 0 ? void 0 : log.warn) === null || _j === void 0 ? void 0 : _j.call(log, `状态快照写入失败：${(e === null || e === void 0 ? void 0 : e.message) || String(e)}`);
+                }
+            }
+        }
+        return { plan, results };
+    }
+    /**
+     * 将扁平 plan 按「连续相同资源类型」切成有序 segments
+     *
+     * segment 之间保留 DEPLOY_ORDER 依赖顺序（严格串行）；segment 内部为同类型
+     * 多实例，可并行执行。例如 [db, fnA, fnB, hostingX, hostingY, gateway]
+     * → [[db], [fnA, fnB], [hostingX, hostingY], [gateway]]
+     */
+    segmentPlan(plan) {
+        const segments = [];
+        let current = [];
+        let currentType;
+        for (const item of plan) {
+            if (currentType === undefined || item.type === currentType) {
+                current.push(item);
+                currentType = item.type;
+            }
+            else {
+                segments.push(current);
+                current = [item];
+                currentType = item.type;
+            }
+        }
+        if (current.length > 0) {
+            segments.push(current);
+        }
+        return segments;
+    }
+    /**
+     * 部署成功后写回本地 state 快照
+     *
+     * - hosting：成功部署/未变更（skip）的项重算产物指纹；失败项保留旧快照
+     * - app：成功部署写 buildAppConfig 快照；skip 复用旧快照
+     * - gateway：保留旧快照（本轮不做路由级实时快照）
+     */
+    async persistState(options) {
+        var _a, _b, _c, _d, _e, _f;
+        const { config, plan, results, cwd } = options;
+        const stateStore = new StateStore_1.StateStore({ cwd });
+        const prev = stateStore.read();
+        // hosting
+        const hostingEntries = [];
+        for (const h of config.hosting || []) {
+            const name = h.name || 'default';
+            const planItem = plan.find(p => p.type === 'hosting' && p.name === name);
+            const result = results.find(r => r.type === 'hosting' && r.name === name);
+            if (!result || !result.ok) {
+                // 未执行（fail-fast 中断，results 中无对应条目）或部署失败：
+                // 保留旧快照（下次 diff 仍会检测到差异）
+                const prevEntry = (_b = (_a = prev === null || prev === void 0 ? void 0 : prev.resources) === null || _a === void 0 ? void 0 : _a.hosting) === null || _b === void 0 ? void 0 : _b.find(s => s.name === name);
+                if (prevEntry) {
+                    hostingEntries.push(prevEntry);
+                }
+                continue;
+            }
+            if ((planItem === null || planItem === void 0 ? void 0 : planItem.status) === 'skip') {
+                const prevEntry = (_d = (_c = prev === null || prev === void 0 ? void 0 : prev.resources) === null || _c === void 0 ? void 0 : _c.hosting) === null || _d === void 0 ? void 0 : _d.find(s => s.name === name);
+                if (prevEntry) {
+                    hostingEntries.push(prevEntry);
+                    continue;
+                }
+            }
+            // 成功部署：重算当前指纹（含 size，供下次 diff 做 size 预判）
+            // 注意：deployHosting 可能执行本地构建，产物已更新，必须独立重算而非复用 plan 指纹
+            const root = path_1.default.resolve(cwd, h.root || '.');
+            // outputDir 与 StaticDeployer.deployHosting 完全复用同一解析逻辑
+            const outputDir = (0, framework_1.resolveHostingOutputDir)(h, root);
+            try {
+                const files = await stateStore.computeHostingFingerprints(outputDir, h.ignore || []);
+                hostingEntries.push({ name, deployPath: h.deployPath, files });
+            }
+            catch (_g) {
+                // 目录缺失 / 文件数超限：不写入（下次 diff 走云端兜底或全量部署）
+            }
+        }
+        // app
+        let appEntry;
+        if (config.app) {
+            const appResult = results.find(r => r.type === 'app');
+            if (appResult === null || appResult === void 0 ? void 0 : appResult.ok) {
+                appEntry = stateStore.buildAppConfig(config.app);
+            }
+            else {
+                appEntry = (_e = prev === null || prev === void 0 ? void 0 : prev.resources) === null || _e === void 0 ? void 0 : _e.app;
+            }
+        }
+        const resources = {};
+        if (hostingEntries.length) {
+            resources.hosting = hostingEntries;
+        }
+        if (appEntry) {
+            resources.app = appEntry;
+        }
+        if ((_f = prev === null || prev === void 0 ? void 0 : prev.resources) === null || _f === void 0 ? void 0 : _f.gateway) {
+            resources.gateway = prev.resources.gateway;
+        }
+        if (Object.keys(resources).length) {
+            stateStore.write({ resources });
+        }
+    }
+    /**
+     * 构建完整部署计划（按依赖顺序 + 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 展示。
+     */
+    async buildPlan(config, options) {
+        const { only, skip, refresh } = options;
+        const cwd = options.cwd || process.cwd();
+        const envId = options.envId;
+        const plan = [];
+        const isEnabled = (type) => {
+            if ((only === null || only === void 0 ? void 0 : only.length) && !only.includes(type))
+                return false;
+            if (skip === null || skip === void 0 ? void 0 : skip.includes(type))
+                return false;
+            return true;
+        };
+        // 本地 state 快照（diff 基准）：--refresh 时忽略本地 skip 判定
+        const stateStore = new StateStore_1.StateStore({ cwd });
+        const state = refresh ? null : stateStore.read();
+        const planCtx = { config, envId, stateStore, state, refresh, cwd };
+        for (const type of DEPLOY_ORDER) {
+            if (!isEnabled(type))
+                continue;
+            const typePlans = await this.buildPlanForType(type, planCtx);
+            plan.push(...typePlans);
+        }
+        return plan;
+    }
+    /**
+     * 按资源类型构建计划（拆分自 buildPlan，控制圈复杂度）
+     */
+    async buildPlanForType(type, ctx) {
+        const { config, envId, stateStore, state, refresh, cwd } = ctx;
+        if (type === 'database') {
+            return this.buildDatabasePlan(config, cwd, envId);
+        }
+        if (type === 'functions') {
+            const existingFunctions = await this.listExistingFunctionNames();
+            return (config.functions || []).map((fn) => {
+                const exists = existingFunctions.has(fn.name);
+                const details = [];
+                const runtime = fn.runtime || 'Nodejs20.19';
+                const memorySize = fn.memorySize || 256;
+                details.push({ label: '运行时', value: `${runtime}, ${memorySize}MB` });
+                if (fn.type === 'HTTP') {
+                    const strategy = fn.buildStrategy || 'zip';
+                    details.push({ label: '构建', value: strategy });
+                    if (fn.public) {
+                        details.push({ label: '访问', value: 'public: true（自动配置匿名访问）' });
+                    }
+                    if (fn.gatewayPath) {
+                        details.push({ label: '网关路径', value: fn.gatewayPath });
+                    }
+                }
+                else {
+                    const install = fn.installDependency === false ? '本地安装依赖打包' : '云端安装依赖';
+                    details.push({ label: '依赖', value: install });
+                }
+                return {
+                    type,
+                    name: fn.name,
+                    status: exists ? 'update' : 'create',
+                    action: exists
+                        ? `覆盖更新已存在函数 ${fn.name}`
+                        : `新建函数 ${fn.name}`,
+                    details
+                };
+            });
+        }
+        if (type === 'app') {
+            return this.buildAppPlan({ config, envId, stateStore, state, refresh });
+        }
+        if (type === 'hosting') {
+            return this.buildHostingPlans(config, ctx);
+        }
+        return this.buildGatewayPlans(config, envId);
+    }
+    /**
+     * database 计划：preview 聚合成单条资源级计划项
+     */
+    async buildDatabasePlan(config, cwd, envId) {
+        if (!config.database)
+            return [];
+        const dbConfig = config.database;
+        const migrationPlans = await this.databaseDeployer.plan(dbConfig, cwd, envId);
+        const pending = migrationPlans.filter(item => item.status === 'pending');
+        const conflicts = migrationPlans.filter(item => item.status === 'conflict');
+        // database 是资源级步骤：无论有多少 migration，plan 中最多只保留一条 database 记录
+        const details = migrationPlans.map(item => ({
+            label: `${item.version}_${item.name || 'unknown'}`,
+            value: item.status === 'pending'
+                ? '待应用'
+                : item.status === 'conflict'
+                    ? `冲突：${item.reason || 'checksum mismatch'}`
+                    : '已应用，跳过'
+        }));
+        if (conflicts.length > 0) {
+            return [
+                {
+                    type: 'database',
+                    name: 'postgresql',
+                    status: 'conflict',
+                    action: `数据库迁移存在 ${conflicts.length} 个冲突，执行时将中断部署`,
+                    changes: conflicts.map(item => ({
+                        field: `conflict.${item.version}_${item.name || 'unknown'}`,
+                        to: item.reason || 'checksum mismatch'
+                    })),
+                    details
+                }
+            ];
+        }
+        if (pending.length > 0) {
+            return [
+                {
+                    type: 'database',
+                    name: 'postgresql',
+                    status: 'create',
+                    action: `将执行 ${pending.length} 条数据库迁移`,
+                    changes: pending.map(item => ({
+                        field: 'migration',
+                        to: `${item.version}_${item.name}`
+                    })),
+                    details
+                }
+            ];
+        }
+        // 全部 applied 时不产生 database 计划项
+        return [];
+    }
+    /**
+     * app 计划：本地 state 配置一致 → skip；否则按云端存在性 → create / update
+     */
+    async buildAppPlan(options) {
+        var _a;
+        const { config, envId, stateStore, state, refresh } = options;
+        if (!config.app)
+            return [];
+        const name = config.app.serviceName || 'app';
+        // 本地 state 配置一致 → skip（真增量，不重复构建版本）
+        const appEntry = stateStore.buildAppConfig(config.app);
+        const stateApp = (_a = state === null || state === void 0 ? void 0 : state.resources) === null || _a === void 0 ? void 0 : _a.app;
+        const appUnchanged = !refresh &&
+            stateApp !== undefined &&
+            appEntry !== undefined &&
+            this.deepEqual(stateApp, appEntry);
+        if (appUnchanged) {
+            return [
+                {
+                    type: 'app',
+                    name,
+                    status: 'skip',
+                    action: `云应用 ${name} 配置未变更，跳过`
+                }
+            ];
+        }
+        const appExists = await this.appExists(name);
+        const changes = this.appConfigChanges(stateApp, appEntry);
+        return [
+            Object.assign({ type: 'app', name, status: appExists ? 'update' : 'create', action: appExists
+                    ? `覆盖更新云应用 ${name}`
+                    : `新建云应用 ${name}` }, (changes.length ? { changes } : {}))
+        ];
+    }
+    /**
+     * hosting 计划：本地 state 指纹 diff → 一致 skip / 有差异 deploy（带文件级明细）
+     */
+    async buildHostingPlans(config, ctx) {
+        var _a, _b;
+        const { stateStore, state, refresh, cwd } = ctx;
+        const plans = [];
+        for (const h of config.hosting || []) {
+            const name = h.name || 'default';
+            const root = path_1.default.resolve(cwd, h.root || '.');
+            const buildCommand = (0, framework_1.resolveBuildCommand)(h, root);
+            // outputDir 与 StaticDeployer.deployHosting 完全复用同一解析逻辑
+            const outputDir = (0, framework_1.resolveHostingOutputDir)(h, root);
+            const stateHosting = (_b = (_a = state === null || state === void 0 ? void 0 : state.resources) === null || _a === void 0 ? void 0 : _a.hosting) === null || _b === void 0 ? void 0 : _b.find(s => s.name === name);
+            // 懒加载 diff：size 预判 + 按需 hash（目录缺失 / 文件数超限 → 保守部署）
+            let fileDiff = null;
+            try {
+                fileDiff = await stateStore.diffHostingFiles(outputDir, stateHosting === null || stateHosting === void 0 ? void 0 : stateHosting.files, {
+                    ignore: h.ignore || []
+                });
+            }
+            catch (_c) {
+                fileDiff = null;
+            }
+            const unchanged = !refresh && fileDiff !== null && fileDiff.unchanged;
+            if (unchanged) {
+                plans.push({
+                    type: 'hosting',
+                    name,
+                    status: 'skip',
+                    action: `静态托管 ${name} 产物未变更，跳过`
+                });
+                continue;
+            }
+            const hasBuild = !!h.buildCommand ||
+                (!!h.framework && h.framework !== 'static' && h.framework !== 'custom');
+            const details = [
+                { label: '框架', value: h.framework || 'static' },
+                {
+                    label: '构建',
+                    value: hasBuild
+                        ? `本地构建（${buildCommand || 'npm run build'}）→ 上传 ${outputDir}`
+                        : '无构建，直接上传'
+                },
+                { label: '部署路径', value: h.deployPath || '/' }
+            ];
+            if (fileDiff === null || fileDiff === void 0 ? void 0 : fileDiff.overLimit) {
+                details.push({ label: '指纹', value: '文件数超上限，降级为全量部署' });
+            }
+            plans.push(Object.assign({ type: 'hosting', name, status: 'deploy', action: hasBuild
+                    ? `本地构建后直传静态托管 ${name}`
+                    : `直传覆盖静态托管 ${name}`, details }, (fileDiff && !fileDiff.overLimit
+                ? {
+                    fileDiff: {
+                        added: fileDiff.added,
+                        modified: fileDiff.modified,
+                        deleted: fileDiff.deleted,
+                        totalChanged: fileDiff.totalChanged
+                    }
+                }
+                : {})));
+        }
+        return plans;
+    }
+    /**
+     * gateway 计划：planRoutes 对比云端路由 → create / update / skip（含变更字段明细）
+     */
+    async buildGatewayPlans(config, envId) {
+        var _a;
+        const routes = ((_a = config.gateway) === null || _a === void 0 ? void 0 : _a.routes) || [];
+        if (routes.length === 0)
+            return [];
+        const routePlans = await this.gatewayDeployer.planRoutes({
+            routes,
+            envId,
+            hostings: config.hosting || []
+        });
+        const routeConfigMap = new Map(routes.map(r => [r.path, r]));
+        return routePlans.map(rp => {
+            const routeCfg = routeConfigMap.get(rp.path);
+            const details = [];
+            if (routeCfg === null || routeCfg === void 0 ? void 0 : routeCfg.target) {
+                details.push({ label: '目标', value: routeCfg.target });
+            }
+            if (routeCfg === null || routeCfg === void 0 ? void 0 : routeCfg.domain) {
+                details.push({ label: '域名', value: routeCfg.domain });
+            }
+            return Object.assign({ type: 'gateway', name: rp.path, status: rp.status, action: rp.status === 'create'
+                    ? `新建路由 ${rp.path}`
+                    : rp.status === 'update'
+                        ? `更新路由 ${rp.path}`
+                        : `路由 ${rp.path} 配置一致，跳过`, changes: rp.changes }, (details.length ? { details } : {}));
+        });
+    }
+    /**
+     * 查询环境中已存在的函数名集合（查询失败返回空集，降级为全新建判定）
+     */
+    async listExistingFunctionNames() {
+        try {
+            const list = await this.environment.getFunctionService().listFunctions(100);
+            // listFunctions 返回字段名为 FunctionName（SCF ListFunctions API），兜底兼容 Name/name
+            return new Set((list || []).map((f) => f.FunctionName || f.Name || f.name));
+        }
+        catch (_a) {
+            return new Set();
+        }
+    }
+    /**
+     * 判断云应用是否已存在（查询失败返回 false，降级为新建判定）
+     */
+    async appExists(name) {
+        try {
+            await this.environment.getCloudAppService().describeAppInfo({
+                deployType: 'static-hosting',
+                serviceName: name
+            });
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * 执行单个计划步骤
+     */
+    async executeStep(options) {
+        const { item, config, envId, cwd } = options;
+        switch (item.type) {
+            case 'database': {
+                const dbConfig = config.database;
+                const result = await this.databaseDeployer.deploy(dbConfig, cwd, envId);
+                return result.taskId ? `task:${result.taskId}` : undefined;
+            }
+            case 'functions': {
+                const fn = (config.functions || []).find((f) => f.name === item.name);
+                if (!fn)
+                    return undefined;
+                // 函数代码目录解析（对齐 CLI FunctionPathResolver 的 dir 语义）：
+                // - 显式配置 dir → path.resolve(cwd, dir)（独立于 functionRoot，不拼接）
+                // - 未配置 dir → path.join(functionRootPath, name) = {cwd}/{functionRoot}/{name}
+                const functionRoot = config.functionRoot || 'functions';
+                const functionRootPath = path_1.default.resolve(cwd, functionRoot);
+                const functionPath = fn.dir
+                    ? path_1.default.resolve(cwd, fn.dir)
+                    : path_1.default.join(functionRootPath, fn.name);
+                // 声明式部署幂等语义：函数已存在则覆盖更新（force=true），支持重跑续传
+                const result = await this.functionDeployer.deploy({
+                    func: fn,
+                    functionRootPath,
+                    functionPath,
+                    force: true
+                });
+                return result.url;
+            }
+            case 'app': {
+                const result = await this.staticDeployer.deployApp({ config: config.app, cwd });
+                return result.url;
+            }
+            case 'hosting': {
+                const h = (config.hosting || []).find((x) => (x.name || 'default') === item.name);
+                const result = await this.staticDeployer.deployHosting({ config: h, cwd });
+                return result.url;
+            }
+            case 'gateway': {
+                const result = await this.gatewayDeployer.deploy({
+                    routes: config.gateway.routes,
+                    envId,
+                    // 传入 hosting 配置：hosting 路由自动生成 PathRewrite.Prefix = deployPath
+                    hostings: config.hosting || []
+                });
+                return result.domain;
+            }
+        }
+    }
+    /** 深比较（JSON 快照语义）：仅用于 app 配置快照等简单对象 */
+    deepEqual(a, b) {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    /** app 配置差异明细（from → to） */
+    appConfigChanges(prev, curr) {
+        const changes = [];
+        const keys = new Set([
+            ...Object.keys(prev || {}),
+            ...Object.keys(curr || {})
+        ]);
+        for (const key of keys) {
+            const from = prev === null || prev === void 0 ? void 0 : prev[key];
+            const to = curr === null || curr === void 0 ? void 0 : curr[key];
+            if (from !== to) {
+                changes.push({ field: String(key), from, to });
+            }
+        }
+        return changes;
+    }
+    /**
+     * 轻量 inline 守卫：配置合法 + 目录存在（validateProject 接线点）
+     */
+    guardConfig(config) {
+        if (!config || typeof config !== 'object') {
+            throw new error_1.CloudBaseError('无效的配置：config 必须为对象');
+        }
+        if (!config.envId) {
+            throw new error_1.CloudBaseError('无效的配置：缺少 envId');
+        }
+    }
+}
+exports.DeployOrchestrator = DeployOrchestrator;