mcp-server-esa 1.0.0

package/src/utils/helpers.ts

@@ -0,0 +1,181 @@
+import { GetRoutineStagingCodeUploadInfoResponse } from '@alicloud/esa20240910';
+import { IOssConfig } from './types';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
+
+export function log(...args: unknown[]) {
+  const msg = `[DEBUG ${new Date().toISOString()}] ${args.join(' ')}\n`;
+  process.stderr.write(msg);
+}
+
+export const uploadCodeToOSS = async (
+  res: GetRoutineStagingCodeUploadInfoResponse,
+  code: string,
+) => {
+  const ossConfig = res?.body?.ossPostConfig as IOssConfig;
+
+  if (res.statusCode !== 200 || !ossConfig) {
+    return false;
+  }
+
+  const { OSSAccessKeyId, Signature, callback, Url, key, policy }: IOssConfig =
+    ossConfig;
+  const formData = new FormData();
+  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 fetch(Url, {
+    method: 'POST',
+    body: formData,
+    headers: formData.getHeaders(),
+  });
+
+  return ossRes && ossRes.status === 200;
+};
+
+/* 操作符号枚举 */
+export enum OPERATOR_ENUM {
+  Eq = 'eq',
+  Ne = 'ne',
+  Contains = 'contains',
+  Negate_Contains = 'negate_contains',
+  StartsWith = 'starts_with',
+  Negate_StartsWith = 'negate_starts_with',
+  EndsWith = 'ends_with',
+  Negate_EndsWith = 'negate_ends_with',
+  Matches = 'matches',
+  Negate_Matches = 'negate_matches',
+  In = 'in',
+  Negate_In = 'negate_in',
+  Gt = 'gt',
+  Lt = 'lt',
+  Ge = 'ge',
+  Le = 'le',
+  InList = 'in_list',
+  Negate_InList = 'negate_in_list',
+}
+const RuleMatchTypeHost = 'http.host';
+const RuleMatchTypeUriPath = 'http.request.uri.path';
+const RuleMatchOperatorEq = OPERATOR_ENUM.Eq;
+const RuleMatchOperatorStartsWith = OPERATOR_ENUM.StartsWith;
+const RuleMatchOperatorEndsWith = OPERATOR_ENUM.EndsWith;
+
+export const transferRouteToRuleString = (routePath: string): string => {
+  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;
+};
+
+export const transferRuleStringToRoute = (ruleStr: string): string => {
+  if (!ruleStr) {
+    return '';
+  }
+  // 去掉外层括号并按 " and " 分割
+  const cleanedRule = ruleStr.replace(/^\(|\)$/g, '');
+  const parts = cleanedRule.split(' and ');
+  if (parts.length !== 2) {
+    return '';
+  }
+
+  let host = '';
+  let uriPath = '';
+
+  // 处理host部分
+  const hostPart = parts[0].trim();
+  if (
+    hostPart.startsWith(`${RuleMatchOperatorEndsWith}(${RuleMatchTypeHost},`)
+  ) {
+    // host匹配eq时的逻辑
+    // ends_with(http.host, "value")
+    const match = hostPart.match(/ends_with\(http\.host,\s*"([^"]+)"\)/);
+    if (match) {
+      host = `*${match[1]}`; // 加前缀 *
+    }
+  } else if (
+    hostPart.startsWith(`${RuleMatchTypeHost} ${RuleMatchOperatorEq}`)
+  ) {
+    // host匹配eq时的逻辑
+    // http.host eq "value"
+    const match = hostPart.match(/http\.host eq "([^"]+)"/);
+    if (match) {
+      host = match[1];
+    }
+  }
+
+  // 处理uriPath 部分
+  const uriPathPart = parts[1].trim();
+  if (
+    uriPathPart.startsWith(
+      `${RuleMatchOperatorStartsWith}(${RuleMatchTypeUriPath},`,
+    )
+  ) {
+    // uriPath匹配startsWith时的逻辑
+    // starts_with(http.request.uri.path, "value")
+    const match = uriPathPart.match(
+      /starts_with\(http\.request\.uri\.path,\s*"([^"]+)"\)/,
+    );
+    if (match) {
+      uriPath = `${match[1]}*`; // 加后缀 *
+    }
+  } else if (
+    uriPathPart.startsWith(`${RuleMatchTypeUriPath} ${RuleMatchOperatorEq}`)
+  ) {
+    // uriPath匹配eq时的逻辑
+    // http.request.uri.path eq "value"
+    const match = uriPathPart.match(/http\.request\.uri\.path eq "([^"]+)"/);
+    if (match) {
+      uriPath = match[1];
+    }
+  }
+
+  if (!host || !uriPath) {
+    return '';
+  }
+
+  return `${host}${uriPath}`;
+};

