@cloudbase/cloudbase-mcp 2.23.3 → 2.23.5

package/dist/index.cjs

@@ -3314,9 +3314,9 @@ function registerEnvTools(server) {
                 .optional()
                 .describe("环境地域（action=create 时可选）。默认 ap-shanghai，可选 ap-guangzhou、ap-beijing 等"),
             resources: zod_1.z
-                .array(zod_1.z.enum(["flexdb", "storage", "function"]))
+                .array(zod_1.z.enum(["flexdb", "storage", "function", "postgresql"]))
                 .optional()
-                .describe("启用的资源类型（action=create 时可选）。默认启用全部三项：flexdb(文档数据库)、storage(存储)、function(云函数)"),
+                .describe("启用的资源类型（action=create 时可选）。默认启用全部四项：flexdb(文档数据库)、storage(存储)、function(云函数)、postgresql(PostgreSQL 数据库)"),
             duration: zod_1.z
                 .number()
                 .int()
@@ -3369,7 +3369,7 @@ function registerEnvTools(server) {
                         return (0, tool_result_js_1.buildJsonToolResult)({
                             ok: false,
                             code: "CONFIRM_REQUIRED",
-                            message: `创建环境需要您确认。请确认以下配置信息后传入 confirm="yes"：\n别名: ${alias}\n套餐: ${packageId}\n地域: ${region}\n资源类型: ${resources?.join(", ") ?? "flexdb, storage, function"}\n时长: ${duration} 个月`,
+                            message: `创建环境需要您确认。请确认以下配置信息后传入 confirm="yes"：\n别名: ${alias}\n套餐: ${packageId}\n地域: ${region}\n资源类型: ${resources?.join(", ") ?? "flexdb, storage, function, postgresql"}\n时长: ${duration} 个月`,
                             next_step: {
                                 tool: "manageEnv",
                                 action: "create",
@@ -37032,6 +37032,119 @@ module.exports.Printf
   = Printf;
 
 
+/***/ }),
+
+/***/ 8901:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MonitorService = void 0;
+const error_1 = __webpack_require__(40430);
+const utils_1 = __webpack_require__(62358);
+__exportStar(__webpack_require__(57676), exports);
+// Period 与时间范围的约束规则
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const THREE_DAYS_MS = 3 * ONE_DAY_MS;
+const PERIOD_RULES = [
+    { maxRangeMs: ONE_DAY_MS, allowed: [300, 3600] },
+    { maxRangeMs: THREE_DAYS_MS, allowed: [300, 3600, 86400] },
+    // 超过3天
+    { maxRangeMs: Infinity, allowed: [3600, 86400] }
+];
+function validatePeriod(startStr, endStr, period) {
+    if (period === undefined)
+        return;
+    const startMs = new Date(startStr).getTime();
+    const endMs = new Date(endStr).getTime();
+    if (isNaN(startMs) || isNaN(endMs))
+        return;
+    const rangeMs = endMs - startMs;
+    const rule = PERIOD_RULES.find(r => rangeMs <= r.maxRangeMs);
+    if (rule && !rule.allowed.includes(period)) {
+        throw new error_1.CloudBaseError(`Period=${period} 不适用于当前时间范围。` +
+            `时间范围 ${startStr} ~ ${endStr}（约 ${(rangeMs / ONE_DAY_MS).toFixed(1)} 天）` +
+            `仅支持 Period: [${rule.allowed.join(', ')}]`);
+    }
+}
+class MonitorService {
+    constructor(environment) {
+        this.envId = environment.getEnvId();
+        this.cloudService = new utils_1.CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08');
+    }
+    /**
+     * 查询环境监控数据
+     *
+     * 根据指定指标名称，查询当前环境在指定时间范围内的监控数据，
+     * 返回按统计粒度聚合后的时序数据。
+     *
+     * @param params 查询参数
+     * @returns 时序监控数据
+     *
+     * @example
+     * // 查询静态网站存储容量
+     * const res = await monitor.describeCurveData({
+     *     MetricName: 'StaticFsSizePkg',
+     *     StartTime: '2026-02-05 00:00:00',
+     *     EndTime: '2026-02-06 23:59:59',
+     *     Period: 3600
+     * })
+     *
+     * @example
+     * // 查询云托管某服务某版本的错误响应
+     * const res = await monitor.describeCurveData({
+     *     MetricName: 'TkeHttpErrorService',
+     *     StartTime: '2026-03-13 00:00:00',
+     *     EndTime: '2026-03-16 23:59:59',
+     *     ResourceID: 'my-service',
+     *     SubresourceID: 'my-service-001'
+     * })
+     */
+    async describeCurveData(params) {
+        // 校验 Period 与时间范围的约束关系
+        validatePeriod(params.StartTime, params.EndTime, params.Period);
+        const requestParams = {
+            EnvId: this.envId,
+            MetricName: params.MetricName,
+            StartTime: params.StartTime,
+            EndTime: params.EndTime
+        };
+        if (params.ResourceID !== undefined) {
+            requestParams.ResourceID = params.ResourceID;
+        }
+        if (params.WxAppId !== undefined) {
+            requestParams.WxAppId = params.WxAppId;
+        }
+        if (params.SubresourceID !== undefined) {
+            requestParams.SubresourceID = params.SubresourceID;
+        }
+        if (params.ThirdResource !== undefined) {
+            requestParams.ThirdResource = params.ThirdResource;
+        }
+        if (params.Period !== undefined) {
+            requestParams.Period = params.Period;
+        }
+        return this.cloudService.request('DescribeCurveData', requestParams);
+    }
+}
+exports.MonitorService = MonitorService;
+
+
 /***/ }),
 
 /***/ 8904:
@@ -39129,6 +39242,8 @@ function registerAgentTools(server) {
             category: "agents",
         },
     }, async ({ action, agentId, name, description, runtime, timeout, memorySize, installDependency, zipFile, cosBucketRegion, tempCosObjectName, sessionConfig, cwd, params, }) => {
+        let _agentName;
+        let _agentRuntime;
         try {
             const cloudbase = await getManager();
             const payload = normalizeAgentPayload({
@@ -39145,11 +39260,19 @@ function registerAgentTools(server) {
                 cwd,
                 ...(params ?? {}),
             });
+            _agentName = payload?.Name;
+            _agentRuntime = payload?.Runtime;
             if (action === "createAgent") {
                 const normalizedName = normalizeString(payload.Name);
                 if (!normalizedName) {
                     throw new Error("action=createAgent 时必须提供 name（可通过顶层 name 或 params.name 传入）");
                 }
+                // CloudBase 后端在创建 Agent 时会同步创建云函数，函数名/别名长度受 SCF 限制（最大 64 字符）。
+                // envId 可能被用作前缀或别名的一部分，因此这里预留足够余量，避免后端 CreateFunction 失败。
+                if (normalizedName.length > 30) {
+                    throw new Error(`agent name 过长（当前 ${normalizedName.length} 字符）。CloudBase 创建 Agent 时会同步创建云函数，` +
+                        `函数名/别名受 SCF 64 字符限制，且 envId 可能作为前缀拼接。请将 name 控制在 30 字符以内。`);
+                }
                 const createPayload = {
                     ...payload,
                     Name: normalizedName,
@@ -39188,6 +39311,17 @@ function registerAgentTools(server) {
             }, "Agent 删除成功"));
         }
         catch (error) {
+            // 对后端 InternalError 提供更有意义的错误信息
+            const errMsg = error instanceof Error ? error.message : String(error);
+            if (errMsg.includes("InternalError") || errMsg.includes("服务处理出错")) {
+                server.logger?.({
+                    type: "createAgentError",
+                    message: "createAgent 后端返回 InternalError，可能是云函数创建失败",
+                    originalError: errMsg,
+                    name: _agentName,
+                    runtime: _agentRuntime,
+                });
+            }
             return (0, json_content_js_1.jsonContent)(buildErrorEnvelope(error));
         }
     });
@@ -51060,6 +51194,207 @@ function configure (options) {
 }
 
 
