@atlisp/mcp 1.0.19 → 1.0.20

package/src/handlers/resource-handlers.js

@@ -1,5 +1,23 @@
 import { cad } from '../cad.js';
 import { CAD_PLATFORMS, FILE_EXTENSIONS, MOCK_PACKAGES } from '../constants.js';
+import { log } from '../logger.js';
+import config from '../config.js';
+
+const CACHE_TTL = config.resourceCacheTtl;
+const resourceCache = new Map();
+
+function getCached(key) {
+    const entry = resourceCache.get(key);
+    if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+        return entry.data;
+    }
+    resourceCache.delete(key);
+    return null;
+}
+
+function setCache(key, data) {
+    resourceCache.set(key, { data, timestamp: Date.now() });
+}
 
 function parseLispList(str) {
     if (!str || typeof str !== 'string') return null;
@@ -122,33 +140,41 @@ export async function readResource(uri) {
 }
 
 async function getCadInfo() {
+    const cached = getCached('cad:info');
+    if (cached) return cached;
+
     if (!cad.connected) {
         await cad.connect();
     }
-    
+
     if (!cad.connected) {
-        return {
-            connected: false,
-            platform: null,
-            version: null,
-            busy: false
-        };
+        const result = { connected: false, platform: null, version: null, busy: false };
+        setCache('cad:info', result);
+        return result;
     }
-    
+
     let busy = false;
     try {
         busy = await cad.isBusy();
-    } catch (e) {}
-    
-    return {
+    } catch (e) {
+        log(`Error checking CAD busy status: ${e.message}`);
+    }
+
+    const result = {
         connected: true,
         platform: cad.getPlatform(),
         version: cad.getVersion(),
         busy
     };
+    setCache('cad:info', result);
+    return result;
 }
 
 async function getLayers(filterName = null) {
+    const cacheKey = filterName ? `layers:${filterName}` : 'layers:all';
+    const cached = getCached(cacheKey);
+    if (cached) return cached;
+
     if (!cad.connected) await cad.connect();
     if (!cad.connected) return [];
     
@@ -159,8 +185,11 @@ async function getLayers(filterName = null) {
         
         const result = await cad.sendCommandWithResult(code);
         
-        if (!result || result === "" || result === "nil") return [];
-        
+        if (!result || result === "" || result === "nil") {
+            setCache(cacheKey, []);
+            return [];
+        }
+
         let layers = [];
         try {
             layers = JSON.parse(result);
@@ -172,7 +201,7 @@ async function getLayers(filterName = null) {
                 layers = [];
             }
         }
-        
+
         if (!Array.isArray(layers)) {
             if (typeof layers === 'number') {
                 layers = [[result, layers, 0]];
@@ -180,8 +209,8 @@ async function getLayers(filterName = null) {
                 layers = [[layers, 7, 0]];
             }
         }
-        
-        return layers.map(l => {
+
+        const mapped = 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;
@@ -192,58 +221,76 @@ async function getLayers(filterName = null) {
                 frozen: (flags & 1) !== 0
             };
         });
+        setCache(cacheKey, mapped);
+        return mapped;
     } catch (e) {
+        setCache(cacheKey, []);
         return [];
     }
 }
 
 async function getEntities(filterType = null) {
+    const cacheKey = filterType ? `entities:${filterType}` : 'entities:all';
+    const cached = getCached(cacheKey);
+    if (cached) return cached;
+
     if (!cad.connected) await cad.connect();
-    if (!cad.connected) return { total: 0, byType: {} };
-    
+    if (!cad.connected) {
+        const result = { total: 0, byType: {} };
+        setCache(cacheKey, result);
+        return result;
+    }
+
     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
-            };
+            const result = { type: filterType, count: parseInt(count) || 0 };
+            setCache(cacheKey, result);
+            return result;
         } 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: {} };
+            const resultStr = await cad.sendCommandWithResult(code);
+
+            if (!resultStr || resultStr === "" || resultStr === "nil") {
+                const result = { total: 0, byType: {} };
+                setCache(cacheKey, result);
+                return result;
             }
-            
+
             let statResult = [];
             try {
-                statResult = JSON.parse(result);
+                statResult = JSON.parse(resultStr);
             } catch (e) {
-                const parsed = parseLispList(result);
+                const parsed = parseLispList(resultStr);
                 if (parsed) {
                     statResult = parsed;
                 }
             }
-            
+
             if (!Array.isArray(statResult)) {
-                return { total: 0, byType: {} };
+                const result = { total: 0, byType: {} };
+                setCache(cacheKey, result);
+                return result;
             }
-            
+
             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 };
+            const result = { total, byType };
+            setCache(cacheKey, result);
+            return result;
         }
     } catch (e) {
-        return { total: 0, byType: {} };
+        const result = { total: 0, byType: {} };
+        setCache(cacheKey, result);
+        return result;
     }
 }
 

package/src/sse-session-manager.js

@@ -130,6 +130,4 @@ export class SseSessionManager {
         }
         this.#sessions.clear();
     }
-}
-
-export const globalSessionManager = new SseSessionManager();
+}

package/src/sse-session.js

@@ -1,7 +1,8 @@
 import { randomUUID } from 'crypto';
 
 const DEFAULT_HEARTBEAT_INTERVAL = 30000;
-const RECONNECT_DELAY = 5000;
+const DEFAULT_RETRY_INTERVAL = 30000;
+const MAX_SENT_MESSAGES = 1000;
 
 export const SSE_EVENTS = {
     MESSAGE: 'message',
@@ -19,15 +20,26 @@ export class SseSession {
     #heartbeatTimer = null;
     #lastEventId = 0;
     #heartbeatInterval;
+    #retryInterval;
     #sessionData = {};
+    #sentMessages = [];
+    #backpressureBuffer = [];
+    #drainHandler = null;
 
     constructor(res, options = {}) {
         this.#res = res;
         this.#clientId = options.clientId || randomUUID();
         this.#heartbeatInterval = options.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
+        this.#retryInterval = options.retryInterval || DEFAULT_RETRY_INTERVAL;
         this.#sessionData = options.sessionData || {};
 
+        if (options.resumeFromId && options.resumeFromId > 0) {
+            this.#lastEventId = options.resumeFromId;
+        }
+
         this._setupSseHeaders();
+        this._sendRetry();
+        this._setupDrain();
     }
 
     get clientId() {
@@ -38,10 +50,22 @@ export class SseSession {
         return this.#active;
     }
 
+    get lastEventId() {
+        return this.#lastEventId;
+    }
+
     get sessionData() {
         return this.#sessionData;
     }
 
+    get sentMessages() {
+        return [...this.#sentMessages];
+    }
+
+    getMessagesSince(eventId) {
+        return this.#sentMessages.filter(m => m.id > eventId);
+    }
+
     setSessionData(key, value) {
         this.#sessionData[key] = value;
     }
@@ -50,49 +74,122 @@ export class SseSession {
         return this.#sessionData[key];
     }
 
+    get retryInterval() {
+        return this.#retryInterval;
+    }
+
+    setRetryInterval(ms) {
+        this.#retryInterval = ms;
+    }
+
+    _sendRetry() {
+        this._write(`retry: ${this.#retryInterval}\n\n`);
+    }
+
     _setupSseHeaders() {
         this.#res.setHeader('Content-Type', 'text/event-stream');
         this.#res.setHeader('Cache-Control', 'no-cache');
         this.#res.setHeader('Connection', 'keep-alive');
         this.#res.setHeader('Transfer-Encoding', 'chunked');
         this.#res.setHeader('X-Accel-Buffering', 'no');
+        if (typeof this.#res.flush !== 'function') {
+            this.#res.flush = () => {};
+        }
     }
 
     _formatEvent(event, data, id = null) {
-        let lines = [];
+        const lines = [];
         if (id !== null) {
             lines.push(`id: ${id}`);
         }
         lines.push(`event: ${event}`);
-        
-        const jsonStr = JSON.stringify(data);
-        lines.push(`data: ${jsonStr}`);
-        
+
+        if (data !== null && data !== undefined) {
+            const jsonStr = JSON.stringify(data);
+            lines.push(`data: ${jsonStr}`);
+        } else {
+            lines.push('data:');
+        }
+
         return lines.join('\n') + '\n\n';
     }
 
+    _setupDrain() {
+        if (typeof this.#res.on !== 'function') return;
+        this.#drainHandler = () => {
+            if (!this.#active) return;
+            if (this.#backpressureBuffer.length > 0) {
+                this._drainBuffer();
+            }
+        };
+        this.#res.on('drain', this.#drainHandler);
+    }
+
+    _drainBuffer() {
+        const batch = this.#backpressureBuffer.splice(0, 50);
+        for (const item of batch) {
+            const ok = this.#res.write(item);
+            if (!ok) {
+                this.#backpressureBuffer.unshift(...batch.slice(batch.indexOf(item)));
+                return;
+            }
+        }
+        this._flush();
+        if (this.#backpressureBuffer.length > 0) {
+            this._drainBuffer();
+        }
+    }
+
     _write(content) {
         if (!this.#active) return false;
         try {
+            if (this.#backpressureBuffer.length > 0) {
+                this.#backpressureBuffer.push(content);
+                return true;
+            }
             const result = this.#res.write(content);
             if (typeof this.#res.flush === 'function') {
                 this.#res.flush();
             }
             if (result === false) {
-                this.#active = false;
-                return false;
+                this.#backpressureBuffer.push(content);
+                return true;
             }
             return true;
         } catch (e) {
             this.#active = false;
+            this.close();
             return false;
         }
     }
 
+    _flush() {
+        try {
+            if (typeof this.#res.flush === 'function') {
+                this.#res.flush();
+            }
+        } catch (e) {
+            // Ignore flush errors
+        }
+    }
+
+    flushBackpressure() {
+        if (this.#backpressureBuffer.length > 0) {
+            this._drainBuffer();
+        }
+    }
+
     sendEvent(event, data, id = null) {
         this.#lastEventId++;
         const eventId = id !== null ? id : this.#lastEventId;
-        return this._write(this._formatEvent(event, data, eventId));
+        const formatted = this._formatEvent(event, data, eventId);
+        this.#sentMessages.push({ event, data, id: eventId, timestamp: Date.now() });
+        if (this.#sentMessages.length > MAX_SENT_MESSAGES) {
+            this.#sentMessages.splice(0, this.#sentMessages.length - MAX_SENT_MESSAGES);
+        }
+        this._write(formatted);
+        this._flush();
+        return true;
     }
 
     sendMessage(data) {
@@ -100,7 +197,7 @@ export class SseSession {
     }
 
     sendEndpoint(path) {
-        return this.sendEvent(SSE_EVENTS.ENDPOINT, { path });
+        return this._write(`: endpoint ${path}\n\n`);
     }
 
     sendError(code, message, id = null) {
@@ -108,7 +205,7 @@ export class SseSession {
     }
 
     sendPing() {
-        return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
+        return this._write(': ping ' + Date.now() + '\n\n');
     }
 
     sendProgress(current, total, message = '') {
@@ -116,7 +213,7 @@ export class SseSession {
     }
 
     sendCapabilities(capabilities) {
-        return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
+        return this._write(`: capabilities ${JSON.stringify(capabilities)}\n\n`);
     }
 
     sendResponse(jsonrpcResponse, id = null) {
@@ -150,6 +247,11 @@ export class SseSession {
     close() {
         this.#active = false;
         this.stopHeartbeat();
+        if (this.#drainHandler) {
+            this.#res.removeListener('drain', this.#drainHandler);
+            this.#drainHandler = null;
+        }
+        this.#backpressureBuffer = [];
         try {
             this.#res.end();
         } catch (e) {
@@ -163,10 +265,19 @@ export function setupSseHeaders(res) {
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
     res.setHeader('Transfer-Encoding', 'chunked');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.setHeader('Vary', 'Accept');
+    if (typeof res.flush !== 'function') {
+        res.flush = () => {};
+    }
 }
 
-export function sendSSE(res, data, event = SSE_EVENTS.MESSAGE) {
+let sseGlobalId = 0;
+
+export function sendSSE(res, data, event = SSE_EVENTS.MESSAGE, id = null) {
+    const eventId = id !== null ? id : ++sseGlobalId;
     const lines = [
+        `id: ${eventId}`,
         `event: ${event}`,
         `data: ${JSON.stringify(data)}`,
         ''
@@ -182,11 +293,10 @@ export function createSseResponseHandler(res, acceptSse = false) {
 
     return {
         send: (data, done = false) => {
-            const json = JSON.stringify(data);
             if (acceptSse) {
                 sendSSE(res, data);
-                if (done) res.end();
             } else {
+                const json = JSON.stringify(data);
                 res.setHeader('Content-Type', 'application/json');
                 res.end(json);
             }

package/src/subscription-manager.js

@@ -1,4 +1,9 @@
 const subscriptions = new Map();
+let _notifyFn = null;
+
+export function setNotify(fn) {
+    _notifyFn = fn;
+}
 
 export function subscribe(uri) {
     subscriptions.set(uri, Date.now());
@@ -17,6 +22,12 @@ export function isSubscribed(uri) {
     return subscriptions.has(uri);
 }
 
+export function notify(uri, data) {
+    if (_notifyFn) {
+        _notifyFn(uri, data);
+    }
+}
+
 export function clear() {
     subscriptions.clear();
 }