package/src/utils/service.ts

@@ -0,0 +1,337 @@
+import ESA, {
+  CommitRoutineStagingCodeRequest,
+  CommitRoutineStagingCodeResponse,
+  CreateRoutineRelatedRecordRequest,
+  CreateRoutineRelatedRecordResponse,
+  CreateRoutineRequest,
+  CreateRoutineResponse,
+  CreateRoutineRouteRequest,
+  CreateRoutineRouteResponse,
+  DeleteRoutineCodeVersionRequest,
+  DeleteRoutineCodeVersionResponse,
+  DeleteRoutineRelatedRecordRequest,
+  DeleteRoutineRelatedRecordResponse,
+  DeleteRoutineRequest,
+  DeleteRoutineResponse,
+  DeleteRoutineRouteRequest,
+  DeleteRoutineRouteResponse,
+  GetRoutineRequest,
+  GetRoutineResponse,
+  GetRoutineRouteRequest,
+  GetRoutineRouteResponse,
+  GetRoutineStagingCodeUploadInfoRequest,
+  GetRoutineStagingCodeUploadInfoResponse,
+  ListRoutineRoutesRequest,
+  ListRoutineRoutesResponse,
+  ListSiteRoutesRequest,
+  ListSiteRoutesResponse,
+  ListSitesRequest,
+  ListSitesResponse,
+  PublishRoutineCodeVersionRequest,
+  PublishRoutineCodeVersionResponse,
+  UpdateRoutineRouteRequest,
+  UpdateRoutineRouteResponse,
+} from '@alicloud/esa20240910';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as $Util from '@alicloud/tea-util';
+import { log } from './helpers';
+import {
+  CliConfig,
+  GetMatchSiteRequest,
+  ListRoutineRelatedRecordsRequest,
+} from './types';
+
+export interface ApiMethod<RequestType, ResponseType> {
+  (runtime: $Util.RuntimeOptions): Promise<ResponseType>;
+  (request: RequestType, runtime: $Util.RuntimeOptions): Promise<ResponseType>;
+}
+class Client {
+  client: ESA;
+
+  constructor() {
+    const config = {
+      auth: {
+        accessKeyId: process.env.ESA_ACCESS_KEY_ID || '',
+        accessKeySecret: process.env.ESA_ACCESS_KEY_SECRET || '',
+      },
+      endpoint: 'esa.cn-hangzhou.aliyuncs.com',
+    };
+    this.client = Client.createClient(config);
+  }
+
+  static createClient(config: CliConfig) {
+    const apiConfig = new $OpenApi.Config({
+      accessKeyId: config.auth?.accessKeyId || '',
+      accessKeySecret: config.auth?.accessKeySecret || '',
+      endpoint: config.endpoint,
+    });
+    return new ESA(apiConfig);
+  }
+
+  callApi = async <RequestType, ResponseType>(
+    action: ApiMethod<RequestType, ResponseType>,
+    request?: RequestType,
+  ): Promise<ResponseType> => {
+    const runtime = new $Util.RuntimeOptions({
+      connectTimeout: 10000,
+      readTimeout: 10000,
+      autoretry: true,
+      maxAttempts: 3,
+    });
+    const response = request
+      ? await action(request, runtime)
+      : await action(runtime);
+    return response;
+  };
+
+  createRoutine(params: CreateRoutineRequest) {
+    const request = new CreateRoutineRequest(params);
+    log('Creating routine with parameters:', JSON.stringify(params));
+    return this.callApi(
+      this.client.createRoutine.bind(this.client) as ApiMethod<
+        CreateRoutineRequest,
+        CreateRoutineResponse
+      >,
+      request,
+    );
+  }
+
+  deleteRoutine(params: DeleteRoutineRequest) {
+    const request = new DeleteRoutineRequest(params);
+    return this.callApi(
+      this.client.deleteRoutineWithOptions.bind(this.client) as ApiMethod<
+        DeleteRoutineRequest,
+        DeleteRoutineResponse
+      >,
+      request,
+    );
+  }
+
+  getRoutine(params: GetRoutineRequest) {
+    const request = new GetRoutineRequest(params);
+    return this.callApi(
+      this.client.getRoutineWithOptions.bind(this.client) as ApiMethod<
+        GetRoutineRequest,
+        GetRoutineResponse
+      >,
+      request,
+    );
+  }
+
+  getRoutineUserInfo() {
+    return this.callApi(this.client.getRoutineUserInfo.bind(this.client));
+  }
+
+  async getRoutineStagingCodeUploadInfo(
+    params: GetRoutineStagingCodeUploadInfoRequest,
+  ) {
+    const request = new GetRoutineStagingCodeUploadInfoRequest(params);
+
+    return this.callApi(
+      this.client.getRoutineStagingCodeUploadInfo.bind(
+        this.client,
+      ) as ApiMethod<
+        GetRoutineStagingCodeUploadInfoRequest,
+        GetRoutineStagingCodeUploadInfoResponse
+      >,
+      request,
+    );
+  }
+
+  commitRoutineStagingCode(params: CommitRoutineStagingCodeRequest) {
+    const request = new CommitRoutineStagingCodeRequest(params);
+    return this.callApi(
+      this.client.commitRoutineStagingCode.bind(this.client) as ApiMethod<
+        CommitRoutineStagingCodeRequest,
+        CommitRoutineStagingCodeResponse
+      >,
+      request,
+    );
+  }
+
+  publishRoutineCodeVersion(params: PublishRoutineCodeVersionRequest) {
+    const request = new PublishRoutineCodeVersionRequest(params);
+    return this.callApi(
+      this.client.publishRoutineCodeVersion.bind(this.client) as ApiMethod<
+        PublishRoutineCodeVersionRequest,
+        PublishRoutineCodeVersionResponse
+      >,
+      request,
+    );
+  }
+
+  listRoutineCanaryAreas() {
+    return this.callApi(this.client.listRoutineCanaryAreas.bind(this.client));
+  }
+
+  listSites(params: ListSitesRequest) {
+    const request = new ListSitesRequest(params);
+    return this.callApi(
+      this.client.listSites.bind(this.client) as ApiMethod<
+        ListSitesRequest,
+        ListSitesResponse
+      >,
+      request,
+    );
+  }
+
+  deleteRoutineCodeVersion(params: DeleteRoutineCodeVersionRequest) {
+    const request = new DeleteRoutineCodeVersionRequest(params);
+    return this.callApi(
+      this.client.deleteRoutineCodeVersion.bind(this.client) as ApiMethod<
+        DeleteRoutineCodeVersionRequest,
+        DeleteRoutineCodeVersionResponse
+      >,
+      request,
+    );
+  }
+
+  createRoutineRelatedRecord(params: CreateRoutineRelatedRecordRequest) {
+    const request = new CreateRoutineRelatedRecordRequest(params);
+    return this.callApi(
+      this.client.createRoutineRelatedRecord.bind(this.client) as ApiMethod<
+        CreateRoutineRelatedRecordRequest,
+        CreateRoutineRelatedRecordResponse
+      >,
+      request,
+    );
+  }
+
+  createRoutineRoute(params: CreateRoutineRouteRequest) {
+    const request = new CreateRoutineRouteRequest(params);
+    return this.callApi(
+      this.client.createRoutineRoute.bind(this.client) as ApiMethod<
+        CreateRoutineRouteRequest,
+        CreateRoutineRouteResponse
+      >,
+      request,
+    );
+  }
+
+  deleteRoutineRoute(params: DeleteRoutineRouteRequest) {
+    const request = new DeleteRoutineRouteRequest(params);
+    return this.callApi(
+      this.client.deleteRoutineRoute.bind(this.client) as ApiMethod<
+        DeleteRoutineRouteRequest,
+        DeleteRoutineRouteResponse
+      >,
+      request,
+    );
+  }
+
+  getRoutineRoute(params: GetRoutineRouteRequest) {
+    const request = new GetRoutineRouteRequest(params);
+    return this.callApi(
+      this.client.getRoutineRoute.bind(this.client) as ApiMethod<
+        GetRoutineRouteRequest,
+        GetRoutineRouteResponse
+      >,
+      request,
+    );
+  }
+
+  listSiteRoutes(params: ListSiteRoutesRequest) {
+    const request = new ListSiteRoutesRequest(params);
+    return this.callApi(
+      this.client.listSiteRoutes.bind(this.client) as ApiMethod<
+        ListSiteRoutesRequest,
+        ListSiteRoutesResponse
+      >,
+      request,
+    );
+  }
+
+  listRoutineRoutes(params: ListRoutineRoutesRequest) {
+    const request = new ListRoutineRoutesRequest(params);
+    return this.callApi(
+      this.client.listRoutineRoutes.bind(this.client) as ApiMethod<
+        ListRoutineRoutesRequest,
+        ListRoutineRoutesResponse
+      >,
+      request,
+    );
+  }
+
+  updateRoutineRoute(params: UpdateRoutineRouteRequest) {
+    const request = new UpdateRoutineRouteRequest(params);
+    return this.callApi(
+      this.client.updateRoutineRoute.bind(this.client) as ApiMethod<
+        UpdateRoutineRouteRequest,
+        UpdateRoutineRouteResponse
+      >,
+      request,
+    );
+  }
+
+  deleteRoutineRelatedRecord(params: DeleteRoutineRelatedRecordRequest) {
+    const request = new DeleteRoutineRelatedRecordRequest(params);
+    return this.callApi(
+      this.client.deleteRoutineRelatedRecord.bind(this.client) as ApiMethod<
+        DeleteRoutineRelatedRecordRequest,
+        DeleteRoutineRelatedRecordResponse
+      >,
+      request,
+    );
+  }
+
+  getMatchSite(requestParams: GetMatchSiteRequest) {
+    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.OpenApiRequest({
+      query: {
+        RecordName: requestParams.recordName,
+      },
+    });
+    const runtime = {
+      toMap: function () {
+        return this;
+      },
+    };
+    return this.client.callApi(params, request, runtime);
+  }
+
+  listRoutineRelatedRecords(requestParams: ListRoutineRelatedRecordsRequest) {
+    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.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);
+  }
+}
+
+export default new Client();

