@atlisp/mcp 1.0.18 → 1.0.20

package/src/cad.js

@@ -1,12 +1,11 @@
 import { spawn } from 'child_process';
 import path from 'path';
-import os from 'os';
-import fs from 'fs';
 import { fileURLToPath } from 'url';
 import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
+import config from './config.js';
 
-const MESSAGE_TIMEOUT = parseInt(process.env.MESSAGE_TIMEOUT || '60000', 10);
-const RESULT_ENCODING = process.env.RESULT_ENCODING || '';
+const MESSAGE_TIMEOUT = config.messageTimeout;
+const HEARTBEAT_INTERVAL = config.heartbeatInterval;
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerPath = path.join(__dirname, 'cad-worker.js');
@@ -15,7 +14,6 @@ let worker = null;
 let _platform = null;
 let _version = null;
 
-const HEARTBEAT_INTERVAL = parseInt(process.env.HEARTBEAT_INTERVAL || '30000', 10);
 let heartbeatTimer = null;
 
 export function resetWorker() {
@@ -73,39 +71,48 @@ export function sendMessage(msg) {
   return new Promise((resolve, reject) => {
     const w = getWorker();
     let responded = false;
-    
+    let buffer = '';
+
     const timeout = setTimeout(() => {
       if (!responded) {
         responded = true;
         reject(new Error('Timeout waiting for worker'));
       }
     }, MESSAGE_TIMEOUT);
-    
+
     const handler = (data) => {
       try {
-        const lines = data.toString().split('\n');
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
         for (const line of lines) {
           if (!line.trim()) continue;
-          const result = JSON.parse(line);
-          if (result.error) {
-            if (!responded) {
-              responded = true;
-              clearTimeout(timeout);
-              w.stdout.off('data', handler);
-              reject(new Error(result.error));
-            }
-          } else {
-            if (!responded) {
-              responded = true;
-              clearTimeout(timeout);
-              w.stdout.off('data', handler);
-              resolve(result);
+          try {
+            const result = JSON.parse(line);
+            if (result.error) {
+              if (!responded) {
+                responded = true;
+                clearTimeout(timeout);
+                w.stdout.off('data', handler);
+                reject(new Error(result.error));
+              }
+            } else {
+              if (!responded) {
+                responded = true;
+                clearTimeout(timeout);
+                w.stdout.off('data', handler);
+                resolve(result);
+              }
             }
+          } catch (parseErr) {
+            console.error('JSON parse error in worker output:', parseErr.message, 'line:', line.slice(0, 200));
           }
         }
-      } catch (e) {}
+      } catch (e) {
+        console.error('Unexpected error in worker stdout handler:', e.message);
+      }
     };
-    
+
     w.stdout.on('data', handler);
     w.stdin.write(JSON.stringify(msg) + '\n');
   });
@@ -146,9 +153,9 @@ class CadConnection {
     throw new Error(result.error || '发送失败');
   }
 
-  async sendCommandWithResult(code) {
+  async sendCommandWithResult(code, encoding = null) {
     if (!this.connected) throw new Error('未连接 CAD');
-    const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform, encoding: RESULT_ENCODING });
+    const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform, encoding: encoding || '' });
     if (result.success) {
       return result.result || '';
     }

package/src/config.js

@@ -0,0 +1,28 @@
+const config = {
+    port: parseInt(process.env.PORT || '8110', 10),
+    host: process.env.HOST || '0.0.0.0',
+    transport: process.env.TRANSPORT || 'http',
+    apiKey: process.env.MCP_API_KEY || '',
+    enableSse: process.env.ENABLE_SSE !== 'false',
+    messageTimeout: parseInt(process.env.MESSAGE_TIMEOUT || '60000', 10),
+    heartbeatInterval: parseInt(process.env.HEARTBEAT_INTERVAL || '30000', 10),
+    busyRetries: parseInt(process.env.BUSY_RETRIES || '10', 10),
+    busyDelay: parseInt(process.env.BUSY_DELAY || '500', 10),
+    enableCors: process.env.ENABLE_CORS !== 'false',
+    corsOrigin: process.env.CORS_ORIGIN || '*',
+    rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW || '60000', 10),
+    rateLimitMax: parseInt(process.env.RATE_LIMIT_MAX || '100', 10),
+    resourceCacheTtl: parseInt(process.env.RESOURCE_CACHE_TTL || '5000', 10),
+    debug: process.env.DEBUG === 'true',
+    debugFile: process.env.DEBUG_FILE || '',
+};
+
+export function getConfig(key) {
+    return config[key];
+}
+
+export function getAllConfig() {
+    return { ...config };
+}
+
+export default config;

