@cloudbase/manager-node 5.8.3 → 5.8.4

package/types/deploy/function/config-guard.d.ts

@@ -22,6 +22,24 @@ export declare function parseImageReference(reference: string): IParsedImageRefe
 export declare function normalizeGatewayPath(input: string): string | null;
 /** 判断是否为自定义镜像运行时 */
 export declare function isCustomImageRuntime(runtime?: string): boolean;
+/**
+ * 应用最小化镜像配置的可安全默认值，不执行 IO，不生成凭证。
+ * 仅填充构建上下文、仓库名、namespace 和运行时固定值；用户凭证必须显式传入。
+ *
+ * 直接在 cloudbaserc 的嵌套形状上操作：镜像字段位于 imageConfig，构建目标位于
+ * imageConfig.build，不再做字段平铺映射。
+ */
+export declare function applyMinimalDeployConfigDefaults(config: IFunctionDeployConfig, context?: import('../types').IMinimalDeployConfigContext): IFunctionDeployConfig;
+/**
+ * 返回最小化部署在当前配置下仍缺失的输入字段；不执行网络、文件或凭证操作。
+ */
+export declare function getMissingDeployInputs(config: IFunctionDeployConfig, context?: {
+    envId?: string;
+}): import('../types').IDeployInputField[];
+/**
+ * 生成最小化配置准备结果：先应用安全默认值，再返回剩余缺失字段和默认值路径。
+ */
+export declare function prepareMinimalDeployConfig(config: IFunctionDeployConfig, context?: import('../types').IMinimalDeployConfigContext): import('../types').IMinimalDeployConfigResult;
 /**
  * 规范化部署配置
  *

package/types/deploy/function/enterprise-tcr.d.ts

@@ -17,12 +17,12 @@ export interface IEnterpriseTcrCredential {
     username: string;
     token: string;
 }
-export declare function prepareEnterpriseTcrTarget(config: EnterpriseBuildConfig, options: {
+export declare function prepareEnterpriseTcrTarget<T extends EnterpriseBuildConfig>(config: T, options: {
     envId: string;
     region: string;
     service: ITcrApiService;
 }): Promise<{
-    config: EnterpriseBuildConfig;
+    config: T;
     target: IEnterpriseTcrTarget;
 }>;
 export declare function createEnterpriseTcrCredential(service: ITcrApiService, registryId: string): Promise<IEnterpriseTcrCredential>;

package/types/deploy/types.d.ts

@@ -1,4 +1,4 @@
-import { ICloudFunctionTrigger, IFunctionImageConfig, IFunctionVPC } from '../interfaces';
+import { ICloudFunctionTrigger, IFunctionVPC } from '../interfaces';
 /**
  * 镜像 HTTP 函数固定监听端口
  * SCF HTTP 自定义镜像函数要求容器监听 9000
@@ -295,15 +295,29 @@ export interface IImageBuildTarget {
     /** 个人版 TCR 保留的最新镜像标签数量 */
     retainedTags?: number;
 }
