item-wms-public-api-tool 2.0.4

package/src/client.ts

@@ -0,0 +1,90 @@
+// src/client.ts
+import { DEFAULT_BASE_URL } from "./config";
+
+export type ClientOptions = {
+  baseUrl?: string;
+  token?: string;
+};
+
+function resolveAuthHeader(token?: string): string | undefined {
+  if (!token) {
+    return undefined;
+  }
+  const trimmed = token.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (/^bearer\s+/i.test(trimmed)) {
+    return trimmed;
+  }
+  return `Bearer ${trimmed}`;
+}
+
+function resolveBaseUrl(opts: ClientOptions): string {
+  const baseUrl = opts.baseUrl || process.env.WMS_BASE_URL || DEFAULT_BASE_URL;
+  return baseUrl.replace(/\/$/, '');
+}
+
+function buildUrl(baseUrl: string, path: string, query?: Record<string, any>): string {
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const url = new URL(`${baseUrl}${normalizedPath}`);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item !== undefined && item !== null) {
+            url.searchParams.append(key, String(item));
+          }
+        });
+      } else {
+        url.searchParams.append(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+
+export async function request<T>(
+  method: string,
+  path: string,
+  opts: ClientOptions,
+  body?: any,
+  extraHeaders?: Record<string, string>,
+  query?: Record<string, any>
+): Promise<T> {
+  const baseUrl = resolveBaseUrl(opts);
+  const url = buildUrl(baseUrl, path, query);
+  const authHeader = resolveAuthHeader(opts.token);
+  const headers: Record<string, string> = {
+    ...(authHeader ? { Authorization: authHeader } : {}),
+    ...(extraHeaders || {})
+  };
+
+  const methodUpper = method.toUpperCase();
+  const canSendBody = methodUpper !== 'GET' && methodUpper !== 'DELETE' && methodUpper !== 'HEAD';
+  if (canSendBody) {
+    headers['content-type'] = 'application/json';
+  }
+
+  const resp = await fetch(url, {
+    method: methodUpper,
+    headers,
+    body: canSendBody && body !== undefined ? JSON.stringify(body) : undefined
+  });
+
+  if (!resp.ok) {
+    throw new Error(`HTTP ${resp.status}: ${await resp.text()}`);
+  }
+  return resp.json();
+}
+
+export async function get<T>(path: string, opts: ClientOptions): Promise<T> {
+  return request<T>('GET', path, opts);
+}
+
+export async function post<T>(path: string, body: any, opts: ClientOptions): Promise<T> {
+  return request<T>('POST', path, opts, body);
+}

package/src/config.ts

@@ -0,0 +1,126 @@
+// src/config.ts
+
+/**
+ * CLI配置选项接口
+ */
+export interface CliConfig {
+  baseUrl?: string;
+  token?: string;
+  companyId?: string;
+  facilityId?: string;
+  customerId?: string;
+}
+
+export const DEFAULT_BASE_URL = "https://wms-staging.item.com/api/public";
+export const DEFAULT_COMPANY_ID = "LT";
+export const DEFAULT_FACILITY_ID = "889";
+export const DEFAULT_CUSTOMER_ID = "FLAANT0001";
+
+export type DefaultParams = {
+  CompanyID?: string;
+  FacilityID?: string;
+  CustomerID?: string;
+};
+
+function normalizeConfigValue(value?: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function resolveDefaultParams(): DefaultParams {
+  const companyId = normalizeConfigValue(process.env.WMS_COMPANY_ID) ?? DEFAULT_COMPANY_ID;
+  const facilityId = normalizeConfigValue(process.env.WMS_FACILITY_ID) ?? DEFAULT_FACILITY_ID;
+  const customerId = normalizeConfigValue(process.env.WMS_CUSTOMER_ID) ?? DEFAULT_CUSTOMER_ID;
+
+  return {
+    CompanyID: companyId,
+    FacilityID: facilityId,
+    CustomerID: customerId
+  };
+}
+
+/**
+ * 解析命令行参数
+ * @param argv 命令行参数数组
+ * @returns CLI配置对象
+ */
+export function parseArgs(argv: string[]): CliConfig {
+  const config: CliConfig = {};
+
+  // 简单的命令行参数解析
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eqIndex = arg.indexOf('=');
+
+    if (arg.startsWith('--') && eqIndex > 2) {
+      const flag = arg.slice(0, eqIndex);
+      const value = arg.slice(eqIndex + 1);
+      if (flag === '--baseUrl') {
+        config.baseUrl = value;
+        continue;
+      }
+      if (flag === '--token') {
+        config.token = value;
+        continue;
+      }
+      if (flag === '--companyId') {
+        config.companyId = value;
+        continue;
+      }
+      if (flag === '--facilityId') {
+        config.facilityId = value;
+        continue;
+      }
+      if (flag === '--customerId') {
+        config.customerId = value;
+        continue;
+      }
+    }
+    
+    if (arg === '--baseUrl' && i + 1 < argv.length) {
+      config.baseUrl = argv[++i];
+    } else if (arg === '--token' && i + 1 < argv.length) {
+      config.token = argv[++i];
+    } else if (arg === '--companyId' && i + 1 < argv.length) {
+      config.companyId = argv[++i];
+    } else if (arg === '--facilityId' && i + 1 < argv.length) {
+      config.facilityId = argv[++i];
+    } else if (arg === '--customerId' && i + 1 < argv.length) {
+      config.customerId = argv[++i];
+    }
+  }
+
+  return config;
+}
+
+/**
+ * 应用CLI配置
+ * @param config CLI配置对象
+ */
+export function applyCliConfig(config: CliConfig): void {
+  // 将CLI配置应用到环境变量
+  const baseUrl = normalizeConfigValue(config.baseUrl);
+  const token = normalizeConfigValue(config.token);
+  const companyId = normalizeConfigValue(config.companyId);
+  const facilityId = normalizeConfigValue(config.facilityId);
+  const customerId = normalizeConfigValue(config.customerId);
+
+  if (baseUrl) {
+    process.env.WMS_BASE_URL = baseUrl;
+  }
+  if (token) {
+    process.env.WMS_TOKEN = token;
+  }
+  if (companyId) {
+    process.env.WMS_COMPANY_ID = companyId;
+  }
+  if (facilityId) {
+    process.env.WMS_FACILITY_ID = facilityId;
+  }
+  if (customerId) {
+    process.env.WMS_CUSTOMER_ID = customerId;
+  }
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// src/index.ts
+import { applyCliConfig, parseArgs } from "./config";
+import { startServer } from "./server";
+import { parseAndExecuteCli } from "./cli";
+
+/**
+ * 主入口函数
+ */
+async function main(): Promise<void> {
+  // 解析命令行参数
+  const cliConfig = parseArgs(process.argv.slice(2));
+
+  // 应用CLI配置到环境变量
+  applyCliConfig(cliConfig);
+
+  // 支持两种模式：CLI模式和stdio模式
+  if (process.stdin.isTTY) {
+    // CLI模式：直接执行CLI命令
+    await parseAndExecuteCli();
+  } else {
+    // stdio模式：启动MCP服务器
+    await startServer();
+  }
+}
+
+// 执行主函数
+main().catch((error) => {
+  console.error("Unexpected error:", error);
+  process.exit(1);
+});

package/src/openapi-tools.ts

@@ -0,0 +1,346 @@
+// src/openapi-tools.ts
+import fs from 'fs';
+import YAML from 'yaml';
+import type { ClientOptions } from './client';
+import { request } from './client';
+import { resolveDefaultParams } from './config';
+
+export type McpTool = {
+  name: string;
+  description: string;
+  inputSchema: Record<string, any>;
+};
+
+export type OpenApiOperation = {
+  name: string;
+  method: string;
+  path: string;
+  description: string;
+  parameters: any[];
+  requestBody?: any;
+  inputSchema?: Record<string, any>;
+};
+
+export type OpenApiIndex = {
+  tools: McpTool[];
+  operations: Record<string, OpenApiOperation>;
+};
+
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+const DEFAULT_PARAM_KEYS = ['CompanyID', 'FacilityID', 'CustomerID'] as const;
+
+type DefaultParamKey = typeof DEFAULT_PARAM_KEYS[number];
+
+function isJsonLike(raw: string): boolean {
+  const trimmed = raw.trimStart();
+  return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+
+function isPlainObject(value: any): value is Record<string, any> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasOwnProperty(target: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+
+function applyDefaultParams(
+  operation: OpenApiOperation,
+  args: Record<string, any>
+): Record<string, any> {
+  const defaults = resolveDefaultParams();
+  const schemaProps = operation.inputSchema?.properties ?? {};
+  const paramNames = new Set<string>();
+
+  for (const param of operation.parameters || []) {
+    if (param && typeof param.name === 'string' && param.name) {
+      paramNames.add(param.name);
+    }
+  }
+
+  const bodyProvided = hasOwnProperty(args, 'body');
+  const bodyIsObject = isPlainObject(args.body);
+  const body = bodyIsObject ? { ...args.body } : undefined;
+  let bodyModified = false;
+
+  const nextArgs: Record<string, any> = { ...args };
+
+  for (const key of DEFAULT_PARAM_KEYS) {
+    const defaultValue = defaults[key as DefaultParamKey];
+    if (!defaultValue) {
+      continue;
+    }
+    if (hasOwnProperty(args, key)) {
+      continue;
+    }
+
+    if (paramNames.has(key)) {
+      nextArgs[key] = defaultValue;
+      continue;
+    }
+
+    if (!hasOwnProperty(schemaProps, key)) {
+      continue;
+    }
+
+    if (bodyProvided && !bodyIsObject) {
+      continue;
+    }
+
+    if (bodyIsObject && hasOwnProperty(args.body, key)) {
+      continue;
+    }
+
+    if (bodyIsObject && body) {
+      body[key] = defaultValue;
+      bodyModified = true;
+      continue;
+    }
+
+    nextArgs[key] = defaultValue;
+  }
+
+  if (bodyModified) {
+    nextArgs.body = body;
+  }
+
+  return nextArgs;
+}
+
+function normalizeToolName(method: string, pathName: string): string {
+  const normalizedPath = pathName.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+  return `${method.toLowerCase()}_${normalizedPath.toLowerCase()}`;
+}
+
+function mergeSchema(base: Record<string, any>, extra?: Record<string, any>): Record<string, any> {
+  if (!extra) {
+    return base;
+  }
+  const merged = { ...base, ...extra };
+  merged.properties = {
+    ...(base.properties || {}),
+    ...(extra.properties || {})
+  };
+  if (extra.anyOf) {
+    merged.anyOf = extra.anyOf;
+  } else if (base.anyOf) {
+    merged.anyOf = base.anyOf;
+  }
+  if (extra.required) {
+    merged.required = extra.required;
+  } else if (base.required) {
+    merged.required = base.required;
+  }
+  return merged;
+}
+
+function resolveSchema(schema: any, components?: any, seen = new Set<string>()): any {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (schema.$ref && typeof schema.$ref === 'string') {
+    const match = schema.$ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (!match) {
+      return { ...schema };
+    }
+    const name = match[1];
+    if (seen.has(name)) {
+      return { ...schema };
+    }
+    const target = components && components.schemas ? components.schemas[name] : undefined;
+    if (!target) {
+      return { ...schema };
+    }
+    seen.add(name);
+    const resolved = resolveSchema(target, components, seen);
+    seen.delete(name);
+    return resolved;
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    const merged = schema.allOf.reduce(
+      (acc: Record<string, any>, item: any) => mergeSchema(acc, resolveSchema(item, components, seen)),
+      { type: 'object', properties: {} }
+    );
+    const combined = mergeSchema(merged, schema);
+    delete combined.allOf;
+    return combined;
+  }
+
+  const copy: Record<string, any> = { ...schema };
+  if (Array.isArray(copy.anyOf)) {
+    copy.anyOf = copy.anyOf.map((item: any) => resolveSchema(item, components, seen));
+  }
+  if (Array.isArray(copy.oneOf)) {
+    copy.oneOf = copy.oneOf.map((item: any) => resolveSchema(item, components, seen));
+  }
+  if (copy.properties && typeof copy.properties === 'object') {
+    const nextProps: Record<string, any> = {};
+    for (const [key, value] of Object.entries(copy.properties)) {
+      nextProps[key] = resolveSchema(value, components, seen);
+    }
+    copy.properties = nextProps;
+  }
+  if (copy.items) {
+    copy.items = resolveSchema(copy.items, components, seen);
+  }
+
+  return copy;
+}
+
+function ensureObjectSchema(schema: any): Record<string, any> {
+  if (!schema || typeof schema !== 'object') {
+    return { type: 'object', properties: {} };
+  }
+  if (!schema.type && !schema.properties) {
+    return { type: 'object', properties: {}, ...schema };
+  }
+  if (schema.type && schema.type !== 'object' && !schema.properties) {
+    return {
+      type: 'object',
+      properties: { body: schema },
+      required: ['body']
+    };
+  }
+  if (!schema.properties) {
+    return { ...schema, properties: {} };
+  }
+  return schema;
+}
+
+function buildInputSchema(operation: any, parameters: any[], components?: any): Record<string, any> {
+  const requestSchema = operation.requestBody?.content?.['application/json']?.schema;
+  const resolvedSchema = resolveSchema(requestSchema, components);
+  const baseSchema = ensureObjectSchema(resolvedSchema);
+  const requiredSet = new Set<string>(baseSchema.required || []);
+  const properties: Record<string, any> = { ...(baseSchema.properties || {}) };
+
+  for (const param of parameters) {
+    if (!param || !param.name) {
+      continue;
+    }
+    if (!properties[param.name]) {
+      properties[param.name] = resolveSchema(param.schema, components) || { type: 'string' };
+    }
+    if (param.required) {
+      requiredSet.add(param.name);
+    }
+  }
+
+  const inputSchema: Record<string, any> = { ...baseSchema, properties };
+  if (requiredSet.size > 0) {
+    inputSchema.required = Array.from(requiredSet);
+  } else {
+    delete inputSchema.required;
+  }
+  return inputSchema;
+}
+
+export function loadOpenApiSpec(openApiPath: string): any {
+  const raw = fs.readFileSync(openApiPath, 'utf8');
+  if (isJsonLike(raw)) {
+    return JSON.parse(raw);
+  }
+  return YAML.parse(raw);
+}
+
+export function buildOpenApiIndex(spec: any, options?: { pathPrefix?: string }): OpenApiIndex {
+  const tools: McpTool[] = [];
+  const operations: Record<string, OpenApiOperation> = {};
+  const prefix = options?.pathPrefix;
+
+  for (const [pathName, pathItem] of Object.entries<any>(spec.paths || {})) {
+    if (prefix && !pathName.startsWith(prefix)) {
+      continue;
+    }
+    const commonParams = Array.isArray(pathItem.parameters) ? pathItem.parameters : [];
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) {
+        continue;
+      }
+      const name = normalizeToolName(method, pathName);
+      const parameters = [
+        ...commonParams,
+        ...(Array.isArray(operation.parameters) ? operation.parameters : [])
+      ];
+      const description = operation.summary || operation.description || `${method.toUpperCase()} ${pathName}`;
+      const inputSchema = buildInputSchema(operation, parameters, spec.components);
+
+      let finalName = name;
+      let counter = 2;
+      while (operations[finalName]) {
+        finalName = `${name}_${counter}`;
+        counter += 1;
+      }
+
+      operations[finalName] = {
+        name: finalName,
+        method,
+        path: pathName,
+        description,
+        parameters,
+        requestBody: operation.requestBody,
+        inputSchema
+      };
+      tools.push({
+        name: finalName,
+        description,
+        inputSchema
+      });
+    }
+  }
+
+  tools.sort((a, b) => a.name.localeCompare(b.name));
+  return { tools, operations };
+}
+
+export async function callOpenApiOperation(
+  operation: OpenApiOperation,
+  args: Record<string, any>,
+  clientOpts: ClientOptions
+): Promise<any> {
+  const params = applyDefaultParams(operation, args || {});
+  const method = operation.method.toUpperCase();
+  let pathName = operation.path;
+  const headers: Record<string, string> = {};
+  const query: Record<string, any> = {};
+  const remaining: Record<string, any> = { ...params };
+
+  for (const param of operation.parameters) {
+    const name = param.name;
+    if (!name) {
+      continue;
+    }
+    const value = params[name];
+    if (value === undefined || value === null) {
+      if (param.required && param.in === 'path') {
+        throw new Error(`Missing required path parameter: ${name}`);
+      }
+      continue;
+    }
+    if (param.in === 'path') {
+      pathName = pathName.replace(new RegExp(`{${name}}`, 'g'), encodeURIComponent(String(value)));
+      delete remaining[name];
+    } else if (param.in === 'query') {
+      query[name] = value;
+      delete remaining[name];
+    } else if (param.in === 'header') {
+      headers[name] = String(value);
+      delete remaining[name];
+    }
+  }
+
+  let body: any = undefined;
+  const hasBody = Boolean(operation.requestBody);
+  if (hasBody) {
+    body = Object.prototype.hasOwnProperty.call(params, 'body') ? params.body : remaining;
+  }
+
+  const methodLower = method.toLowerCase();
+  const bodyAllowed = methodLower !== 'get' && methodLower !== 'delete' && methodLower !== 'head';
+  const finalBody = bodyAllowed ? body : undefined;
+
+  return request(method, pathName, clientOpts, finalBody, headers, query);
+}