@cloudbase/manager-node 5.6.0-beta.1 → 5.6.0

package/lib/integration/constants.js

@@ -3,8 +3,6 @@
  * 集成中心常量定义（与 dev-platform 对齐）
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIN_AES_CIPHERTEXT_LENGTH = exports.USER_KEY_BUSINESS = void 0;
+exports.USER_KEY_BUSINESS = void 0;
 /** 业务类型标识：集成中心来源的密钥对 */
 exports.USER_KEY_BUSINESS = 'integration';
-/** 密文最小长度（小于该长度视为非密文，解密时原样返回） */
-exports.MIN_AES_CIPHERTEXT_LENGTH = 24;

package/lib/integration/index.js

@@ -23,14 +23,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntegrationService = void 0;
 const error_1 = require("../error");
 const utils_1 = require("../utils");
-const secretKey_1 = require("./secretKey");
-const fields_1 = require("./fields");
+const constants_1 = require("./constants");
 __exportStar(require("./types"), exports);
 /**
  * 集成中心（UserKey）服务
  *
  * 复用现有 tcb 云 API（version 2018-06-08），统一携带 Business='integration'。
- * 敏感字段加解密、bindFunction 编排在后续模块叠加。
+ *
+ * 本服务只做云 API 的纯封装：不识别模板字段、不做敏感字段加解密、不做
+ * "绑定资源"这类编排逻辑——这些依赖模板结构 / 七彩石密钥 / 上层交互，
+ * 由调用方（CLI / 控制台）按各自场景自行编排后，通过 `ext` 传入最终 JSON 字符串。
  */
 class IntegrationService {
     constructor(environment) {
@@ -40,19 +42,20 @@ class IntegrationService {
     // =========== 只读 API ===========
     /** 列出集成模板（密钥对模版列表） */
     async listTemplates(params = {}) {
-        var _a, _b;
+        var _a, _b, _c;
         const { envId } = this.getEnvInfo();
         return this.tcbService.request('GetUserKeyTemplateList', {
             EnvId: envId,
             Offset: (_a = params.offset) !== null && _a !== void 0 ? _a : 0,
             Limit: (_b = params.limit) !== null && _b !== void 0 ? _b : 100,
             AuthTypeCode: params.authTypeCode,
-            AuthTypeName: params.authTypeName
+            AuthTypeName: params.authTypeName,
+            Business: (_c = params.business) !== null && _c !== void 0 ? _c : constants_1.USER_KEY_BUSINESS // 默认 integration
         });
     }
     /** 列出集成实例（密钥对列表） */
     async listUserKeys(params = {}) {
-        var _a, _b;
+        var _a, _b, _c;
         const { envId } = this.getEnvInfo();
         return this.tcbService.request('GetUserKeyList', {
             EnvId: envId,
@@ -60,77 +63,66 @@ class IntegrationService {
             Limit: (_b = params.limit) !== null && _b !== void 0 ? _b : 100,
             Name: params.name,
             AuthTypeCode: params.authTypeCode,
-            Business: params.business // ✅ 新增：业务类型
+            Business: (_c = params.business) !== null && _c !== void 0 ? _c : constants_1.USER_KEY_BUSINESS // 默认 integration
         });
     }
     /** 查询单个集成实例详情 */
     async getUserKey(params) {
-        var _a;
+        var _a, _b;
         this.validateRequiredParams(params, ['keyId']);
         const { envId } = this.getEnvInfo();
         return this.tcbService.request('GetOneUserKey', {
             EnvId: envId,
             KeyID: params.keyId,
             NeedPwd: (_a = params.needPwd) !== null && _a !== void 0 ? _a : false,
-            Business: params.business // ✅ 新增：业务类型
+            Business: (_b = params.business) !== null && _b !== void 0 ? _b : constants_1.USER_KEY_BUSINESS // 默认 integration
         });
     }
     // =========== 写 API ===========
-    /** 创建集成实例 */
+    /**
+     * 创建集成实例。
+     *
+     * `Ext` 为最终写入的 JSON 字符串，由调用方按模板字段自行拼装（含敏感字段
+     * 加密），本方法不做任何解析或加工，原样传递给云 API。
+     */
     async createUserKey(params) {
+        var _a;
         this.validateRequiredParams(params, ['name', 'authTypeCode']);
         const { envId } = this.getEnvInfo();
-        const ext = await this.buildExt({
-            authTypeCode: params.authTypeCode,
-            envVariables: params.envVariables,
-            ext: params.ext
-        });
         return this.tcbService.request('CreateUserKey', {
             EnvId: envId,
             Name: params.name,
             KeyID: params.keyId,
             AuthTypeCode: params.authTypeCode,
             Description: params.description,
-            Ext: ext,
+            Ext: params.ext,
             TicketID: params.ticketId,
-            Business: params.business, // ✅ 新增：业务类型
-            DemoCodeFunctionName: params.demoCodeFunctionName, // ✅ 新增：示例代码云函数名称
-            RuntimeConfig: params.runtimeConfig // ✅ 新增：Agent 云函数配置
+            Business: (_a = params.business) !== null && _a !== void 0 ? _a : constants_1.USER_KEY_BUSINESS, // 默认 integration
+            DemoCodeFunctionName: params.demoCodeFunctionName,
+            RuntimeConfig: params.runtimeConfig
         });
     }
-    /** 更新集成实例 */
+    /**
+     * 更新集成实例。
+     *
+     * `Ext` 为最终写入的 JSON 字符串，由调用方自行完成"与现有 Ext 合并"
+     * "敏感字段加密"等编排后传入；未传 `ext` 时后端保留原有 Ext 不变。
+     */
     async updateUserKey(params) {
-        var _a, _b;
+        var _a;
         this.validateRequiredParams(params, ['keyId']);
         const { envId } = this.getEnvInfo();
-        // 传入 envVariables 时需回查现有实例：用于合并 Ext（保留未改动字段）并兜底 authTypeCode
-        let authTypeCode = params.authTypeCode;
-        let existingExt;
-        if (params.envVariables) {
-            const existing = await this.getUserKey({ keyId: params.keyId });
-            existingExt = (_a = existing.UserKeyInfo) === null || _a === void 0 ? void 0 : _a.Ext;
-            if (!authTypeCode) {
-                authTypeCode = (_b = existing.UserKeyInfo) === null || _b === void 0 ? void 0 : _b.AuthTypeCode;
-            }
-        }
-        const ext = await this.buildExt({
-            authTypeCode,
-            envVariables: params.envVariables,
-            ext: params.ext,
-            existingExt
-        });
-        const requestParams = {
+        return this.tcbService.request('UpdateUserKey', {
             EnvId: envId,
             KeyID: params.keyId,
             Name: params.name,
-            AuthTypeCode: authTypeCode,
+            AuthTypeCode: params.authTypeCode,
             Description: params.description,
-            Ext: ext,
+            Ext: params.ext,
             DemoCodeFunctionName: params.demoCodeFunctionName,
-            Business: params.business,
+            Business: (_a = params.business) !== null && _a !== void 0 ? _a : constants_1.USER_KEY_BUSINESS, // 默认 integration
             RuntimeConfig: params.runtimeConfig
-        };
-        return this.tcbService.request('UpdateUserKey', requestParams);
+        });
     }
     /** 删除集成实例 */
     async deleteUserKey(params) {
@@ -141,135 +133,7 @@ class IntegrationService {
             KeyID: params.keyId
         });
     }
-    // =========== 编排 API ===========
-    /**
-     * 将集成实例绑定到云函数（口径 A）。
-     *
-     * 绑定载体为 `DemoCodeFunctionName`：调 `UpdateUserKey` 设置该字段，
-     * 后端负责把集成配置注入函数运行时；CLI 不读写函数环境变量。
-     *
-     * - 集成与云函数一对一：已绑定到不同函数且未传 `force` 时报错；
-     * - 幂等：已绑定到同一函数时直接返回，不发送请求；
-     * - 不携带 `Ext`，保留集成原有配置。
-     */
-    async bindFunction(params) {
-        this.validateRequiredParams(params, ['keyId', 'functionName']);
-        const { keyId, functionName, force } = params;
-        const { UserKeyInfo } = await this.getUserKey({ keyId, business: 'integration' });
-        if (!UserKeyInfo) {
-            throw new error_1.CloudBaseError(`集成实例不存在: ${keyId}`);
-        }
-        const previousFunctionName = UserKeyInfo.DemoCodeFunctionName;
-        // 已绑定到同一函数：幂等返回
-        if (previousFunctionName === functionName) {
-            return {
-                keyId,
-                functionName,
-                previousFunctionName,
-                overwritten: false,
-                alreadyBound: true
-            };
-        }
-        // 已绑定到不同函数：需 force 覆盖
-        const overwritten = Boolean(previousFunctionName);
-        if (overwritten && !force) {
-            throw new error_1.CloudBaseError(`集成实例 ${keyId} 已绑定云函数 ${previousFunctionName}，如需改绑请使用 force 覆盖`);
-        }
-        // 与控制台对齐：传递完整参数，business: 'integration' 标记来源
-        const result = await this.updateUserKey({
-            keyId,
-            name: UserKeyInfo.Name,
-            authTypeCode: UserKeyInfo.AuthTypeCode,
-            description: UserKeyInfo.Description,
-            ext: UserKeyInfo.Ext,
-            demoCodeFunctionName: functionName,
-            business: 'integration'
-        });
-        return {
-            keyId,
-            functionName,
-            previousFunctionName,
-            overwritten,
-            alreadyBound: false
-        };
-    }
-    /**
-     * 解密集成实例 Ext 中的 password 字段，返回扁平明文对象。
-     * 供 bind-resource / 详情展示使用；解密失败的字段保留原值。
-     */
-    async decryptUserKeyExt(userKeyInfo) {
-        const extObj = this.safeParseExt(userKeyInfo.Ext);
-        const passwordFieldNames = await this.resolvePasswordFieldNames(userKeyInfo.AuthTypeCode);
-        if (!passwordFieldNames.length) {
-            return extObj;
-        }
-        const { envId } = this.getEnvInfo();
-        const aesKey = await (0, secretKey_1.getAesKey)({ envId });
-        return (0, fields_1.decryptPasswordFields)(extObj, passwordFieldNames, aesKey);
-    }
     // =========== 辅助方法 ===========
-    /**
-     * 构建最终写入的 Ext（JSON 字符串）。
-     *
-     * - 显式传入 `ext` 时优先使用（不做额外处理）；
-     * - 传入 `envVariables` 时：
-     *   - 提供 `existingExt`（update 场景）时与现有 Ext **合并**，仅加密本次传入（变更）
-     *     的 password 字段，未传入的 password 字段保留现有密文、非 password 字段保留原值；
-     *   - **编辑模式下空值删除字段**（与控制台对齐：空值表示不更新）；
-     *   - 未提供 `existingExt`（create 场景）时按模板识别 password 字段并加密有值字段；
-     * - 两者均未传时返回 undefined（保持原有 Ext 不变）。
-     */
-    async buildExt(params) {
-        if (params.ext !== undefined) {
-            return params.ext;
-        }
-        if (!params.envVariables) {
-            return undefined;
-        }
-        const passwordFieldNames = await this.resolvePasswordFieldNames(params.authTypeCode);
-        let changedObj = Object.assign({}, params.envVariables);
-        // 编辑模式（existingExt 存在）：删除空值字段（表示不更新，与控制台对齐）
-        if (params.existingExt) {
-            for (const [name, value] of Object.entries(changedObj)) {
-                if (value === '' || value === null || value === undefined) {
-                    delete changedObj[name];
-                }
-            }
-        }
-        // 仅加密本次传入（变更）的 password 字段，避免对现有密文二次加密
-        const changedPasswordNames = passwordFieldNames.filter(name => name in changedObj);
-        if (changedPasswordNames.length) {
-            const { envId } = this.getEnvInfo();
-            // 注：manager-node 暂以国内七彩石为默认；国际站由上层透传后扩展
-            const aesKey = await (0, secretKey_1.getAesKey)({ envId });
-            changedObj = (0, fields_1.encryptPasswordFields)(changedObj, changedPasswordNames, aesKey);
-        }
-        // 合并现有 Ext（update）：现有字段打底，变更字段覆盖
-        const existingObj = params.existingExt ? this.safeParseExt(params.existingExt) : {};
-        const merged = Object.assign(Object.assign({}, existingObj), changedObj);
-        return JSON.stringify(merged);
-    }
-    /** 按 authTypeCode 拉取模板并解析 password 字段名集合 */
-    async resolvePasswordFieldNames(authTypeCode) {
-        var _a, _b;
-        if (!authTypeCode)
-            return [];
-        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;
-        return (0, fields_1.parsePasswordFieldNames)(templateExt);
-    }
-    /** 安全解析实例 Ext（扁平对象），失败返回空对象 */
-    safeParseExt(ext) {
-        if (!ext)
-            return {};
-        try {
-            const parsed = JSON.parse(ext);
-            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
-        }
-        catch (_a) {
-            return {};
-        }
-    }
     /** 获取环境信息 */
     getEnvInfo() {
         const envConfig = this.environment.lazyEnvironmentConfig;
@@ -305,6 +169,3 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], IntegrationService.prototype, "deleteUserKey", null);
-__decorate([
-    (0, utils_1.preLazy)()
-], IntegrationService.prototype, "bindFunction", null);

package/package.json

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

package/types/integration/constants.d.ts

@@ -3,5 +3,3 @@
  */
 /** 业务类型标识：集成中心来源的密钥对 */
 export declare const USER_KEY_BUSINESS = "integration";
-/** 密文最小长度（小于该长度视为非密文，解密时原样返回） */
-export declare const MIN_AES_CIPHERTEXT_LENGTH = 24;

package/types/integration/index.d.ts

@@ -1,11 +1,14 @@
 import { Environment } from '../environment';
-import { IListTemplatesParams, IListUserKeysParams, IGetUserKeyParams, ICreateUserKeyParams, IUpdateUserKeyParams, IDeleteUserKeyParams, IGetUserKeyTemplateListResult, IGetUserKeyListResult, IGetOneUserKeyResult, ICreateUserKeyResult, IUpdateUserKeyResult, IDeleteUserKeyResult, IUserKeyInfo, IBindFunctionParams, IBindResult } from './types';
+import { IListTemplatesParams, IListUserKeysParams, IGetUserKeyParams, ICreateUserKeyParams, IUpdateUserKeyParams, IDeleteUserKeyParams, IGetUserKeyTemplateListResult, IGetUserKeyListResult, IGetOneUserKeyResult, ICreateUserKeyResult, IUpdateUserKeyResult, IDeleteUserKeyResult } from './types';
 export * from './types';
 /**
  * 集成中心（UserKey）服务
  *
  * 复用现有 tcb 云 API（version 2018-06-08），统一携带 Business='integration'。
- * 敏感字段加解密、bindFunction 编排在后续模块叠加。
+ *
+ * 本服务只做云 API 的纯封装：不识别模板字段、不做敏感字段加解密、不做
+ * "绑定资源"这类编排逻辑——这些依赖模板结构 / 七彩石密钥 / 上层交互，
+ * 由调用方（CLI / 控制台）按各自场景自行编排后，通过 `ext` 传入最终 JSON 字符串。
  */
 export declare class IntegrationService {
     private tcbService;
@@ -17,44 +20,22 @@ export declare class IntegrationService {
     listUserKeys(params?: IListUserKeysParams): Promise<IGetUserKeyListResult>;
     /** 查询单个集成实例详情 */
     getUserKey(params: IGetUserKeyParams): Promise<IGetOneUserKeyResult>;
-    /** 创建集成实例 */
-    createUserKey(params: ICreateUserKeyParams): Promise<ICreateUserKeyResult>;
-    /** 更新集成实例 */
-    updateUserKey(params: IUpdateUserKeyParams): Promise<IUpdateUserKeyResult>;
-    /** 删除集成实例 */
-    deleteUserKey(params: IDeleteUserKeyParams): Promise<IDeleteUserKeyResult>;
     /**
-     * 将集成实例绑定到云函数（口径 A）。
-     *
-     * 绑定载体为 `DemoCodeFunctionName`：调 `UpdateUserKey` 设置该字段，
-     * 后端负责把集成配置注入函数运行时；CLI 不读写函数环境变量。
+     * 创建集成实例。
      *
-     * - 集成与云函数一对一：已绑定到不同函数且未传 `force` 时报错；
-     * - 幂等：已绑定到同一函数时直接返回，不发送请求；
-     * - 不携带 `Ext`，保留集成原有配置。
+     * `Ext` 为最终写入的 JSON 字符串，由调用方按模板字段自行拼装（含敏感字段
+     * 加密），本方法不做任何解析或加工，原样传递给云 API。
      */
-    bindFunction(params: IBindFunctionParams): Promise<IBindResult>;
-    /**
-     * 解密集成实例 Ext 中的 password 字段，返回扁平明文对象。
-     * 供 bind-resource / 详情展示使用；解密失败的字段保留原值。
-     */
-    decryptUserKeyExt(userKeyInfo: IUserKeyInfo): Promise<Record<string, string>>;
+    createUserKey(params: ICreateUserKeyParams): Promise<ICreateUserKeyResult>;
     /**
-     * 构建最终写入的 Ext（JSON 字符串）。
+     * 更新集成实例。
      *
-     * - 显式传入 `ext` 时优先使用（不做额外处理）；
-     * - 传入 `envVariables` 时：
-     *   - 提供 `existingExt`（update 场景）时与现有 Ext **合并**，仅加密本次传入（变更）
-     *     的 password 字段，未传入的 password 字段保留现有密文、非 password 字段保留原值；
-     *   - **编辑模式下空值删除字段**（与控制台对齐：空值表示不更新）；
-     *   - 未提供 `existingExt`（create 场景）时按模板识别 password 字段并加密有值字段；
-     * - 两者均未传时返回 undefined（保持原有 Ext 不变）。
+     * `Ext` 为最终写入的 JSON 字符串，由调用方自行完成"与现有 Ext 合并"
+     * "敏感字段加密"等编排后传入；未传 `ext` 时后端保留原有 Ext 不变。
      */
-    private buildExt;
-    /** 按 authTypeCode 拉取模板并解析 password 字段名集合 */
-    private resolvePasswordFieldNames;
-    /** 安全解析实例 Ext（扁平对象），失败返回空对象 */
-    private safeParseExt;
+    updateUserKey(params: IUpdateUserKeyParams): Promise<IUpdateUserKeyResult>;
+    /** 删除集成实例 */
+    deleteUserKey(params: IDeleteUserKeyParams): Promise<IDeleteUserKeyResult>;
     /** 获取环境信息 */
     private getEnvInfo;
     /** 校验必填参数 */

package/types/integration/types.d.ts

@@ -96,6 +96,8 @@ export interface IListTemplatesParams {
     limit?: number;
     authTypeCode?: string;
     authTypeName?: string;
+    /** 业务类型，integration：从集成中心来的，默认为空，表示是从授权管理中心来的 */
+    business?: string;
 }
 /** 列出集成实例入参 */
 export interface IListUserKeysParams {
@@ -119,9 +121,10 @@ export interface ICreateUserKeyParams {
     name: string;
     authTypeCode: string;
     description?: string;
-    /** 环境变量键值对（敏感字段传明文，内部加密后写入 Ext） */
-    envVariables?: Record<string, string>;
-    /** 直接传入 Ext JSON 字符串（与 envVariables 二选一，envVariables 优先） */
+    /**
+     * Ext JSON 字符串（模板动态字段的最终取值，含敏感字段密文）。
+     * 由调用方按模板字段自行拼装（含加密），本层不做任何解析或加工。
+     */
     ext?: string;
     keyId?: string;
     ticketId?: string;
@@ -138,9 +141,10 @@ export interface IUpdateUserKeyParams {
     name?: string;
     authTypeCode?: string;
     description?: string;
-    /** 待变更的环境变量键值对（仅传需要改动的字段，敏感字段传明文） */
-    envVariables?: Record<string, string>;
-    /** 直接传入 Ext JSON 字符串（与 envVariables 二选一，envVariables 优先） */
+    /**
+     * Ext JSON 字符串（模板动态字段的最终取值，含敏感字段密文）。
+     * 由调用方自行完成"与现有 Ext 合并"等编排后传入；未传时后端保留原有 Ext 不变。
+     */
     ext?: string;
     /** 绑定的示例代码云函数名称（bind-resource 使用） */
     demoCodeFunctionName?: string;
@@ -153,24 +157,6 @@ export interface IUpdateUserKeyParams {
 export interface IDeleteUserKeyParams {
     keyId: string;
 }
-/** 绑定集成到云函数入参 */
-export interface IBindFunctionParams {
-    keyId: string;
-    functionName: string;
-    /** 已绑定到其它函数时是否强制覆盖 */
-    force?: boolean;
-}
-/** 绑定结果摘要 */
-export interface IBindResult {
-    keyId: string;
-    functionName: string;
-    /** 先前绑定的云函数名（无则 undefined） */
-    previousFunctionName?: string;
-    /** 是否覆盖了已有的不同绑定 */
-    overwritten: boolean;
-    /** 已绑定到同一函数、无需变更时为 true（幂等） */
-    alreadyBound: boolean;
-}
 export interface IGetUserKeyTemplateListResult {
     KeyTemplateList: IUserKeyTemplate[];
     TotalCount: number;

package/lib/integration/crypto.js

@@ -1,102 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __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('密钥必须是 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/fields.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePasswordFieldNames = parsePasswordFieldNames;
-exports.encryptPasswordFields = encryptPasswordFields;
-exports.decryptPasswordFields = decryptPasswordFields;
-/**
- * 集成中心敏感字段处理（与 dev-platform 对齐）
- *
- * - 实例 Ext 为扁平对象 `{ [fieldName]: value }`
- * - 模板 Ext 为 `{ fields: [{ name, type }] }`，type === 'password' 即敏感字段
- * - 加密：仅加密有值的 password 字段（create / update 同一逻辑，后端对未改动 password 做保留）
- * - 解密：长度 > MIN_AES_CIPHERTEXT_LENGTH 才尝试解密，失败保留原值不中断
- */
-const crypto_1 = require("./crypto");
-const constants_1 = require("./constants");
-/**
- * 从模板 Ext（JSON：`{ fields: [{ name, type }] }`）解析出 password 字段名集合。
- * 解析失败或无 fields 时返回空数组。
- */
-function parsePasswordFieldNames(templateExt) {
-    if (!templateExt)
-        return [];
-    try {
-        const parsed = JSON.parse(templateExt);
-        const fields = (parsed === null || parsed === void 0 ? void 0 : parsed.fields) || [];
-        return fields
-            .filter(f => (f === null || f === void 0 ? void 0 : f.type) === 'password' && (f === null || f === void 0 ? void 0 : f.name))
-            .map(f => f.name);
-    }
-    catch (_a) {
-        return [];
-    }
-}
-/**
- * 加密 ext 对象中的 password 字段（仅加密有值的字段）。
- * 返回新对象，不修改入参。
- */
-function 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 字段。
- * - 仅处理长度 > MIN_AES_CIPHERTEXT_LENGTH 的字符串（规避明显非密文的噪音）
- * - 解密失败保留原值，不中断流程
- * 返回新对象，不修改入参。
- */
-function decryptPasswordFields(extObj, passwordFieldNames, aesKey) {
-    const result = Object.assign({}, extObj);
-    passwordFieldNames.forEach(name => {
-        const encrypted = result[name];
-        if (typeof encrypted !== 'string' || encrypted.length <= constants_1.MIN_AES_CIPHERTEXT_LENGTH) {
-            return;
-        }
-        try {
-            result[name] = crypto_1.AESCrypto.decrypt(encrypted, aesKey);
-        }
-        catch (_a) {
-            // 解密失败保留原值，不打断主流程
-        }
-    });
-    return result;
-}

package/lib/integration/secretKey.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAesKey = getAesKey;
-exports.__clearAesKeyCache = __clearAesKeyCache;
-/**
- * 集成中心 AES key 获取（七彩石）
- *
- * 与 dev-platform 一致：通过 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");
-/** 七彩石配置（与 dev-platform constants 对齐） */
-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（与 dev-platform 行为一致） */
-const FALLBACK_UIN = '3309033';
-/** 进程内缓存（按 group 维度），key 不落盘、不打印 */
-const keyCache = {};
-/**
- * 获取集成中心 AES key（进程内缓存）
- * @throws CloudBaseError 拉取或解析失败
- */
-async function getAesKey(params = {}) {
-    var _a, _b;
-    const { envId, isIntl = false, proxy } = 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)
-        }, proxy);
-    }
-    catch (e) {
-        throw new error_1.CloudBaseError('获取集成加解密密钥失败：七彩石配置拉取请求异常，请检查网络连接或代理设置', {
-            original: e
-        });
-    }
-    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('获取集成加解密密钥失败：七彩石配置内容解析失败', {
-            original: e
-        });
-    }
-    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/types/integration/crypto.d.ts

@@ -1,16 +0,0 @@
-/**
- * 使用指定 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/fields.d.ts

@@ -1,17 +0,0 @@
-/**
- * 从模板 Ext（JSON：`{ fields: [{ name, type }] }`）解析出 password 字段名集合。
- * 解析失败或无 fields 时返回空数组。
- */
-export declare function parsePasswordFieldNames(templateExt?: string): string[];
-/**
- * 加密 ext 对象中的 password 字段（仅加密有值的字段）。
- * 返回新对象，不修改入参。
- */
-export declare function encryptPasswordFields(extObj: Record<string, string>, passwordFieldNames: string[], aesKey: string): Record<string, string>;
-/**
- * 解密 ext 对象中的 password 字段。
- * - 仅处理长度 > MIN_AES_CIPHERTEXT_LENGTH 的字符串（规避明显非密文的噪音）
- * - 解密失败保留原值，不中断流程
- * 返回新对象，不修改入参。
- */
-export declare function decryptPasswordFields(extObj: Record<string, string>, passwordFieldNames: string[], aesKey: string): Record<string, string>;

package/types/integration/secretKey.d.ts

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