+/***/ }),
+
+/***/ 12129:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const crypto = __webpack_require__(55511);
+const utils_1 = __webpack_require__(98786);
+const utils_lang_1 = __webpack_require__(82174);
+const keyvalue_1 = __webpack_require__(36255);
+const url_1 = __webpack_require__(79551);
+const debug = (__webpack_require__(28354).debuglog)('@cloudbase/signature');
+const isStream = __webpack_require__(31232);
+exports.signedParamsSeparator = ';';
+const HOST_KEY = 'host';
+const CONTENT_TYPE_KEY = 'content-type';
+var MIME;
+(function (MIME) {
+    MIME["MULTIPART_FORM_DATA"] = "multipart/form-data";
+    MIME["APPLICATION_JSON"] = "application/json";
+})(MIME || (MIME = {}));
+class Signer {
+    constructor(credential, service, options = {}) {
+        this.credential = credential;
+        this.service = service;
+        this.algorithm = 'TC3-HMAC-SHA256';
+        this.options = options;
+    }
+    static camSafeUrlEncode(str) {
+        return encodeURIComponent(str)
+            .replace(/!/g, '%21')
+            .replace(/'/g, '%27')
+            .replace(/\(/g, '%28')
+            .replace(/\)/g, '%29')
+            .replace(/\*/g, '%2A');
+    }
+    /**
+     * 将一个对象处理成 KeyValue 形式，嵌套的对象将会被处理成字符串，Key转换成小写字母
+     * @param {Object}  obj - 待处理的对象
+     * @param {Object}  options
+     * @param {Boolean} options.enableBuffer
+     */
+    static formatKeyAndValue(obj, options = {}) {
+        if (!utils_lang_1.isPlainObject(obj)) {
+            return obj;
+        }
+        // enableValueToLowerCase：头部字段，要求小写，其他数据不需要小写，所以这里避免转小写
+        const { multipart, enableValueToLowerCase = false, selectedKeys, filter } = options;
+        const kv = {};
+        Object.keys(obj || {}).forEach(key => {
+            // NOTE: 客户端类型在服务端可能会丢失
+            const lowercaseKey = Signer.camSafeUrlEncode(key.toLowerCase().trim());
+            // 过滤 Key，服务端接收到的数据，可能含有未签名的 Key，通常是签名的时候被过滤掉的流，数据量可能会比较大
+            // 所以这里提供一个过滤的判断，避免不必要的计算
+            // istanbul ignore next
+            if (Array.isArray(selectedKeys) && !selectedKeys.includes(lowercaseKey)) {
+                return;
+            }
+            // istanbul ignore next
+            if (typeof filter === 'function') {
+                if (filter(key, obj[key], options)) {
+                    return;
+                }
+            }
+            // istanbul ignore else
+            if (key && obj[key] !== undefined) {
+                if (lowercaseKey === CONTENT_TYPE_KEY) {
+                    // multipart/form-data; boundary=???
+                    if (obj[key].startsWith(MIME.MULTIPART_FORM_DATA)) {
+                        kv[lowercaseKey] = MIME.MULTIPART_FORM_DATA;
+                    }
+                    else {
+                        kv[lowercaseKey] = obj[key];
+                    }
+                    return;
+                }
+                if (isStream(obj[key])) {
+                    // 这里如果是个文件流，在发送的时候可以识别
+                    // 服务端接收到数据之后传到这里判断不出来的
+                    // 所以会进入后边的逻辑
+                    return;
+                }
+                else if (utils_1.isNodeEnv() && Buffer.isBuffer(obj[key])) {
+                    if (multipart) {
+                        kv[lowercaseKey] = obj[key];
+                    }
+                    else {
+                        kv[lowercaseKey] = enableValueToLowerCase
+                            ? utils_1.stringify(obj[key]).trim().toLowerCase()
+                            : utils_1.stringify(obj[key]).trim();
+                    }
+                }
+                else {
+                    kv[lowercaseKey] = enableValueToLowerCase
+                        ? utils_1.stringify(obj[key]).trim().toLowerCase()
+                        : utils_1.stringify(obj[key]).trim();
+                }
+            }
+        });
+        return kv;
+    }
+    static calcParamsHash(params, keys = null, options = {}) {
+        debug(params, 'calcParamsHash');
+        if (utils_lang_1.isString(params)) {
+            return utils_1.sha256hash(params);
+        }
+        // 只关心业务参数，不关心以什么类型的 Content-Type 传递的
+        // 所以 application/json multipart/form-data 计算方式是相同的
+        keys = keys || keyvalue_1.SortedKeyValue.kv(params).keys();
+        const hash = crypto.createHash('sha256');
+        for (const key of keys) {
+            // istanbul ignore next
+            if (!params[key]) {
+                continue;
+            }
+            // istanbul ignore next
+            if (isStream(params[key])) {
+                continue;
+            }
+            // string && buffer
+            hash.update(`&${key}=`);
+            hash.update(params[key]);
+            hash.update('\r\n');
+        }
+        return hash.digest(options.encoding || 'hex');
+    }
+    /**
+     * 计算签名信息
+     * 注：默认是tcb签名算法，传入 options.isCloudApi=true，则使用云API V3签名算法
+     * 云API V3算法文档：https://cloud.tencent.com/document/api/598/38504#NodeJS
+     *
+     * @param {string} method       - Http Verb：GET/get POST/post 区分大小写
+     * @param {string} url          - 地址：http://abc.org/api/v1?a=1&b=2
+     * @param {Object} headers      - 需要签名的头部字段
+     * @param {string} params       - 请求参数
+     * @param {number} [timestamp]  - 签名时间戳
+     * @param {object} [options]    - 可选参数
+     */
+    tc3sign(method, url, headers, params, timestamp, options = {}) {
+        timestamp = timestamp || utils_1.second();
+        const urlInfo = url_1.parse(url);
+        const formatedHeaders = Signer.formatKeyAndValue(headers, {
+            enableValueToLowerCase: true
+        });
+        const headerKV = keyvalue_1.SortedKeyValue.kv(formatedHeaders);
+        const signedHeaders = headerKV.keys();
+        const canonicalHeaders = headerKV.toString(':', '\n') + '\n';
+        const { enableHostCheck = true, enableContentTypeCheck = true, isCloudApi = false } = options;
+        if (enableHostCheck && headerKV.get(HOST_KEY) !== urlInfo.host) {
+            throw new TypeError(`host:${urlInfo.host} in url must be equals to host:${headerKV.get('host')} in headers`);
+        }
+        if (enableContentTypeCheck && !headerKV.get(CONTENT_TYPE_KEY)) {
+            throw new TypeError(`${CONTENT_TYPE_KEY} field must in headers`);
+        }
+        const multipart = headerKV.get(CONTENT_TYPE_KEY).startsWith(MIME.MULTIPART_FORM_DATA);
+        const formatedParams = isCloudApi ?
+            JSON.stringify(params)
+            : method.toUpperCase() === 'GET'
+                ? ''
+                : Signer.formatKeyAndValue(params, {
+                    multipart
+                });
+        const paramKV = keyvalue_1.SortedKeyValue.kv(formatedParams);
+        const signedParams = paramKV.keys();
+        const hashedPayload = Signer.calcParamsHash(formatedParams, null);
+        const signedUrl = isCloudApi ? urlInfo.pathname : url.replace(/^https?:/, '').split('?')[0];
+        const canonicalRequest = `${method}\n${signedUrl}\n${urlInfo.query || ''}\n${canonicalHeaders}\n${signedHeaders.join(';')}\n${hashedPayload}`;
+        debug(canonicalRequest, 'canonicalRequest\n\n');
+        const date = utils_1.formateDate(timestamp);
+        const service = this.service;
+        const algorithm = this.algorithm;
+        const credentialScope = `${date}/${service}/tc3_request`;
+        const stringToSign = `${algorithm}\n${timestamp}\n${credentialScope}\n${utils_1.sha256hash(canonicalRequest)}`;
+        debug(stringToSign, 'stringToSign\n\n');
+        const secretDate = utils_1.sha256hmac(date, `TC3${this.credential.secretKey}`);
+        const secretService = utils_1.sha256hmac(service, secretDate);
+        const secretSigning = utils_1.sha256hmac('tc3_request', secretService);
+        const signature = utils_1.sha256hmac(stringToSign, secretSigning, 'hex');
+        debug(secretDate.toString('hex'), 'secretDate');
+        debug(secretService.toString('hex'), 'secretService');
+        debug(secretSigning.toString('hex'), 'secretSigning');
+        debug(signature, 'signature');
+        const { withSignedParams = false } = options;
+        return {
+            // 需注意该字段长度
+            // https://stackoverflow.com/questions/686217/maximum-on-http-header-values
+            // https://www.tutorialspoint.com/What-is-the-maximum-size-of-HTTP-header-values
+            authorization: `${algorithm} Credential=${this.credential.secretId}/${credentialScope},${withSignedParams ? ` SignedParams=${signedParams.join(';')},` : ''} SignedHeaders=${signedHeaders.join(';')}, Signature=${signature}`,
+            signedParams,
+            signedHeaders,
+            signature,
+            timestamp,
+            multipart
+        };
+    }
+}
+exports.Signer = Signer;
+
+
 /***/ }),
 
 /***/ 12146:
@@ -62038,6 +62373,14 @@ class DatabaseService {
             Tag: Databases[0].InstanceId
         };
     }
