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

package/lib/deploy/StateStore.js

@@ -0,0 +1,327 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateStore = exports.DEFAULT_HASH_LENGTH = exports.DEFAULT_MAX_HOSTING_FILES = exports.HostingFilesOverLimitError = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
+const error_1 = require("../error");
+/** hosting 指纹文件数超过上限时抛出（触发降级为全量部署） */
+class HostingFilesOverLimitError extends Error {
+    constructor(fileCount, limit) {
+        super(`hosting 文件数 ${fileCount} 超过指纹上限 ${limit}，跳过逐文件 diff，降级为全量部署`);
+        this.name = 'HostingFilesOverLimitError';
+        this.fileCount = fileCount;
+        this.limit = limit;
+    }
+}
+exports.HostingFilesOverLimitError = HostingFilesOverLimitError;
+/** 默认强制忽略的目录/文件（不可被调用方关闭） */
+const DEFAULT_IGNORE = ['.DS_Store', 'node_modules/'];
+/** 默认指纹文件数上限（防快照膨胀与 I/O 失控） */
+exports.DEFAULT_MAX_HOSTING_FILES = 50000;
+/** 默认 hash 截断长度（16 位 hex = 64bit，碰撞概率可忽略；快照体积减半） */
+exports.DEFAULT_HASH_LENGTH = 16;
+/**
+ * 部署状态快照（StateStore）
+ *
+ * 职责：读写 `.cloudbase/state.json`（默认），为 dry-run 的 hosting/app diff 提供本地基准，
+ * 避免每次 diff 都拉取云端。
+ *
+ * 指纹算法：hosting = 产物目录逐文件内容 sha256（相对路径为 key）。
+ * 只存 hash 不存内容，体积 = O(文件数)；app 快照不写入 envVariables（敏感过滤）。
+ */
+class StateStore {
+    constructor(options = {}) {
+        this.cwd = options.cwd || process.cwd();
+        this.env = options.env;
+        this.stateFile = options.stateFile;
+    }
+    /**
+     * 计算 state 文件路径：
+     * - 自定义 stateFile 优先
+     * - 否则 {cwd}/.cloudbase/state.json（无 env）或 state.{env}.json（多环境隔离）
+     */
+    getFilePath() {
+        if (this.stateFile) {
+            return this.stateFile;
+        }
+        const base = this.env ? `state.${this.env}.json` : 'state.json';
+        return path_1.default.join(this.cwd, '.cloudbase', base);
+    }
+    /**
+     * 读取状态快照；文件不存在或 JSON 损坏返回 null（缺失降级，由调用方走云端兜底）
+     */
+    read() {
+        const filePath = this.getFilePath();
+        if (!fs_1.default.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    /**
+     * 写入状态快照（自动补 version/updatedAt/gitCommit，自动创建 .cloudbase 目录）
+     */
+    write(state) {
+        var _a;
+        const filePath = this.getFilePath();
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        const full = {
+            version: 1,
+            updatedAt: new Date().toISOString(),
+            gitCommit: (_a = state.gitCommit) !== null && _a !== void 0 ? _a : this.resolveGitCommit(),
+            resources: state.resources
+        };
+        fs_1.default.writeFileSync(filePath, JSON.stringify(full, null, 2), 'utf8');
+    }
+    /**
+     * 计算产物目录逐文件 sha256 指纹（仅 hash，兼容旧调用）
+     *
+     * @param projectPath 产物目录（hosting 的 outputDir / root）
+     * @param ignore 自定义忽略规则（追加到默认 node_modules / .DS_Store 之后）
+     * @param options 扫描选项（maxFiles / hashLength）
+     * @returns 相对路径（/ 分隔）→ 文件内容 sha256（默认截断 16 位）
+     */
+    async computeHostingFiles(projectPath, ignore = [], options = {}) {
+        const fingerprints = await this.computeHostingFingerprints(projectPath, ignore, options);
+        const result = {};
+        for (const [relPath, fp] of Object.entries(fingerprints)) {
+            result[relPath] = fp.hash;
+        }
+        return result;
+    }
+    /**
+     * 计算产物目录逐文件指纹（hash + size）
+     *
+     * - 强制忽略 node_modules / .DS_Store（与传入 ignore 合并，不可关闭）
+     * - hash 默认截断为 16 位 hex（hashLength 可调，64 = 完整 sha256）
+     * - 文件数超过 maxFiles 抛 HostingFilesOverLimitError（防快照膨胀与 I/O 失控）
+     *
+     * @param projectPath 产物目录（hosting 的 outputDir / root）
+     * @param ignore 自定义忽略规则
+     * @param options 扫描选项（maxFiles / hashLength）
+     * @returns 相对路径（/ 分隔）→ { hash, size }
+     */
+    async computeHostingFingerprints(projectPath, ignore = [], options = {}) {
+        if (!fs_1.default.existsSync(projectPath) || !fs_1.default.statSync(projectPath).isDirectory()) {
+            throw new error_1.CloudBaseError(`产物目录不存在或不是目录：${projectPath}`);
+        }
+        const { maxFiles = exports.DEFAULT_MAX_HOSTING_FILES, hashLength = exports.DEFAULT_HASH_LENGTH } = options;
+        const effectiveIgnore = this.mergeIgnore(ignore);
+        const files = {};
+        let count = 0;
+        const walk = (dir, rel) => {
+            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                const entryPath = path_1.default.join(dir, entry.name);
+                const relPath = rel ? path_1.default.join(rel, entry.name) : entry.name;
+                if (entry.isDirectory()) {
+                    if (this.isIgnored(relPath, effectiveIgnore)) {
+                        continue;
+                    }
+                    walk(entryPath, relPath);
+                }
+                else if (entry.isFile() && !this.isIgnored(relPath, effectiveIgnore)) {
+                    count++;
+                    if (maxFiles > 0 && count > maxFiles) {
+                        throw new HostingFilesOverLimitError(count, maxFiles);
+                    }
+                    const normalized = relPath.split(path_1.default.sep).join('/');
+                    files[normalized] = {
+                        hash: this.hashFile(entryPath, hashLength),
+                        size: fs_1.default.statSync(entryPath).size
+                    };
+                }
+            }
+        };
+        walk(projectPath, '');
+        return files;
+    }
+    /**
+     * 计算产物目录与快照的变更集（懒加载）
+     *
+     * 优化：先 stat 拿 size，size 与快照不同的文件直接判定变更（不读文件内容），
+     * 只有 size 相同（或旧快照 size 未知）的文件才读内容 hash 对比，
+     * 避免为未变文件做无谓的 I/O 与 hash。
+     * 文件数超过 maxFiles 时放弃 diff，返回 overLimit=true（调用方应降级为全量部署）。
+     *
+     * @param projectPath 产物目录（hosting 的 outputDir / root）
+     * @param previous 上次快照指纹（undefined = 首次部署，全部视为新增）
+     * @param options 选项（ignore / maxFiles / hashLength）
+     */
+    async diffHostingFiles(projectPath, previous, options = {}) {
+        if (!fs_1.default.existsSync(projectPath) || !fs_1.default.statSync(projectPath).isDirectory()) {
+            throw new error_1.CloudBaseError(`产物目录不存在或不是目录：${projectPath}`);
+        }
+        const { ignore = [], maxFiles = exports.DEFAULT_MAX_HOSTING_FILES, hashLength = exports.DEFAULT_HASH_LENGTH } = options;
+        const effectiveIgnore = this.mergeIgnore(ignore);
+        // 归一化快照：旧格式（string）size 未知 → -1，走 hash 对比而非 size 预判
+        let prev;
+        if (previous) {
+            prev = {};
+            for (const [k, v] of Object.entries(previous)) {
+                prev[k] = this.normalizeFileValue(v);
+            }
+        }
+        const localFiles = new Set();
+        const added = [];
+        const modified = [];
+        let count = 0;
+        let overLimit = false;
+        const walk = (dir, rel) => {
+            if (overLimit) {
+                return;
+            }
+            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                const entryPath = path_1.default.join(dir, entry.name);
+                const relPath = rel ? path_1.default.join(rel, entry.name) : entry.name;
+                if (entry.isDirectory()) {
+                    if (this.isIgnored(relPath, effectiveIgnore)) {
+                        continue;
+                    }
+                    walk(entryPath, relPath);
+                }
+                else if (entry.isFile() && !this.isIgnored(relPath, effectiveIgnore)) {
+                    count++;
+                    if (maxFiles > 0 && count > maxFiles) {
+                        overLimit = true;
+                        return;
+                    }
+                    const normalized = relPath.split(path_1.default.sep).join('/');
+                    localFiles.add(normalized);
+                    const prevEntry = prev === null || prev === void 0 ? void 0 : prev[normalized];
+                    if (!prevEntry) {
+                        added.push(normalized);
+                    }
+                    else if (prevEntry.size !== -1 && prevEntry.size !== fs_1.default.statSync(entryPath).size) {
+                        // size 变化 → 内容必变，无需读文件（懒加载核心）
+                        modified.push(normalized);
+                    }
+                    else {
+                        // size 相同或旧快照 size 未知 → 读内容 hash 确认
+                        const hash = this.hashFile(entryPath, hashLength);
+                        if (prevEntry.hash !== hash) {
+                            modified.push(normalized);
+                        }
+                    }
+                }
+            }
+        };
+        walk(projectPath, '');
+        if (overLimit) {
+            return {
+                added: [],
+                modified: [],
+                deleted: [],
+                totalChanged: 0,
+                unchanged: false,
+                overLimit: true
+            };
+        }
+        const deleted = prev
+            ? Object.keys(prev).filter(k => !localFiles.has(k) && !this.isIgnored(k, effectiveIgnore))
+            : [];
+        const totalChanged = added.length + modified.length + deleted.length;
+        return { added, modified, deleted, totalChanged, unchanged: totalChanged === 0 };
+    }
+    /**
+     * 提取 app 配置快照（仅 diff 白名单字段）
+     * envVariables / ignore 等非 diff 字段与敏感信息不进入快照
+     */
+    buildAppConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return undefined;
+        }
+        const entry = {};
+        if (config.serviceName !== undefined) {
+            entry.serviceName = config.serviceName;
+        }
+        if (config.installCommand !== undefined) {
+            entry.installCommand = config.installCommand;
+        }
+        if (config.buildCommand !== undefined) {
+            entry.buildCommand = config.buildCommand;
+        }
+        if (config.outputDir !== undefined) {
+            entry.outputDir = config.outputDir;
+        }
+        if (config.deployPath !== undefined) {
+            entry.deployPath = config.deployPath;
+        }
+        return entry;
+    }
+    hashFile(filePath, hashLength = exports.DEFAULT_HASH_LENGTH) {
+        const content = fs_1.default.readFileSync(filePath);
+        return crypto_1.default.createHash('sha256').update(content).digest('hex').slice(0, hashLength);
+    }
+    /** 合并默认忽略规则（node_modules / .DS_Store 不可被调用方关闭） */
+    mergeIgnore(ignore) {
+        return Array.from(new Set([...DEFAULT_IGNORE, ...(ignore || [])]));
+    }
+    /** 归一化快照指纹值：旧格式（纯 string = 仅 hash，size 未知用 -1 表示） */
+    normalizeFileValue(value) {
+        if (typeof value === 'string') {
+            return { hash: value, size: -1 };
+        }
+        return value;
+    }
+    /**
+     * 是否命中忽略规则：
+     * - 目录模式（结尾 /）：匹配该目录及其下所有
+     * - glob（含 **）：转换为正则匹配相对路径
+     * - 其余：精确/前缀匹配
+     */
+    isIgnored(relPath, ignore) {
+        const normalized = relPath.split(path_1.default.sep).join('/');
+        for (const pattern of ignore) {
+            if (this.matchPattern(normalized, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchPattern(relPath, pattern) {
+        const p = pattern.trim();
+        if (!p) {
+            return false;
+        }
+        // 目录模式（结尾 /）：匹配目录本身及下所有内容
+        if (p.endsWith('/')) {
+            const prefix = p.slice(0, -1);
+            return relPath === prefix || relPath.startsWith(prefix + '/');
+        }
+        // glob（含 **）：把 ** 转成 .*，其余转义后整体匹配
+        if (p.includes('**')) {
+            const regexStr = '^' +
+                p.split('**').map(part => this.escapeRegExp(part)).join('.*') +
+                '$';
+            return new RegExp(regexStr).test(relPath);
+        }
+        // 精确匹配或前缀匹配（目录下的文件）
+        return relPath === p || relPath.startsWith(p + '/');
+    }
+    escapeRegExp(s) {
+        return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /** 解析当前 git commit（非 git 仓库或失败返回 undefined，不阻断） */
+    resolveGitCommit() {
+        try {
+            const out = (0, child_process_1.execSync)('git rev-parse HEAD', {
+                cwd: this.cwd,
+                stdio: 'pipe'
+            });
+            return out.toString().trim() || undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+}
+exports.StateStore = StateStore;

package/lib/deploy/StaticDeployer.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticDeployer = void 0;
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const error_1 = require("../error");
+const framework_1 = require("./framework");
+/** 环境变量值统一转字符串（execSync env 要求 string） */
+function stringifyEnvValues(envVariables) {
+    const result = {};
+    if (envVariables) {
+        for (const [key, value] of Object.entries(envVariables)) {
+            result[key] = String(value);
+        }
+    }
+    return result;
+}
+/**
+ * app/hosting 声明式部署器
+ *
+ * app：framework=static → 直传产物 + SkipBuild 写记录（对齐 tcb app deploy 纯静态分支）；
+ *      其余 framework → 云端构建（上传源码 → 云端构建 → 写版本记录），与现有 tcb app deploy 一致
+ * hosting：固定静态流程（buildCommand 非空则本地构建后直传），不写版本记录（现有 tcb hosting deploy 行为）
+ */
+class StaticDeployer {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    /**
+     * app 部署（与现有 tcb app deploy 一致）
+     *
+     * framework=static：直传产物（hosting uploadFiles）+ createApp(SkipBuild) 后台写部署记录，跳过云端构建。
+     * 其余 framework：上传源码 ZIP → createApp 云端构建 → 写版本记录。
+     */
+    async deployApp(options) {
+        const { config, cwd = process.cwd() } = options;
+        const serviceName = config.serviceName;
+        if (!serviceName) {
+            throw new error_1.CloudBaseError('app 部署需要配置 serviceName');
+        }
+        const projectPath = path_1.default.resolve(cwd, config.root || '.');
+        const resolvedDeployPath = config.deployPath || `/${serviceName}`;
+        // 纯静态：直传产物 + SkipBuild 写记录（对齐 tcb app deploy 的 deployStaticApp 分支）
+        if (config.framework === 'static') {
+            return this.deployAppStatic({ config, serviceName, projectPath, resolvedDeployPath });
+        }
+        return this.deployAppCloud(config, serviceName, projectPath);
+    }
+    /**
+     * hosting 部署（固定静态流程，不写版本记录）
+     *
+     * 支持本地构建（对齐 Netlify）：buildCommand 非空时自动执行 install + build 后上传产物；
+     * 纯静态（buildCommand 空/未配置且无法检测框架）时直接上传 outputDir（默认 root，保持现状）。
+     * 访问地址 = https://{CdnDomain}{deployPath}（与 tcb hosting deploy 一致）
+     */
+    async deployHosting(options) {
+        const { config, cwd = process.cwd() } = options;
+        const name = config.name || 'default';
+        const root = path_1.default.resolve(cwd, config.root || '.');
+        const cloudPath = config.deployPath || '/';
+        // 1. 解析构建命令：显式 buildCommand > framework 映射 > package.json 自动探测 > null（纯静态）
+        const buildCommand = (0, framework_1.resolveBuildCommand)(config, root);
+        // 2. 有构建命令 → 本地构建（install + build）；纯静态 → 跳过构建直接上传
+        if (buildCommand) {
+            this.runLocalBuild(root, Object.assign(Object.assign({}, config), { buildCommand }), config.envVariables);
+        }
+        // 3. outputDir：由 framework.resolveHostingOutputDir 统一解析，
+        //    确保与 DeployOrchestrator(buildHostingPlans/persistState) 保持一致。
+        const outputDir = (0, framework_1.resolveHostingOutputDir)(config, root);
+        const hostingOptions = {
+            localPath: outputDir,
+            cloudPath,
+            ignore: config.ignore || ['.DS_Store']
+        };
+        await this.environment.getHostingService().uploadFiles(hostingOptions);
+        const url = await this.resolveHostingUrl(cloudPath);
+        return { name, url, wroteRecord: false };
+    }
+    /**
+     * app 纯静态直传（对齐 tcb app deploy 的 deployStaticApp 分支）
+     *
+     * 1. hosting uploadFiles 直传产物（文件级上传，立即可访问，无需打 ZIP）
+     * 2. 后台异步 createApp(SkipBuild) 写部署记录（失败不影响文件访问）
+     * 3. 跳过云端构建轮询，返回访问地址
+     */
+    async deployAppStatic(options) {
+        const { config, serviceName, projectPath, resolvedDeployPath } = options;
+        const cloudAppService = this.environment.getCloudAppService();
+        // 1. 直传产物（outputDir 默认项目根；cloudPath 与云端构建分支的 deployCmd 保持一致，
+        //    避免同一服务名切换构建/纯静态时访问路径漂移）
+        //    默认排除 node_modules（对齐 CLI 纯静态 DEFAULT_APP_IGNORE），避免产物目录含依赖时上传失控
+        const uploadDir = path_1.default.resolve(projectPath, config.outputDir || '.');
+        await this.environment.getHostingService().uploadFiles({
+            localPath: uploadDir,
+            cloudPath: resolvedDeployPath,
+            ignore: ['.DS_Store', 'node_modules/**', '**/.DS_Store', ...(config.ignore || [])]
+        });
+        // 2. 后台异步写部署记录（fire-and-forget：文件已直传，记录失败不影响访问）
+        const recordTask = (async () => {
+            try {
+                const uploadResult = await cloudAppService.uploadCode({
+                    deployType: 'static-hosting',
+                    serviceName,
+                    localPath: projectPath,
+                    ignore: ['.git/**', ...(config.ignore || [])]
+                });
+                await cloudAppService.createApp({
+                    deployType: 'static-hosting',
+                    serviceName,
+                    buildType: 'ZIP',
+                    skipBuild: true,
+                    staticConfig: {
+                        cosTimestamp: uploadResult.unixTimestamp,
+                        appPath: resolvedDeployPath,
+                        framework: config.framework,
+                        staticCmd: {
+                            installCmd: '',
+                            buildCmd: '',
+                            deployCmd: `tcb hosting deploy ${config.outputDir || '.'} ${resolvedDeployPath}`
+                        }
+                    }
+                });
+            }
+            catch (_a) {
+                // 部署记录写入失败不影响已上传的文件访问
+            }
+        })();
+        recordTask.catch(() => { });
+        // 3. 访问地址：静态托管 CDN 域名 + 部署路径（与 tcb app deploy 纯静态分支一致）
+        const url = await this.resolveHostingUrl(resolvedDeployPath);
+        return { name: serviceName, url, wroteRecord: true };
+    }
+    /**
+     * app 云端构建：上传源码 ZIP → createApp 云端构建 → 写版本记录
+     */
+    async deployAppCloud(config, serviceName, projectPath) {
+        const cloudAppService = this.environment.getCloudAppService();
+        const uploadResult = await cloudAppService.uploadCode({
+            deployType: 'static-hosting',
+            serviceName,
+            localPath: projectPath,
+            // 云端构建：不排除 node_modules（云端 install 需要私有/离线依赖随包上传）
+            excludeNodeModules: false,
+            ignore: ['.git/**', ...(config.ignore || [])]
+        });
+        await cloudAppService.createApp({
+            deployType: 'static-hosting',
+            serviceName,
+            buildType: 'ZIP',
+            staticConfig: {
+                cosTimestamp: uploadResult.unixTimestamp,
+                appPath: config.deployPath || `/${serviceName}`,
+                staticCmd: {
+                    installCmd: config.installCommand || 'npm install',
+                    buildCmd: config.buildCommand || 'npm run build',
+                    deployCmd: `tcb hosting deploy ${config.outputDir || 'dist'} ${config.deployPath || `/${serviceName}`}`
+                }
+            }
+        });
+        const url = await this.resolveAppUrl(serviceName, config.deployPath || `/${serviceName}`);
+        return { name: serviceName, url, wroteRecord: true };
+    }
+    /**
+     * 解析 hosting 访问地址：https://{CdnDomain}{deployPath}
+     */
+    async resolveHostingUrl(cloudPath) {
+        var _a;
+        try {
+            const info = await this.environment.getHostingService().getInfo();
+            const cdnDomain = (_a = info === null || info === void 0 ? void 0 : info[0]) === null || _a === void 0 ? void 0 : _a.CdnDomain;
+            if (!cdnDomain) {
+                return undefined;
+            }
+            const normalizedPath = cloudPath.startsWith('/') ? cloudPath : `/${cloudPath}`;
+            return `https://${cdnDomain}${normalizedPath}`;
+        }
+        catch (_b) {
+            return undefined;
+        }
+    }
+    /**
+     * 本地构建（install + build）
+     *
+     * - installCommand：默认 npm install，显式空字符串跳过安装
+     * - buildCommand：由调用方保证非空（hosting 经 resolveBuildCommand 判定；app local 由 if 判定）
+     * - envVariables：注入构建进程环境变量（值统一转字符串）
+     */
+    runLocalBuild(projectPath, config, envVariables) {
+        var _a;
+        const installCommand = (_a = config.installCommand) !== null && _a !== void 0 ? _a : 'npm install';
+        const buildCommand = config.buildCommand || '';
+        const env = Object.assign(Object.assign({}, process.env), stringifyEnvValues(envVariables));
+        const commands = [];
+        if (installCommand) {
+            commands.push({ cmd: installCommand, label: '安装依赖' });
+        }
+        if (buildCommand) {
+            commands.push({ cmd: buildCommand, label: '构建' });
+        }
+        try {
+            for (const { cmd } of commands) {
+                (0, child_process_1.execSync)(cmd, { cwd: projectPath, stdio: 'inherit', env });
+            }
+        }
+        catch (e) {
+            const detail = ((e === null || e === void 0 ? void 0 : e.stderr) || (e === null || e === void 0 ? void 0 : e.stdout) || (e === null || e === void 0 ? void 0 : e.message) || String(e)).toString().trim();
+            const executed = commands.map(c => c.cmd).join('」或「');
+            throw new error_1.CloudBaseError(`本地构建失败：在 ${projectPath} 执行「${executed}」失败。\n` +
+                `请先在项目目录手动执行该命令排查原因（常见原因：npm registry 网络不可达、依赖安装权限、lockfile 不一致）。\n` +
+                (detail ? `原始错误：${detail.slice(0, 500)}` : ''));
+        }
+    }
+    /**
+     * 解析 app 访问地址（describeAppInfo.Domain + appPath）
+     */
+    async resolveAppUrl(serviceName, appPath) {
+        try {
+            const appInfo = await this.environment.getCloudAppService().describeAppInfo({
+                deployType: 'static-hosting',
+                serviceName
+            });
+            if (!appInfo.Domain) {
+                return undefined;
+            }
+            const normalizedPath = appPath.startsWith('/') ? appPath : `/${appPath}`;
+            return `https://${appInfo.Domain}${normalizedPath}`;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+}
+exports.StaticDeployer = StaticDeployer;

package/lib/deploy/domain.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAccessServiceDomain = resolveAccessServiceDomain;
+exports.getGatewayBaseUrl = getGatewayBaseUrl;
+/** 环境 HTTP 访问服务默认域名后缀（如 `xxx-1326375956.ap-shanghai.${ACCESS_DOMAIN_SUFFIX}`） */
+const ACCESS_DOMAIN_SUFFIX = 'app.tcloudbase.com';
+/**
+ * 构造环境 HTTP 访问服务默认域名 `${envId}-${AppId}.${region}.${ACCESS_DOMAIN_SUFFIX}`
+ *
+ * 关键：用 `UserInfo.AppId`（腾讯云 appid）而非 `UserInfo.Uin`（账号 uin）。
+ * 控制台默认域名格式是 `${envId}-${AppId}.${region}.${ACCESS_DOMAIN_SUFFIX}`
+ * （如 `xxx-1326375956.ap-shanghai.app.tcloudbase.com`），与 cookie 中的 `appid` 字段对应。
+ * AppId/Region 缺失或查询失败时返回 undefined
+ */
+async function resolveAccessServiceDomain(environment, envId) {
+    var _a;
+    try {
+        const { EnvInfo } = await environment.getEnvService().getEnvInfo();
+        const appId = (_a = EnvInfo === null || EnvInfo === void 0 ? void 0 : EnvInfo.UserInfo) === null || _a === void 0 ? void 0 : _a.AppId;
+        const region = EnvInfo === null || EnvInfo === void 0 ? void 0 : EnvInfo.Region;
+        if (appId && region) {
+            return `${envId}-${appId}.${region}.${ACCESS_DOMAIN_SUFFIX}`;
+        }
+    }
+    catch (_b) {
+        // getEnvInfo 失败，忽略
+    }
+    return undefined;
+}
+/**
+ * 构造网关基础地址 `https://{envId}.api.tcloudbasegateway.com`
+ *
+ * 对齐 CLI 的 `EDomain.Gateway`：`isInternalEndpoint` 决定是否国际站域名
+ * （`api.intl.tcloudbasegateway.com`）。
+ */
+function getGatewayBaseUrl(environment, envId) {
+    const host = environment.cloudBaseContext.isInternalEndpoint()
+        ? `${envId}.api.intl.tcloudbasegateway.com`
+        : `${envId}.api.tcloudbasegateway.com`;
+    return `https://${host}`;
+}