@atlisp/mcp 1.7.0 → 1.8.1

package/dist/atlisp-mcp.js

@@ -215,6 +215,7 @@ __export(cad_exports, {
   cad: () => cad,
   default: () => cad_default,
   getWorker: () => getWorker,
+  onDocumentChanged: () => onDocumentChanged,
   resetWorker: () => resetWorker,
   sendMessage: () => sendMessage
 });
@@ -222,6 +223,21 @@ import { spawn } from "child_process";
 import path2 from "path";
 import { fileURLToPath } from "url";
 import { randomUUID } from "crypto";
+function onDocumentChanged(callback) {
+  _docChangeCallbacks.push(callback);
+}
+function emitDocumentChanged(info) {
+  if (info.docName === _activeDocName)
+    return;
+  _activeDocName = info.docName || "";
+  for (const cb of _docChangeCallbacks) {
+    try {
+      cb(info);
+    } catch (e) {
+      console.error("doc change callback error:", e.message);
+    }
+  }
+}
 function resetWorker() {
   for (const [id, { reject, timeout }] of pendingRequests) {
     clearTimeout(timeout);
@@ -285,6 +301,8 @@ function setupStdoutHandler(w) {
             } else {
               resolve(result);
             }
+          } else if (result.type === "event" && result.eventType === "documentChanged") {
+            emitDocumentChanged({ docName: result.docName, docPath: result.docPath });
           }
         } catch (parseErr) {
           console.error("JSON parse error in worker output:", parseErr.message);
@@ -337,6 +355,16 @@ function startHeartbeat() {
       if (!result?.pong) {
         console.error("heartbeat failed, worker may be dead");
         resetWorker();
+        return;
+      }
+      if (_platform) {
+        try {
+          const docResult = await sendMessage({ type: "getActiveDocInfo", platform: _platform });
+          if (docResult?.docName) {
+            emitDocumentChanged({ docName: docResult.docName, docPath: docResult.docPath || "" });
+          }
+        } catch (e) {
+        }
       }
     } catch (e) {
       console.error("heartbeat error:", e.message);
@@ -365,7 +393,7 @@ function sendMessage(msg) {
     }
   });
 }
