@atlisp/mcp 1.0.1

package/README.md

@@ -0,0 +1,148 @@
+# @lisp MCP Server
+
+MCP (Model Context Protocol) Server for @lisp on CAD - 为 CAD 环境提供 @lisp 包管理服务的 MCP 服务器。
+
+## 功能特性
+
+- 连接 AutoCAD/ZWCAD/GStarCAD/BricsCAD
+- 执行 AutoLISP 代码
+- 管理 @lisp 包（列出、搜索、安装）
+- 获取 CAD 平台信息
+- 通过 MCP 协议提供标准化接口
+
+## 安装
+
+```bash
+cd tools/mcp-server
+npm install
+```
+
+## 使用方法
+
+### 启动服务器
+
+**HTTP 模式（默认）**：
+```bash
+npm start
+# 或
+TRANSPORT=http node src/index.js
+```
+
+**Stdio 模式**（用于 MCP 客户端）：
+```bash
+TRANSPORT=stdio node src/index.js
+```
+
+### 环境变量
+
+| 变量 | 默认值 | 说明 |
+|------|--------|------|
+| `TRANSPORT` | `http` | 传输模式：`http` 或 `stdio` |
+| `PORT` | `8110` | HTTP 模式监听端口 |
+| `HOST` | `0.0.0.0` | HTTP 模式监听地址 |
+
+## API
+
+### 健康检查
+
+```bash
+curl http://localhost:8110/health
+```
+
+返回：
+```json
+{"status":"ok","cad":"connected"}
+```
+
+### MCP 端点
+
+HTTP 模式：`POST http://localhost:8110/mcp`
+
+#### 列出工具
+
+```bash
+curl -X POST http://localhost:8110/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+```
+
+#### 调用工具
+
+```bash
+curl -X POST http://localhost:8110/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"工具名","arguments":{参数}}}'
+```
+
+## 可用工具
+
+| 工具名称 | 描述 | 参数 |
+|---------|------|------|
+| `connect_cad` | 连接到 CAD | 无 |
+| `eval_lisp` | 在 CAD 中执行 AutoLISP 代码 | `code`: 字符串 |
+| `get_cad_info` | 获取当前 CAD 信息 | 无 |
+| `list_packages` | 列出已安装的 @lisp 包 | 无 |
+| `search_packages` | 搜索 @lisp 包 | `query`: 搜索关键词 |
+| `install_package` | 安装 @lisp 包到 CAD | `packageName`: 包名称 |
+| `get_platform_info` | 获取 CAD 平台信息 | 无 |
+| `get_file_extensions` | 获取指定平台的文件扩展名 | `platform`: 平台名称 |
+| `get_install_code` | 获取 @lisp 安装代码 | 无 |
+| `at_command` | 执行 @lisp 命令 | `command`: 命令 |
+| `install_atlisp` | 在 CAD 中安装 @lisp | 无 |
+
+## 支持的平台
+
+- **AutoCAD** (文件扩展名: `.fas`, `.vlx`)
+- **ZWCAD** (文件扩展名: `.zelx`, `.vls`)
+- **GStarCAD** (文件扩展名: `.des`)
+- **BricsCAD** (文件扩展名: `.des`)
+
+## 技术栈
+
+- **Runtime**: Node.js >= 18
+- **MCP SDK**: `@modelcontextprotocol/sdk`
+- **CAD 连接**: `edge-js` (通过 .NET COM 互操作)
+
+## 工作原理
+
+1. MCP Server 通过 `edge-js` 调用 .NET 代码
+2. .NET 代码通过 COM 互操作连接 CAD 应用程序
+3. 支持获取活动 CAD 实例或启动新实例
+4. 通过 `SendCommand` 方法向 CAD 发送 LISP 代码
+
+## 示例
+
+### 连接 CAD
+
+```bash
+curl -X POST http://localhost:8110/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"connect_cad","arguments":{}}}'
+```
+
+### 执行 LISP 代码
+
+```bash
+curl -X POST http://localhost:8110/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"eval_lisp","arguments":{"code":"(getvar \"acadver\")"}}}'
+```
+
+### 搜索包
+
+```bash
+curl -X POST http://localhost:8110/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"search_packages","arguments":{"query":"base"}}}'
+```
+
+## 注意事项
+
+- 仅支持 Windows 平台（依赖 COM 互操作）
+- 需要安装对应的 CAD 软件
+- CAD 必须正在运行或可被启动
+- 某些操作可能需要以管理员权限运行
+
+## 许可证
+
+ISC

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "@atlisp/mcp",
+    "version": "1.0.1",
+    "description": "MCP Server for @lisp on CAD",
+    "type": "module",
+    "bin": {
+        "atlisp-mcp": "./src/cli.js"
+    },
+    "main": "src/index.js",
+    "exports": {
+        ".": "./src/index.js",
+        "./cad": "./src/cad.js"
+    },
+    "files": [
+        "src"
+    ],
+    "scripts": {
+        "start": "node src/index.js",
+        "build": "webpack",
+        "test": "echo \"No tests yet\" && exit 0"
+    },
+    "keywords": [
+        "mcp",
+        "atlisp",
+        "cad",
+        "autolisp",
+        "package-manager"
+    ],
+    "author": "vitalgg",
+    "license": "ISC",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "edge-js": "^25.0.1"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+
+}

package/src/cad-worker.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import edge from 'edge-js';
+import process from 'process';
+
+const cadConnect = edge.func(function() {/*
+  async (input) => {
+      // Try existing CAD instances
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("AutoCAD.Application");
+          if (cad != null) {
+              string ver = cad.Version.ToString();
+              return new { success = true, platform = "AutoCAD", version = ver };
+          }
+      } catch {}
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("ZWCAD.Application");
+          if (cad != null) {
+              string ver = cad.Version.ToString();
+              return new { success = true, platform = "ZWCAD", version = ver };
+          }
+      } catch {}
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("GStarCAD.Application");
+          if (cad != null) {
+              string ver = cad.Version.ToString();
+              return new { success = true, platform = "GStarCAD", version = ver };
+          }
+      } catch {}
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("BricsCAD.Application");
+          if (cad != null) {
+              string ver = cad.Version.ToString();
+              return new { success = true, platform = "BricsCAD", version = ver };
+          }
+      } catch {}
+      
+      // Try to create new CAD instance
+      string[] cadPaths = new string[] {
+          @"C:\Program Files\Autodesk\AutoCAD 2022\acad.exe",
+          @"C:\Program Files\Autodesk\AutoCAD 2024\acad.exe",
+          @"C:\Program Files\Autodesk\AutoCAD 2023\acad.exe",
+          @"C:\Program Files\Autodesk\AutoCAD 2021\acad.exe",
+          @"C:\Program Files\Autodesk\AutoCAD 2020\acad.exe",
+          @"C:\Program Files\ZWSOFT\ZWCAD 2024\zwcad.exe",
+          @"C:\Program Files\ZWSOFT\ZWCAD 2023\zwcad.exe",
+          @"C:\Program Files\ZWSOFT\ZWCAD 2022\zwcad.exe",
+          @"C:\Program Files\ZWSOFT\ZWCAD 2021\zwcad.exe",
+          @"C:\Program Files\GSTARSOFT\GStarCAD 2024\GCAD.exe",
+          @"C:\Program Files\GSTARSOFT\GStarCAD 2023\GCAD.exe",
+          @"C:\Program Files\Bricsys\BricsCAD\V24\BricsCAD.exe",
+          @"C:\Program Files\Bricsys\BricsCAD\V23\BricsCAD.exe"
+      };
+      
+      foreach (string path in cadPaths) {
+          if (System.IO.File.Exists(path)) {
+              try {
+                  System.Diagnostics.Process.Start(path);
+                  System.Threading.Thread.Sleep(60000);
+                  
+                  // Try to connect to newly started CAD
+                  try {
+                      dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("AutoCAD.Application");
+                      if (cad != null) {
+                          string ver = cad.Version.ToString();
+                          return new { success = true, platform = "AutoCAD", version = ver };
+                      }
+                  } catch {}
+                  try {
+                      dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("ZWCAD.Application");
+                      if (cad != null) {
+                          string ver = cad.Version.ToString();
+                          return new { success = true, platform = "ZWCAD", version = ver };
+                      }
+                  } catch {}
+                  try {
+                      dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("GStarCAD.Application");
+                      if (cad != null) {
+                          string ver = cad.Version.ToString();
+                          return new { success = true, platform = "GStarCAD", version = ver };
+                      }
+                  } catch {}
+                  try {
+                      dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject("BricsCAD.Application");
+                      if (cad != null) {
+                          string ver = cad.Version.ToString();
+                          return new { success = true, platform = "BricsCAD", version = ver };
+                      }
+                  } catch {}
+              } catch {}
+          }
+      }
+      
+      return new { success = false, error = "No CAD found" };
+  }
+*/});
+
+const cadSend = edge.func(function() {/*
+  async (input) => {
+      dynamic d = input;
+      string code = d.code.ToString();
+      string platform = d.platform.ToString();
+      string progId = platform + ".Application";
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
+          if (cad != null) {
+              dynamic doc = cad.ActiveDocument;
+              if (doc == null || doc.Name == "") {
+                  // Try default template path
+                  string templatePath = @"C:\Users\Public\Documents\AutoCAD 2024\Sample\basics.dwg";
+                  if (System.IO.File.Exists(templatePath)) {
+                      cad.Documents.Open(templatePath, false);
+                  } else {
+                      cad.Documents.Add("");
+                  }
+                  System.Threading.Thread.Sleep(2000);
+              }
+              doc = cad.ActiveDocument;
+              if (doc != null) {
+                  doc.SendCommand(code);
+                  return new { success = true };
+              }
+          }
+      } catch {}
+      return new { success = false };
+  }
+*/});
+
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (data) => {
+  const lines = data.trim().split('\n');
+  for (const line of lines) {
+    if (!line) continue;
+    try {
+      const msg = JSON.parse(line);
+      handleMessage(msg).then(result => {
+        process.stdout.write(JSON.stringify(result) + '\n');
+      }).catch(err => {
+        process.stdout.write(JSON.stringify({ error: err.message }) + '\n');
+      });
+    } catch (e) {
+      process.stdout.write(JSON.stringify({ error: 'invalid message' }) + '\n');
+    }
+  }
+});
+
+const cadHasDoc = edge.func(function() {/*
+  async (input) => {
+      string platform = input.ToString();
+      string progId = platform + ".Application";
+      try {
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
+          if (cad != null) {
+              dynamic doc = cad.ActiveDocument;
+              if (doc != null && doc.Name != "") {
+                  return new { hasDoc = true, name = doc.Name };
+              }
+          }
+      } catch {}
+      return new { hasDoc = false };
+  }
+*/});
+
+async function handleMessage(msg) {
+  if (msg.type === 'connect') {
+    return new Promise((resolve, reject) => {
+      cadConnect({}, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === 'hasdoc') {
+    return new Promise((resolve, reject) => {
+      cadHasDoc(msg.platform || 'AutoCAD', (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === 'send') {
+    const checkResult = await new Promise((resolve, reject) => {
+      cadHasDoc(msg.platform, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    if (!checkResult.hasDoc) {
+      const newDoc = await new Promise((resolve, reject) => {
+        cadSend({ code: "\n", platform: msg.platform }, (e, r) => {
+          if (e) reject(e);
+          else resolve(r);
+        });
+      });
+    }
+    return new Promise((resolve, reject) => {
+      cadSend({ code: msg.code, platform: msg.platform }, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  return { error: 'unknown message type' };
+}

package/src/cad.js

@@ -0,0 +1,138 @@
+import { spawn } from 'child_process';
+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']
+};
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const workerPath = path.join(__dirname, 'cad-worker.js');
+
+let worker = null;
+let _platform = null;
+let _version = null;
+
+function getWorker() {
+  if (!worker || !worker.connected) {
+    worker = spawn('node', [workerPath], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    worker.connected = true;
+    
+    worker.stderr.on('data', (d) => console.error('worker stderr:', d.toString()));
+    worker.on('exit', (code) => {
+      console.error('worker exited:', code);
+      worker.connected = false;
+    });
+  }
+  return worker;
+}
+
+function sendMessage(msg) {
+  return new Promise((resolve, reject) => {
+    const w = getWorker();
+    let responded = false;
+    
+    const timeout = setTimeout(() => {
+      if (!responded) {
+        responded = true;
+        reject(new Error('Timeout waiting for worker'));
+      }
+    }, 60000);
+    
+    const handler = (data) => {
+      try {
+        const lines = data.toString().split('\n');
+        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);
+            }
+          }
+        }
+      } catch (e) {}
+    };
+    
+    w.stdout.on('data', handler);
+    w.stdin.write(JSON.stringify(msg) + '\n');
+  });
+}
+
+class CadConnection {
+  constructor() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+  }
+
+  isAvailable() {
+    return process.platform === 'win32';
+  }
+
+  async connect() {
+    if (!this.isAvailable()) return false;
+    try {
+      const result = await sendMessage({ type: 'connect' });
+      if (result && result.success) {
+        this.version = result.version;
+        this.product = result.platform;
+        _platform = result.platform;
+        this.connected = true;
+        return true;
+      }
+    } catch (e) {
+      console.error('CAD connect error:', e.message);
+    }
+    return false;
+  }
+
+  async sendCommand(code) {
+    if (!this.connected) throw new Error('未连接 CAD');
+    try {
+      const result = await sendMessage({ type: 'send', code: code, platform: _platform });
+      return result && result.success;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  getVersion() { return this.version; }
+  getPlatform() { return this.product; }
+  
+  async getInfo() {
+    if (!this.connected) return 'CAD 未连接';
+    return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
+  }
+
+  async disconnect() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+    _platform = null;
+    if (worker) {
+      worker.kill();
+      worker = null;
+    }
+  }
+}
+
+export const cad = new CadConnection();
+export default CadConnection;

package/src/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverPath = path.join(__dirname, 'index.js');
+
+const args = process.argv.slice(2);
+const env = { ...process.env };
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--transport' && args[i + 1]) {
+    env.TRANSPORT = args[i + 1];
+    i++;
+  } else if (args[i] === '--port' && args[i + 1]) {
+    env.PORT = args[i + 1];
+    i++;
+  } else if (args[i] === '--host' && args[i + 1]) {
+    env.HOST = args[i + 1];
+    i++;
+  } else if (args[i] === '--stdio') {
+    env.TRANSPORT = 'stdio';
+  } else if (args[i] === '--help' || args[i] === '-h') {
+    console.log(`
+@lisp MCP Server
+
+Usage: atlisp-mcp [options]
+
+Options:
+  --transport <type>   Transport type: http or stdio (default: http)
+  --port <port>        HTTP port (default: 8110)
+  --host <host>        HTTP host (default: 0.0.0.0)
+  --stdio              Shorthand for --transport stdio
+  -h, --help           Show this help message
+
+Examples:
+  atlisp-mcp                       # Start HTTP server on port 8110
+  atlisp-mcp --port 3000           # Start HTTP server on port 3000
+  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
+  atlisp-mcp --transport stdio     # Same as --stdio
+`);
+    process.exit(0);
+  }
+}
+
+const child = spawn('node', [serverPath], {
+  env,
+  stdio: 'inherit'
+});
+
+child.on('exit', (code) => {
+  process.exit(code);
+});

package/src/index.js

@@ -0,0 +1,279 @@
+import express from 'express';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { cad } from './cad.js';
+
+const DEBUG_FILE = path.join(os.tmpdir(), 'mcp-server-debug.log');
+function log(msg) {
+  fs.writeFileSync(DEBUG_FILE, new Date().toISOString() + ' ' + msg + '\n', { flag: 'a' });
+}
+log('Server starting, cad loaded: ' + typeof cad);
+
+const PORT = process.env.PORT || 8110;
+const HOST = process.env.HOST || '0.0.0.0';
+const TRANSPORT = process.env.TRANSPORT || 'http';
+
+const CAD_PLATFORMS = ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'];
+const FILE_EXTENSIONS = {
+  'AutoCAD': ['.fas', '.vlx'],
+  'ZWCAD': ['.zelx', '.vls'],
+  'BricsCAD': ['.des']
+};
+
+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' }
+];
+
+const tools = [
+  {
+    name: 'connect_cad',
+    description: '连接到 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'eval_lisp',
+    description: '在 CAD 中执行 AutoLISP 代码',
+    inputSchema: {
+      type: 'object',
+      properties: { code: { type: 'string', description: '要执行的 LISP 代码' } },
+      required: ['code']
+    }
+  },
+  {
+    name: 'get_cad_info',
+    description: '获取当前 CAD 信息',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'list_packages',
+    description: '列出已安装的 @lisp 包',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'search_packages',
+    description: '搜索 @lisp 包',
+    inputSchema: {
+      type: 'object',
+      properties: { query: { type: 'string', description: '搜索关键词' } },
+      required: ['query']
+    }
+  },
+  {
+    name: 'install_package',
+    description: '安装 @lisp 包到 CAD',
+    inputSchema: {
+      type: 'object',
+      properties: { packageName: { type: 'string', description: '包名称' } },
+      required: ['packageName']
+    }
+  },
+  {
+    name: 'get_platform_info',
+    description: '获取 CAD 平台信息',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_file_extensions',
+    description: '获取指定平台的文件扩展名',
+    inputSchema: {
+      type: 'object',
+      properties: { platform: { type: 'string', enum: CAD_PLATFORMS, description: 'CAD 平台' } },
+      required: ['platform']
+    }
+  },
+  {
+    name: 'get_install_code',
+    description: '获取 @lisp 安装代码',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'at_command',
+    description: '执行 @lisp 命令',
+    inputSchema: {
+      type: 'object',
+      properties: { command: { type: 'string', description: '@lisp 命令' } },
+      required: ['command']
+    }
+  },
+  {
+    name: 'install_atlisp',
+    description: '在 CAD 中安装 @lisp',
+    inputSchema: { type: 'object', properties: {} }
+  }
+];
+
+async function handleToolCall(name, args) {
+  switch (name) {
+    case 'connect_cad':
+      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 };
+
+    case 'eval_lisp':
+      if (!cad.connected) { await cad.connect(); }
+      if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+      await cad.sendCommand(args.code + '\n');
+      return { content: [{ type: 'text', text: `已发送命令: ${args.code}` }] };
+
+    case 'get_cad_info':
+      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 }] };
+
+    case 'list_packages':
+      const packages = MOCK_PACKAGES.map(p => `${p.name} v${p.version} - ${p.description}`);
+      return { content: [{ type: 'text', text: `已安装的 @lisp 包:\n${packages.join('\n')}` }] };
+
+    case 'search_packages':
+      const results = MOCK_PACKAGES.filter(p => p.name.includes(args.query) || p.description.includes(args.query));
+      if (results.length === 0) return { content: [{ type: 'text', text: `未找到包含 "${args.query}" 的包` }] };
+      return { content: [{ type: 'text', text: `搜索结果:\n${results.map(p => `${p.name} v${p.version} - ${p.description}`).join('\n')}` }] };
+
+    case 'install_package':
+      const pkg = MOCK_PACKAGES.find(p => p.name === args.packageName);
+      if (!pkg) return { content: [{ type: 'text', text: `错误: 包 "${args.packageName}" 不存在` }], isError: true };
+      if (cad.connected) await cad.sendCommand(`(@::load-module '${args.packageName})\n`);
+      return { content: [{ type: 'text', text: `包 "${args.packageName}" 安装命令已发送！` }] };
+
+    case 'get_platform_info':
+      return { content: [{ type: 'text', text: `支持的 CAD 平台:\n${CAD_PLATFORMS.join('\n')}\n当前连接: ${cad.connected ? '已连接' : '未连接'}` }] };
+
+    case 'get_file_extensions':
+      const exts = FILE_EXTENSIONS[args.platform];
+      if (!exts) return { content: [{ type: 'text', text: `错误: 不支持的平台 "${args.platform}"` }], isError: true };
+      return { content: [{ type: 'text', text: `${args.platform} 文件扩展名: ${exts.join(', ')}` }] };
+
+    case 'get_install_code':
+      const code = '(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))))';
+      return { content: [{ type: 'text', text: `复制以下代码到 CAD 命令行安装 @lisp:\n\n${code}` }] };
+
+    case 'at_command':
+      if (!cad.connected) return { content: [{ type: 'text', text: '请先连接 CAD' }], isError: true };
+      await cad.sendCommand(`@${args.command}\n`);
+      return { content: [{ type: 'text', text: `已发送命令: @${args.command}` }] };
+
+    case 'install_atlisp':
+      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' }] };
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+const mcpServer = new Server(
+  { name: 'atlisp-mcp-server', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+
+mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+  console.error('setRequestHandler called, name:', request.params.name);
+  const { name, arguments: args } = request.params;
+  return await handleToolCall(name, args || {});
+});
+
+if (TRANSPORT === 'stdio') {
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  console.error('@lisp MCP Server 运行在 stdio 模式');
+} else {
+  const app = express();
+  app.use(express.json({ type: ['application/json', 'application/json-rpc'] }));
+
+  app.get('/health', (req, res) => {
+    res.json({ status: 'ok', cad: cad.connected ? 'connected' : 'disconnected' });
+  });
+
+  app.post('/mcp', async (req, res) => {
+    log('POST /mcp called, body: ' + JSON.stringify(req.body));
+    try {
+      const message = req.body;
+      const id = message.id;
+
+      if (!id) {
+        log('No id, returning 204');
+        return res.status(204).end();
+      }
+
+      if (message.method === 'initialize') {
+        return res.json({
+          jsonrpc: '2.0',
+          id: id,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            serverInfo: { name: 'atlisp-mcp-server', version: '1.0.0' }
+          }
+        });
+      }
+
+      if (message.method === 'tools/list') {
+        return res.json({
+          jsonrpc: '2.0',
+          id: id,
+          result: { tools }
+        });
+      }
+
+      if (message.method === 'tools/call') {
+        log('tools/call called, name: ' + message.params.name);
+        const result = await handleToolCall(message.params.name, message.params.arguments || {});
+        log('tools/call result: ' + JSON.stringify(result));
+        return res.json({
+          jsonrpc: '2.0',
+          id: id,
+          result
+        });
+      }
+
+      res.json({
+        jsonrpc: '2.0',
+        id: id,
+        error: { code: -32601, message: 'Method not found' }
+      });
+    } catch (e) {
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: { code: -32603, message: e.message }
+      });
+    }
+  });
+
+  app.listen(PORT, HOST, () => {
+    const status = cad.connected ? '已连接 CAD' : '未连接 CAD';
+    console.error(`@lisp MCP Server 启动 - http://${HOST}:${PORT} - ${status}`);
+  });
+}