@raiseinfo/smartorder-stdio-mcp 1.0.0 → 1.0.2

package/dist/tools/file-upload.js

@@ -42,33 +42,63 @@ export async function handleUpload(args) {
     await fileReader.validate(file_path);
     let apiUrl;
     let cache = await cacheManager.load();
+    const baseUrl = process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
     if (cache && !cacheManager.isExpired(cache)) {
+        console.log('[Upload] Using cached config');
         apiUrl = cache.apiUrl;
     }
     else {
         try {
+            console.log('[Upload] Fetching new config from backend...');
             const config = await httpClient.getConfig();
-            apiUrl = config.data.apiUrl;
+            if (config?.data?.apiUrl) {
+                apiUrl = config.data.apiUrl;
+                console.log('[Upload] Got config from backend:', apiUrl);
+                await cacheManager.save({
+                    version: 1,
+                    apiUrl: config.data.apiUrl,
+                    folder: config.data.folder,
+                    prefix: config.data.prefix,
+                    tenantCode: process.env.TENANT_CODE || '',
+                    expiresIn: config.data.expiresIn,
+                    obtainedAt: Date.now(),
+                    expiresAt: Date.now() + config.data.expiresIn * 1000,
+                });
+            }
+            else {
+                console.log('[Upload] Backend config invalid, using fallback');
+                apiUrl = baseUrl + '/api/mcp/upload';
+                await cacheManager.save({
+                    version: 1,
+                    apiUrl: apiUrl,
+                    folder: 'smart-order/',
+                    prefix: 'smart-order/',
+                    tenantCode: process.env.TENANT_CODE || '',
+                    expiresIn: 28800,
+                    obtainedAt: Date.now(),
+                    expiresAt: Date.now() + 28800 * 1000,
+                });
+            }
+        }
+        catch (error) {
+            console.log('[Upload] Failed to get config, using fallback URL');
+            console.log('[Upload] Error:', error.message);
+            apiUrl = baseUrl + '/api/mcp/upload';
             await cacheManager.save({
                 version: 1,
-                apiUrl: config.data.apiUrl,
-                folder: config.data.folder,
-                prefix: config.data.prefix,
+                apiUrl: apiUrl,
+                folder: 'smart-order/',
+                prefix: 'smart-order/',
                 tenantCode: process.env.TENANT_CODE || '',
-                expiresIn: config.data.expiresIn,
+                expiresIn: 28800,
                 obtainedAt: Date.now(),
-                expiresAt: Date.now() + config.data.expiresIn * 1000,
+                expiresAt: Date.now() + 28800 * 1000,
             });
         }
-        catch (error) {
-            return {
-                content: [{ type: 'text', text: `获取配置失败：${error.message}` }],
-                isError: true,
-            };
-        }
     }
     try {
-        const result = await httpClient.uploadFile(file_path, folder);
+        console.log('[Upload] Uploading to:', apiUrl);
+        const result = await httpClient.uploadFile(file_path, folder, apiUrl);
         return {
             content: [
                 {
@@ -87,7 +117,8 @@ export async function handleUpload(args) {
         }
         if (error.message.includes('5xx') || error.message.includes('网络')) {
             try {
-                const result = await httpClient.uploadFile(file_path, folder);
+                console.log('[Upload] Retrying upload...');
+                const result = await httpClient.uploadFile(file_path, folder, apiUrl);
                 return {
                     content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
                 };

package/dist/utils/http-client.d.ts

@@ -1,10 +1,13 @@
 import { McpConfigResponse, McpUploadResponse } from '../types/index.js';
 export declare class HttpClient {
-    private baseUrl;
-    private tenantCode;
-    private mcpToken;
-    constructor();
+    private get baseUrl();
+    private get tenantCode();
+    private get mcpToken();
+    private get authHeaders();
     getConfig(): Promise<McpConfigResponse>;
-    uploadFile(filePath: string, folder: string): Promise<McpUploadResponse>;
+    uploadFile(filePath: string, folder: string, apiUrl?: string): Promise<McpUploadResponse>;
+    private uploadWithRetry;
+    private doUpload;
     private request;
+    private handleResponse;
 }

package/dist/utils/http-client.js

@@ -3,79 +3,106 @@ import path from 'path';
 import FormData from 'form-data';
 import http from 'http';
 import https from 'https';
+const MAX_RETRIES = 2;
 export class HttpClient {
-    baseUrl;
-    tenantCode;
-    mcpToken;
-    constructor() {
-        this.baseUrl = process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
-        this.tenantCode = process.env.TENANT_CODE || '';
-        this.mcpToken = process.env.MCP_TOKEN || '';
+    get baseUrl() {
+        return process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
+    }
+    get tenantCode() {
+        return process.env.TENANT_CODE || '';
+    }
+    get mcpToken() {
+        return process.env.MCP_TOKEN || '';
+    }
+    get authHeaders() {
+        return {
+            'X-Tenant-Code': this.tenantCode,
+            'X-Mcp-Token': this.mcpToken,
+        };
     }
     async getConfig() {
         const url = `${this.baseUrl}/api/mcp/config`;
+        console.log('[HTTP] GET', url);
         return this.request('GET', url);
     }
-    async uploadFile(filePath, folder) {
-        const url = `${this.baseUrl}/api/mcp/upload`;
-        const form = new FormData();
-        const fileStream = fs.createReadStream(filePath);
-        const fileName = path.basename(filePath);
-        form.append('file', fileStream, { filename: fileName });
-        form.append('folder', folder);
-        return this.request('POST', url, form, true);
+    async uploadFile(filePath, folder, apiUrl) {
+        const url = apiUrl || `${this.baseUrl}/api/mcp/upload`;
+        return this.uploadWithRetry(filePath, folder, url);
     }
-    request(method, url, body, isFormData = false) {
+    async uploadWithRetry(filePath, folder, url, attempt = 1) {
+        console.log(`[HTTP] Upload attempt ${attempt}/${MAX_RETRIES + 1}:`, filePath);
+        try {
+            return await this.doUpload(filePath, folder, url);
+        }
+        catch (error) {
+            console.error(`[HTTP] Upload attempt ${attempt} failed:`, error.message);
+            if (attempt <= MAX_RETRIES) {
+                console.log(`[HTTP] Retrying... (${attempt + 1}/${MAX_RETRIES + 1})`);
+                return this.uploadWithRetry(filePath, folder, url, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    doUpload(filePath, folder, url) {
         return new Promise((resolve, reject) => {
+            const form = new FormData();
+            form.append('file', fs.createReadStream(filePath), { filename: path.basename(filePath) });
+            form.append('folder', folder);
             const urlObj = new URL(url);
             const client = urlObj.protocol === 'https:' ? https : http;
-            const options = {
+            const req = client.request({
+                hostname: urlObj.hostname,
+                port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+                path: urlObj.pathname,
+                method: 'POST',
+                headers: { ...this.authHeaders, ...form.getHeaders() },
+            });
+            this.handleResponse(req, resolve, reject);
+            req.on('error', (err) => reject(new Error(`网络错误：${err.message}`)));
+            form.pipe(req);
+        });
+    }
+    request(method, url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const client = urlObj.protocol === 'https:' ? https : http;
+            const req = client.request({
                 hostname: urlObj.hostname,
                 port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
                 path: urlObj.pathname,
                 method,
-                headers: {
-                    'X-Tenant-Code': this.tenantCode,
-                    'X-Mcp-Token': this.mcpToken,
-                    ...(isFormData ? body.getHeaders() : { 'Content-Type': 'application/json' }),
-                },
-            };
-            const req = client.request(options, (res) => {
-                let data = '';
-                res.on('data', (chunk) => (data += chunk));
-                res.on('end', () => {
-                    try {
-                        const json = JSON.parse(data);
-                        if (res.statusCode === 200) {
-                            resolve(json);
-                        }
-                        else if (res.statusCode === 401 || res.statusCode === 403) {
-                            reject(new Error('认证失败，请检查租户Token配置'));
-                        }
-                        else if (res.statusCode === 404) {
-                            reject(new Error('上传服务路径不存在，请联系管理员'));
-                        }
-                        else {
-                            reject(new Error(`服务返回错误：${res.statusCode}`));
-                        }
+                headers: { ...this.authHeaders, 'Content-Type': 'application/json' },
+            });
+            this.handleResponse(req, resolve, reject);
+            req.on('error', (err) => reject(new Error(`网络错误：${err.message}`)));
+            req.end();
+        });
+    }
+    handleResponse(req, resolve, reject) {
+        req.on('response', (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                console.log('[HTTP] Response:', res.statusCode, data.substring(0, 200));
+                try {
+                    const json = JSON.parse(data);
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(json);
                     }
-                    catch {
-                        reject(new Error('响应解析失败'));
+                    else if (res.statusCode === 401 || res.statusCode === 403) {
+                        reject(new Error('认证失败，请检查租户Token配置'));
+                    }
+                    else if (res.statusCode === 404) {
+                        reject(new Error('上传服务路径不存在，请联系管理员'));
+                    }
+                    else {
+                        reject(new Error(`服务返回错误：${res.statusCode}`));
                     }
-                });
-            });
-            req.on('error', (err) => {
-                reject(new Error(`网络错误：${err.message}`));
-            });
-            if (body) {
-                if (isFormData) {
-                    body.pipe(req);
                 }
-                else {
-                    req.write(JSON.stringify(body));
+                catch (e) {
+                    reject(new Error('响应解析失败: ' + data.substring(0, 100)));
                 }
-            }
-            req.end();
+            });
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raiseinfo/smartorder-stdio-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "description": "智单通文件上传 MCP Server (stdio模式)",
   "bin": {

package/src/tools/file-upload.ts

@@ -49,34 +49,63 @@ export async function handleUpload(args: { file_path: string; folder?: string })
 
   let apiUrl: string;
   let cache = await cacheManager.load();
+  const baseUrl = process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
 
   if (cache && !cacheManager.isExpired(cache)) {
+    console.log('[Upload] Using cached config');
     apiUrl = cache.apiUrl;
   } else {
     try {
+      console.log('[Upload] Fetching new config from backend...');
       const config = await httpClient.getConfig();
-      apiUrl = config.data.apiUrl;
-
+      
+      if (config?.data?.apiUrl) {
+        apiUrl = config.data.apiUrl;
+        console.log('[Upload] Got config from backend:', apiUrl);
+        await cacheManager.save({
+          version: 1,
+          apiUrl: config.data.apiUrl,
+          folder: config.data.folder,
+          prefix: config.data.prefix,
+          tenantCode: process.env.TENANT_CODE || '',
+          expiresIn: config.data.expiresIn,
+          obtainedAt: Date.now(),
+          expiresAt: Date.now() + config.data.expiresIn * 1000,
+        });
+      } else {
+        console.log('[Upload] Backend config invalid, using fallback');
+        apiUrl = baseUrl + '/api/mcp/upload';
+        await cacheManager.save({
+          version: 1,
+          apiUrl: apiUrl,
+          folder: 'smart-order/',
+          prefix: 'smart-order/',
+          tenantCode: process.env.TENANT_CODE || '',
+          expiresIn: 28800,
+          obtainedAt: Date.now(),
+          expiresAt: Date.now() + 28800 * 1000,
+        });
+      }
+    } catch (error: any) {
+      console.log('[Upload] Failed to get config, using fallback URL');
+      console.log('[Upload] Error:', error.message);
+      apiUrl = baseUrl + '/api/mcp/upload';
       await cacheManager.save({
         version: 1,
-        apiUrl: config.data.apiUrl,
-        folder: config.data.folder,
-        prefix: config.data.prefix,
+        apiUrl: apiUrl,
+        folder: 'smart-order/',
+        prefix: 'smart-order/',
         tenantCode: process.env.TENANT_CODE || '',
-        expiresIn: config.data.expiresIn,
+        expiresIn: 28800,
         obtainedAt: Date.now(),
-        expiresAt: Date.now() + config.data.expiresIn * 1000,
+        expiresAt: Date.now() + 28800 * 1000,
       });
-    } catch (error: any) {
-      return {
-        content: [{ type: 'text', text: `获取配置失败：${error.message}` }],
-        isError: true,
-      };
     }
   }
 
   try {
-    const result = await httpClient.uploadFile(file_path, folder);
+    console.log('[Upload] Uploading to:', apiUrl);
+    const result = await httpClient.uploadFile(file_path, folder, apiUrl);
     return {
       content: [
         {
@@ -95,7 +124,8 @@ export async function handleUpload(args: { file_path: string; folder?: string })
 
     if (error.message.includes('5xx') || error.message.includes('网络')) {
       try {
-        const result = await httpClient.uploadFile(file_path, folder);
+        console.log('[Upload] Retrying upload...');
+        const result = await httpClient.uploadFile(file_path, folder, apiUrl);
         return {
           content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
         };
@@ -112,4 +142,4 @@ export async function handleUpload(args: { file_path: string; folder?: string })
       isError: true,
     };
   }
-}
+}

package/src/utils/http-client.ts

@@ -5,91 +5,128 @@ import http from 'http';
 import https from 'https';
 import { McpConfigResponse, McpUploadResponse } from '../types/index.js';
 
+const MAX_RETRIES = 2;
+
 export class HttpClient {
-  private baseUrl: string;
-  private tenantCode: string;
-  private mcpToken: string;
-
-  constructor() {
-    this.baseUrl = process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
-    this.tenantCode = process.env.TENANT_CODE || '';
-    this.mcpToken = process.env.MCP_TOKEN || '';
+  private get baseUrl(): string {
+    return process.env.SMARTORDER_API_BASE || 'https://smart-order.raiseinfo.cn';
+  }
+
+  private get tenantCode(): string {
+    return process.env.TENANT_CODE || '';
+  }
+
+  private get mcpToken(): string {
+    return process.env.MCP_TOKEN || '';
+  }
+
+  private get authHeaders(): Record<string, string> {
+    return {
+      'X-Tenant-Code': this.tenantCode,
+      'X-Mcp-Token': this.mcpToken,
+    };
   }
 
   async getConfig(): Promise<McpConfigResponse> {
     const url = `${this.baseUrl}/api/mcp/config`;
+    console.log('[HTTP] GET', url);
     return this.request('GET', url) as Promise<McpConfigResponse>;
   }
 
-  async uploadFile(filePath: string, folder: string): Promise<McpUploadResponse> {
-    const url = `${this.baseUrl}/api/mcp/upload`;
-    const form = new FormData();
+  async uploadFile(filePath: string, folder: string, apiUrl?: string): Promise<McpUploadResponse> {
+    const url = apiUrl || `${this.baseUrl}/api/mcp/upload`;
+    return this.uploadWithRetry(filePath, folder, url);
+  }
 
-    const fileStream = fs.createReadStream(filePath);
-    const fileName = path.basename(filePath);
+  private async uploadWithRetry(
+    filePath: string,
+    folder: string,
+    url: string,
+    attempt: number = 1
+  ): Promise<McpUploadResponse> {
+    console.log(`[HTTP] Upload attempt ${attempt}/${MAX_RETRIES + 1}:`, filePath);
 
-    form.append('file', fileStream, { filename: fileName });
-    form.append('folder', folder);
+    try {
+      return await this.doUpload(filePath, folder, url);
+    } catch (error: any) {
+      console.error(`[HTTP] Upload attempt ${attempt} failed:`, error.message);
 
-    return this.request('POST', url, form, true) as Promise<McpUploadResponse>;
+      if (attempt <= MAX_RETRIES) {
+        console.log(`[HTTP] Retrying... (${attempt + 1}/${MAX_RETRIES + 1})`);
+        return this.uploadWithRetry(filePath, folder, url, attempt + 1);
+      }
+      throw error;
+    }
   }
 
-  private request(
-    method: string,
-    url: string,
-    body?: any,
-    isFormData: boolean = false
-  ): Promise<any> {
+  private doUpload(filePath: string, folder: string, url: string): Promise<McpUploadResponse> {
     return new Promise((resolve, reject) => {
+      const form = new FormData();
+      form.append('file', fs.createReadStream(filePath), { filename: path.basename(filePath) });
+      form.append('folder', folder);
+
       const urlObj = new URL(url);
       const client = urlObj.protocol === 'https:' ? https : http;
 
-      const options: http.RequestOptions = {
+      const req = client.request({
         hostname: urlObj.hostname,
         port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
         path: urlObj.pathname,
-        method,
-        headers: {
-          'X-Tenant-Code': this.tenantCode,
-          'X-Mcp-Token': this.mcpToken,
-          ...(isFormData ? body.getHeaders() : { 'Content-Type': 'application/json' }),
-        },
-      };
-
-      const req = client.request(options, (res) => {
-        let data = '';
-        res.on('data', (chunk) => (data += chunk));
-        res.on('end', () => {
-          try {
-            const json = JSON.parse(data);
-            if (res.statusCode === 200) {
-              resolve(json);
-            } else if (res.statusCode === 401 || res.statusCode === 403) {
-              reject(new Error('认证失败，请检查租户Token配置'));
-            } else if (res.statusCode === 404) {
-              reject(new Error('上传服务路径不存在，请联系管理员'));
-            } else {
-              reject(new Error(`服务返回错误：${res.statusCode}`));
-            }
-          } catch {
-            reject(new Error('响应解析失败'));
-          }
-        });
+        method: 'POST',
+        headers: { ...this.authHeaders, ...form.getHeaders() },
       });
 
-      req.on('error', (err) => {
-        reject(new Error(`网络错误：${err.message}`));
-      });
+      this.handleResponse(req, resolve, reject);
+      req.on('error', (err) => reject(new Error(`网络错误：${err.message}`)));
+      form.pipe(req);
+    });
+  }
 
-      if (body) {
-        if (isFormData) {
-          body.pipe(req);
-        } else {
-          req.write(JSON.stringify(body));
-        }
-      }
+  private request(method: string, url: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const client = urlObj.protocol === 'https:' ? https : http;
 
+      const req = client.request({
+        hostname: urlObj.hostname,
+        port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+        path: urlObj.pathname,
+        method,
+        headers: { ...this.authHeaders, 'Content-Type': 'application/json' },
+      });
+
+      this.handleResponse(req, resolve, reject);
+      req.on('error', (err) => reject(new Error(`网络错误：${err.message}`)));
       req.end();
     });
   }
+
+  private handleResponse(
+    req: http.ClientRequest,
+    resolve: (value: any) => void,
+    reject: (reason: any) => void
+  ): void {
+    req.on('response', (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        console.log('[HTTP] Response:', res.statusCode, data.substring(0, 200));
+
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else if (res.statusCode === 401 || res.statusCode === 403) {
+            reject(new Error('认证失败，请检查租户Token配置'));
+          } else if (res.statusCode === 404) {
+            reject(new Error('上传服务路径不存在，请联系管理员'));
+          } else {
+            reject(new Error(`服务返回错误：${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(new Error('响应解析失败: ' + data.substring(0, 100)));
+        }
+      });
+    });
+  }
 }