@atlisp/mcp 1.0.13 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "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

@@ -47,6 +47,45 @@ const cadConnect = edge.func(function() {/*
   }
 */});
 
+const cadLaunch = edge.func(function() {/*
+  async (input) => {
+      string[] platforms = { "AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD" };
+      string[] progIds = { "AutoCAD.Application", "ZWCAD.Application", "GStarCAD.Application", "BricsCAD.Application" };
+
+      for (int i = 0; i < platforms.Length; i++) {
+          try {
+              dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progIds[i]);
+              if (cad != null) {
+                  string ver = cad.Version.ToString();
+                  return new { success = true, platform = platforms[i], version = ver, launched = false };
+              }
+          } catch {}
+      }
+
+      for (int i = 0; i < platforms.Length; i++) {
+          try {
+              var type = System.Type.GetTypeFromProgID(progIds[i]);
+              if (type != null) {
+                  dynamic cad = System.Activator.CreateInstance(type);
+                  if (cad != null) {
+                      for (int retry = 0; retry < 60; retry++) {
+                          await System.Threading.Tasks.Task.Delay(500);
+                          try {
+                              string ver = cad.Version.ToString();
+                              return new { success = true, platform = platforms[i], version = ver, launched = true };
+                          } catch {}
+                      }
+                  }
+              }
+          } catch (Exception ex) {
+              System.Diagnostics.Debug.WriteLine("Create COM " + platforms[i] + " error: " + ex.Message);
+          }
+      }
+
+      return new { success = false, error = "No CAD found" };
+  }
+*/});
+
 const cadSend = edge.func(function() {/*
   async (input) => {
       try {
@@ -255,8 +294,17 @@ async function handleMessage(msg) {
     return { pong: true };
   }
   if (msg.type === 'connect') {
+    try {
+      const result = await new Promise((resolve, reject) => {
+        cadConnect({}, (e, r) => {
+          if (e) reject(e);
+          else resolve(r);
+        });
+      });
+      if (result && result.success) return result;
+    } catch (e) {}
     return new Promise((resolve, reject) => {
-      cadConnect({}, (e, r) => {
+      cadLaunch({}, (e, r) => {
         if (e) reject(e);
         else resolve(r);
       });

package/src/handlers/cad-handlers.js

@@ -13,7 +13,7 @@ export async function connectCad() {
     } catch (e) {
         log('connect_cad error: ' + e.message);
     }
-    return { content: [{ type: 'text', text: '未找到运行中的 CAD，请确保 CAD 已启动并启用 COM 接口' }], isError: true };
+    return { content: [{ type: 'text', text: '未能连接或启动 CAD，请确保 CAD 已安装' }], isError: true };
 }
 
 export async function evalLisp(code, withResult = false) {

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;
+}