-var MESSAGE_TIMEOUT, HEARTBEAT_INTERVAL, MAX_RESTART_ATTEMPTS, RESTART_BACKOFF_BASE, __dirname, workerPath, worker, _platform, heartbeatTimer, pendingRequests, stdoutHandlerSetup, MAX_BUFFER_SIZE, restartCount, restartTimer, PRIORITY_NORMAL, CommandQueue, commandQueue, CadConnection, cad, cad_default;
+var MESSAGE_TIMEOUT, HEARTBEAT_INTERVAL, MAX_RESTART_ATTEMPTS, RESTART_BACKOFF_BASE, __dirname, workerPath, worker, _platform, heartbeatTimer, pendingRequests, stdoutHandlerSetup, MAX_BUFFER_SIZE, restartCount, restartTimer, PRIORITY_NORMAL, MAX_QUEUE_SIZE, _docChangeCallbacks, _activeDocName, _monitorStarted, CommandQueue, commandQueue, CadConnection, cad, cad_default;
 var init_cad = __esm({
   "src/cad.js"() {
     init_constants();
@@ -385,11 +413,20 @@ var init_cad = __esm({
     restartCount = 0;
     restartTimer = null;
     PRIORITY_NORMAL = 1;
+    MAX_QUEUE_SIZE = 500;
+    _docChangeCallbacks = [];
+    _activeDocName = null;
+    _monitorStarted = false;
     CommandQueue = class {
       #queues = [[], [], []];
       #processing = false;
       #dedupMap = /* @__PURE__ */ new Map();
       enqueue(command, priority = PRIORITY_NORMAL) {
+        const total = this.#queues.reduce((s, q) => s + q.length, 0);
+        if (total >= MAX_QUEUE_SIZE) {
+          command.reject(new Error("Command queue full, try again later"));
+          return;
+        }
         const dedupKey = this._dedupKey(command);
         if (dedupKey) {
           const existing = this.#dedupMap.get(dedupKey);
@@ -475,6 +512,13 @@ var init_cad = __esm({
             this.product = result.platform;
             _platform = result.platform;
             this.connected = true;
+            _activeDocName = null;
+            if (!_monitorStarted) {
+              _monitorStarted = true;
+              sendMessage({ type: "startMonitor", platform: _platform }).catch(() => {
+                _monitorStarted = false;
+              });
+            }
             return true;
           }
         } catch (e) {
@@ -563,6 +607,16 @@ var init_cad = __esm({
           return false;
         }
       }
+      async getActiveDocInfo() {
+        if (!this.connected)
+          return { docName: "", docPath: "", docCount: 0 };
+        try {
+          const result = await sendMessage({ type: "getActiveDocInfo", platform: _platform });
+          return result || { docName: "", docPath: "", docCount: 0 };
+        } catch (e) {
+          return { docName: "", docPath: "", docCount: 0 };
+        }
+      }
       async getInfo() {
         if (!this.connected)
           return "CAD \u672A\u8FDE\u63A5";
@@ -573,6 +627,8 @@ var init_cad = __esm({
         this.version = null;
         this.product = null;
         _platform = null;
+        _activeDocName = null;
+        _monitorStarted = false;
         commandQueue.clear();
         resetWorker();
       }
@@ -589,6 +645,8 @@ var init_cad = __esm({
         this.version = null;
         this.product = null;
         _platform = null;
+        _activeDocName = null;
+        _monitorStarted = false;
         commandQueue.clear();
         resetWorker();
       }
@@ -689,6 +747,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // src/logger.js
 init_config();
 import fs2 from "fs";
+import fsp from "fs/promises";
 import path3 from "path";
 import os2 from "os";
 var DEBUG_FILE = config_default.debugFile || path3.join(os2.tmpdir(), "mcp-server-debug.log");
@@ -696,28 +755,33 @@ var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_LOG_FILES = 5;
 var stream = null;
 function rotateLog() {
-  if (!fs2.existsSync(DEBUG_FILE))
-    return;
-  const stat = fs2.statSync(DEBUG_FILE);
-  if (stat.size < MAX_LOG_SIZE)
-    return;
-  if (stream) {
-    stream.end();
-    stream = null;
-  }
-  for (let i = MAX_LOG_FILES - 1; i > 0; i--) {
-    const oldPath = `${DEBUG_FILE}.${i}`;
-    const newPath = `${DEBUG_FILE}.${i + 1}`;
-    if (fs2.existsSync(oldPath)) {
-      try {
-        fs2.renameSync(oldPath, newPath);
-      } catch {
+  try {
+    if (!fs2.existsSync(DEBUG_FILE))
+      return;
+    const stat = fs2.statSync(DEBUG_FILE);
+    if (stat.size < MAX_LOG_SIZE)
+      return;
+    if (stream) {
+      stream.end();
+      stream = null;
+    }
+    for (let i = MAX_LOG_FILES - 1; i > 0; i--) {
+      const oldPath = `${DEBUG_FILE}.${i}`;
+      if (fs2.existsSync(oldPath)) {
+        try {
+          fs2.renameSync(oldPath, `${DEBUG_FILE}.${i + 1}`);
+        } catch (e) {
+          console.error("log rotate rename error:", e.message);
+        }
       }
     }
-  }
-  try {
-    fs2.renameSync(DEBUG_FILE, `${DEBUG_FILE}.1`);
-  } catch {
+    try {
+      fs2.renameSync(DEBUG_FILE, `${DEBUG_FILE}.1`);
+    } catch (e) {
+      console.error("log rotate rename error:", e.message);
+    }
+  } catch (e) {
+    console.error("log rotate error:", e.message);
   }
 }
 function getStream() {
@@ -756,7 +820,90 @@ function closeLog() {
     stream = null;
   }
 }
-var REQUEST_LOG_FILE = path3.join(os2.hmpdir || os2.homedir(), "@lisp", "logs", "requests.log");
+var requestStream = null;
+var REQUEST_LOG_FILE = path3.join(os2.homedir(), "@lisp", "logs", "requests.log");
+function ensureRequestLogDir() {
+  const dir = path3.dirname(REQUEST_LOG_FILE);
+  if (!fs2.existsSync(dir)) {
+    try {
+      fs2.mkdirSync(dir, { recursive: true });
+    } catch (e) {
+      console.error("request log mkdir error:", e.message);
+    }
+  }
+}
+function rotateRequestLog() {
+  try {
+    if (!fs2.existsSync(REQUEST_LOG_FILE))
+      return;
+    const stat = fs2.statSync(REQUEST_LOG_FILE);
+    if (stat.size < 10 * 1024 * 1024)
+      return;
+    if (requestStream) {
+      requestStream.end();
+      requestStream = null;
+    }
+    for (let i = 5; i > 0; i--) {
+      const oldPath = `${REQUEST_LOG_FILE}.${i}`;
+      if (fs2.existsSync(oldPath)) {
+        try {
+          fs2.renameSync(oldPath, `${REQUEST_LOG_FILE}.${i + 1}`);
+        } catch (e) {
+          console.error("request log rotate error:", e.message);
+        }
+      }
+    }
+    try {
+      fs2.renameSync(REQUEST_LOG_FILE, `${REQUEST_LOG_FILE}.1`);
+    } catch (e) {
+      console.error("request log rotate error:", e.message);
+    }
+  } catch (e) {
+    console.error("request log rotate error:", e.message);
+  }
+}
+function logRequest(req) {
+  if (!config_default.requestLogEnabled)
+    return;
+  try {
+    ensureRequestLogDir();
+    rotateRequestLog();
+    if (!requestStream) {
+      requestStream = fs2.createWriteStream(REQUEST_LOG_FILE, { flags: "a" });
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      method: req.method,
+      path: req.path,
+      query: req.query,
+      ip: req.ip || req.connection?.remoteAddress,
+      userAgent: req.get("user-agent")
+    };
+    requestStream.write(JSON.stringify(entry) + "\n");
+  } catch (e) {
+    console.error("request log error:", e.message);
+  }
+}
+function logResponse(req, res, duration) {
+  if (!config_default.requestLogEnabled)
+    return;
+  try {
+    ensureRequestLogDir();
+    if (!requestStream) {
+      requestStream = fs2.createWriteStream(REQUEST_LOG_FILE, { flags: "a" });
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      method: req.method,
+      path: req.path,
+      statusCode: res.statusCode,
+      duration: `${duration}ms`
+    };
+    requestStream.write(JSON.stringify(entry) + "\n");
+  } catch (e) {
+    console.error("request log error:", e.message);
+  }
+}
 
 // src/handlers/resource-defs.js
 import path4 from "path";
@@ -862,20 +1009,68 @@ init_config();
 import fs3 from "fs";
 import path5 from "path";
 
+// src/errors.js
+var ERROR_CODES = {
+  CAD_NOT_CONNECTED: "CAD_NOT_CONNECTED",
+  CAD_BUSY: "CAD_BUSY",
+  CAD_NO_DOCUMENT: "CAD_NO_DOCUMENT",
+  LISP_PAREN_MISMATCH: "LISP_PAREN_MISMATCH",
+  TIMEOUT: "TIMEOUT",
+  INVALID_PARAMS: "INVALID_PARAMS",
+  METHOD_NOT_FOUND: "METHOD_NOT_FOUND",
+  RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
+  PACKAGE_NOT_FOUND: "PACKAGE_NOT_FOUND",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+var ERROR_MESSAGES = {
+  [ERROR_CODES.CAD_NOT_CONNECTED]: "\u672A\u8FDE\u63A5 CAD\uFF0C\u8BF7\u5148\u8C03\u7528 connect_cad",
+  [ERROR_CODES.CAD_BUSY]: "CAD \u5FD9\u788C\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  [ERROR_CODES.CAD_NO_DOCUMENT]: "CAD \u4E2D\u6CA1\u6709\u6253\u5F00\u7684\u6587\u6863",
+  [ERROR_CODES.LISP_PAREN_MISMATCH]: "LISP \u4EE3\u7801\u62EC\u53F7\u4E0D\u5339\u914D",
+  [ERROR_CODES.TIMEOUT]: "\u64CD\u4F5C\u8D85\u65F6",
+  [ERROR_CODES.INVALID_PARAMS]: "\u65E0\u6548\u7684\u53C2\u6570",
+  [ERROR_CODES.METHOD_NOT_FOUND]: "\u65B9\u6CD5\u4E0D\u5B58\u5728",
+  [ERROR_CODES.RESOURCE_NOT_FOUND]: "\u8D44\u6E90\u4E0D\u5B58\u5728",
+  [ERROR_CODES.PACKAGE_NOT_FOUND]: "\u5305\u4E0D\u5B58\u5728",
+  [ERROR_CODES.INTERNAL_ERROR]: "\u5185\u90E8\u9519\u8BEF"
+};
+var MCPError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MCPError";
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+function createError(code, details = {}) {
+  const message = ERROR_MESSAGES[code] || ERROR_MESSAGES[ERROR_CODES.INTERNAL_ERROR];
+  return new MCPError(code, message, details);
+}
+function mcpSuccessResponse(text) {
+  return { content: [{ type: "text", text: String(text) }] };
+}
+
 // src/handler-utils.js
-init_cad();
 function mcpSuccess(text) {
-  return { content: [{ type: "text", text: String(text) }] };
+  return mcpSuccessResponse(text);
 }
 function mcpError(text) {
   return { content: [{ type: "text", text: String(text) }], isError: true };
 }
 async function ensureCadConnected() {
-  if (!cad.connected) {
-    await cad.connect();
+  const { cad: cad2 } = await Promise.resolve().then(() => (init_cad(), cad_exports));
+  if (!cad2.connected) {
+    await cad2.connect();
   }
-  if (!cad.connected) {
-    throw new Error("CAD \u672A\u8FDE\u63A5");
+  if (!cad2.connected) {
+    throw createError(ERROR_CODES.CAD_NOT_CONNECTED);
   }
 }
 function escapeLispString(str) {
@@ -2610,7 +2805,9 @@ import {
   ListPromptsRequestSchema,
   GetPromptRequestSchema,
   ListRootsRequestSchema,
-  CreateMessageRequestSchema
+  CreateMessageRequestSchema,
+  CompleteRequestSchema,
+  PingRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
@@ -3122,12 +3319,11 @@ var RESOURCE_TEMPLATES = [
   }
 ];
 var SERVER_CAPABILITIES = {
-  tools: { completionNotification: true },
-  resources: { subscribe: true, listChanged: true, templates: true },
+  tools: { listChanged: true },
+  resources: { subscribe: true, listChanged: true },
   prompts: {},
-  roots: { listChanged: true },
-  sampling: {},
-  logging: {}
+  logging: {},
+  completions: {}
 };
 function createMcpServer(handlers = {}) {
   const { tools: tools18 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
@@ -3202,15 +3398,27 @@ function createMcpServer(handlers = {}) {
   }));
   server.setRequestHandler(CreateMessageRequestSchema, async (request) => {
     const { message } = request.params;
-    logger.info("Sampling request received", { message: message.content?.[0]?.text });
+    log("Sampling request received", { text: message.content?.[0]?.text });
     return {
       content: [{
         type: "text",
-        role: "user",
-        content: message.content[0]
-      }]
+        text: "[sampling] LLM integration not configured; returning original message"
+      }],
+      model: "default",
+      role: "assistant"
+    };
+  });
+  server.setRequestHandler(CompleteRequestSchema, async (request) => {
+    const { argument, ref } = request.params;
+    return {
+      completion: {
+        values: [],
+        hasMore: false,
+        total: 0
+      }
     };
   });
+  server.setRequestHandler(PingRequestSchema, async () => ({ pong: true }));
   return server;
 }
 
@@ -8696,8 +8904,8 @@ function setupRoutes(app) {
   app.use((req, res, next) => {
     const start = Date.now();
     res.on("finish", () => {
-      log(req);
-      error(req, res, Date.now() - start);
+      logRequest(req);
+      logResponse(req, res, Date.now() - start);
     });
     next();
   });
@@ -8735,7 +8943,7 @@ function setupRoutes(app) {
       },
       mcp: {
         sessions: sessionServers.size,
-        tools: 60
+        tools: tools17.length
       }
     });
   });
@@ -8791,7 +8999,7 @@ function setupRoutes(app) {
     <h1>@lisp MCP Server API</h1>
     <div class="info">
         <strong>Version:</strong> 1.6.0 | 
-        <strong>Tools:</strong> 60 |
+        <strong>Tools:</strong> ${tools17.length} |
         <strong>Resources:</strong> 11
     </div>
     
@@ -8917,7 +9125,7 @@ curl -X POST http://localhost:8110/mcp \\
         </table>
     </div>
 
-    <h2>Tools (${cad.getToolCount ? cad.getToolCount() : 60})</h2>
+    <h2>Tools (${tools17.length})</h2>
     <div class="card">
         <p>Use <code>tools/list</code> MCP method to get full tool list.</p>
     </div>
@@ -9172,6 +9380,22 @@ async function startServer() {
     process.on("SIGTERM", () => shutdown("SIGTERM"));
   }
 }
+onDocumentChanged((info) => {
+  const uris = [
+    "atlisp://dwg/name",
+    "atlisp://dwg/path",
+    "atlisp://cad/dwgs",
+    "atlisp://dwg/tbl",
+    "atlisp://dwg/entities",
+    "atlisp://dwg/block-refs",
+    "atlisp://dwg/text-content",
+    "atlisp://dwg/groups"
+  ];
+  for (const uri of uris) {
+    clearCache(uri);
+    notify(uri, { docName: info.docName, docPath: info.docPath });
+  }
+});
 if (!process.env.VITEST) {
   await startServer();
 }

package/dist/cad-worker.js

@@ -245,6 +245,63 @@ string encoding = d.encoding != null ? d.encoding.ToString() : "";
   }
   */});
 
+const cadGetActiveDocInfo = edge.func(function() {/*
+  async (input) => {
+      try {
+          string platform = input.ToString();
+          string progId = platform == "BricsCAD" ? "BricscadApp.AcadApplication" : platform + ".Application";
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
+          if (cad != null) {
+              int docCount = cad.Documents.Count;
+              string docName = "";
+              string docPath = "";
+              try {
+                  docName = cad.ActiveDocument.Name;
+                  docPath = cad.ActiveDocument.FullName;
+              } catch {}
+              return new { hasDoc = docCount > 0, docCount = docCount, docName = docName, docPath = docPath };
+          }
+      } catch (Exception ex) {
+          System.Diagnostics.Debug.WriteLine("cadGetActiveDocInfo error: " + ex.Message);
+      }
+      return new { hasDoc = false, docCount = 0, docName = "", docPath = "" };
+  }
+ */});
+
+const cadStartMonitor = edge.func(function() {/*
+  async (input) => {
+      try {
+          string platform = input.ToString();
+          string progId = platform == "BricsCAD" ? "BricscadApp.AcadApplication" : platform + ".Application";
+          dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
+          if (cad == null) return new { success = false, error = "CAD not found" };
+
+          string prevName = "";
+          var timer = new System.Threading.Timer((_) => {
+              try {
+                  string docName = cad.ActiveDocument.Name;
+                  if (docName != prevName) {
+                      prevName = docName;
+                      string docPath = "";
+                      try { docPath = cad.ActiveDocument.FullName; } catch {}
+                      string json = "{\"type\":\"event\",\"eventType\":\"documentChanged\",\"docName\":\"" +
+                          docName.Replace("\\", "\\\\").Replace("\"", "\\\"") +
+                          "\",\"docPath\":\"" +
+                          docPath.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"}";
+                      Console.WriteLine(json);
+                  }
+              } catch (Exception ex) {
+                  System.Diagnostics.Debug.WriteLine("cadMonitor timer error: " + ex.Message);
+              }
+          }, null, 3000, 3000);
+
+          return new { success = true };
+      } catch (Exception ex) {
+          return new { success = false, error = ex.Message };
+      }
+  }
+ */});
+
 process.stdin.setEncoding('utf8');
 
 let stdinBuffer = '';
@@ -581,5 +638,21 @@ async function handleMessage(msg) {
       });
     });
   }
+  if (msg.type === 'getActiveDocInfo') {
+    return new Promise((resolve, reject) => {
+      cadGetActiveDocInfo(msg.platform || 'AutoCAD', (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
+  if (msg.type === 'startMonitor') {
+    return new Promise((resolve, reject) => {
+      cadStartMonitor(msg.platform || 'AutoCAD', (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+  }
   return { error: 'unknown message type' };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.7.0",
+    "version": "1.8.1",
     "description": "MCP Server for @lisp on CAD,support AutoCAD/GstarCAD/ZWCAD/BricsCAD or CAD platform compatible with AutoLISP",
     "type": "module",
     "bin": {