package/src/utils/types.ts

@@ -0,0 +1,71 @@
+import z from 'zod';
+import {
+  Result,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { CreateRoutineRouteRequest } from '@alicloud/esa20240910';
+
+export type ToolHandlers = Record<
+  string,
+  (request: z.infer<typeof CallToolRequestSchema>) => Promise<Result>
+>;
+export interface IOssConfig {
+  OSSAccessKeyId: string;
+  Signature: string;
+  Url: string;
+  callback: string;
+  key: string;
+  policy: string;
+  'x:codeDescription': string;
+}
+
+export class CreateRoutineRouteRequestExt extends CreateRoutineRouteRequest {
+  mode: 'simple' | 'custom';
+  constructor(params: CreateRoutineRouteRequest) {
+    super(params);
+    this.mode = params.mode;
+  }
+}
+
+export interface AuthConfig {
+  accessKeyId: string;
+  accessKeySecret: string;
+}
+
+export interface CliConfig {
+  [key: string]: unknown;
+  auth?: AuthConfig;
+  endpoint?: string;
+  lang?: string;
+}
+
+export interface GetMatchSiteRequest {
+  recordName: string;
+}
+export interface GetMatchSiteResponse {
+  code: string;
+  data: { SiteId: number; SiteName: string };
+}
+
+export interface ListRoutineRelatedRecordsRequest {
+  Name: string;
+  PageNumber?: number;
+  PageSize?: number;
+  SearchKeyWord?: string;
+}
+export interface ListRoutineRelatedRecordsResponse {
+  code: string;
+  data: {
+    RequestId: string;
+    PageNumber: number;
+    PageSize: number;
+    TotalCount: number;
+    RelatedRecords: {
+      RecordName: string;
+      SiteId: number;
+      SiteName: string;
+      RecordId: number;
+    }[];
+  };
+}
+export type Map = Record<string, unknown>;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2021"],
+    "module": "ESNext",
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "bundler",
+    "useDefineForClassFields": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src"]
+}