gexinsofts-mcp 0.0.1

package/index.js

@@ -0,0 +1,344 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/core/errors/ConnectorError.ts
+var ConnectorError;
+var init_ConnectorError = __esm({
+  "src/core/errors/ConnectorError.ts"() {
+    "use strict";
+    ConnectorError = class extends Error {
+    };
+  }
+});
+
+// src/core/errors/ConfigurationError.ts
+var ConfigurationError;
+var init_ConfigurationError = __esm({
+  "src/core/errors/ConfigurationError.ts"() {
+    "use strict";
+    init_ConnectorError();
+    ConfigurationError = class extends ConnectorError {
+      constructor(name) {
+        super(`\u51ED\u8BC1\u6570\u636E\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11\u5B57\u6BB5\uFF1A${name}`);
+      }
+    };
+  }
+});
+
+// src/core/errors/HttpRequestError.ts
+var HttpRequestError;
+var init_HttpRequestError = __esm({
+  "src/core/errors/HttpRequestError.ts"() {
+    "use strict";
+    init_ConnectorError();
+    HttpRequestError = class extends ConnectorError {
+      constructor(error) {
+        const codes = ["ECONNABORTED", "ETIMEDOUT", "ERR_NETWORK"];
+        const message = error.code && codes.includes(error.code) ? "\u65E0\u6CD5\u8FDE\u63A5\u81F3 ERP \u670D\u52A1\u5668\uFF0C\u5EFA\u8BAE\u68C0\u67E5\u7F51\u7EDC" : "ERP \u670D\u52A1\u5668\u8BF7\u6C42\u51FA\u9519\uFF0C\u5EFA\u8BAE\u7A0D\u540E\u91CD\u8BD5";
+        super(message);
+        this.error = error;
+      }
+      error;
+    };
+  }
+});
+
+// src/core/errors/HttpResponseError.ts
+import { isObjectLike } from "es-toolkit/compat";
+var HttpResponseError;
+var init_HttpResponseError = __esm({
+  "src/core/errors/HttpResponseError.ts"() {
+    "use strict";
+    init_ConnectorError();
+    HttpResponseError = class extends ConnectorError {
+      constructor(response) {
+        const message = isObjectLike(response.data) ? `ERP \u8FD4\u56DE\u4E1A\u52A1\u9519\u8BEF\u4FE1\u606F\uFF1A${response.data.msg}` : "\u670D\u52A1\u5668\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5";
+        super(message);
+        this.response = response;
+      }
+      response;
+    };
+  }
+});
+
+// src/core/errors/UnauthorizedError.ts
+var UnauthorizedError;
+var init_UnauthorizedError = __esm({
+  "src/core/errors/UnauthorizedError.ts"() {
+    "use strict";
+    init_ConnectorError();
+    UnauthorizedError = class extends ConnectorError {
+      constructor(error) {
+        super("\u767B\u5F55\u72B6\u6001\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+        this.error = error;
+      }
+      error;
+    };
+  }
+});
+
+// src/core/errors/index.ts
+var init_errors = __esm({
+  "src/core/errors/index.ts"() {
+    "use strict";
+    init_ConfigurationError();
+    init_HttpRequestError();
+    init_HttpResponseError();
+    init_UnauthorizedError();
+  }
+});
+
+// src/core/http-client/interceptor.ts
+import { isAxiosError, isCancel } from "axios";
+function useAuthorizationInterceptor(instance) {
+  instance.interceptors.request.use((request) => {
+    const token = process.env.TOKEN;
+    if (token && request.withAuthorization !== false) {
+      request.headers.setAuthorization(`Bearer ${token}`);
+    }
+    return request;
+  });
+}
+function useRejectionInterceptor(instance, _) {
+  instance.interceptors.request.use(void 0, (rejection) => {
+    if (isAxiosError(rejection)) {
+      throw new HttpRequestError(rejection);
+    }
+    throw rejection;
+  });
+  instance.interceptors.response.use(void 0, (rejection) => {
+    if (!isAxiosError(rejection) || isCancel(rejection)) {
+      throw rejection;
+    }
+    if (rejection.response) {
+      throw new HttpResponseError(rejection.response);
+    }
+    throw new HttpRequestError(rejection);
+  });
+}
+function useStandardResponseInterceptor(axios2, policies) {
+  axios2.interceptors.response.use((response) => {
+    const data = response.data;
+    if (policies.validator.isValidJsonData(data)) {
+      if (!policies.validator.isValidCode(data.code)) {
+        if (policies.validator.isSessionExpired(data)) {
+          throw new UnauthorizedError(response);
+        }
+        throw new HttpResponseError(response);
+      }
+      if (response.config.unwrapResponse !== false) {
+        response.data = data.data;
+      }
+    }
+    return response;
+  });
+}
+var init_interceptor = __esm({
+  "src/core/http-client/interceptor.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/core/http-client/providers/policy.ts
+function createHttpClientDefaultPolicies() {
+  return {
+    validator: createHttpClientValidator()
+  };
+}
+function createHttpClientValidator() {
+  const isValidCode = (code) => {
+    return code === "00000";
+  };
+  const isSessionExpired = (data) => {
+    return data.code === "A0230";
+  };
+  const isValidJsonData = (response) => {
+    if (response === null || typeof response !== "object") {
+      return false;
+    }
+    return Reflect.has(response, "code") && Reflect.has(response, "msg");
+  };
+  return { isSessionExpired, isValidCode, isValidJsonData };
+}
+var init_policy = __esm({
+  "src/core/http-client/providers/policy.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/http-client/utils/factory.ts
+import axios from "axios";
+function createHttpClient(policies) {
+  const httpClient2 = axios.create({
+    baseURL: process.env.SERVER_URL,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    timeout: 1e3 * 10
+  });
+  useAuthorizationInterceptor(httpClient2);
+  useStandardResponseInterceptor(httpClient2, policies);
+  useRejectionInterceptor(httpClient2, policies);
+  return httpClient2;
+}
+var httpClient;
+var init_factory = __esm({
+  "src/core/http-client/utils/factory.ts"() {
+    "use strict";
+    init_interceptor();
+    init_policy();
+    httpClient = createHttpClient(createHttpClientDefaultPolicies());
+  }
+});
+
+// src/core/http-client/utils/signal.ts
+function useSignal() {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const abort = () => controller.abort();
+  return { abort, signal };
+}
+var init_signal = __esm({
+  "src/core/http-client/utils/signal.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/http-client/index.ts
+function defineQuery(query, defaultConfig) {
+  return (data, config) => {
+    const { abort, signal } = useSignal();
+    const payload = data ?? {};
+    const request = query(httpClient, payload, {
+      ...defaultConfig,
+      ...config,
+      signal
+    });
+    const result = request.then(({ data: data2 }) => data2);
+    return { abort, result, signal };
+  };
+}
+function defineQueryNoData(query, defaultConfig) {
+  return (config) => {
+    const { abort, signal } = useSignal();
+    const request = query(httpClient, { ...defaultConfig, ...config, signal });
+    const result = request.then(({ data }) => data);
+    return { abort, result, signal };
+  };
+}
+var init_http_client = __esm({
+  "src/core/http-client/index.ts"() {
+    "use strict";
+    init_factory();
+    init_signal();
+  }
+});
+
+// src/api/auth/index.ts
+import JSEncrypt from "jsencrypt";
+var getPublicKey, login, AuthApi;
+var init_auth = __esm({
+  "src/api/auth/index.ts"() {
+    "use strict";
+    init_http_client();
+    getPublicKey = defineQueryNoData((httpClient2, config) => {
+      return httpClient2.get("/api/Next/getPublicKey", config);
+    });
+    login = defineQuery(
+      async (httpClient2, data, config) => {
+        const { RSA_PUBLICKEY } = await getPublicKey({
+          withAuthorization: false
+        }).result;
+        const publicKey = `-----BEGIN PUBLIC KEY-----
+${RSA_PUBLICKEY}
+-----END PUBLIC KEY-----`;
+        const encryptor = new JSEncrypt();
+        encryptor.setPublicKey(publicKey);
+        const formData = new FormData();
+        formData.set("username", data.username);
+        formData.set("password", encryptor.encrypt(data.password));
+        formData.set("isMobile", "false");
+        formData.set("rememberMe", "false");
+        return httpClient2.post("/apiLogin", formData, {
+          ...config,
+          withAuthorization: false
+        });
+      }
+    );
+    AuthApi = { login };
+  }
+});
+
+// src/features/token.ts
+import { isNil } from "es-toolkit";
+async function initAuthToken() {
+  const username = process.env.USERNAME;
+  const password = process.env.PASSWORD;
+  if (isNil(username)) {
+    throw new ConfigurationError("\u7528\u6237\u540D(USERNAME)");
+  }
+  if (isNil(password)) {
+    throw new ConfigurationError("\u5BC6\u7801(PASSWORD)");
+  }
+  const authResult = await AuthApi.login({ password, username }).result;
+  const token = authResult?.token;
+  if (!token) {
+    throw new Error("ERP \u767B\u5F55\u672A\u8FD4\u56DE\u6709\u6548 token\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458");
+  }
+  process.env.TOKEN = token;
+  return token;
+}
+var init_token = __esm({
+  "src/features/token.ts"() {
+    "use strict";
+    init_auth();
+    init_errors();
+  }
+});
+
+// src/tools/test.ts
+import * as z from "zod/v4";
+function useTestTool(server) {
+  server.registerTool(
+    "test",
+    {
+      description: "\u9A8C\u8BC1 ERP \u8FDE\u63A5\u548C\u767B\u5F55\u72B6\u6001",
+      inputSchema: z.object({ message: z.string().optional() })
+    },
+    async ({ message }) => {
+      await initAuthToken();
+      return {
+        content: [{ text: message ?? "", type: "text" }]
+      };
+    }
+  );
+}
+var init_test = __esm({
+  "src/tools/test.ts"() {
+    "use strict";
+    init_token();
+  }
+});
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+var require_index = __commonJS({
+  "src/index.ts"() {
+    init_test();
+    async function main() {
+      const server = new McpServer({ name: "greeting-server", version: "1.0.0" });
+      useTestTool(server);
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    }
+    main();
+  }
+});
+export default require_index();

package/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "gexinsofts-mcp",
+  "version": "0.0.1",
+  "description": "革新软件 Workbuddy MCP 工具",
+  "type": "module",
+  "main": "index.js"
+}