package/src/constants.js

@@ -2,12 +2,13 @@ export const CAD_PLATFORMS = ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'];
 export const FILE_EXTENSIONS = {
     'AutoCAD': ['.fas', '.vlx'],
     'ZWCAD': ['.zelx', '.vls'],
+    'GStarCAD': ['.fas', '.vlx'],
     'BricsCAD': ['.des']
 };
 
 export const PROTOCOL_VERSION = '2024-11-05';
 export const SERVER_NAME = 'atlisp-mcp-server';
-export const SERVER_VERSION = '1.0.18';
+export const SERVER_VERSION = '1.0.20';
 
 export const MOCK_PACKAGES = [
     { name: 'base', description: '基础函数库', version: '1.0.0' },

package/src/errors.js

@@ -0,0 +1,55 @@
+export const ERROR_CODES = {
+    CAD_NOT_CONNECTED: 'CAD_NOT_CONNECTED',
+    CAD_BUSY: 'CAD_BUSY',
+    CAD_NO_DOCUMENT: 'CAD_NO_DOCUMENT',
+    LISP_PAREN_MISMATCH: 'LISP_PAREN_MISMATCH',
+    TIMEOUT: 'TIMEOUT',
+    INVALID_PARAMS: 'INVALID_PARAMS',
+    METHOD_NOT_FOUND: 'METHOD_NOT_FOUND',
+    RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
+    PACKAGE_NOT_FOUND: 'PACKAGE_NOT_FOUND',
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+};
+
+export const ERROR_MESSAGES = {
+    [ERROR_CODES.CAD_NOT_CONNECTED]: '未连接 CAD，请先调用 connect_cad',
+    [ERROR_CODES.CAD_BUSY]: 'CAD 忙碌，请稍后重试',
+    [ERROR_CODES.CAD_NO_DOCUMENT]: 'CAD 中没有打开的文档',
+    [ERROR_CODES.LISP_PAREN_MISMATCH]: 'LISP 代码括号不匹配',
+    [ERROR_CODES.TIMEOUT]: '操作超时',
+    [ERROR_CODES.INVALID_PARAMS]: '无效的参数',
+    [ERROR_CODES.METHOD_NOT_FOUND]: '方法不存在',
+    [ERROR_CODES.RESOURCE_NOT_FOUND]: '资源不存在',
+    [ERROR_CODES.PACKAGE_NOT_FOUND]: '包不存在',
+    [ERROR_CODES.INTERNAL_ERROR]: '内部错误',
+};
+
+export class MCPError extends Error {
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'MCPError';
+    }
+
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            details: this.details
+        };
+    }
+}
+
+export function createError(code, details = {}) {
+    const message = ERROR_MESSAGES[code] || ERROR_MESSAGES[ERROR_CODES.INTERNAL_ERROR];
+    return new MCPError(code, message, details);
+}
+
+export function toMcpError(error) {
+    if (error instanceof MCPError) return error;
+    if (error instanceof Error) {
+        return new MCPError(ERROR_CODES.INTERNAL_ERROR, error.message, { stack: error.stack });
+    }
+    return new MCPError(ERROR_CODES.INTERNAL_ERROR, String(error));
+}

package/src/handlers/cad-handlers.js

@@ -16,14 +16,14 @@ export async function connectCad() {
     return { content: [{ type: 'text', text: '未能连接或启动 CAD，请确保 CAD 已安装' }], isError: true };
 }
 
-export async function evalLisp(code, withResult = false) {
+export async function evalLisp(code, withResult = false, encoding = null) {
     if (!cad.connected) { await cad.connect(); }
     if (!cad.connected) {
         return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
     }
     try {
         if (withResult) {
-            const result = await cad.sendCommandWithResult(code);
+            const result = await cad.sendCommandWithResult(code, encoding);
             if (result !== null) {
                 return { content: [{ type: 'text', text: result }] };
             }

package/src/handlers/function-handlers.js

@@ -1,8 +1,13 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
+import { log } from '../logger.js';
 
-const FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || 'E:/Users/vitalgg/atlisp/lib/json';
-const FUNCTIONS_URL = process.env.FUNCTIONS_URL || 'http://s3.atlisp.cn/json/';
+const FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || '';
+const FUNCTIONS_URL = process.env.FUNCTIONS_URL || 'https://s3.atlisp.cn/json/';
+
+async function fileExists(filePath) {
+    try { await fs.access(filePath); return true; } catch { return false; }
+}
 
 export async function getFunctionUsage(funcName, packageName) {
     try {
@@ -21,20 +26,24 @@ export async function getFunctionUsage(funcName, packageName) {
                     if (func) results.push(func);
                 }
             }
-        } catch (e) {}
+        } catch (e) {
+            log(`function-handlers fetch error: ${e.message}`);
+        }
 
-        if (results.length === 0 && fs.existsSync(FUNCTIONS_DIR)) {
+        if (results.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
             if (packageName) {
                 const filePath = path.join(FUNCTIONS_DIR, `${packageName}.json`);
-                if (fs.existsSync(filePath)) {
-                    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                if (await fileExists(filePath)) {
+                    const raw = await fs.readFile(filePath, 'utf-8');
+                    const data = JSON.parse(raw);
                     const func = data.functions?.find(f => f.name === funcName);
                     if (func) results.push(func);
                 }
             } else {
-                const files = fs.readdirSync(FUNCTIONS_DIR).filter(f => f.endsWith('.json'));
+                const files = (await fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
                 for (const file of files) {
-                    const data = JSON.parse(fs.readFileSync(path.join(FUNCTIONS_DIR, file), 'utf-8'));
+                    const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                    const data = JSON.parse(raw);
                     const func = data.functions?.find(f => f.name === funcName);
                     if (func) results.push(func);
                 }
@@ -76,12 +85,15 @@ export async function listFunctions(packageName) {
                         : data.functions.map(f => `${f.name}: ${f.description || '-'}`);
                 }
             }
-        } catch (e) {}
+        } catch (e) {
+            log(`function-handlers list fetch error: ${e.message}`);
+        }
 
-        if (allFuncs.length === 0 && fs.existsSync(FUNCTIONS_DIR)) {
-            const files = fs.readdirSync(FUNCTIONS_DIR).filter(f => f.endsWith('.json'));
+        if (allFuncs.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
+            const files = (await fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
             for (const file of files) {
-                const data = JSON.parse(fs.readFileSync(path.join(FUNCTIONS_DIR, file), 'utf-8'));
+                const raw = await fs.readFile(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                const data = JSON.parse(raw);
                 if (packageName) {
                     if (data.package === packageName) {
                         allFuncs = data.functions || [];

package/src/handlers/prompt-handlers.js

@@ -0,0 +1,268 @@
+import { cad } from '../cad.js';
+
+const CACHE_TTL = 60000;
+const cache = new Map();
+
+function getCached(key) {
+    const entry = cache.get(key);
+    if (entry && Date.now() - entry.timestamp < CACHE_TTL) return entry.data;
+    cache.delete(key);
+    return null;
+}
+
+function setCache(key, data) {
+    cache.set(key, { data, timestamp: Date.now() });
+}
+
+export const PROMPTS = [
+    {
+        name: "draw-residential",
+        description: "生成农村民居平面布置图",
+        arguments: [
+            { name: "width", description: "建筑宽度 (mm)", required: true },
+            { name: "depth", description: "建筑深度 (mm)", required: true },
+            { name: "rooms", description: "房间数量", required: false }
+        ]
+    },
+    {
+        name: "draw-floor-plan",
+        description: "生成建筑楼层平面图",
+        arguments: [
+            { name: "floor", description: "楼层名称", required: true },
+            { name: "scale", description: "图纸比例", required: false }
+        ]
+    },
+    {
+        name: "analyze-drawing",
+        description: "分析当前图纸统计信息",
+        arguments: []
+    },
+    {
+        name: "batch-draw-lines",
+        description: "批量绘制线段",
+        arguments: [
+            { name: "count", description: "线段数量", required: true },
+            { name: "length", description: "线段长度", required: false }
+        ]
+    },
+    {
+        name: "generate-dimension",
+        description: "生成尺寸标注",
+        arguments: [
+            { name: "style", description: "标注样式 (horizontal/vertical/aligned)", required: false }
+        ]
+    },
+    {
+        name: "export-entities",
+        description: "导出图纸实体统计",
+        arguments: [
+            { name: "format", description: "导出格式 (json/list)", required: false }
+        ]
+    }
+];
+
+export async function listPrompts() {
+    return PROMPTS;
+}
+
+export async function getPrompt(name, arguments_ = {}) {
+    switch (name) {
+        case "draw-residential":
+            return generateResidentialPrompt(arguments_);
+        case "draw-floor-plan":
+            return generateFloorPlanPrompt(arguments_);
+        case "analyze-drawing":
+            return generateAnalyzePrompt();
+        case "batch-draw-lines":
+            return generateBatchLinesPrompt(arguments_);
+        case "generate-dimension":
+            return generateDimensionPrompt(arguments_);
+        case "export-entities":
+            return generateExportPrompt(arguments_);
+        default:
+            throw new Error(`Unknown prompt: ${name}`);
+    }
+}
+
+async function generateResidentialPrompt(args) {
+    const { width = 15000, depth = 12000, rooms = 6 } = args;
+    const code = `(defun c:draw-residential (/ old-layer p)
+  (setq old-layer (getvar "clayer"))
+  (setvar "clayer" "0")
+  (setq p (list 0 0))
+  (command "_.rectangle" p (list ${width} ${depth}))
+  ${generateRoomLayout(width, depth, rooms)}
+  (setvar "clayer" old-layer)
+  (princ)
+)
+(c:draw-residential)`;
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `请在 CAD 中绘制农村民居平面图，尺寸 ${width}x${depth}mm，${rooms} 个房间。\n\n生成的 AutoLISP 代码：\n\`\`\`lisp\n${code}\n\`\`\`\n\n直接执行此代码即可生成图纸。`
+            }
+        }]
+    };
+}
+
+function generateRoomLayout(width, depth, rooms) {
+    if (rooms === 6) {
+        return `(command "_.line" (list 5000 0) (list 5000 ${depth}) "")
+               (command "_.line" (list 0 4000) (list ${width} 4000) "")
+               (command "_.text" "j" "c" "2500,2000" 800 0 "客厅")
+               (command "_.text" "j" "c" "7500,6000" 800 0 "餐厅")
+               (command "_.text" "j" "c" "12500,2000" 800 0 "主卧")`;
+    }
+    return `(command "_.text" "j" "c" (list (/ ${width} 2) (/ ${depth} 2)) 800 0 "房间")`;
+}
+
+async function generateFloorPlanPrompt(args) {
+    const { floor = "一层", scale = "1:100" } = args;
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `生成 ${floor} 平面图，比例 ${scale}。\n\n提示：\n1. 使用 RECTANGLE 命令绘制外墙\n2. 使用 LINE 命令绘制内部隔墙\n3. 使用 TEXT 命令添加房间标注\n4. 使用 DIMLINEAR 或 DIMALIGNED 添加尺寸标注\n\n需要我执行哪些操作？`
+            }
+        }]
+    };
+}
+
+async function generateAnalyzePrompt() {
+    let entities = { total: 0, byType: {} };
+    let layers = [];
+
+    try {
+        if (cad.connected) {
+            const entResult = await cad.sendCommandWithResult(
+                `(progn(setq ss(ssget "_X"))(if ss(progn(setq elst(mapcar(quote(lambda(x)(cdr(assoc 0(entget x))))) (pickset:to-list ss)))(stat:stat elst))))`
+            );
+            if (entResult) {
+                try { entities = JSON.parse(entResult); } catch {}
+            }
+
+            const layerResult = await cad.sendCommandWithResult(
+                `(progn(setq res nil)(while(setq e(tblnext "LAYER"(null res)))(setq res(cons(cdr(assoc 2 e))res)))(reverse res))`
+            );
+            if (layerResult) {
+                try { layers = JSON.parse(layerResult); } catch {}
+            }
+        }
+    } catch (e) {}
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `图纸分析报告：
+
+**实体统计：** ${entities.total} 个
+${Object.entries(entities.byType).map(([t, c]) => `- ${t}: ${c}`).join('\n')}
+
+**图层列表：** ${layers.length} 个
+${layers.slice(0, 10).join(', ')}${layers.length > 10 ? '...' : ''}
+
+**建议：**\n${generateSuggestions(entities, layers)}`
+            }
+        }]
+    };
+}
+
+function generateSuggestions(entities, layers) {
+    const suggestions = [];
+    if (entities.total > 1000) suggestions.push("- 图纸实体较多，建议使用图层分类管理");
+    if (layers.length > 20) suggestions.push("- 图层较多，建议清理未使用的图层");
+    if (entities.byType.LINE && entities.byType.LINE > 500) suggestions.push("- 线条较多，可考虑使用 BLOCK 减少实体数量");
+    if (!entities.byType.DIMENSION) suggestions.push("- 未发现尺寸标注，建议添加标注");
+    return suggestions.length ? suggestions.join('\n') : '- 图纸结构良好';
+}
+
+async function generateBatchLinesPrompt(args) {
+    const { count = 5, length = 1000 } = args;
+
+    const code = `(defun c:batch-lines (/ i)
+  (setq i 0)
+  (repeat ${count}
+    (command "_.line" (list (* i ${length}) 0) (list (* (1+ i) ${length}) 0) "")
+    (setq i (1+ i))
+  )
+  (princ)
+)
+(c:batch-lines)`;
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `批量绘制 ${count} 条长度为 ${length} 的水平线段：\n\n\`\`\`lisp\n${code}\n\`\`\`\n\n此代码将绘制 ${count} 条首尾相连的水平线段。`
+            }
+        }]
+    };
+}
+
+async function generateDimensionPrompt(args) {
+    const { style = "aligned" } = args;
+
+    let dimStyle = "aligned";
+    let lispStyle = "DIMALIGNED";
+    if (style === "horizontal") { dimStyle = "水平"; lispStyle = "DIMLINEAR"; }
+    if (style === "vertical") { dimStyle = "垂直"; lispStyle = "DIMLINEAR"; }
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `生成 ${dimStyle} 尺寸标注代码：\n\n\`\`\`lisp\n(command "_${lispStyle}" "0,0" "1000,0" "500,200" "")
+\`\`\`\n\n参数说明：\n- 起点: 0,0\n- 终点: 1000,0\n- 标注位置: 500,200\n\n执行后将创建 ${dimStyle} 尺寸标注。`
+            }
+        }]
+    };
+}
+
+async function generateExportPrompt(args) {
+    const { format = "json" } = args;
+
+    const code = format === "json"
+        ? `(progn
+  (setq ss(ssget "_X"))
+  (if ss
+    (progn
+      (setq elst(mapcar(quote(lambda(x)(list(cdr(assoc 0(entget x)))(vlax-get x 'ObjectName))))(pickset:to-list ss)))
+      (stat:stat(mapcar(quote car)elst))
+    )
+  )
+)`
+        : `(progn
+  (princ "\\n实体统计:\\n")
+  (princ "类型              数量\\n")
+  (princ "---------------------\\n")
+  (setq ss(ssget "_X"))
+  (if ss
+    (progn
+      (setq elst(mapcar(quote(lambda(x)(cdr(assoc 0(entget x))))) (pickset:to-list ss)))
+      (foreach t '("LINE" "CIRCLE" "ARC" "TEXT" "MTEXT" "POLYLINE" "LWPOLYLINE" "INSERT")
+        (setq cnt(length(member t elst)))
+        (if(> cnt 0)(princ(strcat t "           "(itoa cnt) "\\n")))
+      )
+    )
+  )
+)`;
+
+    return {
+        messages: [{
+            role: "user",
+            content: {
+                type: "text",
+                text: `导出实体统计 (${format} 格式)：\n\n\`\`\`lisp\n${code}\n\`\`\`\n\n执行后将输出实体统计信息。`
+            }
+        }]
+    };
+}