@atlisp/mcp 1.0.9 → 1.0.11

package/src/cad.js

@@ -3,13 +3,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
-
-const CAD_PLATFORMS = ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'];
-const FILE_EXTENSIONS = {
-  'AutoCAD': ['.fas', '.vlx'],
-  'ZWCAD': ['.zelx', '.vls'],
-  'BricsCAD': ['.des']
-};
+import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
 
 const MESSAGE_TIMEOUT = parseInt(process.env.MESSAGE_TIMEOUT || '60000', 10);
 
@@ -20,8 +14,23 @@ let worker = null;
 let _platform = null;
 let _version = null;
 
-function getWorker() {
+const HEARTBEAT_INTERVAL = parseInt(process.env.HEARTBEAT_INTERVAL || '30000', 10);
+let heartbeatTimer = null;
+
+export function resetWorker() {
+  if (worker) {
+    worker.kill();
+    worker = null;
+  }
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+
+export function getWorker() {
   if (!worker || !worker.connected) {
+    if (worker) worker.kill();
     worker = spawn('node', [workerPath], {
       stdio: ['pipe', 'pipe', 'pipe']
     });
@@ -31,12 +40,33 @@ function getWorker() {
     worker.on('exit', (code) => {
       console.error('worker exited:', code);
       worker.connected = false;
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
     });
+    startHeartbeat();
   }
   return worker;
 }
 
-function sendMessage(msg) {
+function startHeartbeat() {
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  heartbeatTimer = setInterval(async () => {
+    try {
+      const result = await sendMessage({ type: 'ping' });
+      if (!result?.pong) {
+        console.error('heartbeat failed, worker may be dead');
+        resetWorker();
+      }
+    } catch (e) {
+      console.error('heartbeat error:', e.message);
+      resetWorker();
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+
+export function sendMessage(msg) {
   return new Promise((resolve, reject) => {
     const w = getWorker();
     let responded = false;
@@ -110,9 +140,10 @@ class CadConnection {
     if (!this.connected) throw new Error('未连接 CAD');
     try {
       const result = await sendMessage({ type: 'send', code: code, platform: _platform });
-      return result && result.success;
+      if (result.success) return true;
+      throw new Error(result.error || '发送失败');
     } catch (e) {
-      return false;
+      throw e;
     }
   }
 
@@ -120,12 +151,12 @@ class CadConnection {
     if (!this.connected) throw new Error('未连接 CAD');
     try {
       const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform });
-      if (result && result.success) {
+      if (result.success) {
         return result.result || '';
       }
-      return null;
+      throw new Error(result.error || '发送失败');
     } catch (e) {
-      return null;
+      throw e;
     }
   }
 
@@ -172,11 +203,25 @@ class CadConnection {
     this.version = null;
     this.product = null;
     _platform = null;
-    if (worker) {
-      worker.kill();
-      worker = null;
+    resetWorker();
+  }
+
+  async ping() {
+    try {
+      const result = await sendMessage({ type: 'ping' });
+      return result && result.pong;
+    } catch (e) {
+      return false;
     }
   }
+
+  _reset() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+    _platform = null;
+    resetWorker();
+  }
 }
 
 export const cad = new CadConnection();

package/src/cli.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const serverPath = path.join(__dirname, 'index.js');
+const serverPath = path.join(__dirname, 'atlisp-mcp.js');
 
 const args = process.argv.slice(2);
 const env = { ...process.env };

package/src/constants.js

@@ -0,0 +1,22 @@
+export const CAD_PLATFORMS = ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'];
+export const FILE_EXTENSIONS = {
+    'AutoCAD': ['.fas', '.vlx'],
+    'ZWCAD': ['.zelx', '.vls'],
+    'BricsCAD': ['.des']
+};
+
+export const PROTOCOL_VERSION = '2024-11-05';
+export const SERVER_NAME = 'atlisp-mcp-server';
+export const SERVER_VERSION = '1.0.11';
+
+export const MOCK_PACKAGES = [
+    { name: 'base', description: '基础函数库', version: '1.0.0' },
+    { name: 'at-pm', description: '工程项目管理', version: '2.1.0' },
+    { name: 'network', description: '网络功能模块', version: '1.5.0' },
+    { name: 'userman', description: '用户管理', version: '1.2.0' },
+    { name: 'pkgman', description: '包管理器', version: '2.0.0' },
+    { name: 'sidebar', description: '侧边栏工具', version: '1.0.0' },
+    { name: 'aibot', description: 'AI 助手', version: '0.9.0' },
+    { name: 'tips', description: '每日提示', version: '1.0.0' },
+    { name: 'function', description: '函数库', version: '3.0.0' }
+];

package/src/handlers/cad-handlers.js

@@ -0,0 +1,69 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+
+export async function connectCad() {
+    log('connect_cad called, cad.connected before: ' + cad.connected);
+    try {
+        log('calling cad.connect()...');
+        const connected = await cad.connect();
+        log('cad.connect() returned: ' + connected + ', cad.connected: ' + cad.connected);
+        if (connected) {
+            return { content: [{ type: 'text', text: `已连接到 ${cad.getPlatform()} ${cad.getVersion()}` }] };
+        }
+    } catch (e) {
+        log('connect_cad error: ' + e.message);
+    }
+    return { content: [{ type: 'text', text: '未找到运行中的 CAD，请确保 CAD 已启动并启用 COM 接口' }], isError: true };
+}
+
+export async function evalLisp(code, withResult = false) {
+    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);
+            if (result !== null) {
+                return { content: [{ type: 'text', text: result }] };
+            }
+            return { content: [{ type: 'text', text: '执行失败或无返回值' }], isError: true };
+        } else {
+            await cad.sendCommand(code + '\n');
+            return { content: [{ type: 'text', text: `已发送命令: ${code}` }] };
+        }
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getCadInfo() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: 'CAD 未连接' }] };
+    const info = await cad.getInfo();
+    return { content: [{ type: 'text', text: info }] };
+}
+
+export async function atCommand(command) {
+    if (!cad.connected) return { content: [{ type: 'text', text: '请先连接 CAD' }], isError: true };
+    await cad.sendCommand(`${command}\n`);
+    return { content: [{ type: 'text', text: `已发送命令: ${command}` }] };
+}
+
+export async function newDocument() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const result = await cad.newDoc();
+    if (result) {
+        return { content: [{ type: 'text', text: '已在 CAD 中新建空白文档' }] };
+    }
+    return { content: [{ type: 'text', text: '新建文档失败' }], isError: true };
+}
+
+export async function installAtlisp() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const installCode = '(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o\'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o\'send)(v o\'WaitforResponse 1000)(e(r(vlax-get-property o\'ResponseText))))';
+    await cad.sendCommand(installCode + '\n');
+    return { content: [{ type: 'text', text: '已发送 @lisp 安装代码到 CAD' }] };
+}

package/src/handlers/function-handlers.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+
+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/';
+
+export async function getFunctionUsage(funcName, packageName) {
+    try {
+        let results = [];
+
+        const url = packageName
+            ? `${FUNCTIONS_URL}${packageName}.json`
+            : `${FUNCTIONS_URL}all.json`;
+
+        try {
+            const response = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (response.ok) {
+                const data = await response.json();
+                if (data.functions) {
+                    const func = data.functions.find(f => f.name === funcName);
+                    if (func) results.push(func);
+                }
+            }
+        } catch (e) {}
+
+        if (results.length === 0 && fs.existsSync(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'));
+                    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'));
+                for (const file of files) {
+                    const data = JSON.parse(fs.readFileSync(path.join(FUNCTIONS_DIR, file), 'utf-8'));
+                    const func = data.functions?.find(f => f.name === funcName);
+                    if (func) results.push(func);
+                }
+            }
+        }
+
+        if (results.length === 0) {
+            return { content: [{ type: 'text', text: `未找到函数: ${funcName}` }], isError: true };
+        }
+
+        const f = results[0];
+        const text = `函数: ${f.name}
+描述: ${f.description || '-'}
+参数: ${f.params?.join(', ') || '-'}
+返回值: ${f.return || '-'}
+示例: ${f.usage || '-'}`;
+
+        return { content: [{ type: 'text', text }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function listFunctions(packageName) {
+    try {
+        let allFuncs = [];
+
+        const url = packageName
+            ? `${FUNCTIONS_URL}${packageName}.json`
+            : `${FUNCTIONS_URL}all.json`;
+
+        try {
+            const response = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (response.ok) {
+                const data = await response.json();
+                if (data.functions) {
+                    allFuncs = packageName
+                        ? data.functions
+                        : data.functions.map(f => `${f.name}: ${f.description || '-'}`);
+                }
+            }
+        } catch (e) {}
+
+        if (allFuncs.length === 0 && fs.existsSync(FUNCTIONS_DIR)) {
+            const files = fs.readdirSync(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'));
+                if (packageName) {
+                    if (data.package === packageName) {
+                        allFuncs = data.functions || [];
+                    }
+                } else {
+                    for (const f of (data.functions || [])) {
+                        allFuncs.push(`${f.name}: ${f.description || '-'}`);
+                    }
+                }
+            }
+        }
+
+        if (allFuncs.length === 0) {
+            return { content: [{ type: 'text', text: '函数库为空' }] };
+        }
+
+        if (packageName) {
+            return { content: [{ type: 'text', text: `${packageName} 包函数 (${allFuncs.length}):\n${allFuncs.map(f => f.name).join('\n')}` }] };
+        }
+
+        return { content: [{ type: 'text', text: `函数库共 ${allFuncs.length} 个函数` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}

package/src/handlers/package-handlers.js

@@ -0,0 +1,26 @@
+import { cad } from '../cad.js';
+import { MOCK_PACKAGES } from '../constants.js';
+
+export async function listPackages() {
+    const packages = MOCK_PACKAGES.map(p => `${p.name} v${p.version} - ${p.description}`);
+    return { content: [{ type: 'text', text: `已安装的 @lisp 包:\n${packages.join('\n')}` }] };
+}
+
+export async function searchPackages(query) {
+    const results = MOCK_PACKAGES.filter(p => p.name.includes(query) || p.description.includes(query));
+    if (results.length === 0) {
+        return { content: [{ type: 'text', text: `未找到包含 "${query}" 的包` }] };
+    }
+    return { content: [{ type: 'text', text: `搜索结果:\n${results.map(p => `${p.name} v${p.version} - ${p.description}`).join('\n')}` }] };
+}
+
+export async function installPackage(packageName) {
+    const pkg = MOCK_PACKAGES.find(p => p.name === packageName);
+    if (!pkg) {
+        return { content: [{ type: 'text', text: `错误: 包 "${packageName}" 不存在` }], isError: true };
+    }
+    if (cad.connected) {
+        await cad.sendCommand(`(@::load-module '${packageName})\n`);
+    }
+    return { content: [{ type: 'text', text: `包 "${packageName}" 安装命令已发送！` }] };
+}

package/src/logger.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const DEBUG_FILE = process.env.DEBUG_FILE || path.join(os.tmpdir(), 'mcp-server-debug.log');
+
+let stream = null;
+
+function getStream() {
+    if (!stream) {
+        stream = fs.createWriteStream(DEBUG_FILE, { flags: 'a' });
+    }
+    return stream;
+}
+
+export function log(msg) {
+    const entry = `${new Date().toISOString()} ${msg}\n`;
+    getStream().write(entry);
+}
+
+export function logError(msg) {
+    log(`ERROR: ${msg}`);
+}
+
+export function closeLog() {
+    if (stream) {
+        stream.end();
+        stream = null;
+    }
+}

package/src/sse-utils.js

@@ -0,0 +1,32 @@
+export function setupSseHeaders(res) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('Transfer-Encoding', 'chunked');
+}
+
+export function sendSSE(res, data, event = 'message') {
+    const json = JSON.stringify(data);
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${json}\n\n`);
+    if (typeof res.flush === 'function') res.flush();
+}
+
+export function createSseResponseHandler(res, acceptSse = false) {
+    if (acceptSse) {
+        setupSseHeaders(res);
+    }
+
+    return {
+        send: (data, done = false) => {
+            const json = JSON.stringify(data);
+            if (acceptSse) {
+                sendSSE(res, data);
+                if (done) res.end();
+            } else {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(json);
+            }
+        }
+    };
+}