-/** HTTP 自定义镜像公共配置 */
-export interface IHttpImageRuntimeCommon extends IHttpFunctionDeployCommon {
-    runtime?: typeof CUSTOM_IMAGE_RUNTIME;
-    /** 容器监听端口，仅允许 9000 */
-    imagePort?: number;
+/**
+ * 声明式镜像运行时配置
+ *
+ * 直接对齐 toolbox schema 的 ICloudBaseFunctionImageConfig：镜像相关字段全部
+ * 收敛在 imageConfig 命名空间下，构建目标进一步嵌套在 imageConfig.build。
+ * manager-node 直接消费该形状，不再做字段平铺映射。
+ */
+export interface IDeployImageConfig {
     /** 镜像类型；省略时有 registryId 推断为 enterprise，否则推断为 personal */
     imageType?: 'enterprise' | 'personal';
-    /** 企业版 TCR 实例 ID 的运行时规范位置；个人版镜像不传 */
+    /** 已有镜像地址，image 策略必填 */
+    imageUri?: string;
+    /** 企业版 TCR 实例 ID；个人版镜像不传 */
     registryId?: string;
+    /** 镜像构建目标，cloud/local 策略必填 */
+    build?: IImageBuildTarget;
+    /**
+     * 本地构建环境不可用时的处理方式
+     * 默认 error，避免静默改变构建环境
+     */
+    localFallback?: 'cloud' | 'error';
+    /** 容器监听端口，仅允许 9000 */
+    imagePort?: number;
     entryPoint?: string;
     command?: string;
     args?: string;
@@ -311,29 +325,59 @@ export interface IHttpImageRuntimeCommon extends IHttpFunctionDeployCommon {
     argsList?: string[];
     containerImageAccelerate?: boolean;
 }
+/** HTTP 自定义镜像公共配置 */
+export interface IHttpImageRuntimeCommon extends IHttpFunctionDeployCommon {
+    runtime?: typeof CUSTOM_IMAGE_RUNTIME;
+    /** 镜像运行时配置，对齐 toolbox schema 的嵌套形状 */
+    imageConfig?: IDeployImageConfig;
+}
 /** 云端构建镜像部署 */
 export interface IHttpCloudDeployConfig extends IHttpImageRuntimeCommon {
     buildStrategy: 'cloud';
-    build: IImageBuildTarget;
+    imageConfig: IDeployImageConfig;
 }
 /** 本地构建镜像部署 */
 export interface IHttpLocalDeployConfig extends IHttpImageRuntimeCommon {
     buildStrategy: 'local';
-    build: IImageBuildTarget;
-    /**
-     * 本地构建环境不可用时的处理方式
-     * 默认 error，避免静默改变构建环境
-     */
-    localFallback?: 'cloud' | 'error';
+    imageConfig: IDeployImageConfig;
 }
 /** 已有镜像直接部署 */
 export interface IHttpImageDeployConfig extends IHttpImageRuntimeCommon {
     buildStrategy: 'image';
-    imageConfig: IFunctionImageConfig;
+    imageConfig: IDeployImageConfig;
 }
 export type IHttpFunctionDeployConfig = IHttpZipDeployConfig | IHttpCloudDeployConfig | IHttpLocalDeployConfig | IHttpImageDeployConfig;
 export type IFunctionDeployConfig = IEventFunctionDeployConfig | IHttpFunctionDeployConfig;
-/** 规范化后的 Event 配置 */
+export interface IDeployInputField {
+    /** 稳定字段名，供 CLI/MCP 决定如何收集输入 */
+    name: 'envId' | 'imageUri' | 'registryId' | 'repository' | 'namespace' | 'registryCredential.username' | 'registryCredential.password';
+    /** 配置中的字段路径 */
+    path: string;
+    /** 是否必须补齐才能继续部署 */
+    required: boolean;
+    /** 面向调用方的原因，不包含敏感信息 */
+    reason: string;
+}
+/** 最小化镜像配置的默认值上下文 */
+export interface IMinimalDeployConfigContext {
+    envId?: string;
+    functionPath?: string;
+    functionRootPath?: string;
+    /** 调用方明确提供的非交互默认值；密码等敏感值只在显式传入时使用 */
+    defaults?: {
+        imageUri?: string;
+        registryId?: string;
+        repository?: string;
+        namespace?: string;
+        registryCredential?: IRegistryCredential;
+    };
+}
+/** 最小化配置准备结果 */
+export interface IMinimalDeployConfigResult {
+    config: IFunctionDeployConfig;
+    missing: IDeployInputField[];
+    appliedDefaults: string[];
+}
 export type INormalizedEventConfig = IEventFunctionDeployConfig & {
     type: 'Event';
     buildStrategy: 'zip';
@@ -348,22 +392,34 @@ export type INormalizedHttpCloudConfig = IHttpCloudDeployConfig & {
     type: 'HTTP';
     buildStrategy: 'cloud';
     runtime: typeof CUSTOM_IMAGE_RUNTIME;
-    imagePort: number;
+    imageConfig: IDeployImageConfig & {
+        imagePort: number;
+        imageType: 'enterprise' | 'personal';
+        build: IImageBuildTarget;
+    };
 };
 /** 规范化后的 HTTP 本地构建配置 */
 export type INormalizedHttpLocalConfig = IHttpLocalDeployConfig & {
     type: 'HTTP';
     buildStrategy: 'local';
     runtime: typeof CUSTOM_IMAGE_RUNTIME;
-    imagePort: number;
-    localFallback: 'cloud' | 'error';
+    imageConfig: IDeployImageConfig & {
+        imagePort: number;
+        imageType: 'enterprise' | 'personal';
+        build: IImageBuildTarget;
+        localFallback: 'cloud' | 'error';
+    };
 };
 /** 规范化后的 HTTP 已有镜像配置 */
 export type INormalizedHttpImageConfig = IHttpImageDeployConfig & {
     type: 'HTTP';
     buildStrategy: 'image';
     runtime: typeof CUSTOM_IMAGE_RUNTIME;
-    imagePort: number;
+    imageConfig: IDeployImageConfig & {
+        imagePort: number;
+        imageType: 'enterprise' | 'personal';
+        imageUri: string;
+    };
 };
 export type INormalizedDeployConfig = INormalizedEventConfig | INormalizedHttpZipConfig | INormalizedHttpCloudConfig | INormalizedHttpLocalConfig | INormalizedHttpImageConfig;
 /** 代码类部署物 */

package/types/projectValidator/types.d.ts

@@ -14,7 +14,6 @@ export interface ProjectValidationSummary {
 }
 export interface ProjectValidationResult {
     valid: boolean;
-    version: string;
     errors: ProjectValidationIssue[];
     warnings: ProjectValidationIssue[];
     summary: ProjectValidationSummary;

package/lib/deploy/StateStore.js

@@ -1,328 +0,0 @@
-"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(),
-            envId: state.envId,
-            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;