+    getMongoConnector() {
+        const currEnv = this.environment;
+        const { Databases } = currEnv.lazyEnvironmentConfig;
+        return {
+            DatabaseName: Databases[0].InstanceId,
+            InstanceId: 'flexdb'
+        };
+    }
     async checkCollectionExists(collectionName) {
         try {
             const result = await this.describeCollection(collectionName);
@@ -62055,9 +62398,10 @@ class DatabaseService {
         }
     }
     async createCollection(collectionName) {
-        let { Tag } = this.getDatabaseConfig();
-        const res = await this.collOpService.request('CreateTable', {
-            Tag,
+        const MongoConnector = this.getMongoConnector();
+        const res = await this.dbOpService.request('CreateTable', {
+            EnvId: this.envId,
+            MongoConnector,
             TableName: collectionName
         });
         return res;
@@ -62066,9 +62410,10 @@ class DatabaseService {
         // 先检查当前集合是否存在
         const existRes = await this.checkCollectionExists(collectionName);
         if (existRes.Exists) {
-            let { Tag } = this.getDatabaseConfig();
-            const res = await this.collOpService.request('DeleteTable', {
-                Tag,
+            const MongoConnector = this.getMongoConnector();
+            const res = await this.dbOpService.request('DeleteTable', {
+                EnvId: this.envId,
+                MongoConnector,
                 TableName: collectionName
             });
             return res;
@@ -62078,14 +62423,15 @@ class DatabaseService {
         }
     }
     async updateCollection(collectionName, indexiesInfo) {
-        let { Tag } = this.getDatabaseConfig();
-        const res = await this.collOpService.request('UpdateTable', Object.assign({ Tag, TableName: collectionName }, indexiesInfo));
+        const MongoConnector = this.getMongoConnector();
+        const res = await this.dbOpService.request('UpdateTable', Object.assign({ EnvId: this.envId, MongoConnector, TableName: collectionName }, indexiesInfo));
         return res;
     }
     async describeCollection(collectionName) {
-        let { Tag } = this.getDatabaseConfig();
-        return this.collOpService.request('DescribeTable', {
-            Tag,
+        const MongoConnector = this.getMongoConnector();
+        return this.dbOpService.request('DescribeTable', {
+            EnvId: this.envId,
+            MongoConnector,
             TableName: collectionName
         });
     }
@@ -62094,14 +62440,14 @@ class DatabaseService {
         MgoLimit: this.DEFAULT_MGO_LIMIT,
         MgoOffset: this.DEFAULT_MGO_OFFSET
     }) {
-        let { Tag } = this.getDatabaseConfig();
+        const MongoConnector = this.getMongoConnector();
         if (options.MgoLimit === undefined) {
             options.MgoLimit = this.DEFAULT_MGO_LIMIT;
         }
         if (options.MgoOffset === undefined) {
             options.MgoOffset = this.DEFAULT_MGO_OFFSET;
         }
-        const res = await this.collOpService.request('ListTables', Object.assign({ Tag }, options));
+        const res = await this.dbOpService.request('ListTables', Object.assign({ EnvId: this.envId, MongoConnector }, options));
         if (res.Tables === null) {
             // 无集合
             res.Collections = [];
@@ -62266,12 +62612,16 @@ class DatabaseService {
     }
     /**
      * 执行文档型数据库命令
-     * @param options 命令参数（命令列表、可选的 Tag/EnvId/MongoConnector）
+     * @param options 命令参数（命令列表、可选的 EnvId/MongoConnector）
      * @returns 执行结果，Data 为 JSON 字符串数组
      */
     async runCommands(options) {
-        let { Tag } = this.getDatabaseConfig();
-        return this.dbOpService.request('RunCommands', Object.assign({ MgoCommands: options.MgoCommands, Tag: options.Tag || Tag, EnvId: options.EnvId || this.envId }, (options.MongoConnector ? { MongoConnector: options.MongoConnector } : {})));
+        const MongoConnector = options.MongoConnector || this.getMongoConnector();
+        return this.dbOpService.request('RunCommands', {
+            MgoCommands: options.MgoCommands,
+            MongoConnector,
+            EnvId: options.EnvId || this.envId,
+        });
     }
     /**
      * 在 PostgreSQL 数据库上执行 SQL 语句
@@ -86776,7 +87126,11 @@ class PermissionService {
     constructor(environment) {
         this.environment = environment;
         this.tcbService = new utils_1.CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08');
+        this.lowcodeService = new utils_1.CloudService(environment.cloudBaseContext, 'lowcode', '2021-01-08');
     }
+    /**
+     * @deprecated 已废弃，网关鉴权策略已由 OPA 接管，请使用 modifyEnvAuthzConfig 替代
+     */
     async modifyResourcePermission(options) {
         const { EnvId } = this.environment.lazyEnvironmentConfig;
         const { resourceType, resource, permission, securityRule } = options;
@@ -86809,6 +87163,9 @@ class PermissionService {
         }
         return this.tcbService.request('ModifyResourcePermission', reqData);
     }
+    /**
+     * @deprecated 已废弃，网关鉴权策略已由 OPA 接管，请使用 describeResourcePolicyList 或 describeEnvAuthzConfig 替代
+     */
     async describeResourcePermission(options) {
         const { EnvId } = this.environment.lazyEnvironmentConfig;
         const { resourceType, resources } = options;
@@ -87046,6 +87403,102 @@ class PermissionService {
             RoleIds: roleIds
         });
     }
+    /**
+     * 拉取环境下的所有用户自定义的网关鉴权策略列表
+     * 注意：PG 环境无需调用，直接按照无存量策略处理；
+     * 若环境 meta 中 authz_engine 值为 opa，则网关策略不生效，无需调用
+     */
+    async describeResourcePolicyList(options = {}) {
+        const { resourceType } = options;
+        if (resourceType !== undefined && (typeof resourceType !== 'string' || resourceType.trim().length === 0)) {
+            throw new Error('Invalid resourceType');
+        }
+        // PG 环境无需调用，直接返回空策略列表
+        if (await this.isPostgresqlEnv()) {
+            const emptyData = { PolicyList: [], Total: '0' };
+            return {
+                Data: emptyData,
+                RequestId: ''
+            };
+        }
+        // authz_engine 为 opa 时网关策略不生效，无需调用，直接返回空策略列表
+        if (await this.isOpaAuthzEngine()) {
+            const emptyData = { PolicyList: [], Total: '0' };
+            return {
+                Data: emptyData,
+                RequestId: ''
+            };
+        }
+        const { EnvId } = this.environment.lazyEnvironmentConfig;
+        const reqData = {
+            EnvId,
+            ResourceType: resourceType || 'policy'
+        };
+        return this.lowcodeService.request('DescribeResourcePolicyList', reqData);
+    }
+    /**
+     * 拉取环境下的鉴权策略配置
+     * key: authz.platform.extension.rego - 单独为该环境配置的策略
+     * key: authz.user.rego - 用户配置的策略
+     */
+    async describeEnvAuthzConfig(options) {
+        const { key } = options;
+        if (!key || (key !== 'authz.platform.extension.rego' && key !== 'authz.user.rego')) {
+            throw new Error('key must be "authz.platform.extension.rego" or "authz.user.rego"');
+        }
+        const { EnvId } = this.environment.lazyEnvironmentConfig;
+        return this.tcbService.request('DescribeEnvConfig', {
+            EnvId,
+            Key: key
+        });
+    }
+    /**
+     * 保存用户编写的 rego 策略，保存后旧网关鉴权将直接失效
+     */
+    async modifyEnvAuthzConfig(options) {
+        const { EnvId } = this.environment.lazyEnvironmentConfig;
+        const { key, value } = options;
+        if (key !== 'authz.user.rego') {
+            throw new Error('key must be "authz.user.rego"');
+        }
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            throw new Error('value is required and must be a non-empty string');
+        }
+        return this.tcbService.request('ModifyEnvConfig', {
+            EnvId,
+            Key: key,
+            Value: value
+        });
+    }
+    /**
+     * 获取完整的环境基础信息（含 PostgreSQL、Meta 等字段）
+     */
+    async getEnvBaseInfo() {
+        var _a;
+        const { EnvId } = this.environment.lazyEnvironmentConfig;
+        const params = { EnvId };
+        const res = await this.environment.getEnvService().describeEnvInfo(params);
+        return ((_a = res === null || res === void 0 ? void 0 : res.EnvInfo) === null || _a === void 0 ? void 0 : _a.EnvBaseInfo) || {};
+    }
+    /**
+     * 判断当前环境是否为 PostgreSQL 环境
+     */
+    async isPostgresqlEnv() {
+        return this.environment.getEnvService().isPostgresqlEnv();
+    }
+    /**
+     * 判断当前环境的 authz_engine 是否为 opa
+     * 从环境 Meta 中查找 Key 为 authz_engine 的标签，Value 为 opa 表示已切到 OPA
+     */
+    async isOpaAuthzEngine() {
+        const envBaseInfo = await this.getEnvBaseInfo();
+        const meta = envBaseInfo === null || envBaseInfo === void 0 ? void 0 : envBaseInfo.Meta;
+        if (!Array.isArray(meta)) {
+            return false;
+        }
+        const authzEngineTag = meta.find(tag => tag.Key === 'authz_engine');
+        return (authzEngineTag === null || authzEngineTag === void 0 ? void 0 : authzEngineTag.Value) === 'opa';
+    }
 }
 exports.PermissionService = PermissionService;
 __decorate([
@@ -87066,6 +87519,15 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], PermissionService.prototype, "deleteRoles", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], PermissionService.prototype, "describeResourcePolicyList", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], PermissionService.prototype, "describeEnvAuthzConfig", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], PermissionService.prototype, "modifyEnvAuthzConfig", null);
 
 
 /***/ }),
@@ -89171,7 +89633,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MANAGE_FUNCTION_ACTIONS = exports.QUERY_FUNCTION_ACTIONS = exports.TRIGGER_CONFIG_EXAMPLES = exports.SUPPORTED_TRIGGER_TYPES = exports.DEFAULT_NODEJS_RUNTIME = exports.SUPPORTED_NODEJS_RUNTIMES = exports.RECOMMENDED_RUNTIMES = exports.DEFAULT_RUNTIME = exports.ALL_SUPPORTED_RUNTIMES = exports.SUPPORTED_RUNTIMES = void 0;
+exports.CUSTOM_IMAGE_RUNTIME = exports.MANAGE_FUNCTION_ACTIONS = exports.QUERY_FUNCTION_ACTIONS = exports.TRIGGER_CONFIG_EXAMPLES = exports.SUPPORTED_TRIGGER_TYPES = exports.DEFAULT_NODEJS_RUNTIME = exports.SUPPORTED_NODEJS_RUNTIMES = exports.RECOMMENDED_RUNTIMES = exports.DEFAULT_RUNTIME = exports.ALL_SUPPORTED_RUNTIMES = exports.SUPPORTED_RUNTIMES = void 0;
 exports.formatRuntimeList = formatRuntimeList;
 exports.validateTimerCron = validateTimerCron;
 exports.shouldInstallDependencyForFunction = shouldInstallDependencyForFunction;
@@ -89279,6 +89741,41 @@ const VPC_SCHEMA = zod_1.z.object({
     vpcId: zod_1.z.string(),
     subnetId: zod_1.z.string(),
 });
+// 镜像部署值，对应 SCF Runtime=CustomImage
+exports.CUSTOM_IMAGE_RUNTIME = "CustomImage";
+// HTTP 函数镜像部署配置，对应 Manager SDK 的 IFunctionImageConfig（camelCase）。
+// 用于 zip→COS→CloudApp custom 构建→TCR→SCF 镜像部署链路的「阶段 B」：基于已推送到 TCR 的镜像创建/更新函数。
+const IMAGE_CONFIG_SCHEMA = zod_1.z.object({
+    imageType: zod_1.z
+        .enum(["enterprise", "personal"])
+        .optional()
+        .describe("镜像仓库类型：enterprise（企业版 TCR）或 personal（个人版）。省略时默认 enterprise。"),
+    imageUri: zod_1.z
+        .string()
+        .describe("完整镜像地址（必须含 tag），格式 {domain}/{namespace}/{image}:{tag}，" +
+        "例如 ccr.ccs.tencentyun.com/your-ns/demo-app:demo-app-001。不要使用 :latest。"),
+    registryId: zod_1.z
+        .string()
+        .optional()
+        .describe("TCR 实例 ID，形如 tcr-xxxxxxxx。imageType=enterprise 时必填。"),
+    command: zod_1.z
+        .string()
+        .optional()
+        .describe("覆盖镜像 ENTRYPOINT。不填则使用 Dockerfile 默认值，例如 python。"),
+    args: zod_1.z
+        .string()
+        .optional()
+        .describe("覆盖镜像 CMD，空格分隔，例如 -u app.py。"),
+    entryPoint: zod_1.z.string().optional().describe("镜像入口点，一般不需要单独设置。"),
+    imagePort: zod_1.z
+        .number()
+        .optional()
+        .describe("容器监听端口。Web Server 函数填 9000（默认），Job 型镜像填 -1。"),
+    containerImageAccelerate: zod_1.z
+        .boolean()
+        .optional()
+        .describe("是否开启镜像加速。镜像较大时建议开启以缩短冷启动时间。"),
+});
 const SEVEN_FIELD_CRON_REGEX = /^\s*\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s*$/;
 function validateTimerCron(config) {
     const trimmed = config.trim();
@@ -89338,7 +89835,11 @@ const CREATE_FUNCTION_SCHEMA = zod_1.z.object({
         `  Python: ${exports.RECOMMENDED_RUNTIMES.python}\n` +
         `  PHP: ${exports.RECOMMENDED_RUNTIMES.php}\n` +
         `  Java: ${exports.RECOMMENDED_RUNTIMES.java}\n` +
-        `  Go: ${exports.RECOMMENDED_RUNTIMES.golang}`),
+        `  Go: ${exports.RECOMMENDED_RUNTIMES.golang}\n\n` +
+        `镜像部署（基于 TCR 镜像创建函数）时填 "${exports.CUSTOM_IMAGE_RUNTIME}"，并提供 imageConfig；此时无需 functionRootPath/zipFile。`),
+    imageConfig: IMAGE_CONFIG_SCHEMA.optional().describe("镜像部署配置（仅 runtime=CustomImage 时使用）。" +
+        "用于 zip→COS→CloudApp custom 构建→TCR→SCF 的「阶段 B」：基于已推送到 TCR 的镜像创建 HTTP 函数。" +
+        "传入 imageConfig 后即按镜像部署处理，函数无需打包本地代码、scf_bootstrap 或 Handler。"),
     triggers: zod_1.z.array(TRIGGER_SCHEMA).optional().describe("触发器配置数组"),
     handler: zod_1.z.string().optional().describe("函数入口"),
     ignore: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().describe("忽略文件"),
@@ -89487,7 +89988,12 @@ function registerFunctionTools(server) {
             return;
         }
         if (input.action === "createFunction" || input.action === "updateFunctionCode") {
-            throw new Error(`${input.action} 在 cloud mode 下不可用，因为该操作依赖本地函数代码目录。请改用本地模式执行。`);
+            // 镜像部署不依赖本地代码目录（代码已在 TCR），cloud mode 下可用。
+            const hasImageConfig = Boolean(input.imageConfig ?? input.func?.imageConfig);
+            if (hasImageConfig) {
+                return;
+            }
+            throw new Error(`${input.action} 在 cloud mode 下不可用，因为该操作依赖本地函数代码目录。请改用本地模式执行，或使用镜像部署（runtime=CustomImage + imageConfig）。`);
         }
         if (input.action === "createLayerVersion" && input.contentPath) {
             throw new Error("createLayerVersion 在 cloud mode 下不支持 contentPath，本地文件内容请改为 base64Content 或改用本地模式执行。");
@@ -89837,6 +90343,70 @@ function registerFunctionTools(server) {
                 const func = { ...input.func };
                 const functionName = String(func.name);
                 (0, logger_js_1.debug)(`[createFunction] name=${functionName}, type=${String(func.type || "Event")}`);
+                // 镜像部署分支（Runtime=CustomImage）：基于已推送到 TCR 的镜像创建 HTTP 函数。
+                // 对应 zip→COS→CloudApp custom 构建→TCR→SCF 链路的「阶段 B」。
+                const createImageConfig = input.imageConfig ??
+                    func.imageConfig;
+                const isImageRuntime = typeof func.runtime === "string" &&
+                    func.runtime.replace(/\s+/g, "").toLowerCase() ===
+                        exports.CUSTOM_IMAGE_RUNTIME.toLowerCase();
+                if (createImageConfig || isImageRuntime) {
+                    if (!createImageConfig?.imageUri) {
+                        throw new Error("镜像部署（runtime=CustomImage）时，imageConfig.imageUri 是必需的，" +
+                            "格式为 {domain}/{namespace}/{image}:{tag}（含 tag，不要用 :latest）。");
+                    }
+                    if ((createImageConfig.imageType ?? "enterprise") === "enterprise" &&
+                        !createImageConfig.registryId) {
+                        throw new Error("imageType=enterprise（企业版 TCR）时，imageConfig.registryId（tcr-xxxxxxxx）是必需的。");
+                    }
+                    // 镜像函数即 HTTP 函数；Manager SDK 会自动补 ImageType=enterprise、ImagePort=9000，
+                    // 并在镜像部署时剥离 Handler / InstallDependency，故此处不需要 functionRootPath。
+                    const imageFunc = {
+                        ...func,
+                        type: func.type ?? "HTTP",
+                        runtime: exports.CUSTOM_IMAGE_RUNTIME,
+                        imageConfig: createImageConfig,
+                    };
+                    delete imageFunc.installDependency;
+                    let imageResult;
+                    try {
+                        imageResult = await cloudbase.functions.createFunction({
+                            func: imageFunc,
+                            deployMode: "image",
+                            force: Boolean(input.force),
+                        });
+                    }
+                    catch (error) {
+                        throw wrapFunctionOperationError("createFunction", functionName, undefined, error);
+                    }
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, imageResult);
+                    return buildEnvelope({
+                        action: input.action,
+                        functionName,
+                        deployMode: "image",
+                        imageUri: createImageConfig.imageUri,
+                        raw: imageResult,
+                    }, `已基于镜像 ${createImageConfig.imageUri} 创建 HTTP 函数 ${functionName}。` +
+                        `请确认 TCR、SCF 与构建管道处于同一地域；如需通过 URL 访问，请显式调用 ` +
+                        `manageGateway(action="createAccess", type="HTTP") 并按需调整函数安全规则。` +
+                        `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪。`, [
+                        {
+                            tool: "queryFunctions",
+                            action: "getFunctionDetail",
+                            reason: "确认镜像函数已就绪（Active）",
+                        },
+                        {
+                            tool: "manageFunctions",
+                            action: "updateFunctionCode",
+                            reason: "后续迭代只需用新镜像 tag 调用 updateFunctionCode 更新镜像",
+                        },
+                        {
+                            tool: "manageGateway",
+                            action: "createAccess",
+                            reason: "如需通过 URL 访问镜像 HTTP 函数，显式创建网关访问入口并传 type=\"HTTP\"",
+                        },
+                    ]);
+                }
                 if (func.type !== "HTTP") {
                     const originalRuntime = typeof func.runtime === "string" ? func.runtime : undefined;
                     func.runtime = resolveEventFunctionRuntime(func.runtime);
@@ -89930,6 +90500,42 @@ function registerFunctionTools(server) {
                     throw new Error("updateFunctionCode 操作时，functionName 参数是必需的");
                 }
                 const cloudbase = await getManager();
+                // 镜像更新分支：后续迭代只需用新镜像 tag 更新函数。
+                const updateImageConfig = input.imageConfig ??
+                    input.func?.imageConfig;
+                if (updateImageConfig) {
+                    if (!updateImageConfig.imageUri) {
+                        throw new Error("镜像更新时，imageConfig.imageUri 是必需的，格式为 {domain}/{namespace}/{image}:{tag}（含 tag，不要用 :latest）。");
+                    }
+                    let imageResult;
+                    try {
+                        imageResult = await cloudbase.functions.updateFunctionCode({
+                            func: {
+                                name: input.functionName,
+                                imageConfig: updateImageConfig,
+                            },
+                            deployMode: "image",
+                        });
+                    }
+                    catch (error) {
+                        throw wrapFunctionOperationError("updateFunctionCode", input.functionName, undefined, error);
+                    }
+                    (0, cloudbase_manager_js_1.logCloudBaseResult)(server.logger, imageResult);
+                    return buildEnvelope({
+                        action: input.action,
+                        functionName: input.functionName,
+                        deployMode: "image",
+                        imageUri: updateImageConfig.imageUri,
+                        raw: imageResult,
+                    }, `已将函数 ${input.functionName} 的镜像更新为 ${updateImageConfig.imageUri}。` +
+                        `部署后可用 queryFunctions(action="getFunctionDetail") 确认函数已就绪（Active）。`, [
+                        {
+                            tool: "queryFunctions",
+                            action: "getFunctionDetail",
+                            reason: "确认镜像更新后函数已就绪（Active）",
+                        },
+                    ]);
+                }
                 const processedRootPath = processFunctionRootPath(input.functionRootPath, input.functionName);
                 const updateParams = {
                     func: {
@@ -90340,6 +90946,8 @@ function registerFunctionTools(server) {
         title: "管理 CloudBase 云函数",
         description: "CloudBase 云函数统一写入口。支持创建函数、更新代码、更新配置、调用函数、管理定时跑 / 定时任务 / scheduled job 的 timer 触发器和层绑定。" +
             "如果要创建 cron 定时任务，先用 createFunction 创建函数，再用 createFunctionTrigger 创建 timer 触发器（支持7段cron表达式），deleteFunctionTrigger 删除触发器。" +
+            "镜像部署（Runtime=CustomImage）：先把代码经 zip→COS→CloudApp custom 构建→TCR 推镜像（这一阶段为裸腾讯云 API，本工具不覆盖），" +
+            "再用 createFunction(func.runtime=\"CustomImage\", imageConfig) 基于 TCR 镜像创建 HTTP 函数；后续迭代用 updateFunctionCode + imageConfig 换镜像 tag。" +
             "危险操作需要显式 confirm=true。",
         inputSchema: {
             action: zod_1.z
@@ -90379,6 +90987,9 @@ function registerFunctionTools(server) {
                 .optional()
                 .describe("updateFunctionLayers 的目标层列表，顺序即最终顺序"),
             codeSecret: zod_1.z.string().optional().describe("层绑定时的代码保护密钥"),
+            imageConfig: IMAGE_CONFIG_SCHEMA.optional().describe("镜像部署配置（Runtime=CustomImage）。createFunction 时基于 TCR 镜像创建 HTTP 函数，" +
+                "updateFunctionCode 时仅更换镜像 tag。需提供 imageUri（含 tag），企业版 TCR 还需 registryId。" +
+                "也可在 func.imageConfig 中提供；两处都传时以顶层 imageConfig 优先。"),
             confirm: zod_1.z.boolean().optional().describe("危险操作确认开关。deleteFunction、deleteFunctionTrigger、deleteLayerVersion、detachLayer 等删除类操作需要显式传入 confirm=true"),
             incrementalFile: zod_1.z.string().optional().describe("incrementalDeployFunction 增量部署时的变更文件路径"),
         },
@@ -92501,6 +93112,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.EnvService = void 0;
 const cos_nodejs_sdk_v5_1 = __importDefault(__webpack_require__(93625));
 const util_1 = __importDefault(__webpack_require__(28354));
+const http_request_1 = __webpack_require__(72088);
+const signature_nodejs_1 = __webpack_require__(77463);
 const error_1 = __webpack_require__(40430);
 const utils_1 = __webpack_require__(62358);
 const constant_1 = __webpack_require__(40762);
@@ -92515,6 +93128,7 @@ class EnvService {
         this.tcbService = new utils_1.CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08');
         this.commonService = environment.getCommonService('lowcode', '2021-01-08');
         this.billingService = new billing_1.BillingService(environment.cloudBaseContext);
+        this.tokenCache = new Map();
     }
     /**
      * 列出所有环境
@@ -92632,7 +93246,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 类型
+        // 将 EnvBaseInfo 完整映射到 EnvInfo 类型，避免新增字段被丢弃
         const envInfo = {
             EnvId: envBaseInfo.EnvId,
             Alias: envBaseInfo.Alias,
@@ -92647,7 +93261,22 @@ class EnvService {
             Region: envBaseInfo.Region || '',
             Source: envBaseInfo.Source,
             CreateTime: envBaseInfo.CreateTime,
-            UpdateTime: envBaseInfo.UpdateTime
+            UpdateTime: envBaseInfo.UpdateTime,
+            StaticStorages: envBaseInfo.StaticStorages,
+            IsAutoDegrade: envBaseInfo.IsAutoDegrade,
+            EnvChannel: envBaseInfo.EnvChannel,
+            PayMode: envBaseInfo.PayMode,
+            IsDefault: envBaseInfo.IsDefault,
+            Tags: envBaseInfo.Tags,
+            EnvType: envBaseInfo.EnvType,
+            IsDauPackage: envBaseInfo.IsDauPackage,
+            PackageType: envBaseInfo.PackageType,
+            ArchitectureType: envBaseInfo.ArchitectureType,
+            Recycle: envBaseInfo.Recycle,
+            EnvPreferences: envBaseInfo.EnvPreferences,
+            Meta: envBaseInfo.Meta,
+            PostgreSQL: envBaseInfo.PostgreSQL,
+            EnvStatus: envBaseInfo.EnvStatus
         };
         return {
             EnvInfo: envInfo,
@@ -92672,6 +93301,18 @@ class EnvService {
     async describeEnvInfo(params) {
         return this.cloudService.request('DescribeEnvInfo', params);
     }
+    /**
+     * 判断当前环境是否为 PostgreSQL 环境
+     * PostgreSQL 字段为数组且长度 > 0 时视为 PG 环境
+     *
+     * @returns 是否为 PG 环境
+     */
+    async isPostgresqlEnv() {
+        var _a, _b;
+        const response = await this.describeEnvInfo({ EnvId: this.envId });
+        const postgresql = (_b = (_a = response === null || response === void 0 ? void 0 : response.EnvInfo) === null || _a === void 0 ? void 0 : _a.EnvBaseInfo) === null || _b === void 0 ? void 0 : _b.PostgreSQL;
+        return Array.isArray(postgresql) && postgresql.length > 0;
+    }
     /**
      * 修改环境名称
      * @param {string} alias 环境名称
@@ -92899,6 +93540,74 @@ class EnvService {
     async describeApiKeyList(options) {
         return this.tcbService.request('DescribeApiKeyList', Object.assign({ EnvId: this.envId }, options));
     }
+    /**
+     * 根据密钥信息获取管理员访问令牌
+     * 使用 secretId、secretKey 和 sessionToken 签发访问令牌
+     * 默认从初始化时的 cloudBaseContext 中读取密钥，也可显式传入 credentials 覆盖
+     * @param {Object} [credentials] 密钥信息，不传则使用初始化时的密钥
+     * @param {string} credentials.secretId 密钥ID
+     * @param {string} credentials.secretKey 密钥Key
+     * @param {string} [credentials.token] sessionToken
+     * @returns {Promise<string>} 访问令牌
+     */
+    async getAdminAccessToken(credentials) {
+        const { secretId, secretKey, token } = credentials || this.environment.cloudBaseContext;
+        if (!secretId || !secretKey) {
+            throw new error_1.CloudBaseError('missing secretId or secretKey of tencent cloud');
+        }
+        const envId = this.envId;
+        const cacheKey = `access_token_secret_${envId}_${secretId}`;
+        const cached = this.tokenCache.get(cacheKey);
+        if (cached && cached.expiry > Date.now()) {
+            return cached.token;
+        }
+        const host = `${envId}${this.environment.cloudBaseContext.isInternalEndpoint()
+            ? '.api.intl.tcloudbasegateway.com'
+            : '.api.tcloudbasegateway.com'}`;
+        const url = `https://${host}/auth/v1/token/clientCredential`;
+        const method = 'POST';
+        const headers = {
+            'Content-Type': 'application/json',
+            Host: host,
+        };
+        const data = { grant_type: 'client_credentials' };
+        const timestamp = Math.floor(new Date().getTime() / 1000) - 1;
+        const { authorization, timestamp: signTimestamp } = (0, signature_nodejs_1.sign)({
+            secretId,
+            secretKey,
+            method,
+            url,
+            headers,
+            params: data,
+            timestamp,
+            withSignedParams: false,
+            isCloudApi: true,
+        });
+        headers['Authorization'] = `${authorization}, Timestamp=${signTimestamp}${token ? `, Token=${token}` : ''}`;
+        headers['X-Signature-Expires'] = 600;
+        headers['X-Timestamp'] = signTimestamp;
+        try {
+            const response = await (0, http_request_1.fetch)(url, {
+                method,
+                headers,
+                body: JSON.stringify(data),
+            });
+            const res = await response.json();
+            const access_token = res === null || res === void 0 ? void 0 : res.access_token;
+            const expires_in = (res === null || res === void 0 ? void 0 : res.expires_in) || 0;
+            if (access_token && expires_in) {
+                this.tokenCache.set(cacheKey, {
+                    token: access_token,
+                    expiry: Date.now() + (expires_in * 1000) / 2,
+                });
+            }
+            return access_token;
+        }
+        catch (e) {
+            console.log(e);
+            throw e;
+        }
+    }
     // 创建自定义登录私钥
     async createCustomLoginKeys() {
         return this.cloudService.request('CreateCustomLoginKeys', {
@@ -112940,6 +113649,52 @@ Promise.PromiseInspection = PromiseInspection;
 };
 
 
+/***/ }),
+
+/***/ 34902:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const utils_1 = __webpack_require__(98786);
+const utils_lang_1 = __webpack_require__(82174);
+const isStream = __webpack_require__(31232);
+/**
+ * 是否能够使用 FormData 发送数据
+ * @param {any} data - 待发送的数据
+ */
+function canUseFormdata(data) {
+    let enable = true;
+    for (const key in data) {
+        const value = data[key];
+        if (!isStream(value) && (utils_1.isNodeEnv() && !Buffer.isBuffer(value)) && !utils_lang_1.isString(value) && !utils_lang_1.isNumber(value)) {
+            enable = false;
+            break;
+        }
+    }
+    return enable;
+}
+exports.canUseFormdata = canUseFormdata;
+/**
+ * 是否一定要通过 FormData 发送数据
+ * 如果有 Buffer 和 Stream 必须用 multipart/form-data，如果同时还含有
+ * @param {any} data - 待发送的数据
+ */
+function mustUseFormdata(data) {
+    let must = false;
+    for (const key in data) {
+        const value = data[key];
+        if ((utils_1.isNodeEnv() && Buffer.isBuffer(value)) || isStream(value)) {
+            must = true;
+            break;
+        }
+    }
+    return must;
+}
+exports.mustUseFormdata = mustUseFormdata;
+
+
 /***/ }),
 
 /***/ 34958:
@@ -115366,6 +116121,59 @@ function callSuccessCallback(callback, entries) {
 }
 
 
+/***/ }),
+
+/***/ 36255:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const utils_lang_1 = __webpack_require__(82174);
+class SortedKeyValue {
+    constructor(obj, selectkeys) {
+        this._keys = [];
+        this._values = [];
+        this._pairs = [];
+        this._obj = {};
+        if (!utils_lang_1.isObject(obj)) {
+            return this;
+        }
+        // https://stackoverflow.com/questions/5525795/does-javascript-guarantee-object-property-order
+        // https://www.stefanjudis.com/today-i-learned/property-order-is-predictable-in-javascript-objects-since-es2015/
+        Object.keys(obj || {}).sort((l, r) => {
+            return l.toString().localeCompare(r);
+        }).forEach(key => {
+            if (!selectkeys || selectkeys.includes(key)) {
+                this._keys.push(key);
+                this._values.push(obj[key]);
+                this._pairs.push([key, obj[key]]);
+                this._obj[key.toLowerCase()] = obj[key];
+            }
+        });
+    }
+    static kv(obj, selectkeys) {
+        return new SortedKeyValue(obj, selectkeys);
+    }
+    get(key) {
+        return this._obj[key];
+    }
+    keys() {
+        return this._keys;
+    }
+    values() {
+        return this._values;
+    }
+    pairs() {
+        return this._pairs;
+    }
+    toString(kvSeparator = '=', joinSeparator = '&') {
+        return this._pairs.map((pair) => pair.join(kvSeparator)).join(joinSeparator);
+    }
+}
+exports.SortedKeyValue = SortedKeyValue;
+
+
 /***/ }),
 
 /***/ 36340:
@@ -125826,6 +126634,7 @@ module.exports = setup;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.removeEmptyStringParams = removeEmptyStringParams;
 exports.buildCapiErrorMessage = buildCapiErrorMessage;
 exports.registerCapiTools = registerCapiTools;
 const zod_1 = __webpack_require__(21614);
@@ -125861,6 +126670,19 @@ function levenshteinDistance(left, right) {
     }
     return matrix[left.length][right.length];
 }
+/**
+ * Remove empty string parameters from the params object.
+ * Tencent Cloud APIs reject empty strings for required parameters like StartTime/EndTime.
+ */
+function removeEmptyStringParams(params) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== "") {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
 function findTcbActionEntry(action) {
     if (tcb_action_index_js_1.TCB_ACTION_INDEX_MAP[action]) {
         return tcb_action_index_js_1.TCB_ACTION_INDEX_MAP[action];
@@ -126047,9 +126869,10 @@ function registerCapiTools(server) {
         }
         let result;
         try {
+            const cleanedParams = params ? removeEmptyStringParams(params) : {};
             result = await cloudbase.commonService(service).call({
                 Action: action,
-                Param: params ?? {},
+                Param: cleanedParams,
             });
         }
         catch (error) {
@@ -135849,7 +136672,7 @@ class TelemetryReporter {
         const nodeVersion = process.version; // Node.js版本
         const arch = os_1.default.arch(); // 系统架构
         // 从构建时注入的版本号获取MCP版本信息
-        const mcpVersion = process.env.npm_package_version || "2.23.3" || 0;
+        const mcpVersion = process.env.npm_package_version || "2.23.5" || 0;
         return {
             userAgent: `${osType} ${osRelease} ${arch} ${nodeVersion} CloudBase-MCP/${mcpVersion}`,
             deviceId: this.deviceId,
@@ -168346,6 +169169,16 @@ class SyncReader extends reader_1.default {
 exports["default"] = SyncReader;
 
 
+/***/ }),
+
+/***/ 57676:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
 /***/ }),
 
 /***/ 57705:
@@ -171475,6 +172308,7 @@ const cloudApp_1 = __webpack_require__(32665);
 const permission_1 = __webpack_require__(24786);
 const sandbox_1 = __webpack_require__(48488);
 const aiModel_1 = __webpack_require__(34800);
+const monitor_1 = __webpack_require__(8901);
 class Environment {
     constructor(context, envId) {
         this.inited = false;
@@ -171500,6 +172334,7 @@ class Environment {
         this.cloudAppService = new cloudApp_1.CloudAppService(this);
         this.sandboxService = new sandbox_1.SandboxService(this);
         this.aiModelService = new aiModel_1.AiModelService(this);
+        this.monitorService = new monitor_1.MonitorService(this);
     }
     async lazyInit() {
         if (!this.inited) {
@@ -171574,6 +172409,9 @@ class Environment {
     getAiModelService() {
         return this.aiModelService;
     }
+    getMonitorService() {
+        return this.monitorService;
+    }
     getCommonService(serviceType = 'tcb', serviceVersion) {
         return new common_1.CommonService(this, serviceType, serviceVersion);
     }
@@ -187714,7 +188552,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CloudBaseContext = void 0;
 const constant_1 = __webpack_require__(40762);
 class CloudBaseContext {
-    constructor({ secretId = '', secretKey = '', token = '', proxy = '', region = '', envType = '', useInternalEndpoint = undefined, internalEndpointRegion = undefined, requestFn = undefined }) {
+    constructor({ secretId = '', secretKey = '', token = '', proxy = '', region = '', envType = '', useInternalEndpoint = undefined, internalEndpointRegion = undefined }) {
         this.secretId = secretId;
         this.secretKey = secretKey;
         this.token = token;
@@ -187723,7 +188561,6 @@ class CloudBaseContext {
         this.envType = envType;
         this.useInternalEndpoint = useInternalEndpoint;
         this.internalEndpointRegion = internalEndpointRegion;
-        this.requestFn = requestFn;
     }
     isInternalEndpoint() {
         return this.useInternalEndpoint !== undefined ? this.useInternalEndpoint : constant_1.USE_INTERNAL_ENDPOINT;
@@ -195620,7 +196457,7 @@ ${envIdSection}
 ## 环境信息
 - 操作系统: ${os_1.default.type()} ${os_1.default.release()}
 - Node.js版本: ${process.version}
-- MCP 版本：${process.env.npm_package_version || "2.23.3" || 0}
+- MCP 版本：${process.env.npm_package_version || "2.23.5" || 0}
 - 系统架构: ${os_1.default.arch()}
 - 时间: ${new Date().toISOString()}
 - 请求ID: ${requestId}
@@ -195701,7 +196538,7 @@ function createWrappedHandler(name, handler, server) {
                 requestId: (typeof error === 'object' && error && 'requestId' in error) ? error.requestId : '',
                 ide: server.ide || process.env.INTEGRATION_IDE || ''
             });
-            const mcpVersion =  true ? "2.23.3" : 0;
+            const mcpVersion =  true ? "2.23.5" : 0;
             const requestIdSuffix = requestId ? `\n🆔 RequestId: ${requestId}` : '';
             const enhancedErrorMessage = `${errorMessage}${requestIdSuffix}\n\n📦 CloudBase MCP v${mcpVersion}\n🔗 遇到问题？请复制以下链接到浏览器打开\n即可自动携带错误详情快速创建 GitHub Issue：\n${issueLink}`;
             // 创建新的错误对象，保持原有的错误类型但更新消息
@@ -197010,7 +197847,7 @@ class UserService {
     }
     async describeUserList(options = {}) {
         const { EnvId } = this.environment.lazyEnvironmentConfig;
-        const { pageNo = 1, pageSize = 20, name, nickName, phone, email } = options;
+        const { pageNo = 1, pageSize = 20, name, nickName, phone, email, uidList } = options;
         if (!Number.isInteger(pageNo) || pageNo < 1) {
             throw new Error('Invalid pageNo');
         }
@@ -197030,6 +197867,8 @@ class UserService {
             reqData.Phone = phone;
         if (this.isValidStr(email))
             reqData.Email = email;
+        if (Array.isArray(uidList) && uidList.length > 0)
+            reqData.UidList = uidList;
         return this.tcbService.request('DescribeUserList', reqData);
     }
     async modifyUser(options) {
@@ -199065,8 +199904,8 @@ class StorageService {
                 typeof cacheControl === 'number' ? `max-age=${cacheControl}` : String(cacheControl);
         }
         if (metadata) {
-            // X-Metadata 放在 Header 里，具体大小限制由服务端/网关决定
-            headers['X-Metadata'] = Buffer.from(JSON.stringify(metadata), 'utf8').toString('base64');
+            // x-metadata 放在 Header 里，具体大小限制由服务端/网关决定
+            headers['x-metadata'] = Buffer.from(JSON.stringify(metadata), 'utf8').toString('base64');
         }
         if (upsert) {
             headers['x-upsert'] = 'true';
@@ -211713,7 +212552,7 @@ function registerSetupTools(server) {
     server.registerTool("downloadTemplate", {
         title: "下载项目模板",
         description: `自动下载并部署CloudBase项目模板。
-**Note**: Call this tool when the user requests to create a new project using a CloudBase template.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.23.3" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
+**Note**: Call this tool when the user requests to create a new project using a CloudBase template.\n\n支持的模板:\n- react: React + CloudBase 全栈应用模板\n- vue: Vue + CloudBase 全栈应用模板\n- miniprogram: 微信小程序 + 云开发模板  \n- uniapp: UniApp + CloudBase 跨端应用模板\n- rules: 只包含AI编辑器配置文件（包含Cursor、WindSurf、CodeBuddy等所有主流编辑器配置），适合在已有项目中补充AI编辑器配置\n\n支持的IDE类型:\n- all: 下载所有IDE配置\n- cursor: Cursor AI编辑器\n- 其他IDE类型见下方列表\n\n注意：如果未传入 ide 参数且无法从环境变量检测到 IDE，将提示错误并要求传入 ide 参数\n- windsurf: WindSurf AI编辑器\n- codebuddy: CodeBuddy AI编辑器\n- claude-code: Claude Code AI编辑器\n- cline: Cline AI编辑器\n- gemini-cli: Gemini CLI\n- opencode: OpenCode AI编辑器\n- qwen-code: 通义灵码\n- baidu-comate: 百度Comate\n- openai-codex-cli: OpenAI Codex CLI\n- augment-code: Augment Code\n- github-copilot: GitHub Copilot\n- roocode: RooCode AI编辑器\n- tongyi-lingma: 通义灵码\n- trae: Trae AI编辑器\n- qoder: Qoder AI编辑器\n- antigravity: Google Antigravity AI编辑器\n- vscode: Visual Studio Code\n- kiro: Kiro AI编辑器\n- aider: Aider AI编辑器\n\n特别说明：\n- rules 模板会自动包含当前 mcp 版本号信息（版本号：${ true ? "2.23.5" : 0}），便于后续维护和版本追踪\n- 下载 rules 模板时，如果项目中已存在 README.md 文件，系统会自动保护该文件不被覆盖（除非设置 overwrite=true）`,
         inputSchema: {
             template: zod_1.z
                 .enum(["react", "vue", "miniprogram", "uniapp", "rules"])
@@ -213556,6 +214395,50 @@ module.exports = function one(fn) {
 };
 
 
+/***/ }),
+
+/***/ 77463:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__export(__webpack_require__(36255));
+__export(__webpack_require__(12129));
+__export(__webpack_require__(34902));
+__export(__webpack_require__(82174));
+__export(__webpack_require__(98786));
+const signer_1 = __webpack_require__(12129);
+const utils_1 = __webpack_require__(98786);
+const clone = __webpack_require__(1779);
+function sign(options) {
+    const { secretId, secretKey, method, url, service, withSignedParams, isCloudApi } = options;
+    // isCloudApi 为 true, 说明使用 cloud api v3, 返回签名值中不能携带 signedParams
+    let validWithSignedParams = withSignedParams;
+    if (isCloudApi === true && withSignedParams === true) {
+        console.warn('isCloudApi 和 withSignedParams 参数同时为 true, withSignedParams 会自动转为 false');
+        validWithSignedParams = false;
+    }
+    const signer = new signer_1.Signer({ secretId, secretKey }, service || 'tcb');
+    const headers = clone(options.headers || {});
+    const params = clone(options.params || {});
+    const timestamp = options.timestamp || utils_1.second() - 1;
+    const signatureInfo = signer.tc3sign(method, url, headers, params, timestamp, {
+        withSignedParams: validWithSignedParams,
+        isCloudApi
+    });
+    return {
+        authorization: signatureInfo.authorization,
+        timestamp: signatureInfo.timestamp,
+        multipart: signatureInfo.multipart
+    };
+}
+exports.sign = sign;
+
+
 /***/ }),
 
 /***/ 77474:
@@ -221900,13 +222783,12 @@ function getDate(timestamp) {
 }
 class CloudService {
     /* eslint-disable-next-line */
-    constructor(context, service, version, baseParams, requestFn) {
+    constructor(context, service, version, baseParams) {
         this.service = service;
         this.version = version;
         this.timeout = 60000;
         this.baseParams = baseParams || {};
         this.cloudBaseContext = context;
-        this.requestFn = requestFn !== null && requestFn !== void 0 ? requestFn : context.requestFn;
     }
     get baseUrl() {
         const internalEndpoint = this.cloudBaseContext.isInternalEndpoint();
@@ -221938,31 +222820,8 @@ class CloudService {
         }
     }
     async request(action, data = {}, method = 'POST') {
-        var _a;
         this.action = action;
         this.data = deepRemoveVoid(Object.assign(Object.assign({}, data), this.baseParams));
-        // 如果注入了 requestFn，直接委托，跳过 TC3 签名逻辑
-        if (this.requestFn) {
-            try {
-                const result = await this.requestFn({
-                    service: this.service,
-                    action,
-                    version: this.version,
-                    region: (_a = this.cloudBaseContext.region) !== null && _a !== void 0 ? _a : '',
-                    payload: this.data,
-                });
-                return result;
-            }
-            catch (e) {
-                if (e.name === 'CloudBaseError') {
-                    throw e;
-                }
-                throw new error_1.CloudBaseError(e.message, {
-                    action,
-                    code: e.code
-                });
-            }
-        }
         this.method = method;
         this.url = this.baseUrl;
         let { secretId, secretKey, token } = this.cloudBaseContext;
@@ -222363,6 +223222,32 @@ webpackEmptyContext.resolve = webpackEmptyContext;
 webpackEmptyContext.id = 82154;
 module.exports = webpackEmptyContext;
 
+/***/ }),
+
+/***/ 82174:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+function isNumber(v) {
+    return v === +v;
+}
+exports.isNumber = isNumber;
+function isString(v) {
+    return typeof v === 'string';
+}
+exports.isString = isString;
+function isObject(v) {
+    return v != null && typeof v === 'object' && Array.isArray(v) === false;
+}
+exports.isObject = isObject;
+function isPlainObject(v) {
+    return isObject(v) && [null, Object.prototype].includes(Object.getPrototypeOf(v));
+}
+exports.isPlainObject = isPlainObject;
+
+
 /***/ }),
 
 /***/ 82218:
@@ -252713,7 +253598,7 @@ const queryStorageInputSchema = {
 // Input schema for manageStorage tool
 const manageStorageInputSchema = {
     action: zod_1.z.enum(['upload', 'download', 'delete']).describe('管理操作类型：upload=上传文件或目录，download=下载文件或目录，delete=删除文件或目录'),
-    localPath: zod_1.z.string().describe('本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt'),
+    localPath: zod_1.z.string().optional().describe('本地文件路径，建议传入绝对路径，例如 /tmp/files/data.txt；upload/download 操作时必填，delete 操作时不需要传该参数'),
     cloudPath: zod_1.z.string().describe('云端文件路径，例如 files/data.txt'),
     force: zod_1.z.boolean().optional().default(false).describe('强制操作开关，删除操作时建议设置为true以确认删除，默认false'),
     isDirectory: zod_1.z.boolean().optional().default(false).describe('是否为目录操作，true=目录操作，false=文件操作，默认false')
@@ -252963,14 +253848,16 @@ function registerStorageTools(server) {
         const storageService = manager.storage;
         switch (input.action) {
             case 'upload': {
+                const localPath = input.localPath;
+                const cloudPath = input.cloudPath;
                 if (input.isDirectory) {
                     if (storageOverrides?.uploadDirectory) {
-                        await storageOverrides.uploadDirectory({ localPath: input.localPath, cloudPath: input.cloudPath });
+                        await storageOverrides.uploadDirectory({ localPath, cloudPath });
                     }
                     else {
                         await storageService.uploadDirectory({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
+                            localPath,
+                            cloudPath,
                             onProgress: (progressData) => {
                                 console.log("Upload directory progress:", progressData);
                             }
@@ -252979,12 +253866,12 @@ function registerStorageTools(server) {
                 }
                 else {
                     if (storageOverrides?.uploadFile) {
-                        await storageOverrides.uploadFile({ localPath: input.localPath, cloudPath: input.cloudPath });
+                        await storageOverrides.uploadFile({ localPath, cloudPath });
                     }
                     else {
                         await storageService.uploadFile({
-                            localPath: input.localPath,
-                            cloudPath: input.cloudPath,
+                            localPath,
+                            cloudPath,
                             onProgress: (progressData) => {
                                 console.log("Upload file progress:", progressData);
                             }
@@ -253051,25 +253938,27 @@ function registerStorageTools(server) {
                 };
             }
             case 'download': {
+                const dlCloudPath = input.cloudPath;
+                const dlLocalPath = input.localPath;
                 if (input.isDirectory) {
                     if (storageOverrides?.downloadDirectory) {
-                        await storageOverrides.downloadDirectory({ cloudPath: input.cloudPath, localPath: input.localPath });
+                        await storageOverrides.downloadDirectory({ cloudPath: dlCloudPath, localPath: dlLocalPath });
                     }
                     else {
                         await storageService.downloadDirectory({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
+                            cloudPath: dlCloudPath,
+                            localPath: dlLocalPath
                         });
                     }
                 }
                 else {
                     if (storageOverrides?.downloadFile) {
-                        await storageOverrides.downloadFile({ cloudPath: input.cloudPath, localPath: input.localPath });
+                        await storageOverrides.downloadFile({ cloudPath: dlCloudPath, localPath: dlLocalPath });
                     }
                     else {
                         await storageService.downloadFile({
-                            cloudPath: input.cloudPath,
-                            localPath: input.localPath
+                            cloudPath: dlCloudPath,
+                            localPath: dlLocalPath
                         });
                     }
                 }
@@ -261405,9 +262294,9 @@ class CloudBase {
     }
     constructor(config = {}) {
         this.cloudBaseConfig = {};
-        let { secretId, secretKey, token, envId, proxy, region, envType, useInternalEndpoint, internalEndpointRegion, requestFn } = config;
-        // config 中传入的 secretId secretkey 必须同时存在（有 requestFn 时可以不传）
-        if (!requestFn && ((secretId && !secretKey) || (!secretId && secretKey))) {
+        let { secretId, secretKey, token, envId, proxy, region, envType, useInternalEndpoint, internalEndpointRegion } = config;
+        // config 中传入的 secretId secretkey 必须同时存在
+        if ((secretId && !secretKey) || (!secretId && secretKey)) {
             throw new Error('secretId and secretKey must be a pair');
         }
         this.cloudBaseConfig = {
@@ -261420,7 +262309,6 @@ class CloudBase {
             region,
             useInternalEndpoint,
             internalEndpointRegion,
-            requestFn,
         };
         // 初始化 context
         this.context = new context_1.CloudBaseContext(this.cloudBaseConfig);
@@ -261509,6 +262397,9 @@ class CloudBase {
     get aiModel() {
         return this.currentEnvironment().getAiModelService();
     }
+    get monitor() {
+        return this.currentEnvironment().getMonitorService();
+    }
     get docs() {
         if (!this.docsService) {
             this.docsService = new docs_1.DocsService();
@@ -266328,6 +267219,48 @@ if (typeof fs.realpath.native === 'function') {
 }
 
 
+/***/ }),
+
+/***/ 98786:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const crypto = __webpack_require__(55511);
+function formateDate(timestamp) {
+    return new Date(timestamp * 1000).toISOString().split('T')[0];
+}
+exports.formateDate = formateDate;
+function second() {
+    // istanbul ignore next
+    return Math.floor(new Date().getTime() / 1000);
+}
+exports.second = second;
+function stringify(v) {
+    return typeof v !== 'string' ? JSON.stringify(v) : v;
+}
+exports.stringify = stringify;
+function sha256hash(string, encoding = 'hex') {
+    return crypto
+        .createHash('sha256')
+        .update(string)
+        .digest(encoding);
+}
+exports.sha256hash = sha256hash;
+function sha256hmac(string, secret = '', encoding) {
+    return crypto
+        .createHmac('sha256', secret)
+        .update(string)
+        .digest(encoding);
+}
+exports.sha256hmac = sha256hmac;
+function isNodeEnv() {
+    return process && process.release && process.release.name === 'node';
+}
+exports.isNodeEnv = isNodeEnv;
+
+
 /***/ }),
 
 /***/ 98916: