@atlisp/mcp 1.0.19 → 1.0.20

package/src/atlisp-mcp.js

@@ -1,6 +1,7 @@
 import express from 'express';
 import rawBody from 'raw-body';
 import iconv from 'iconv-lite';
+import rateLimit from 'express-rate-limit';
 const { decode: charsetDecode, encodingExists } = iconv;
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -11,28 +12,58 @@ import {
     ReadResourceRequestSchema,
     SubscribeRequestSchema,
     UnsubscribeRequestSchema,
+    ListPromptsRequestSchema,
+    GetPromptRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { cad } from './cad.js';
 import { CAD_PLATFORMS, FILE_EXTENSIONS, PROTOCOL_VERSION, SERVER_NAME, SERVER_VERSION } from './constants.js';
-import { log } from './logger.js';
+import { log, closeLog } 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 { listPrompts, getPrompt } from './handlers/prompt-handlers.js';
 import * as subMgr from './subscription-manager.js';
 import { SseSession, SSE_EVENTS, createSseResponseHandler, parseLastEventId } from './sse-session.js';
 import { SseSessionManager } from './sse-session-manager.js';
+import { createError, toMcpError } from './errors.js';
+import config from './config.js';
 
-const PORT = process.env.PORT || 8110;
-const HOST = process.env.HOST || '0.0.0.0';
-const TRANSPORT = process.env.TRANSPORT || 'http';
-const API_KEY = process.env.MCP_API_KEY || '';
-const ENABLE_SSE = process.env.ENABLE_SSE === 'true';
-if (API_KEY) log('API Key authentication enabled');
-if (ENABLE_SSE) log('SSE mode enabled');
+const SERVER_CAPABILITIES = {
+    tools: {},
+    resources: { subscribe: true, listChanged: true },
+    prompts: {}
+};
+
+const SERVER_INFO = {
+    protocolVersion: PROTOCOL_VERSION,
+    capabilities: SERVER_CAPABILITIES,
+    serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+};
+
+const { port, host, transport, apiKey, enableSse, rateLimitWindow, rateLimitMax } = config;
+
+if (apiKey) log('API Key authentication enabled');
+if (enableSse) log('SSE mode enabled');
+
+const mcpLimiter = rateLimit({
+    windowMs: rateLimitWindow,
+    max: rateLimitMax,
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { error: '请求过于频繁，请稍后再试' }
+});
 
 const sseSessionManager = new SseSessionManager();
 
+subMgr.setNotify((uri, data) => {
+    sseSessionManager.broadcast(SSE_EVENTS.MESSAGE, {
+        jsonrpc: '2.0',
+        method: 'notifications/resources/updated',
+        params: { uri, data }
+    });
+});
+
 export { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from './constants.js';
 
 const TOOL_HANDLERS = {
@@ -183,7 +214,31 @@ export const tools = [
 export async function handleToolCall(name, args) {
     const handler = TOOL_HANDLERS[name];
     if (!handler) return { content: [{ type: 'text', text: `未知工具: ${name}` }], isError: true };
-    return handler(args);
+    try {
+        const result = await handler(args || {});
+        notifyResourceChanges(name);
+        return result;
+    } catch (e) {
+        log(`Tool call error [${name}]: ${e.message}`);
+        return { content: [{ type: 'text', text: `工具执行错误: ${e.message}` }], isError: true };
+    }
+}
+
+function notifyResourceChanges(toolName) {
+    const resourceMap = {
+        connect_cad:    ['atlisp://cad/info'],
+        new_document:   ['atlisp://dwg/name', 'atlisp://dwg/path', 'atlisp://cad/layers', 'atlisp://cad/entities'],
+        install_package: ['atlisp://packages'],
+        install_atlisp: ['atlisp://packages'],
+    };
+    const uris = resourceMap[toolName];
+    if (uris) {
+        for (const uri of uris) {
+            if (subMgr.isSubscribed(uri)) {
+                subMgr.notify(uri, null);
+            }
+        }
+    }
 }
 
 async function initCadConnection() {
@@ -206,7 +261,7 @@ let server = null;
 export function createMcpServer() {
     server = new Server(
 	{ name: SERVER_NAME, version: SERVER_VERSION },
-	{ capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } } }
+	{ capabilities: SERVER_CAPABILITIES }
     );
 
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
@@ -252,88 +307,82 @@ export function createMcpServer() {
         return { success: true };
     });
 
+    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+        prompts: await listPrompts()
+    }));
+
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return await getPrompt(name, args || {});
+    });
+
     return server;
 }
 
-async function handleMcpRequest(session, method, params, id) {
+async function dispatchMcpMethod(responder, method, params, id) {
     try {
         if (method === 'initialize') {
-            session.sendResponse({ jsonrpc: '2.0', id, result: {
-                protocolVersion: PROTOCOL_VERSION,
-                capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
-                serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
-            } });
+            responder({ jsonrpc: '2.0', id, result: SERVER_INFO });
             return;
         }
 
-        if (method === 'tools/list') {
-            session.sendResponse({ jsonrpc: '2.0', id, result: { tools } });
-            return;
-        }
-
-        if (method === 'resources/list') {
-            const resources = await listResources(subMgr.list());
-            session.sendResponse({ jsonrpc: '2.0', id, result: { resources } });
-            return;
-        }
-
-        if (method === 'resources/read') {
-            const uri = params?.uri;
-            if (!uri) {
-                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
-                return;
-            }
-            try {
+        const methodHandlers = {
+            'tools/list': async () => ({ tools }),
+            'resources/list': async () => ({ resources: await listResources(subMgr.list()) }),
+            'resources/read': async () => {
+                const uri = params?.uri;
+                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
                 const data = await readResource(uri);
-                session.sendResponse({ jsonrpc: '2.0', id, result: { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] } });
-            } catch (e) {
-                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } });
-            }
-            return;
-        }
-
-        if (method === 'resources/subscribe') {
-            const uri = params?.uri;
-            if (!uri) {
-                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
-                return;
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] };
+            },
+            'resources/subscribe': async () => {
+                const uri = params?.uri;
+                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
+                subMgr.subscribe(uri);
+                return { success: true };
+            },
+            'resources/unsubscribe': async () => {
+                const uri = params?.uri;
+                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
+                subMgr.unsubscribe(uri);
+                return { success: true };
+            },
+            'tools/call': async () => {
+                const toolName = params?.name;
+                if (!toolName) throw createError('INVALID_PARAMS', { detail: 'missing tool name' });
+                return await handleToolCall(toolName, params?.arguments || {});
+            },
+            'prompts/list': async () => ({ prompts: await listPrompts() }),
+            'prompts/get': async () => {
+                const promptName = params?.name;
+                if (!promptName) throw createError('INVALID_PARAMS', { detail: '缺少 prompt name 参数' });
+                return await getPrompt(promptName, params?.arguments || {});
             }
-            subMgr.subscribe(uri);
-            session.sendResponse({ jsonrpc: '2.0', id, result: { success: true } });
-            return;
+        };
+
+        const handler = methodHandlers[method];
+        if (handler) {
+            const result = await handler();
+            responder({ jsonrpc: '2.0', id, result });
+        } else {
+            responder({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
         }
-
-        if (method === 'resources/unsubscribe') {
-            const uri = params?.uri;
-            if (!uri) {
-                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32600, message: '缺少 uri 参数' } });
-                return;
-            }
-            subMgr.unsubscribe(uri);
-            session.sendResponse({ jsonrpc: '2.0', id, result: { success: true } });
-            return;
-        }
-
-        if (method === 'tools/call') {
-            const toolName = params?.name;
-            if (!toolName) {
-                session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: missing tool name' } });
-                return;
-            }
-            const result = await handleToolCall(toolName, params?.arguments || {});
-            session.sendResponse({ jsonrpc: '2.0', id, result });
-            return;
-        }
-
-        session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
     } catch (e) {
-        log('MCP error: ' + e.message);
-        session.sendResponse({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } });
+        const mcpError = toMcpError(e);
+        log(`MCP error [${method}]: ${mcpError.message}`);
+        responder({ jsonrpc: '2.0', id, error: { code: -32603, message: mcpError.message } });
     }
 }
 
+async function handleMcpRequest(session, method, params, id) {
+    await dispatchMcpMethod(
+        (response) => session.sendResponse(response),
+        method, params, id
+    );
+}
+
 export async function startServer() {
-    if (TRANSPORT === 'stdio') {
+    if (transport === 'stdio') {
         await initCadConnection();
         const mcpServer = createMcpServer();
         const transport = new StdioServerTransport();
@@ -366,11 +415,11 @@ export async function startServer() {
         });
 
         const PUBLIC_PATHS = ['/health'];
-        if (API_KEY) {
+        if (apiKey) {
             app.use((req, res, next) => {
                 if (PUBLIC_PATHS.includes(req.path)) return next();
                 const auth = req.get('Authorization');
-                if (auth === `Bearer ${API_KEY}`) return next();
+                if (auth === `Bearer ${apiKey}`) return next();
                 res.status(401).json({ error: 'Unauthorized' });
             });
         }
@@ -379,11 +428,33 @@ export async function startServer() {
             res.json({ status: 'ok', cad: cad.connected ? 'connected' : 'disconnected' });
         });
 
-        if (process.env.ENABLE_CORS) {
+        app.use((req, res, next) => {
+            const path = req.path;
+            if (path.startsWith('/%7B') || path.startsWith('/{"')) {
+                try {
+                    const decoded = decodeURIComponent(path.slice(1));
+                    if (decoded.startsWith('{"path":')) {
+                        const data = JSON.parse(decoded);
+                        const endpoint = data.path;
+                        log(`Client sent SSE endpoint in URL path, extracting: ${endpoint}`);
+                        req.url = endpoint + ((req._parsedUrl && req._parsedUrl.search) || '');
+                        try { req.path = endpoint; } catch (_) { /* Express 5: req.path is read-only, req.url is sufficient */ }
+                    }
+                } catch (e) {
+                    log(`Failed to parse malformed path: ${e.message}`);
+                }
+            }
+            next();
+        });
+
+        if (config.enableCors) {
             app.use((req, res, next) => {
-                res.setHeader('Access-Control-Allow-Origin', process.env.CORS_ORIGIN || '*');
-                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept, mcp-session-id');
+                res.setHeader('Access-Control-Allow-Origin', config.corsOrigin);
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, CONNECT');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept, mcp-session-id, last-event-id');
+                res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id, content-type, x-accel-buffering');
+                res.setHeader('Access-Control-Max-Age', '86400');
+                res.setHeader('Vary', 'Accept');
                 if (req.method === 'OPTIONS') return res.status(204).end();
                 next();
             });
@@ -391,47 +462,108 @@ export async function startServer() {
 
         createMcpServer();
 
-        if (ENABLE_SSE) {
-            app.get('/sse', (req, res) => {
-                const clientId = req.get('mcp-session-id') || req.get('Last-Event-ID') || crypto.randomUUID();
-                
-                const session = new SseSession(res, { clientId });
-                
-                session.sendEndpoint('/mcp');
-                session.sendCapabilities({
-                    protocolVersion: PROTOCOL_VERSION,
-                    capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
-                    serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
-                });
-                
+        function setupSseConnection(req, res) {
+            log(`SSE connect: ${req.method} ${req.path} - session: ${req.get('mcp-session-id') || 'new'}`);
+            const sessionId = req.get('mcp-session-id');
+            const lastEventId = parseLastEventId(req);
+            const clientId = sessionId || crypto.randomUUID();
+
+            res.setHeader('mcp-session-id', clientId);
+
+            let session;
+            if (sessionId && sseSessionManager.has(sessionId)) {
+                session = sseSessionManager.get(sessionId);
+            } else {
+                session = new SseSession(res, { clientId, resumeFromId: lastEventId });
                 sseSessionManager.add(clientId, session);
-                
-                res.on('close', () => {
-                    sseSessionManager.remove(clientId);
-                });
+            }
+
+            if (lastEventId && lastEventId > 0) {
+                session.sendEvent(SSE_EVENTS.MESSAGE, { type: 'resume', lastEventId }, lastEventId + 1);
+            }
+
+            session.sendPing();
+
+            res.on('close', () => {
+                log(`SSE close: session ${clientId}`);
+                sseSessionManager.remove(clientId);
             });
+        }
 
-            ['/mcp/sse'].forEach(p => app.all(p, (req, res) => {
-                const clientId = req.get('mcp-session-id') || req.get('Last-Event-ID') || crypto.randomUUID();
-                
-                const session = new SseSession(res, { clientId });
-                
-                session.sendEndpoint('/mcp');
-                session.sendCapabilities({
-                    protocolVersion: PROTOCOL_VERSION,
-                    capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
-                    serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
-                });
-                
-                sseSessionManager.add(clientId, session);
-                
-                res.on('close', () => {
-                    sseSessionManager.remove(clientId);
-                });
-            }));
+        if (enableSse) {
+            app.get('/sse', (req, res) => setupSseConnection(req, res));
+            app.get('/mcp/sse', (req, res) => setupSseConnection(req, res));
+
+            app.post('/mcp/message', mcpLimiter, async (req, res) => {
+                const sessionId = req.get('mcp-session-id') || '';
+                const accept = req.get('Accept') || '';
+                const wantsSse = accept.includes('text/event-stream');
+                log(`POST /mcp/message - session: ${sessionId || 'new'} - wantsSSE: ${wantsSse}`);
+
+                let session;
+                if (sessionId && sseSessionManager.has(sessionId)) {
+                    session = sseSessionManager.get(sessionId);
+                } else if (wantsSse) {
+                    const clientId = sessionId || crypto.randomUUID();
+                    res.setHeader('mcp-session-id', clientId);
+                    session = new SseSession(res, { clientId });
+                    sseSessionManager.add(clientId, session);
+                    log(`POST /mcp/message - created new session: ${clientId}`);
+                    res.on('close', () => {
+                        log(`POST SSE close: session ${clientId}`);
+                        sseSessionManager.remove(clientId);
+                    });
+                }
+
+                const body = req.body || {};
+                const { method, params, id } = body;
+
+                if (!id) {
+                    if (session) res.status(204).end();
+                    else res.status(202).end();
+                    return;
+                }
+
+                if (session) {
+                    try {
+                        await handleMcpRequest(session, method, params, id);
+                    } catch (e) {
+                        log('SSE message error: ' + e.message);
+                        session.sendError(-32603, e.message, id);
+                    }
+                    res.status(204).end();
+                } else {
+                    await dispatchMcpMethod(
+                        (response) => {
+                            res.setHeader('Content-Type', 'application/json');
+                            res.status(200).json(response);
+                        },
+                        method, params, id
+                    );
+                }
+            });
         }
 
-        app.post('/mcp', async (req, res) => {
+        app.get('/mcp', (req, res) => {
+            const accept = req.get('Accept') || '';
+            if (accept.includes('text/event-stream')) {
+                if (!enableSse) {
+                    res.status(400).json({ error: 'SSE mode is disabled' });
+                    return;
+                }
+                setupSseConnection(req, res);
+                return;
+            }
+            res.status(200).json({
+                name: SERVER_NAME,
+                version: SERVER_VERSION,
+                transport: 'streamable-http',
+                sseEndpoint: '/sse',
+                messageEndpoint: '/mcp/message'
+            });
+        });
+
+        app.post('/mcp', mcpLimiter, async (req, res) => {
             const body = req.body || {};
             const { method, params, id } = body;
             const accept = req.get('Accept') || '';
@@ -440,110 +572,62 @@ export async function startServer() {
             log(`${req.method} ${req.path} - session: ${sessionId} - method: ${method} - wantsSSE: ${wantsSse}`);
 
             if (wantsSse) {
-                if (!ENABLE_SSE) {
+                if (!enableSse) {
                     res.status(400).json({ error: 'SSE mode is disabled' });
                     return;
                 }
-                res.setHeader('Content-Type', 'text/event-stream');
-                res.setHeader('Cache-Control', 'no-cache');
-                res.setHeader('Connection', 'keep-alive');
-                
+
+                const clientId = sessionId || crypto.randomUUID();
+                res.setHeader('mcp-session-id', clientId);
+
+                let session;
                 if (sessionId && sseSessionManager.has(sessionId)) {
-                    const session = sseSessionManager.get(sessionId);
+                    session = sseSessionManager.get(sessionId);
                     if (!id) {
                         res.status(204).end();
                         return;
                     }
                     await handleMcpRequest(session, method, params, id);
-                    return;
-                }
-            }
-
-            res.setHeader('mcp-session-id', sessionId || crypto.randomUUID());
-            const { send } = createSseResponseHandler(res, wantsSse);
-
-            if (!id) return res.status(204).end();
-
-            try {
-                if (method === 'initialize') {
-                    send({ jsonrpc: '2.0', id, result: {
-                        protocolVersion: PROTOCOL_VERSION,
-                        capabilities: { tools: {}, resources: { subscribe: true, listChanged: true } },
-                        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
-                    } }, true);
+                    res.status(204).end();
                     return;
                 }
 
-                if (method === 'tools/list') {
-                    send({ jsonrpc: '2.0', id, result: { tools } }, true);
-                    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;
-                }
+                session = new SseSession(res, { clientId });
+                sseSessionManager.add(clientId, session);
 
-                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);
+                if (!id) {
                     return;
                 }
+                await handleMcpRequest(session, method, params, id);
+                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;
-                }
+            res.setHeader('mcp-session-id', sessionId || crypto.randomUUID());
+            const { send } = createSseResponseHandler(res, wantsSse);
 
-                if (method === 'tools/call') {
-                    const toolName = params?.name;
-                    if (!toolName) {
-                        send({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: missing tool name' } }, true);
-                        return;
-                    }
-                    const result = await handleToolCall(toolName, params?.arguments || {});
-                    send({ jsonrpc: '2.0', id, result }, true);
-                    return;
-                }
+            if (!id) return res.status(204).end();
 
-                send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } }, true);
-            } catch (e) {
-                log('MCP error: ' + e.message);
-                send({ jsonrpc: '2.0', id, error: { code: -32603, message: e.message } }, true);
-            }
+            await dispatchMcpMethod(
+                (response) => send(response, true),
+                method, params, id
+            );
         });
 
-	app.listen(PORT, HOST, async () => {
+	const httpServer = app.listen(config.port, config.host, async () => {
 	    await initCadConnection();
-	    console.error(`@lisp MCP Server 启动 - http://${HOST}:${PORT} - Streamable HTTP`);
+	    console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP`);
 	});
+
+	async function shutdown(signal) {
+	    console.error(`\n收到 ${signal}，正在优雅关闭...`);
+	    sseSessionManager.closeAll();
+	    await cad.disconnect();
+	    closeLog();
+	    httpServer.close(() => process.exit(0));
+	    setTimeout(() => process.exit(1), 5000);
+	}
+	process.on('SIGINT', () => shutdown('SIGINT'));
+	process.on('SIGTERM', () => shutdown('SIGTERM'));
     }
 }
 

package/src/cad-worker.js

@@ -11,7 +11,9 @@ const DEBUG_FILE = process.env.DEBUG_FILE || path.join(process.env.TEMP || '/tmp
 
 function log(msg) {
     const entry = `${new Date().toISOString()} ${msg}\n`;
-    fs.appendFileSync(DEBUG_FILE, entry);
+    if (process.env.DEBUG) {
+        fs.appendFile(DEBUG_FILE, entry, () => {});
+    }
 }
 
 const cadConnect = edge.func(function() {/*
@@ -221,10 +223,13 @@ const cadSendWithResult = edge.func(function() {/*
 
 process.stdin.setEncoding('utf8');
 
+let stdinBuffer = '';
 process.stdin.on('data', (data) => {
-  const lines = data.trim().split('\n');
+  stdinBuffer += data;
+  const lines = stdinBuffer.split('\n');
+  stdinBuffer = lines.pop() || '';
   for (const line of lines) {
-    if (!line) continue;
+    if (!line.trim()) continue;
     try {
       const msg = JSON.parse(line);
       handleMessage(msg).then(result => {
@@ -374,7 +379,9 @@ async function handleMessage(msg) {
         });
       });
       if (result && result.success) return result;
-    } catch (e) {}
+    } catch (e) {
+      log('cadConnect failed: ' + e.message);
+    }
     return new Promise((resolve, reject) => {
       cadLaunch({}, (e, r) => {
         if (e) reject(e);