@cloudbase/manager-node 5.6.0 → 5.6.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## @cloudbase/manager-node v5.6.0 版本发布 🚀(2026-07-07)
+
+- 新增 integration
+- 修复测试用例
+
+---
+
 ## @cloudbase/manager-node v5.5.7 版本发布 🚀(2026-06-30)
 
 - 优化云存储上传逻辑，解决 socket hang up 问题

package/lib/cloudrun/index.js

@@ -250,7 +250,7 @@ class CloudRunService {
      */
     async deploy(params) {
         var _a;
-        const { serverName, targetPath = process.cwd(), serverConfig } = params;
+        const { serverName, targetPath = process.cwd(), serverConfig, vpcInfo } = params;
         /**
          * 参数校验和默认值设置
          */
@@ -335,7 +335,8 @@ class CloudRunService {
             return this._upsertFunction(true, {
                 name: serverName,
                 deployInfo,
-                serverConfig: _serverConfig
+                serverConfig: _serverConfig,
+                vpcInfo
             });
         }
     }
@@ -398,15 +399,20 @@ class CloudRunService {
         }
     }
     _upsertFunction(isNew, data) {
-        const { name, deployInfo, serverConfig } = data;
+        const { name, deployInfo, serverConfig, vpcInfo } = data;
         const envConfig = this.environment.lazyEnvironmentConfig;
         const Items = parseObjectToDiffConfigItem(serverConfig);
-        return this.tcbrService.request(isNew ? 'CreateCloudRunServer' : 'UpdateCloudRunServer', {
+        const basePayload = {
             EnvId: envConfig.EnvId,
             ServerName: name,
             DeployInfo: deployInfo,
             Items,
-        });
+        };
+        // CreateCloudRunServer 支持传入 VpcInfo（仅创建时有效）
+        if (isNew && vpcInfo) {
+            basePayload.VpcInfo = vpcInfo;
+        }
+        return this.tcbrService.request(isNew ? 'CreateCloudRunServer' : 'UpdateCloudRunServer', basePayload);
     }
 }
 exports.CloudRunService = CloudRunService;
@@ -550,6 +556,15 @@ function parseObjectToDiffConfigItem(data) {
         else if (['TimerScale'].includes(k)) {
             Items.push({ Key, TimerScale: v });
         }
+        else if (['VpcConf'].includes(k)) {
+            Items.push({ Key, VpcConf: v });
+        }
+        else if (['VolumesConf'].includes(k)) {
+            Items.push({ Key, VolumesConf: v });
+        }
+        else if (['PublicNetConf'].includes(k)) {
+            Items.push({ Key, PublicNetConf: v });
+        }
     });
     return Items;
 }

package/lib/env/index.js

