mcp-server-esa 1.0.7 → 1.0.9

package/dist/index.js

@@ -1,6 +1,154 @@
-#!/usr/bin/env node
 "use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./src/index.js": function(module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var _modelcontextprotocol_sdk_server_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@modelcontextprotocol/sdk/server/index.js");
+                var _modelcontextprotocol_sdk_server_stdio_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("@modelcontextprotocol/sdk/server/stdio.js");
+                var _modelcontextprotocol_sdk_types_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("@modelcontextprotocol/sdk/types.js");
+                const server = new _modelcontextprotocol_sdk_server_index_js__WEBPACK_IMPORTED_MODULE_0__.Server({
+                    name: 'example-server',
+                    version: '1.0.0'
+                }, {
+                    capabilities: {
+                        tools: {}
+                    }
+                });
+                server.setRequestHandler(_modelcontextprotocol_sdk_types_js__WEBPACK_IMPORTED_MODULE_2__.ListToolsRequestSchema, async ()=>({
+                        tools: [
+                            {
+                                name: 'calculate_sum',
+                                description: 'Add two numbers together',
+                                inputSchema: {
+                                    type: 'object',
+                                    properties: {
+                                        a: {
+                                            type: 'number'
+                                        },
+                                        b: {
+                                            type: 'number'
+                                        }
+                                    },
+                                    required: [
+                                        'a',
+                                        'b'
+                                    ]
+                                }
+                            }
+                        ]
+                    }));
+                server.setRequestHandler(_modelcontextprotocol_sdk_types_js__WEBPACK_IMPORTED_MODULE_2__.CallToolRequestSchema, async (request)=>{
+                    if ('calculate_sum' === request.params.name) {
+                        const { a, b } = request.params.arguments;
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: String(a + b)
+                                }
+                            ]
+                        };
+                    }
+                    throw new Error('Tool not found');
+                });
+                const transport = new _modelcontextprotocol_sdk_server_stdio_js__WEBPACK_IMPORTED_MODULE_1__.StdioServerTransport();
+                await server.connect(transport);
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        }, 1);
+    },
+    "@modelcontextprotocol/sdk/server/index.js": function(module) {
+        module.exports = require("@modelcontextprotocol/sdk/server/index.js");
+    },
+    "@modelcontextprotocol/sdk/server/stdio.js": function(module) {
+        module.exports = require("@modelcontextprotocol/sdk/server/stdio.js");
+    },
+    "@modelcontextprotocol/sdk/types.js": function(module) {
+        module.exports = require("@modelcontextprotocol/sdk/types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__";
+    var webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__";
+    var webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (dep[webpackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[webpackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[webpackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[webpackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[webpackQueues] = function() {};
+            ret[webpackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports1 = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[webpackExports] = exports1;
+        promise[webpackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](function() {});
+        };
+        module.exports = promise;
+        body((deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[webpackError]) throw d[webpackError];
+                    return d[webpackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[webpackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        }, (err)=>(err ? reject(promise[webpackError] = err) : outerResolve(exports1), resolveQueue(queue)));
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -21,1294 +169,17 @@ var __webpack_require__ = {};
 (()=>{
     __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();
-var __webpack_exports__ = {};
-const index_js_namespaceObject = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_namespaceObject = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_namespaceObject = require("@modelcontextprotocol/sdk/types.js");
-const esa20240910_namespaceObject = require("@alicloud/esa20240910");
-var esa20240910_default = /*#__PURE__*/ __webpack_require__.n(esa20240910_namespaceObject);
-const openapi_client_namespaceObject = require("@alicloud/openapi-client");
-const tea_util_namespaceObject = require("@alicloud/tea-util");
-const external_form_data_namespaceObject = require("form-data");
-var external_form_data_default = /*#__PURE__*/ __webpack_require__.n(external_form_data_namespaceObject);
-const external_node_fetch_namespaceObject = require("node-fetch");
-var external_node_fetch_default = /*#__PURE__*/ __webpack_require__.n(external_node_fetch_namespaceObject);
-function log(...args) {
-    const msg = `[DEBUG ${new Date().toISOString()}] ${args.join(' ')}\n`;
-    process.stderr.write(msg);
-}
-const uploadCodeToOSS = async (res, code)=>{
-    var _res_body;
-    const ossConfig = null == res ? void 0 : null === (_res_body = res.body) || void 0 === _res_body ? void 0 : _res_body.ossPostConfig;
-    if (200 !== res.statusCode || !ossConfig) return false;
-    const { OSSAccessKeyId, Signature, callback, Url, key, policy } = ossConfig;
-    const formData = new (external_form_data_default())();
-    formData.append('OSSAccessKeyId', OSSAccessKeyId);
-    formData.append('Signature', Signature);
-    formData.append('callback', callback);
-    formData.append("x:codeDescription", ossConfig["x:codeDescription"]);
-    formData.append('policy', policy);
-    formData.append('key', key);
-    formData.append('file', code);
-    const ossRes = await external_node_fetch_default()(Url, {
-        method: 'POST',
-        body: formData,
-        headers: formData.getHeaders()
-    });
-    return ossRes && 200 === ossRes.status;
-};
-const RuleMatchTypeHost = 'http.host';
-const RuleMatchTypeUriPath = 'http.request.uri.path';
-const RuleMatchOperatorEq = "eq";
-const RuleMatchOperatorStartsWith = "starts_with";
-const RuleMatchOperatorEndsWith = "ends_with";
-const transferRouteToRuleString = (routePath)=>{
-    if (!routePath) return '';
-    const index = routePath.indexOf('/');
-    let host = '';
-    let uriPath = '';
-    if (index < 0) {
-        host = routePath;
-        uriPath = '/';
-    } else {
-        host = routePath.substring(0, index);
-        uriPath = routePath.substring(index);
-    }
-    let hostOperator = RuleMatchOperatorEq;
-    if (host.startsWith('*')) {
-        hostOperator = RuleMatchOperatorEndsWith;
-        host = host.replace(/\*/g, '');
-    }
-    let uriPathOperator = RuleMatchOperatorEq;
-    if (uriPath.endsWith('*')) {
-        uriPathOperator = RuleMatchOperatorStartsWith;
-        uriPath = uriPath.replace(/\*$/, '');
-    }
-    let ruleStr = '';
-    if (hostOperator === RuleMatchOperatorEq) {
-        if (uriPathOperator === RuleMatchOperatorEq) ruleStr = `(${RuleMatchTypeHost} ${hostOperator} "${host}" and ${RuleMatchTypeUriPath} ${uriPathOperator} "${uriPath}")`;
-        else if (uriPathOperator === RuleMatchOperatorStartsWith) ruleStr = `(${RuleMatchTypeHost} ${hostOperator} "${host}" and ${RuleMatchOperatorStartsWith}(${RuleMatchTypeUriPath}, "${uriPath}"))`;
-    } else if (hostOperator === RuleMatchOperatorEndsWith) {
-        if (uriPathOperator === RuleMatchOperatorEq) ruleStr = `(${RuleMatchOperatorEndsWith}(${RuleMatchTypeHost}, "${host}") and ${RuleMatchTypeUriPath} ${uriPathOperator} "${uriPath}")`;
-        else if (uriPathOperator === RuleMatchOperatorStartsWith) ruleStr = `(${RuleMatchOperatorEndsWith}(${RuleMatchTypeHost}, "${host}") and ${RuleMatchOperatorStartsWith}(${RuleMatchTypeUriPath}, "${uriPath}"))`;
-    }
-    return ruleStr;
-};
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-class Client {
-    static createClient(config) {
-        var _config_auth, _config_auth1, _config_auth2;
-        const apiConfig = new openapi_client_namespaceObject.Config({
-            accessKeyId: (null === (_config_auth = config.auth) || void 0 === _config_auth ? void 0 : _config_auth.accessKeyId) || '',
-            accessKeySecret: (null === (_config_auth1 = config.auth) || void 0 === _config_auth1 ? void 0 : _config_auth1.accessKeySecret) || '',
-            securityToken: (null === (_config_auth2 = config.auth) || void 0 === _config_auth2 ? void 0 : _config_auth2.securityToken) || '',
-            endpoint: config.endpoint
-        });
-        return new (esa20240910_default())(apiConfig);
-    }
-    createRoutine(params) {
-        const request = new esa20240910_namespaceObject.CreateRoutineRequest(params);
-        log('Creating routine with parameters:', JSON.stringify(params));
-        return this.callApi(this.client.createRoutine.bind(this.client), request);
-    }
-    deleteRoutine(params) {
-        const request = new esa20240910_namespaceObject.DeleteRoutineRequest(params);
-        return this.callApi(this.client.deleteRoutineWithOptions.bind(this.client), request);
-    }
-    getRoutine(params) {
-        const request = new esa20240910_namespaceObject.GetRoutineRequest(params);
-        return this.callApi(this.client.getRoutineWithOptions.bind(this.client), request);
-    }
-    getRoutineUserInfo() {
-        return this.callApi(this.client.getRoutineUserInfo.bind(this.client));
-    }
-    async getRoutineStagingCodeUploadInfo(params) {
-        const request = new esa20240910_namespaceObject.GetRoutineStagingCodeUploadInfoRequest(params);
-        return this.callApi(this.client.getRoutineStagingCodeUploadInfo.bind(this.client), request);
-    }
-    commitRoutineStagingCode(params) {
-        const request = new esa20240910_namespaceObject.CommitRoutineStagingCodeRequest(params);
-        return this.callApi(this.client.commitRoutineStagingCode.bind(this.client), request);
-    }
-    publishRoutineCodeVersion(params) {
-        const request = new esa20240910_namespaceObject.PublishRoutineCodeVersionRequest(params);
-        return this.callApi(this.client.publishRoutineCodeVersion.bind(this.client), request);
-    }
-    listRoutineCanaryAreas() {
-        return this.callApi(this.client.listRoutineCanaryAreas.bind(this.client));
-    }
-    listSites(params) {
-        const request = new esa20240910_namespaceObject.ListSitesRequest(params);
-        return this.callApi(this.client.listSites.bind(this.client), request);
-    }
-    deleteRoutineCodeVersion(params) {
-        const request = new esa20240910_namespaceObject.DeleteRoutineCodeVersionRequest(params);
-        return this.callApi(this.client.deleteRoutineCodeVersion.bind(this.client), request);
-    }
-    createRoutineRelatedRecord(params) {
-        const request = new esa20240910_namespaceObject.CreateRoutineRelatedRecordRequest(params);
-        return this.callApi(this.client.createRoutineRelatedRecord.bind(this.client), request);
-    }
-    createRoutineRoute(params) {
-        const request = new esa20240910_namespaceObject.CreateRoutineRouteRequest(params);
-        return this.callApi(this.client.createRoutineRoute.bind(this.client), request);
-    }
-    deleteRoutineRoute(params) {
-        const request = new esa20240910_namespaceObject.DeleteRoutineRouteRequest(params);
-        return this.callApi(this.client.deleteRoutineRoute.bind(this.client), request);
-    }
-    getRoutineRoute(params) {
-        const request = new esa20240910_namespaceObject.GetRoutineRouteRequest(params);
-        return this.callApi(this.client.getRoutineRoute.bind(this.client), request);
-    }
-    listSiteRoutes(params) {
-        const request = new esa20240910_namespaceObject.ListSiteRoutesRequest(params);
-        return this.callApi(this.client.listSiteRoutes.bind(this.client), request);
-    }
-    listRoutineRoutes(params) {
-        const request = new esa20240910_namespaceObject.ListRoutineRoutesRequest(params);
-        return this.callApi(this.client.listRoutineRoutes.bind(this.client), request);
-    }
-    updateRoutineRoute(params) {
-        const request = new esa20240910_namespaceObject.UpdateRoutineRouteRequest(params);
-        return this.callApi(this.client.updateRoutineRoute.bind(this.client), request);
-    }
-    deleteRoutineRelatedRecord(params) {
-        const request = new esa20240910_namespaceObject.DeleteRoutineRelatedRecordRequest(params);
-        return this.callApi(this.client.deleteRoutineRelatedRecord.bind(this.client), request);
-    }
-    getMatchSite(requestParams) {
-        const params = {
-            action: 'GetMatchSite',
-            version: '2024-09-10',
-            protocol: 'https',
-            method: 'GET',
-            authType: 'AK',
-            bodyType: 'json',
-            reqBodyType: 'json',
-            style: 'RPC',
-            pathname: '/',
-            toMap: function() {
-                return this;
-            }
-        };
-        const request = new openapi_client_namespaceObject.OpenApiRequest({
-            query: {
-                RecordName: requestParams.recordName
-            }
-        });
-        const runtime = {
-            toMap: function() {
-                return this;
-            }
-        };
-        return this.client.callApi(params, request, runtime);
-    }
-    listRoutineRelatedRecords(requestParams) {
-        const params = {
-            action: 'ListRoutineRelatedRecords',
-            version: '2024-09-10',
-            protocol: 'https',
-            method: 'GET',
-            authType: 'AK',
-            bodyType: 'json',
-            reqBodyType: 'json',
-            style: 'RPC',
-            pathname: '/',
-            toMap: function() {
-                return this;
-            }
-        };
-        const request = new openapi_client_namespaceObject.OpenApiRequest({
-            query: {
-                Name: requestParams.Name,
-                PageNumber: requestParams.PageNumber,
-                PageSize: requestParams.PageSize,
-                SearchKeyWord: requestParams.SearchKeyWord
-            }
-        });
-        const runtime = {
-            toMap: function() {
-                return this;
-            }
-        };
-        return this.client.callApi(params, request, runtime);
-    }
-    createRecord(params) {
-        const request = new esa20240910_namespaceObject.CreateRecordRequest(params);
-        return this.callApi(this.client.createRecord.bind(this.client), request);
-    }
-    listRecords(params) {
-        const request = new esa20240910_namespaceObject.ListRecordsRequest(params);
-        return this.callApi(this.client.listRecords.bind(this.client), request);
-    }
-    constructor(){
-        _define_property(this, "client", void 0);
-        _define_property(this, "callApi", async (action, request)=>{
-            const runtime = new tea_util_namespaceObject.RuntimeOptions({
-                connectTimeout: 10000,
-                readTimeout: 10000,
-                autoretry: true,
-                maxAttempts: 3
-            });
-            const response = request ? await action(request, runtime) : await action(runtime);
-            return response;
-        });
-        const config = {
-            auth: {
-                accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID || '',
-                accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET || '',
-                securityToken: process.env.ALIBABA_CLOUD_SECURITY_TOKEN
-            },
-            endpoint: 'esa.cn-hangzhou.aliyuncs.com'
-        };
-        this.client = Client.createClient(config);
-    }
-}
-const service = new Client();
-const ROUTINE_CODE_COMMIT_TOOL = {
-    name: 'routine_code_commit',
-    description: 'Save a code version for future modifications or release within an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine, support lowercase English, numbers, and hyphens, must start with lowercase English, length cannot be less than 2 characters'
-            },
-            description: {
-                type: 'string',
-                description: "Description of the routine, no spaces"
-            },
-            code: {
-                type: 'string',
-                description: 'Source Code of the routine, export default { async fetch(request) { return handleRequest(request); } }'
-            }
-        },
-        required: [
-            'name',
-            'code'
-        ]
-    }
-};
-const routine_code_commit = async (request)=>{
-    const res = await service.getRoutineStagingCodeUploadInfo(request.params.arguments);
-    if (!res) return {
-        content: [
-            {
-                type: 'text',
-                text: `Failed to get routine staging code upload info. ${JSON.stringify(res)}`
-            }
-        ],
-        success: false
-    };
-    {
-        var _request_params_arguments, _request_params;
-        const uploadRes = await uploadCodeToOSS(res, null == request ? void 0 : null === (_request_params = request.params) || void 0 === _request_params ? void 0 : null === (_request_params_arguments = _request_params.arguments) || void 0 === _request_params_arguments ? void 0 : _request_params_arguments.code);
-        if (true !== uploadRes) return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to upload code to OSS. ${uploadRes}`
-                }
-            ],
-            success: false
-        };
-        {
-            const commitRes = await service.commitRoutineStagingCode(request.params.arguments);
-            if (200 !== commitRes.statusCode) return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to commit routine staging code. ${JSON.stringify(commitRes)}`
-                    }
-                ],
-                success: false
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(commitRes)
-                    }
-                ],
-                success: true
-            };
-        }
-    }
-};
-const ROUTINE_CODE_DEPLOY_TOOL = {
-    name: 'routine_code_deploy',
-    description: 'Deploy a selected code version to the staging or production environment. If version is not exist, should call routine_code_commit first',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine, support lowercase English, numbers, and hyphens, must start with lowercase English, length cannot be less than 2 characters'
-            },
-            codeVersion: {
-                type: 'string',
-                description: 'Version of the routine, must be a valid semantic version'
-            },
-            env: {
-                type: 'string',
-                description: 'Environment of the routine, must be "production" or "staging". If the user has no special requirements, it will be deployed to the production environment by default'
-            },
-            canaryAreaList: {
-                type: 'array',
-                description: 'The regions for canary release, must be a valid region name. Need to call ListRoutineCanaryAreas method to get'
-            },
-            canaryCodeVersion: {
-                type: 'string',
-                description: 'Version of the routine, must be a valid semantic version'
-            }
-        },
-        required: [
-            'name',
-            'codeVersion',
-            'env'
-        ]
-    }
-};
-const CANARY_AREA_LIST = {
-    name: 'canary_area_list',
-    description: 'List all available canary areas for routine deployment',
-    inputSchema: {
-        type: 'object',
-        properties: {}
-    }
-};
-const routine_code_deploy = async (request)=>{
-    const res = await service.publishRoutineCodeVersion(request.params.arguments);
-    if (!res) return {
-        content: [
-            {
-                type: 'text',
-                text: `Failed to publish routine code version. ${JSON.stringify(res)}`
-            }
-        ],
-        success: false
-    };
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const canary_area_list = async ()=>{
-    const res = await service.listRoutineCanaryAreas();
-    if (200 !== res.statusCode) return {
-        content: [
-            {
-                type: 'text',
-                text: `Failed to list canary areas. ${JSON.stringify(res)}`
-            }
-        ],
-        success: false
-    };
-    var _res_body;
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify((null === (_res_body = res.body) || void 0 === _res_body ? void 0 : _res_body.canaryAreas) || [])
-            }
-        ],
-        success: true
-    };
-};
-const DEPLOYMENT_DELETE_TOOL = {
-    name: 'deployment_delete',
-    description: 'Delete a specified code version associated with an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the deployment to delete'
-            },
-            codeVersion: {
-                type: 'string',
-                description: 'The version of the code to delete'
-            }
-        },
-        required: [
-            'name',
-            'codeVersion'
-        ]
-    }
-};
-const deployment_delete = async (request)=>{
-    const res = await service.deleteRoutineCodeVersion(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const ER_RECORD_CREATE_TOOL = {
-    name: 'er_record_create',
-    description: 'Create a new record associated with an Edge Routine (ER)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            recordName: {
-                type: 'string',
-                description: 'The name of the record'
-            }
-        },
-        required: [
-            'name',
-            'siteId',
-            'recordName'
-        ]
-    }
-};
-const ER_RECORD_DELETE_TOOL = {
-    name: 'er_record_delete',
-    description: 'Delete a specified record associated with an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            recordId: {
-                type: 'number',
-                description: 'The ID of the record'
-            },
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            recordName: {
-                type: 'string',
-                description: 'The name of the record'
-            }
-        },
-        required: [
-            'name',
-            'siteId',
-            'recordName'
-        ]
-    }
-};
-const ER_RECORD_LIST_TOOL = {
-    name: 'er_record_list',
-    description: 'List all records associated with a specific Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            Name: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            PageNumber: {
-                type: 'number',
-                description: 'The page number of the records'
-            },
-            PageSize: {
-                type: 'number',
-                description: 'The page size of the records'
-            },
-            SearchKeyWord: {
-                type: 'string',
-                description: 'The search key word of the records'
-            }
-        },
-        required: [
-            'Name'
-        ]
-    }
-};
-const er_record_create = async (request)=>{
-    const res = await service.createRoutineRelatedRecord(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const er_record_delete = async (request)=>{
-    const res = await service.deleteRoutineRelatedRecord(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const er_record_list = async (request)=>{
-    const res = await service.listRoutineRelatedRecords(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const ROUTE_CREATE_TOOL = {
-    name: 'route_create',
-    description: 'Create a new route associated with an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            mode: {
-                type: 'enum',
-                enum: [
-                    'simple',
-                    'custom'
-                ],
-                description: 'The mode of the route, default is simple'
-            },
-            route: {
-                type: 'string',
-                description: 'The route of the route, if mode is simple, this field is required. For example: test.example.com/*'
-            },
-            rule: {
-                type: 'string',
-                description: 'The rule of the route, if mode is custom, this field is required'
-            },
-            routineName: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            routeName: {
-                type: 'string',
-                description: 'The name of the route, use to identify the route. For example: test-route'
-            },
-            bypass: {
-                type: 'enum',
-                enum: [
-                    'on',
-                    'off'
-                ],
-                description: 'The bypass of the route, default is off'
-            },
-            routeEnable: {
-                type: 'enum',
-                enum: [
-                    'on',
-                    'off'
-                ],
-                description: 'The enable of the route, default is on'
-            },
-            sequence: {
-                type: 'number',
-                description: 'The sequence of the route, if not passed, default is the current number of routes'
-            }
-        },
-        required: [
-            'siteId',
-            'mode',
-            'rule',
-            'routineName',
-            'routeName',
-            'bypass',
-            'routeEnable'
-        ]
-    }
-};
-const ROUTE_UPDATE_TOOL = {
-    name: 'route_update',
-    description: 'Modify the configuration of an existing Edge Routine route.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            configId: {
-                type: 'number',
-                description: 'The ID of the config'
-            },
-            routeName: {
-                type: 'string',
-                description: 'The name of the route, use to identify the route.'
-            },
-            routeEnable: {
-                type: 'enum',
-                enum: [
-                    'on',
-                    'off'
-                ],
-                description: 'The enable of the route'
-            },
-            rule: {
-                type: 'string',
-                description: 'The rule of the route'
-            },
-            routineName: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            bypass: {
-                type: 'enum',
-                enum: [
-                    'on',
-                    'off'
-                ],
-                description: 'The bypass of the route '
-            },
-            sequence: {
-                type: 'number',
-                description: 'The sequence of the route, if not passed, default is the current number of routes'
-            }
-        },
-        required: [
-            'siteId',
-            'configId',
-            'routeName',
-            'routeEnable',
-            'rule',
-            'routineName',
-            'bypass'
-        ]
-    }
-};
-const ROUTE_DELETE_TOOL = {
-    name: 'route_delete',
-    description: 'Delete a specified route associated with an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            configId: {
-                type: 'number',
-                description: 'The ID of the config'
-            }
-        },
-        required: [
-            'siteId',
-            'configId'
-        ]
-    }
-};
-const ROUTE_GET_TOOL = {
-    name: 'route_get',
-    description: 'Get details of a specific route associated with an Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            configId: {
-                type: 'number',
-                description: 'The ID of the config'
-            }
-        },
-        required: [
-            'siteId',
-            'configId'
-        ]
-    }
-};
-const ROUTINE_ROUTE_LIST_TOOL = {
-    name: 'routine_route_list',
-    description: 'List all routes associated with a specific Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            routineName: {
-                type: 'string',
-                description: 'The name of the routine'
-            },
-            routeName: {
-                type: 'string',
-                description: 'The name of the route, use to filter list results'
-            },
-            pageNumber: {
-                type: 'number',
-                description: 'The page number of the routes'
-            },
-            pageSize: {
-                type: 'number',
-                description: 'The page size of the routes'
-            }
-        },
-        required: [
-            'routineName'
-        ]
-    }
-};
-const SITE_ROUTE_LIST_TOOL = {
-    name: 'site_route_list',
-    description: 'List all routes associated with a specific site.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site'
-            },
-            routeName: {
-                type: 'string',
-                description: 'The name of the route, use to filter list results'
-            },
-            pageNumber: {
-                type: 'number',
-                description: 'The page number of the routes'
-            },
-            pageSize: {
-                type: 'number',
-                description: 'The page size of the routes'
-            }
-        },
-        required: [
-            'siteId'
-        ]
-    }
-};
-const route_create = async (request)=>{
-    const { mode, route } = request.params.arguments;
-    if ('simple' === mode) {
-        const res = await service.createRoutineRoute({
-            ...request.params.arguments,
-            rule: transferRouteToRuleString(route)
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
         });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res)
-                }
-            ],
-            success: true
-        };
-    }
-    {
-        const res = await service.createRoutineRoute(request.params.arguments);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res)
-                }
-            ],
-            success: true
-        };
-    }
-};
-const route_delete = async (request)=>{
-    const res = await service.deleteRoutineRoute(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const route_update = async (request)=>{
-    const { mode, route } = request.params.arguments;
-    if ('simple' === mode) {
-        const res = await service.updateRoutineRoute({
-            ...request.params.arguments,
-            rule: transferRouteToRuleString(route)
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
         });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res)
-                }
-            ],
-            success: true
-        };
-    }
-    {
-        const res = await service.updateRoutineRoute(request.params.arguments);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(res)
-                }
-            ],
-            success: true
-        };
-    }
-};
-const route_get = async (request)=>{
-    const res = await service.getRoutineRoute(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const routine_route_list = async (request)=>{
-    const res = await service.listRoutineRoutes(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const site_route_list = async (request)=>{
-    const res = await service.listSiteRoutes(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const ROUTINE_CREATE_TOOL = {
-    name: 'routine_create',
-    description: 'Create a new Edge Routine (ER) in your Alibaba Cloud account.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine, support lowercase English, numbers, and hyphens, must start with lowercase English, length cannot be less than 2 characters'
-            },
-            description: {
-                type: 'string',
-                description: "Description of the routine, no spaces"
-            },
-            code: {
-                type: 'string',
-                description: 'Source Code of the routine, export default { async fetch(request) { return handleRequest(request); } }'
-            }
-        },
-        required: [
-            'name',
-            'code'
-        ]
-    }
-};
-const ROUTINE_DELETE_TOOL = {
-    name: 'routine_delete',
-    description: 'Delete an existing Edge Routine (ER) from your Alibaba Cloud account.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine to delete'
-            }
-        },
-        required: [
-            'name'
-        ]
-    }
-};
-const ROUTINE_LIST_TOOL = {
-    name: 'routine_list',
-    description: 'List all Edge Routines (ERs) in your Alibaba Cloud account.',
-    inputSchema: {
-        type: 'object',
-        properties: {}
-    }
-};
-const ROUTINE_GET_TOOL = {
-    name: 'routine_get',
-    description: 'Get a the details of a Edge Routine (ER).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: {
-                type: 'string',
-                description: 'The name of the routine to get details for'
-            }
-        },
-        required: [
-            'name'
-        ]
-    }
-};
-const routine_create = async (request)=>{
-    const res = await service.createRoutine(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const routine_delete = async (request)=>{
-    const res = await service.deleteRoutine(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const routine_list = async ()=>{
-    const res = await service.getRoutineUserInfo();
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const routine_get = async (request)=>{
-    const res = await service.getRoutine(request.params.arguments);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const SITE_ACTIVE_LIST_TOOL = {
-    name: 'site_active_list',
-    description: 'List all active sites',
-    inputSchema: {
-        type: 'object',
-        properties: {}
-    }
-};
-const SITE_MATCH_TOOL = {
-    name: 'site_match',
-    description: 'Identify which site in the account matches the provided input criteria.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            recordName: {
-                type: 'string',
-                description: 'The name of the site to match'
-            }
-        },
-        required: [
-            'recordName'
-        ]
-    }
-};
-const SITE_DNS_A_RECORD_CREATE_TOOL = {
-    name: 'site_dns_a_record_create',
-    description: 'Create an A DNS record for a specified site.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            recordName: {
-                type: 'string',
-                description: 'The name of the DNS record (e.g., subdomain or full domain). Required.',
-                examples: [
-                    'www.example.com',
-                    'sub.example.com'
-                ]
-            },
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site, obtained from the ListSites operation. Required.',
-                examples: [
-                    1234567890123
-                ]
-            },
-            data: {
-                type: 'object',
-                description: 'The data for the DNS record, varying by record type. Required.',
-                properties: {
-                    value: {
-                        type: 'string',
-                        description: 'The IP address of the A record. Required.',
-                        examples: [
-                            '2.2.2.2'
-                        ]
-                    }
-                }
-            }
-        },
-        required: [
-            'recordName',
-            'siteId',
-            'data'
-        ]
-    }
-};
-const SITE_DNS_CNAME_RECORD_CREATE_TOOL = {
-    name: 'site_dns_cname_record_create',
-    description: 'Create a CNAME DNS record for a specified site.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            recordName: {
-                type: 'string',
-                description: 'The name of the DNS record (e.g., subdomain or full domain). Required.',
-                examples: [
-                    'www.example.com',
-                    'sub.example.com'
-                ]
-            },
-            siteId: {
-                type: 'number',
-                description: 'The ID of the site, obtained from the ListSites operation. Required.',
-                examples: [
-                    1234567890123
-                ]
-            },
-            data: {
-                type: 'object',
-                description: 'The data for the DNS record, varying by record type. Required.',
-                properties: {
-                    value: {
-                        type: 'string',
-                        description: 'The IP address of the A record. Required.',
-                        examples: [
-                            '2.2.2.2'
-                        ]
-                    }
-                }
-            }
-        },
-        required: [
-            'recordName',
-            'siteId',
-            'data'
-        ]
-    }
-};
-const SITE_RECORD_LIST_TOOL = {
-    name: 'site_record_list',
-    description: 'List DNS records associated with a specific site.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            SiteId: {
-                type: 'number',
-                description: 'The ID of the site, obtained from the ListSites operation. Required.'
-            }
-        }
-    }
-};
-const site_dns_a_record_create = async (request)=>{
-    const res = await service.createRecord({
-        ttl: 1,
-        proxied: true,
-        bizName: 'web',
-        type: 'A/AAAA',
-        ...request.params.arguments
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const site_dns_cname_record_create = async (request)=>{
-    const res = await service.createRecord({
-        ttl: 1,
-        proxied: true,
-        bizName: 'web',
-        type: 'CNAME',
-        sourceType: 'Domain',
-        hostPolicy: 'follow_hostname',
-        ...request.params.arguments
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const site_record_list = async (request)=>{
-    var _request_params_arguments;
-    const res = await service.listRecords({
-        siteId: (null === (_request_params_arguments = request.params.arguments) || void 0 === _request_params_arguments ? void 0 : _request_params_arguments.SiteId) ?? 0
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
     };
-};
-const site_active_list = async ()=>{
-    const res = await service.listSites({
-        siteSearchType: 'fuzzy',
-        status: 'active',
-        pageNumber: 1,
-        pageSize: 500
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const site_match = async (request)=>{
-    var _request_params_arguments;
-    const res = await service.getMatchSite({
-        recordName: (null === (_request_params_arguments = request.params.arguments) || void 0 === _request_params_arguments ? void 0 : _request_params_arguments.recordName) ?? ''
-    });
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(res)
-            }
-        ],
-        success: true
-    };
-};
-const ESA_OPENAPI_ER_LIST = [
-    ROUTINE_CREATE_TOOL,
-    ROUTINE_DELETE_TOOL,
-    ROUTINE_LIST_TOOL,
-    ROUTINE_GET_TOOL,
-    ROUTINE_CODE_COMMIT_TOOL,
-    ROUTINE_CODE_DEPLOY_TOOL,
-    ROUTINE_ROUTE_LIST_TOOL,
-    CANARY_AREA_LIST,
-    DEPLOYMENT_DELETE_TOOL,
-    SITE_ACTIVE_LIST_TOOL,
-    SITE_ROUTE_LIST_TOOL,
-    ROUTE_CREATE_TOOL,
-    ROUTE_DELETE_TOOL,
-    ROUTE_UPDATE_TOOL,
-    ROUTE_GET_TOOL,
-    SITE_MATCH_TOOL,
-    ER_RECORD_CREATE_TOOL,
-    ER_RECORD_DELETE_TOOL,
-    ER_RECORD_LIST_TOOL,
-    SITE_DNS_A_RECORD_CREATE_TOOL,
-    SITE_DNS_CNAME_RECORD_CREATE_TOOL,
-    SITE_RECORD_LIST_TOOL
-];
-const ESA_OPENAPI_LIST = [
-    ...ESA_OPENAPI_ER_LIST
-];
-const routineHandlers = {
-    site_dns_a_record_create: site_dns_a_record_create,
-    site_dns_cname_record_create: site_dns_cname_record_create,
-    site_active_list: site_active_list,
-    site_match: site_match,
-    site_route_list: site_route_list,
-    site_record_list: site_record_list,
-    routine_create: routine_create,
-    routine_delete: routine_delete,
-    routine_list: routine_list,
-    routine_get: routine_get,
-    routine_code_commit: routine_code_commit,
-    routine_code_deploy: routine_code_deploy,
-    routine_route_list: routine_route_list,
-    canary_area_list: canary_area_list,
-    deployment_delete: deployment_delete,
-    route_create: route_create,
-    route_delete: route_delete,
-    route_update: route_update,
-    route_get: route_get,
-    er_record_create: er_record_create,
-    er_record_delete: er_record_delete,
-    er_record_list: er_record_list
-};
-const server = new index_js_namespaceObject.Server({
-    name: 'esa-server',
-    version: '1.0.0'
-}, {
-    capabilities: {
-        tools: {}
-    }
-});
-server.setRequestHandler(types_js_namespaceObject.ListToolsRequestSchema, async ()=>({
-        tools: ESA_OPENAPI_LIST
-    }));
-server.setRequestHandler(types_js_namespaceObject.CallToolRequestSchema, async (request)=>{
-    const toolName = request.params.name;
-    log('Received tool call:', toolName, 'Params:', JSON.stringify(request.params));
-    return await routineHandlers[toolName](request);
-});
-async function main() {
-    const transport = new stdio_js_namespaceObject.StdioServerTransport();
-    await server.connect(transport);
-    console.error('ESA MCP Server running on stdio');
-}
-main().catch((error)=>{
-    console.error('Fatal error in main():', error);
-    process.exit(1);
-});
+})();
+var __webpack_exports__ = __webpack_require__("./src/index.js");
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
 if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {