@atlisp/mcp 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.0.12",
+    "version": "1.0.14",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {

package/src/atlisp-mcp.js

@@ -5,6 +5,10 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import {
     ListToolsRequestSchema,
     CallToolRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+    SubscribeRequestSchema,
+    UnsubscribeRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { cad } from './cad.js';
 import { CAD_PLATFORMS, FILE_EXTENSIONS, PROTOCOL_VERSION, SERVER_NAME, SERVER_VERSION } from './constants.js';
@@ -12,6 +16,8 @@ import { log } from './logger.js';
 import * as cadHandlers from './handlers/cad-handlers.js';
 import * as packageHandlers from './handlers/package-handlers.js';
 import * as functionHandlers from './handlers/function-handlers.js';
+import { listResources, readResource } from './handlers/resource-handlers.js';
+import * as subMgr from './subscription-manager.js';
 import { createSseResponseHandler } from './sse-utils.js';
 
 const PORT = process.env.PORT || 8110;
@@ -184,7 +190,7 @@ let server = null;
 export function createMcpServer() {
     server = new Server(
 	{ name: SERVER_NAME, version: SERVER_VERSION },
-	{ capabilities: { tools: {} } }
+	{ capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } } }
     );
 
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
@@ -194,6 +200,42 @@ export function createMcpServer() {
 	return await handleToolCall(name, args || {});
     });
 
+    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: await listResources(subMgr.list())
+    }));
+
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const { uri } = request.params;
+        try {
+            const data = await readResource(uri);
+            return {
+                contents: [{
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(data)
+                }]
+            };
+        } catch (e) {
+            return {
+                contents: [],
+                isError: true,
+                error: { code: -32603, message: e.message }
+            };
+        }
+    });
+
+    server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+        const { uri } = request.params;
+        subMgr.subscribe(uri);
+        return { success: true };
+    });
+
+    server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+        const { uri } = request.params;
+        subMgr.unsubscribe(uri);
+        return { success: true };
+    });
+
     return server;
 }
 
@@ -263,7 +305,7 @@ export async function startServer() {
 		if (method === 'initialize') {
 		    send({ jsonrpc: '2.0', id, result: {
 			protocolVersion: PROTOCOL_VERSION,
-			capabilities: { tools: {} },
+			capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
 			serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
 		    } }, true);
 		    return;
@@ -274,6 +316,49 @@ export async function startServer() {
 		    return;
 		}
 
+		if (method === 'resources/list') {
+		    const resources = await listResources(subMgr.list());
+		    send({ jsonrpc: '2.0', id, result: { resources } }, true);
+		    return;
+		}
+
+		if (method === 'resources/read') {
+		    const uri = params?.uri;
+		    if (!uri) {
+			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+			return;
+		    }
+		    try {
+			const data = await readResource(uri);
+			send({ jsonrpc: '2.0', id, result: { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] } }, true);
+		    } catch (e) {
+			send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
+		    }
+		    return;
+		}
+
+		if (method === 'resources/subscribe') {
+		    const uri = params?.uri;
+		    if (!uri) {
+			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+			return;
+		    }
+		    subMgr.subscribe(uri);
+		    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
+		    return;
+		}
+
+		if (method === 'resources/unsubscribe') {
+		    const uri = params?.uri;
+		    if (!uri) {
+			send({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } }, true);
+			return;
+		    }
+		    subMgr.unsubscribe(uri);
+		    send({ jsonrpc: '2.0', id, result: { success: true } }, true);
+		    return;
+		}
+
 		if (method === 'tools/call') {
 		    const toolName = params?.name;
 		    if (!toolName) {

package/src/cad-worker.js

@@ -79,16 +79,31 @@ const cadSendWithResult = edge.func(function() {/*
           string progId = platform + ".Application";
           string tempDir = System.IO.Path.GetTempPath();
           tempFile = System.IO.Path.Combine(tempDir, "atlisp_result_" + System.Guid.NewGuid().ToString("N") + ".txt");
-          string lispCode = "(progn(setq f(open \"" + tempFile.Replace("\\", "\\\\") + "\" \"w\"))(print " + code + " f)(close f))";
+          string lispCode = "(progn(setq f(open \"" + tempFile.Replace("\\", "\\\\") + "\" \"w\"))(print " + code + " f)(close f)(princ))";
           dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
           if (cad != null) {
               dynamic doc = cad.ActiveDocument;
               if (doc != null) {
                   doc.SendCommand(lispCode + "\n");
-                  System.Threading.Thread.Sleep(500);
+                  int retries = 10;
+                  string result = "";
+                  while (retries > 0 && !System.IO.File.Exists(tempFile)) {
+                      System.Threading.Thread.Sleep(200);
+                      retries--;
+                  }
                   if (System.IO.File.Exists(tempFile)) {
-                      string result = System.Text.Encoding.GetEncoding("GBK").GetString(System.IO.File.ReadAllBytes(tempFile)).Trim();
-                      System.IO.File.Delete(tempFile);
+                      retries = 5;
+                      while (retries > 0) {
+                          try {
+                              byte[] bytes = System.IO.File.ReadAllBytes(tempFile);
+                              result = System.Text.Encoding.GetEncoding("GBK").GetString(bytes).Trim();
+                              try { System.IO.File.Delete(tempFile); } catch {}
+                              break;
+                          } catch (System.IO.IOException) {
+                              System.Threading.Thread.Sleep(200);
+                              retries--;
+                          }
+                      }
                       if (!string.IsNullOrEmpty(result)) {
                           return new { success = true, result = result };
                       }
@@ -99,17 +114,17 @@ const cadSendWithResult = edge.func(function() {/*
           }
       } catch (Exception ex) {
           System.Diagnostics.Debug.WriteLine("cadSendWithResult error: " + ex.Message);
-          if (tempFile != null && System.IO.File.Exists(tempFile)) {
-              try { System.IO.File.Delete(tempFile); } catch {}
+          if (tempFile != null) {
+              try { if (System.IO.File.Exists(tempFile)) System.IO.File.Delete(tempFile); } catch {}
           }
           return new { success = false, error = ex.Message };
       }
-      if (tempFile != null && System.IO.File.Exists(tempFile)) {
-          try { System.IO.File.Delete(tempFile); } catch {}
+      if (tempFile != null) {
+          try { if (System.IO.File.Exists(tempFile)) System.IO.File.Delete(tempFile); } catch {}
       }
       return new { success = false };
   }
- */});
+  */});
 
 process.stdin.setEncoding('utf8');
 

package/src/constants.js

@@ -7,7 +7,7 @@ export const FILE_EXTENSIONS = {
 
 export const PROTOCOL_VERSION = '2024-11-05';
 export const SERVER_NAME = 'atlisp-mcp-server';
-export const SERVER_VERSION = '1.0.12';
+export const SERVER_VERSION = '1.0.13';
 
 export const MOCK_PACKAGES = [
     { name: 'base', description: '基础函数库', version: '1.0.0' },

package/src/handlers/resource-handlers.js

@@ -0,0 +1,304 @@
+import { cad } from '../cad.js';
+import { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from '../constants.js';
+
+function parseLispList(str) {
+    if (!str || typeof str !== 'string') return null;
+    const trimmed = str.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) return null;
+    const content = trimmed.slice(1, -1).trim();
+    if (!content) return [];
+
+    const result = [];
+    let depth = 0;
+    let current = '';
+    let inString = false;
+    let escaped = false;
+
+    for (let i = 0; i < content.length; i++) {
+        const ch = content[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            current += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            current += ch;
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            current += ch;
+            continue;
+        }
+        if (ch === '(' || ch === '[') {
+            current += ch;
+            depth++;
+        } else if (ch === ')' || ch === ']') {
+            current += ch;
+            depth--;
+        } else if (ch === ' ' && depth === 0) {
+            if (current.trim()) {
+                result.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim()) result.push(current.trim());
+
+    return result.map(item => {
+        const t = item.trim();
+        if (t === 'nil') return null;
+        if (t === 't') return true;
+        if (t === 'T') return true;
+        const num = Number(t);
+        if (!isNaN(num) && t !== '') return num;
+        if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
+        return t;
+    });
+}
+
+export const RESOURCES = [
+    { uri: 'atlisp://cad/info', name: 'CAD Info', description: 'CAD 连接信息', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://cad/layers', name: 'Layers', description: '图层列表', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://cad/entities', name: 'Entities', description: '实体统计', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://dwg/name', name: 'DWG Name', description: '当前 DWG 文件名', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://dwg/path', name: 'DWG Path', description: '文件完整路径', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://packages', name: 'Packages', description: '已安装包列表', mimeType: 'application/json', subscribable: true },
+    { uri: 'atlisp://platforms', name: 'Platforms', description: '支持的平台信息', mimeType: 'application/json', subscribable: false },
+];
+
+function parseQuery(uri) {
+    const qIdx = uri.indexOf('?');
+    if (qIdx === -1) return { base: uri, params: {} };
+    const base = uri.substring(0, qIdx);
+    const params = {};
+    uri.substring(qIdx + 1).split('&').forEach(p => {
+        const eqIdx = p.indexOf('=');
+        const k = eqIdx === -1 ? p : p.substring(0, eqIdx);
+        const v = eqIdx === -1 ? '' : p.substring(eqIdx + 1);
+        if (k) params[k] = decodeURIComponent(v);
+    });
+    return { base, params };
+}
+
+export async function listResources(subscribedUris = []) {
+    return RESOURCES.map(r => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType,
+        subscribed: subscribedUris.includes(r.uri)
+    }));
+}
+
+export async function readResource(uri) {
+    const { base, params } = parseQuery(uri);
+    
+    switch (base) {
+        case 'atlisp://cad/info':
+            return await getCadInfo();
+        case 'atlisp://cad/layers':
+            return await getLayers(params.name);
+        case 'atlisp://cad/entities':
+            return await getEntities(params.type);
+        case 'atlisp://dwg/name':
+            return await getDwgName();
+        case 'atlisp://dwg/path':
+            return await getDwgPath();
+        case 'atlisp://packages':
+            return await getPackages(params.name);
+        case 'atlisp://platforms':
+            return getPlatforms();
+        default:
+            throw new Error(`资源不存在: ${uri}`);
+    }
+}
+
+async function getCadInfo() {
+    if (!cad.connected) {
+        await cad.connect();
+    }
+    
+    if (!cad.connected) {
+        return {
+            connected: false,
+            platform: null,
+            version: null,
+            busy: false
+        };
+    }
+    
+    let busy = false;
+    try {
+        busy = await cad.isBusy();
+    } catch (e) {}
+    
+    return {
+        connected: true,
+        platform: cad.getPlatform(),
+        version: cad.getVersion(),
+        busy
+    };
+}
+
+async function getLayers(filterName = null) {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return [];
+    
+    try {
+        const code = filterName
+            ? `(tblnext "LAYER" T)`
+            : `(progn (setq res nil)(while (setq e (tblnext "LAYER" (null res)))(setq res (cons (list (cdr (assoc 2 e)) (cdr (assoc 62 e)) (cdr (assoc 70 e))) res))) (reverse res))`;
+        
+        const result = await cad.sendCommandWithResult(code);
+        
+        if (!result || result === "" || result === "nil") return [];
+        
+        let layers = [];
+        try {
+            layers = JSON.parse(result);
+        } catch (e) {
+            const parsed = parseLispList(result);
+            if (parsed) {
+                layers = parsed;
+            } else {
+                layers = [];
+            }
+        }
+        
+        if (!Array.isArray(layers)) {
+            if (typeof layers === 'number') {
+                layers = [[result, layers, 0]];
+            } else if (typeof layers === 'string') {
+                layers = [[layers, 7, 0]];
+            }
+        }
+        
+        return layers.map(l => {
+            const name = Array.isArray(l) ? l[0] : l;
+            const color = Array.isArray(l) && l[1] !== undefined ? l[1] : 7;
+            const flags = Array.isArray(l) && l[2] !== undefined ? l[2] : 0;
+            return {
+                name: String(name),
+                color: color,
+                locked: (flags & 4) !== 0,
+                frozen: (flags & 1) !== 0
+            };
+        });
+    } catch (e) {
+        return [];
+    }
+}
+
+async function getEntities(filterType = null) {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return { total: 0, byType: {} };
+    
+    try {
+        let code;
+        if (filterType) {
+            code = `(sslength (ssget "_X" (list (cons 0 "${filterType}"))))`;
+            const count = await cad.sendCommandWithResult(code);
+            return {
+                type: filterType,
+                count: parseInt(count) || 0
+            };
+        } else {
+            code = `(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))))`;
+            const result = await cad.sendCommandWithResult(code);
+            
+            if (!result || result === "" || result === "nil") {
+                return { total: 0, byType: {} };
+            }
+            
+            let statResult = [];
+            try {
+                statResult = JSON.parse(result);
+            } catch (e) {
+                const parsed = parseLispList(result);
+                if (parsed) {
+                    statResult = parsed;
+                }
+            }
+            
+            if (!Array.isArray(statResult)) {
+                return { total: 0, byType: {} };
+            }
+            
+            const byType = {};
+            statResult.forEach(item => {
+                if (Array.isArray(item) && item.length >= 2) {
+                    byType[item[0]] = item[1];
+                }
+            });
+            
+            const total = Object.values(byType).reduce((sum, n) => sum + n, 0);
+            return { total, byType };
+        }
+    } catch (e) {
+        return { total: 0, byType: {} };
+    }
+}
+
+async function getDwgName() {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return { name: null };
+    
+    try {
+        const code = `(vl-princ-to-string (getvar "dwgname"))`;
+        const name = await cad.sendCommandWithResult(code);
+        return { name: name || null };
+    } catch (e) {
+        return { name: null };
+    }
+}
+
+async function getDwgPath() {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return { path: null, name: null };
+    
+    try {
+        const code = `(strcat (vl-princ-to-string (getvar "dwgprefix")) (vl-princ-to-string (getvar "dwgname")))`;
+        const fullPath = await cad.sendCommandWithResult(code);
+        
+        const nameCode = `(vl-princ-to-string (getvar "dwgname"))`;
+        const name = await cad.sendCommandWithResult(nameCode);
+        
+        return {
+            path: fullPath || null,
+            name: name || null
+        };
+    } catch (e) {
+        return { path: null, name: null };
+    }
+}
+
+async function getPackages(filterName = null) {
+    const packages = MOCK_PACKAGES.map(p => ({
+        name: p.name,
+        version: p.version,
+        description: p.description,
+        loaded: true
+    }));
+    
+    if (filterName) {
+        const pkg = packages.find(p => p.name === filterName);
+        return pkg ? [pkg] : [];
+    }
+    
+    return packages;
+}
+
+function getPlatforms() {
+    return CAD_PLATFORMS.map(name => ({
+        name,
+        extensions: FILE_EXTENSIONS[name] || []
+    }));
+}

package/src/subscription-manager.js

@@ -0,0 +1,26 @@
+const subscriptions = new Map();
+
+export function subscribe(uri) {
+    subscriptions.set(uri, Date.now());
+    return true;
+}
+
+export function unsubscribe(uri) {
+    return subscriptions.delete(uri);
+}
+
+export function list() {
+    return Array.from(subscriptions.keys());
+}
+
+export function isSubscribed(uri) {
+    return subscriptions.has(uri);
+}
+
+export function clear() {
+    subscriptions.clear();
+}
+
+export function size() {
+    return subscriptions.size;
+}