@@ -139,7 +139,7 @@ class EnvService {
      * @returns {Promise<IEnvInfoRes>}
      */
     async getEnvInfo() {
-        var _a;
+        var _a, _b;
         // 使用 DescribeEnvInfo 进行单环境查询
         const params = {
             EnvId: this.envId
@@ -147,6 +147,7 @@ class EnvService {
         const response = await this.describeEnvInfo(params);
         const envBaseInfo = (_a = response === null || response === void 0 ? void 0 : response.EnvInfo) === null || _a === void 0 ? void 0 : _a.EnvBaseInfo;
         // 将 EnvBaseInfo 完整映射到 EnvInfo 类型，避免新增字段被丢弃
+        // UserInfo 位于 response.EnvInfo 顶层（非 EnvBaseInfo），单独映射
         const envInfo = {
             EnvId: envBaseInfo.EnvId,
             Alias: envBaseInfo.Alias,
@@ -176,7 +177,8 @@ class EnvService {
             EnvPreferences: envBaseInfo.EnvPreferences,
             Meta: envBaseInfo.Meta,
             PostgreSQL: envBaseInfo.PostgreSQL,
-            EnvStatus: envBaseInfo.EnvStatus
+            EnvStatus: envBaseInfo.EnvStatus,
+            UserInfo: (_b = response === null || response === void 0 ? void 0 : response.EnvInfo) === null || _b === void 0 ? void 0 : _b.UserInfo
         };
         return {
             EnvInfo: envInfo,

package/lib/function/index.js

@@ -1506,7 +1506,7 @@ class FunctionService {
         const { func, functionPath, functionRootPath } = options;
         const { env, appId } = this.getFunctionConfig();
         if (!appId) {
-            throw new error_1.CloudBaseError('无法获取 AppId，请确认环境已开通存储服务');
+            throw new error_1.CloudBaseError('无法获取 AppId，请确认环境初始化完成或已开通存储服务');
         }
         const objectPath = `${appId}/${env}/${func.name}.zip`;
         // 1. 生成存放函数包的临时 Cos 目录
@@ -1742,14 +1742,18 @@ class FunctionService {
      * @memberof FunctionService
      */
     getFunctionConfig() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         const envConfig = this.environment.lazyEnvironmentConfig;
         // Functions 可能为空
         const namespace = ((_b = (_a = envConfig.Functions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.Namespace) || '';
-        // AppId 可能为空字符串，从 Bucket 名称中提取
+        // AppId 优先从 DescribeEnvInfo 的 UserInfo 获取（账号级标识，不依赖存储服务）
+        // 兜底从 Storages[0] 的 AppId 或 Bucket 名提取
         // COS Bucket 格式: {BucketName}-{APPID}，APPID 为纯数字
         const storage = (_c = envConfig.Storages) === null || _c === void 0 ? void 0 : _c[0];
-        const appId = (storage === null || storage === void 0 ? void 0 : storage.AppId) || ((_e = (_d = storage === null || storage === void 0 ? void 0 : storage.Bucket) === null || _d === void 0 ? void 0 : _d.match(/-(\d+)$/)) === null || _e === void 0 ? void 0 : _e[1]) || '';
+        const appId = ((_d = envConfig.UserInfo) === null || _d === void 0 ? void 0 : _d.AppId)
+            || (storage === null || storage === void 0 ? void 0 : storage.AppId)
+            || ((_f = (_e = storage === null || storage === void 0 ? void 0 : storage.Bucket) === null || _e === void 0 ? void 0 : _e.match(/-(\d+)$/)) === null || _f === void 0 ? void 0 : _f[1])
+            || '';
         const { proxy } = this.environment.cloudBaseContext;
         return {
             proxy,

package/lib/integration/crypto.js

@@ -0,0 +1,102 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AESCrypto = void 0;
+exports.aesEncryptWithIv = aesEncryptWithIv;
+/**
+ * 集成中心 AES 加解密
+ *
+ * 与 dev-platform 控制台的 AESCrypto（crypto-js）完全对齐，保证密文可互相解出：
+ * - 算法：AES-256-CBC
+ * - key：32 字节（按 UTF-8 解析）
+ * - IV：每次随机 16 字节
+ * - padding：PKCS7
+ * - 密文格式：base64(IV) + base64(ciphertext)
+ *   （IV 固定 16 字节 → base64 长度恒为 24，前 24 字符即 IV）
+ *
+ * 使用 Node 内置 crypto 复刻，无需引入额外依赖。
+ */
+const crypto = __importStar(require("crypto"));
+const ALGORITHM = 'aes-256-cbc';
+const KEY_BYTE_LENGTH = 32;
+const IV_BYTE_LENGTH = 16;
+/** base64(16 字节) 的固定长度 */
+const IV_BASE64_LENGTH = 24;
+function assertKey(key) {
+    if (Buffer.byteLength(key, 'utf8') !== KEY_BYTE_LENGTH) {
+        throw new Error('AES key 必须是 32 字节长度');
+    }
+}
+/**
+ * 使用指定 IV 加密（供测试与内部使用，保证可重现）
+ */
+function aesEncryptWithIv(plaintext, key, iv) {
+    assertKey(key);
+    if (iv.length !== IV_BYTE_LENGTH) {
+        throw new Error('IV 必须是 16 字节长度');
+    }
+    const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(key, 'utf8'), iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    return iv.toString('base64') + encrypted.toString('base64');
+}
+class AESCryptoImpl {
+    /**
+     * AES-256-CBC 加密，返回 base64(IV)+base64(密文)
+     */
+    encrypt(plaintext, key) {
+        assertKey(key);
+        const iv = crypto.randomBytes(IV_BYTE_LENGTH);
+        return aesEncryptWithIv(plaintext, key, iv);
+    }
+    /**
+     * 解密 base64(IV)+base64(密文) 格式的密文
+     */
+    decrypt(encryptedData, key) {
+        assertKey(key);
+        const ivBase64 = encryptedData.slice(0, IV_BASE64_LENGTH);
+        const ciphertextBase64 = encryptedData.slice(IV_BASE64_LENGTH);
+        const iv = Buffer.from(ivBase64, 'base64');
+        if (iv.length !== IV_BYTE_LENGTH) {
+            throw new Error('密文格式错误：IV 长度非法');
+        }
+        const decipher = crypto.createDecipheriv(ALGORITHM, Buffer.from(key, 'utf8'), iv);
+        const decrypted = Buffer.concat([
+            decipher.update(Buffer.from(ciphertextBase64, 'base64')),
+            decipher.final()
+        ]);
+        return decrypted.toString('utf8');
+    }
+}
+exports.AESCrypto = new AESCryptoImpl();

package/lib/integration/index.js

@@ -24,15 +24,18 @@ exports.IntegrationService = void 0;
 const error_1 = require("../error");
 const utils_1 = require("../utils");
 const constants_1 = require("./constants");
+const crypto_1 = require("./crypto");
+const secretKey_1 = require("./secretKey");
 __exportStar(require("./types"), exports);
 /**
  * 集成中心（UserKey）服务
  *
  * 复用现有 tcb 云 API（version 2018-06-08），统一携带 Business='integration'。
  *
- * 本服务只做云 API 的纯封装：不识别模板字段、不做敏感字段加解密、不做
- * "绑定资源"这类编排逻辑——这些依赖模板结构 / 七彩石密钥 / 上层交互，
- * 由调用方（CLI / 控制台）按各自场景自行编排后，通过 `ext` 传入最终 JSON 字符串。
+ * 提供两种使用模式：
+ * 1. 透传模式：直接传 `ext`（JSON 字符串），SDK 原样传递给云 API（向后兼容）
+ * 2. 自动加解密模式：传 `envVariables`（明文键值对），SDK 自动识别模板中的
+ *    password 字段、拉取七彩石密钥完成加密后拼装 ext
  */
 class IntegrationService {
     constructor(environment) {
@@ -66,36 +69,50 @@ class IntegrationService {
             Business: (_c = params.business) !== null && _c !== void 0 ? _c : constants_1.USER_KEY_BUSINESS // 默认 integration
         });
     }
-    /** 查询单个集成实例详情 */
+    /**
+     * 查询单个集成实例详情。
+     *
+     * 当 `decryptPwd=true` 时，SDK 自动拉取模板识别 password 字段并从七彩石
+     * 获取 AES 密钥解密，Ext 中 password 字段返回明文。解密失败时保留密文原值，
+     * 不中断流程。
+     */
     async getUserKey(params) {
-        var _a, _b;
+        var _a, _b, _c;
         this.validateRequiredParams(params, ['keyId']);
         const { envId } = this.getEnvInfo();
-        return this.tcbService.request('GetOneUserKey', {
+        const result = await this.tcbService.request('GetOneUserKey', {
             EnvId: envId,
             KeyID: params.keyId,
             NeedPwd: (_a = params.needPwd) !== null && _a !== void 0 ? _a : false,
             Business: (_b = params.business) !== null && _b !== void 0 ? _b : constants_1.USER_KEY_BUSINESS // 默认 integration
         });
+        // 自动解密 password 字段
+        if (params.decryptPwd && ((_c = result.UserKeyInfo) === null || _c === void 0 ? void 0 : _c.Ext)) {
+            result.UserKeyInfo = await this.decryptExtIfNeeded(result.UserKeyInfo, envId);
+        }
+        return result;
     }
     // =========== 写 API ===========
     /**
      * 创建集成实例。
      *
-     * `Ext` 为最终写入的 JSON 字符串，由调用方按模板字段自行拼装（含敏感字段
-     * 加密），本方法不做任何解析或加工，原样传递给云 API。
+     * 支持两种传参方式：
+     * - 传 `ext`：透传模式，原样传递给云 API（向后兼容，调用方自行加密）
+     * - 传 `envVariables`：自动加密模式，SDK 识别模板 password 字段并加密后拼装 ext
+     * - 两者都传时以 `ext` 优先
      */
     async createUserKey(params) {
         var _a;
         this.validateRequiredParams(params, ['name', 'authTypeCode']);
         const { envId } = this.getEnvInfo();
+        const ext = await this.buildExtFromParams(envId, params.authTypeCode, { ext: params.ext, envVariables: params.envVariables });
         return this.tcbService.request('CreateUserKey', {
             EnvId: envId,
             Name: params.name,
             KeyID: params.keyId,
             AuthTypeCode: params.authTypeCode,
             Description: params.description,
-            Ext: params.ext,
+            Ext: ext,
             TicketID: params.ticketId,
             Business: (_a = params.business) !== null && _a !== void 0 ? _a : constants_1.USER_KEY_BUSINESS, // 默认 integration
             DemoCodeFunctionName: params.demoCodeFunctionName,
@@ -105,20 +122,28 @@ class IntegrationService {
     /**
      * 更新集成实例。
      *
-     * `Ext` 为最终写入的 JSON 字符串，由调用方自行完成"与现有 Ext 合并"
-     * "敏感字段加密"等编排后传入；未传 `ext` 时后端保留原有 Ext 不变。
+     * 支持两种传参方式：
+     * - 传 `ext`：透传模式，原样传递给云 API（向后兼容）
+     * - 传 `envVariables`：自动加密模式，与现有 Ext 合并后加密写入
+     * - 两者都传时以 `ext` 优先
+     * - 都未传时后端保留原有 Ext 不变
      */
     async updateUserKey(params) {
         var _a;
         this.validateRequiredParams(params, ['keyId']);
         const { envId } = this.getEnvInfo();
+        let ext = params.ext;
+        // 传了 envVariables 且未传 ext：需要合并现有 Ext 后加密
+        if (params.envVariables && !params.ext) {
+            ext = await this.buildMergedExtForUpdate(envId, params.keyId, { authTypeCode: params.authTypeCode, envVariables: params.envVariables });
+        }
         return this.tcbService.request('UpdateUserKey', {
             EnvId: envId,
             KeyID: params.keyId,
             Name: params.name,
             AuthTypeCode: params.authTypeCode,
             Description: params.description,
-            Ext: params.ext,
+            Ext: ext,
             DemoCodeFunctionName: params.demoCodeFunctionName,
             Business: (_a = params.business) !== null && _a !== void 0 ? _a : constants_1.USER_KEY_BUSINESS, // 默认 integration
             RuntimeConfig: params.runtimeConfig
@@ -149,6 +174,163 @@ class IntegrationService {
             }
         }
     }
+    /**
+     * 根据 ext / envVariables 参数构造最终的 Ext JSON 字符串。
+     * ext 优先；envVariables 由 SDK 自动加密 password 字段。
+     */
+    async buildExtFromParams(envId, authTypeCode, opts) {
+        // ext 优先（透传模式）
+        if (opts.ext !== undefined) {
+            return opts.ext;
+        }
+        // 自动加密模式
+        if (opts.envVariables && Object.keys(opts.envVariables).length > 0) {
+            return this.encryptAndStringify(envId, authTypeCode, opts.envVariables);
+        }
+        return undefined;
+    }
+    /**
+     * 更新场景：将 envVariables 与现有实例的 Ext 合并后加密。
+     * 需要先查询现有实例获取当前的 authTypeCode 和 Ext。
+     */
+    async buildMergedExtForUpdate(envId, keyId, opts) {
+        var _a, _b;
+        const { envVariables, authTypeCode } = opts;
+        if (!envVariables || Object.keys(envVariables).length === 0) {
+            return undefined;
+        }
+        // 查询现有实例以合并 Ext
+        let existingExtObj = {};
+        let resolvedAuthTypeCode = authTypeCode;
+        try {
+            const existing = await this.getUserKey({
+                keyId,
+                needPwd: true,
+                decryptPwd: true, // 解密后方便合并
+                business: constants_1.USER_KEY_BUSINESS
+            });
+            const extObj = this.parseExt((_a = existing.UserKeyInfo) === null || _a === void 0 ? void 0 : _a.Ext);
+            existingExtObj = Object.assign({}, extObj);
+            resolvedAuthTypeCode = resolvedAuthTypeCode || ((_b = existing.UserKeyInfo) === null || _b === void 0 ? void 0 : _b.AuthTypeCode);
+        }
+        catch (_c) {
+            // 查询失败时仅使用传入的 envVariables
+        }
+        if (!resolvedAuthTypeCode) {
+            // 无法获取 authTypeCode，无法识别 password 字段，直接 JSON 序列化
+            return JSON.stringify(Object.assign(Object.assign({}, existingExtObj), envVariables));
+        }
+        // 合并：现有 Ext 为基础，envVariables 覆盖
+        const merged = Object.assign(Object.assign({}, existingExtObj), envVariables);
+        return this.encryptAndStringify(envId, resolvedAuthTypeCode, merged);
+    }
+    /**
+     * 加密 envVariables 中的 password 字段并返回 JSON 字符串。
+     * 无 password 字段时直接 JSON.stringify，不请求七彩石。
+     */
+    async encryptAndStringify(envId, authTypeCode, envVariables) {
+        // 1. 拉取模板，识别 password 字段
+        const passwordFieldNames = await this.getPasswordFieldNames(authTypeCode);
+        // 2. 判断是否有 password 字段需要加密
+        const hasPasswordValue = passwordFieldNames.some(name => envVariables[name]);
+        if (!hasPasswordValue) {
+            return JSON.stringify(envVariables);
+        }
+        // 3. 拉取 AES key 并加密
+        try {
+            const aesKey = await (0, secretKey_1.getAesKey)({ envId });
+            const encrypted = this.encryptPasswordFields(envVariables, passwordFieldNames, aesKey);
+            return JSON.stringify(encrypted);
+        }
+        catch (_a) {
+            // 获取密钥失败时以明文写入（与 CLI 行为一致）
+            return JSON.stringify(envVariables);
+        }
+    }
+    /**
+     * 解密 Ext 中的 password 字段并返回新的 IUserKeyInfo。
+     * 解密失败时保留原值，不中断流程。
+     */
+    async decryptExtIfNeeded(userKeyInfo, envId) {
+        if (!userKeyInfo.Ext || !userKeyInfo.AuthTypeCode)
+            return userKeyInfo;
+        try {
+            const passwordFieldNames = await this.getPasswordFieldNames(userKeyInfo.AuthTypeCode);
+            if (passwordFieldNames.length === 0)
+                return userKeyInfo;
+            const extObj = this.parseExt(userKeyInfo.Ext);
+            if (!Object.keys(extObj).length)
+                return userKeyInfo;
+            const hasPasswordValue = passwordFieldNames.some(name => extObj[name]);
+            if (!hasPasswordValue)
+                return userKeyInfo;
+            const aesKey = await (0, secretKey_1.getAesKey)({ envId });
+            const decrypted = this.decryptPasswordFields(extObj, passwordFieldNames, aesKey);
+            return Object.assign(Object.assign({}, userKeyInfo), { Ext: JSON.stringify(decrypted) });
+        }
+        catch (_a) {
+            return userKeyInfo;
+        }
+    }
+    /** 从模板中获取 password 类型字段名列表 */
+    async getPasswordFieldNames(authTypeCode) {
+        var _a, _b;
+        try {
+            const res = await this.listTemplates({ authTypeCode, limit: 1 });
+            const templateExt = (_b = (_a = res.KeyTemplateList) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.Ext;
+            if (!templateExt)
+                return [];
+            const parsed = JSON.parse(templateExt);
+            const fields = Array.isArray(parsed === null || parsed === void 0 ? void 0 : parsed.fields) ? parsed.fields : [];
+            return fields
+                .filter((f) => f && f.type === 'password' && typeof f.name === 'string')
+                .map((f) => f.name);
+        }
+        catch (_c) {
+            return [];
+        }
+    }
+    /** 解析 Ext JSON 字符串为对象，失败返回空对象 */
+    parseExt(ext) {
+        if (!ext)
+            return {};
+        try {
+            const parsed = JSON.parse(ext);
+            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+        }
+        catch (_a) {
+            return {};
+        }
+    }
+    /** 加密 ext 对象中的 password 字段（仅加密有值的字段），返回新对象 */
+    encryptPasswordFields(extObj, passwordFieldNames, aesKey) {
+        const result = Object.assign({}, extObj);
+        passwordFieldNames.forEach(name => {
+            const value = result[name];
+            if (name && value) {
+                result[name] = crypto_1.AESCrypto.encrypt(value, aesKey);
+            }
+        });
+        return result;
+    }
+    /** 解密 ext 对象中的 password 字段，解密失败保留原值，返回新对象 */
+    decryptPasswordFields(extObj, passwordFieldNames, aesKey) {
+        const result = Object.assign({}, extObj);
+        const MIN_CIPHERTEXT_LEN = 24; // base64(16 字节 IV) = 24 字符
+        passwordFieldNames.forEach(name => {
+            const encrypted = result[name];
+            if (typeof encrypted !== 'string' || encrypted.length <= MIN_CIPHERTEXT_LEN) {
+                return;
+            }
+            try {
+                result[name] = crypto_1.AESCrypto.decrypt(encrypted, aesKey);
+            }
+            catch (_a) {
+                // 解密失败保留原值，不中断流程
+            }
+        });
+        return result;
+    }
 }
 exports.IntegrationService = IntegrationService;
 __decorate([

package/lib/integration/secretKey.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAesKey = getAesKey;
+exports.__clearAesKeyCache = __clearAesKeyCache;
+/**
+ * 集成中心 AES key 获取（七彩石）
+ *
+ * 通过 QueryRainbowConfig 拉取 group=tcb-config（国内）/
+ * frontend.tcb-config（国际）下字段 dev-platform-apis 的值作为 AES-256-CBC 密钥。
+ *
+ * 安全约束：
+ * - key 仅在进程内存使用，按 group 维度缓存；
+ * - 绝不写入任何本地文件、绝不打印日志。
+ */
+const http_request_1 = require("../utils/http-request");
+const error_1 = require("../error");
+/** 七彩石配置 */
+const RAINBOW_CONFIG = {
+    ENV_TYPE: 'Default',
+    GROUP_CN: 'tcb-config',
+    GROUP_INTL: 'frontend.tcb-config',
+    /** AES key 在 kvs 中的字段名 */
+    CRYPTO_KEY_FIELD: 'dev-platform-apis'
+};
+const RAINBOW_HOST_CN = 'wedaapi.tcbautomation.cn';
+const RAINBOW_HOST_INTL = 'gray.decisiontcb.tencentcloud.com';
+/** 无 EnvId 时的占位 Uin */
+const FALLBACK_UIN = '3309033';
+/** 进程内缓存（按 group 维度），key 不落盘、不打印 */
+const keyCache = {};
+/**
+ * 获取集成中心 AES key（进程内缓存）
+ * @throws CloudBaseError 拉取或解析失败
+ */
+async function getAesKey(params = {}) {
+    var _a, _b;
+    const { envId, isIntl = false } = params;
+    const group = isIntl ? RAINBOW_CONFIG.GROUP_INTL : RAINBOW_CONFIG.GROUP_CN;
+    if (keyCache[group]) {
+        return keyCache[group];
+    }
+    const host = isIntl ? RAINBOW_HOST_INTL : RAINBOW_HOST_CN;
+    const url = `https://${host}/Graydecision/V1/QueryRainbowConfig?group=${group}`;
+    const payload = {
+        EnvType: RAINBOW_CONFIG.ENV_TYPE,
+        Group: group
+    };
+    if (envId) {
+        payload.EnvId = envId;
+    }
+    else {
+        payload.Uin = FALLBACK_UIN;
+    }
+    let resJson;
+    try {
+        resJson = await (0, http_request_1.fetch)(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload)
+        });
+    }
+    catch (e) {
+        throw new error_1.CloudBaseError('获取集成加解密密钥失败：七彩石配置拉取请求异常');
+    }
+    const data = (_a = resJson === null || resJson === void 0 ? void 0 : resJson.Response) === null || _a === void 0 ? void 0 : _a.Data;
+    if (!data || data.ErrorCode !== '0') {
+        throw new error_1.CloudBaseError(`获取集成加解密密钥失败：七彩石返回异常（ErrorCode=${data === null || data === void 0 ? void 0 : data.ErrorCode}）`);
+    }
+    let config;
+    try {
+        config = JSON.parse(data.ConfigValue)[0];
+    }
+    catch (e) {
+        throw new error_1.CloudBaseError('获取集成加解密密钥失败：七彩石配置内容解析失败');
+    }
+    const kvs = ((_b = config === null || config === void 0 ? void 0 : config.kvs) === null || _b === void 0 ? void 0 : _b.kvs) || [];
+    const target = kvs.find(kv => kv.key === RAINBOW_CONFIG.CRYPTO_KEY_FIELD);
+    const key = target === null || target === void 0 ? void 0 : target.value;
+    if (!key) {
+        throw new error_1.CloudBaseError(`获取集成加解密密钥失败：七彩石配置中缺少 ${RAINBOW_CONFIG.CRYPTO_KEY_FIELD} 字段`);
+    }
+    keyCache[group] = key;
+    return key;
+}
+/** 清空进程内缓存（仅供测试使用） */
+function __clearAesKeyCache() {
+    Object.keys(keyCache).forEach(k => delete keyCache[k]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "5.6.0",
+    "version": "5.6.1",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/types/cloudrun/index.d.ts

@@ -1,6 +1,6 @@
 import { Environment } from '../environment';
 import { IResponseInfo } from '../interfaces';
-import { CloudrunServerType, ICloudrunDetailResponse, ICloudrunListResponse, ICloudrunServerBaseConfig, ICloudrunServerBaseInfo, IBuildLogResponse, IProcessLogResponse, IDiffConfigItem, ITemplate, ReleaseTypeEnum, IDescribeCloudRunDeployRecordResponse } from './type';
+import { CloudrunServerType, ICloudrunDetailResponse, ICloudrunListResponse, ICloudrunServerBaseConfig, ICreateVpcInfo, IBuildLogResponse, IProcessLogResponse, IDiffConfigItem, ITemplate, ReleaseTypeEnum, IDescribeCloudRunDeployRecordResponse } from './type';
 /**
  * 云托管服务管理类
  * 提供云托管服务的初始化、下载、列表查询和删除等功能
@@ -128,7 +128,8 @@ export declare class CloudRunService {
         deployInfo: {
             ReleaseType: ReleaseTypeEnum;
         };
-        serverConfig?: Partial<Pick<ICloudrunServerBaseConfig, 'OpenAccessTypes' | 'Cpu' | 'Mem' | 'MinNum' | 'MaxNum' | 'PolicyDetails' | 'CustomLogs' | 'EnvParams' | 'Port' | 'Dockerfile' | 'BuildDir' | 'InternalAccess' | 'InternalDomain' | 'EntryPoint' | 'Cmd' | 'InstallDependency'>>;
+        vpcInfo?: ICreateVpcInfo;
+        serverConfig?: Partial<Pick<ICloudrunServerBaseConfig, 'OpenAccessTypes' | 'Cpu' | 'Mem' | 'MinNum' | 'MaxNum' | 'PolicyDetails' | 'CustomLogs' | 'EnvParams' | 'Port' | 'Dockerfile' | 'BuildDir' | 'InternalAccess' | 'InternalDomain' | 'EntryPoint' | 'Cmd' | 'InstallDependency' | 'OperationMode' | 'SessionAffinity' | 'LogType' | 'LogSetId' | 'LogTopicId' | 'LogParseType' | 'Tag' | 'TimerScale' | 'VpcConf' | 'VolumesConf' | 'PublicNetConf'>>;
     }): Promise<IResponseInfo>;
     /**
      * 获取云托管服务模板列表
@@ -157,4 +158,4 @@ export declare function codeToZip(cwd: string, options?: {
 /**
  * 将 object 参数转为 [{key:"Port", IntValue:80}] 的格式，并且剔除空字符串
  */
-export declare function parseObjectToDiffConfigItem(data: Partial<ICloudrunServerBaseInfo>): IDiffConfigItem[];
+export declare function parseObjectToDiffConfigItem(data: Partial<ICloudrunServerBaseConfig>): IDiffConfigItem[];

package/types/cloudrun/type.d.ts

@@ -261,6 +261,22 @@ export interface ICloudrunServerBaseConfig {
      * 是否在线安装依赖，true 则本地不打包 node_modules，依赖在线装（如Docker）
      */
     InstallDependency?: boolean;
+    /**
+     * 会话亲和性 open | close
+     */
+    SessionAffinity?: string;
+    /**
+     * VPC 网络配置
+     */
+    VpcConf?: IVpcConf;
+    /**
+     * 存储挂载配置（COS / CFS）
+     */
+    VolumesConf?: IVolumeConf[];
+    /**
+     * 公网访问配置
+     */
+    PublicNetConf?: IPublicNetConf;
 }
 export interface IDiffConfigItem {
     Key: string;
@@ -271,6 +287,9 @@ export interface IDiffConfigItem {
     ArrayValue?: string[];
     PolicyDetails?: ICloudrunHpaPolicy[];
     TimerScale?: ICloudrunTimerScale[];
+    VpcConf?: IVpcConf;
+    VolumesConf?: IVolumeConf[];
+    PublicNetConf?: IPublicNetConf;
 }
 /**
  * 在线版本信息
@@ -471,3 +490,43 @@ export interface IProcessLogResponse {
     /** 请求ID */
     RequestId: string;
 }
+/**
+ * VPC 网络配置
+ */
+export interface IVpcConf {
+    VpcId?: string;
+    VpcCIDR?: string;
+    SubnetId?: string;
+    SubnetCIDR?: string;
+}
+/**
+ * 存储挂载配置（COS / CFS）
+ */
+export interface IVolumeConf {
+    Type?: string;
+    BucketName?: string;
+    Endpoint?: string;
+    KeyID?: string;
+    DstPath?: string;
+    SrcPath?: string;
+    MountIP?: string;
+    ReadOnly?: boolean;
+    InstanceId?: string;
+}
+/**
+ * 公网访问配置
+ */
+export interface IPublicNetConf {
+    PublicNetStatus?: string;
+}
+/**
+ * CreateCloudRunServer VPC 信息（仅创建时使用）
+ */
+export interface ICreateVpcInfo {
+    /** vpc id，必填 */
+    VpcId: string;
+    /** 创建类型：1=新建, 2=指定，必填 */
+    CreateType: 1 | 2;
+    /** 子网ID列表 */
+    SubnetIds?: string[];
+}

package/types/integration/crypto.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 使用指定 IV 加密（供测试与内部使用，保证可重现）
+ */
+export declare function aesEncryptWithIv(plaintext: string, key: string, iv: Buffer): string;
+declare class AESCryptoImpl {
+    /**
+     * AES-256-CBC 加密，返回 base64(IV)+base64(密文)
+     */
+    encrypt(plaintext: string, key: string): string;
+    /**
+     * 解密 base64(IV)+base64(密文) 格式的密文
+     */
+    decrypt(encryptedData: string, key: string): string;
+}
+export declare const AESCrypto: AESCryptoImpl;
+export {};

package/types/integration/index.d.ts

@@ -6,9 +6,10 @@ export * from './types';
  *
  * 复用现有 tcb 云 API（version 2018-06-08），统一携带 Business='integration'。
  *
- * 本服务只做云 API 的纯封装：不识别模板字段、不做敏感字段加解密、不做
- * "绑定资源"这类编排逻辑——这些依赖模板结构 / 七彩石密钥 / 上层交互，
- * 由调用方（CLI / 控制台）按各自场景自行编排后，通过 `ext` 传入最终 JSON 字符串。
+ * 提供两种使用模式：
+ * 1. 透传模式：直接传 `ext`（JSON 字符串），SDK 原样传递给云 API（向后兼容）
+ * 2. 自动加解密模式：传 `envVariables`（明文键值对），SDK 自动识别模板中的
+ *    password 字段、拉取七彩石密钥完成加密后拼装 ext
  */
 export declare class IntegrationService {
     private tcbService;
@@ -18,20 +19,31 @@ export declare class IntegrationService {
     listTemplates(params?: IListTemplatesParams): Promise<IGetUserKeyTemplateListResult>;
     /** 列出集成实例（密钥对列表） */
     listUserKeys(params?: IListUserKeysParams): Promise<IGetUserKeyListResult>;
-    /** 查询单个集成实例详情 */
+    /**
+     * 查询单个集成实例详情。
+     *
+     * 当 `decryptPwd=true` 时，SDK 自动拉取模板识别 password 字段并从七彩石
+     * 获取 AES 密钥解密，Ext 中 password 字段返回明文。解密失败时保留密文原值，
+     * 不中断流程。
+     */
     getUserKey(params: IGetUserKeyParams): Promise<IGetOneUserKeyResult>;
     /**
      * 创建集成实例。
      *
-     * `Ext` 为最终写入的 JSON 字符串，由调用方按模板字段自行拼装（含敏感字段
-     * 加密），本方法不做任何解析或加工，原样传递给云 API。
+     * 支持两种传参方式：
+     * - 传 `ext`：透传模式，原样传递给云 API（向后兼容，调用方自行加密）
+     * - 传 `envVariables`：自动加密模式，SDK 识别模板 password 字段并加密后拼装 ext
+     * - 两者都传时以 `ext` 优先
      */
     createUserKey(params: ICreateUserKeyParams): Promise<ICreateUserKeyResult>;
     /**
      * 更新集成实例。
      *
-     * `Ext` 为最终写入的 JSON 字符串，由调用方自行完成"与现有 Ext 合并"
-     * "敏感字段加密"等编排后传入；未传 `ext` 时后端保留原有 Ext 不变。
+     * 支持两种传参方式：
+     * - 传 `ext`：透传模式，原样传递给云 API（向后兼容）
+     * - 传 `envVariables`：自动加密模式，与现有 Ext 合并后加密写入
+     * - 两者都传时以 `ext` 优先
+     * - 都未传时后端保留原有 Ext 不变
      */
     updateUserKey(params: IUpdateUserKeyParams): Promise<IUpdateUserKeyResult>;
     /** 删除集成实例 */
@@ -40,4 +52,32 @@ export declare class IntegrationService {
     private getEnvInfo;
     /** 校验必填参数 */
     private validateRequiredParams;
+    /**
+     * 根据 ext / envVariables 参数构造最终的 Ext JSON 字符串。
+     * ext 优先；envVariables 由 SDK 自动加密 password 字段。
+     */
+    private buildExtFromParams;
+    /**
+     * 更新场景：将 envVariables 与现有实例的 Ext 合并后加密。
+     * 需要先查询现有实例获取当前的 authTypeCode 和 Ext。
+     */
+    private buildMergedExtForUpdate;
+    /**
+     * 加密 envVariables 中的 password 字段并返回 JSON 字符串。
+     * 无 password 字段时直接 JSON.stringify，不请求七彩石。
+     */
+    private encryptAndStringify;
+    /**
+     * 解密 Ext 中的 password 字段并返回新的 IUserKeyInfo。
+     * 解密失败时保留原值，不中断流程。
+     */
+    private decryptExtIfNeeded;
+    /** 从模板中获取 password 类型字段名列表 */
+    private getPasswordFieldNames;
+    /** 解析 Ext JSON 字符串为对象，失败返回空对象 */
+    private parseExt;
+    /** 加密 ext 对象中的 password 字段（仅加密有值的字段），返回新对象 */
+    private encryptPasswordFields;
+    /** 解密 ext 对象中的 password 字段，解密失败保留原值，返回新对象 */
+    private decryptPasswordFields;
 }

package/types/integration/secretKey.d.ts

@@ -0,0 +1,13 @@
+export interface IGetAesKeyParams {
+    /** 环境 Id（用于灰度命中，无则用占位 Uin） */
+    envId?: string;
+    /** 是否国际站 */
+    isIntl?: boolean;
+}
+/**
+ * 获取集成中心 AES key（进程内缓存）
+ * @throws CloudBaseError 拉取或解析失败
+ */
+export declare function getAesKey(params?: IGetAesKeyParams): Promise<string>;
+/** 清空进程内缓存（仅供测试使用） */
+export declare function __clearAesKeyCache(): void;

package/types/integration/types.d.ts

@@ -111,8 +111,10 @@ export interface IListUserKeysParams {
 /** 查询集成实例详情入参 */
 export interface IGetUserKeyParams {
     keyId: string;
-    /** 为 true 时返回加密字段的密文值 */
+    /** 为 true 时返回加密字段的密文值（原始密文）/ 解密后的明文值（当 decryptPwd=true 时） */
     needPwd?: boolean;
+    /** 为 true 时 SDK 自动解密 Ext 中的 password 字段，返回明文（需同时传 needPwd=true） */
+    decryptPwd?: boolean;
     /** 业务类型，integration：从集成中心来的，默认为空，表示是从授权管理中心来的 */
     business?: string;
 }
@@ -123,9 +125,17 @@ export interface ICreateUserKeyParams {
     description?: string;
     /**
      * Ext JSON 字符串（模板动态字段的最终取值，含敏感字段密文）。
-     * 由调用方按模板字段自行拼装（含加密），本层不做任何解析或加工。
+     * 与 envVariables 二选一：传入 ext 时直接透传；传入 envVariables 时
+     * SDK 自动识别模板中的 password 字段、拉取七彩石密钥完成加密后拼装 ext。
+     * 两者都传时以 ext 优先。
      */
     ext?: string;
+    /**
+     * 环境变量明文键值对。
+     * SDK 自动识别模板中的 password 字段并加密，无需调用方自行处理。
+     * ext 和 envVariables 都未传时，不携带 Ext 字段。
+     */
+    envVariables?: Record<string, string>;
     keyId?: string;
     ticketId?: string;
     /** 业务类型，integration：从集成中心来的，默认为空，表示是从授权管理中心来的 */
@@ -143,9 +153,15 @@ export interface IUpdateUserKeyParams {
     description?: string;
     /**
      * Ext JSON 字符串（模板动态字段的最终取值，含敏感字段密文）。
-     * 由调用方自行完成"与现有 Ext 合并"等编排后传入；未传时后端保留原有 Ext 不变。
+     * 与 envVariables 二选一。都未传时后端保留原有 Ext 不变。
      */
     ext?: string;
+    /**
+     * 环境变量明文键值对。
+     * SDK 自动识别模板中的 password 字段并加密，无需调用方自行处理。
+     * 传入时与现有 Ext 合并后再加密写入。
+     */
+    envVariables?: Record<string, string>;
     /** 绑定的示例代码云函数名称（bind-resource 使用） */
     demoCodeFunctionName?: string;
     /** 业务类型，integration：从集成中心来的，默认为空，表示是从授权管理中心来的 */

package/types/interfaces/tcb.interface.d.ts

@@ -150,6 +150,7 @@ export interface EnvInfo {
     }>;
     PostgreSQL?: PostgreSQLInfo[] | Record<string, any>;
     EnvStatus?: string;
+    UserInfo?: AccountInfoInner;
 }
 export interface FunctionInfo {
     Namespace?: string;