@atlisp/mcp 1.4.0 → 1.4.2

package/dist/atlisp-mcp.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
 // src/atlisp-mcp.js
-import path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path7 from "path";
+import fs6 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire } from "module";
+import os4 from "os";
 import express from "express";
 import rawBody from "raw-body";
 import iconv from "iconv-lite";
@@ -34,8 +36,7 @@ var SessionTransport = class {
     this._started = true;
   }
   async send(message) {
-    if (this._closed)
-      return;
+    if (this._closed) return;
     if (this._pendingRequest) {
       const { resolve, reject, timeout } = this._pendingRequest;
       clearTimeout(timeout);
@@ -44,8 +45,7 @@ var SessionTransport = class {
     }
   }
   async close() {
-    if (this._closed)
-      return;
+    if (this._closed) return;
     this._closed = true;
     if (this._pendingRequest) {
       const { reject, timeout } = this._pendingRequest;
@@ -119,7 +119,7 @@ var FILE_EXTENSIONS = {
   "BricsCAD": [".des"]
 };
 var SERVER_NAME = "atlisp-mcp-server";
-var SERVER_VERSION = "1.4.0";
+var SERVER_VERSION = "1.4.1";
 var MOCK_PACKAGES = [
   { name: "base", description: "\u57FA\u7840\u51FD\u6570\u5E93", version: "1.0.0" },
   { name: "at-pm", description: "\u5DE5\u7A0B\u9879\u76EE\u7BA1\u7406", version: "2.1.0" },
@@ -176,6 +176,8 @@ var config_default = config;
 // src/cad.js
 var MESSAGE_TIMEOUT = config_default.messageTimeout;
 var HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
+var MAX_RESTART_ATTEMPTS = 5;
+var RESTART_BACKOFF_BASE = 1e3;
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var workerPath = path.join(__dirname, "cad-worker.js");
 var worker = null;
@@ -184,6 +186,8 @@ var heartbeatTimer = null;
 var pendingRequests = /* @__PURE__ */ new Map();
 var stdoutHandlerSetup = false;
 var MAX_BUFFER_SIZE = 1024 * 1024;
+var restartCount = 0;
+var restartTimer = null;
 function resetWorker() {
   for (const [id, { reject, timeout }] of pendingRequests) {
     clearTimeout(timeout);
@@ -200,6 +204,27 @@ function resetWorker() {
     heartbeatTimer = null;
   }
 }
+function scheduleRestart() {
+  if (restartTimer) {
+    clearTimeout(restartTimer);
+    restartTimer = null;
+  }
+  if (restartCount >= MAX_RESTART_ATTEMPTS) {
+    console.error("Max worker restart attempts reached, giving up");
+    return;
+  }
+  const delay = Math.min(RESTART_BACKOFF_BASE * Math.pow(2, restartCount), 3e4);
+  restartCount++;
+  console.error(`Scheduling worker restart in ${delay}ms (attempt ${restartCount}/${MAX_RESTART_ATTEMPTS})`);
+  restartTimer = setTimeout(() => {
+    restartTimer = null;
+    console.error("Attempting worker restart...");
+    getWorker(true);
+  }, delay);
+}
+function resetRestartCount() {
+  restartCount = 0;
+}
 function setupStdoutHandler(w) {
   let buffer = "";
   stdoutHandlerSetup = true;
@@ -212,8 +237,7 @@ function setupStdoutHandler(w) {
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
       for (const line of lines) {
-        if (!line.trim())
-          continue;
+        if (!line.trim()) continue;
         try {
           const result = JSON.parse(line);
           const rid = result.requestId;
@@ -235,21 +259,19 @@ function setupStdoutHandler(w) {
       console.error("Unexpected error in worker stdout handler:", e.message);
     }
   });
+  w.stderr.on("data", (d) => console.error("worker stderr:", d.toString()));
 }
-function getWorker() {
-  if (!worker || !worker.connected) {
-    if (worker)
-      worker.kill();
+function getWorker(force = false) {
+  if (!worker || !worker.connected || force) {
+    if (worker) worker.kill();
     worker = spawn("node", [workerPath], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     worker.connected = true;
-    worker.stderr.on("data", (d) => console.error("worker stderr:", d.toString()));
     const w = worker;
     w.on("exit", (code) => {
-      console.error("worker exited:", code);
-      if (w !== worker)
-        return;
+      console.error("worker exited with code:", code);
+      if (w !== worker) return;
       w.connected = false;
       for (const [id, { reject, timeout }] of pendingRequests) {
         clearTimeout(timeout);
@@ -261,15 +283,16 @@ function getWorker() {
         clearInterval(heartbeatTimer);
         heartbeatTimer = null;
       }
+      scheduleRestart();
     });
     setupStdoutHandler(w);
     startHeartbeat();
+    resetRestartCount();
   }
   return worker;
 }
 function startHeartbeat() {
-  if (heartbeatTimer)
-    clearInterval(heartbeatTimer);
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
   heartbeatTimer = setInterval(async () => {
     try {
       const result = await sendMessage({ type: "ping" });
@@ -313,11 +336,11 @@ var CadConnection = class {
   isAvailable() {
     return process.platform === "win32";
   }
-  async connect() {
-    if (!this.isAvailable())
-      return false;
+  async connect(platform = null) {
+    if (!this.isAvailable()) return false;
     try {
-      const result = await sendMessage({ type: "connect" });
+      const msg = platform ? { type: "connect", platform } : { type: "connect" };
+      const result = await sendMessage(msg);
       if (result && result.success) {
         this.version = result.version;
         this.product = result.platform;
@@ -331,16 +354,13 @@ var CadConnection = class {
     return false;
   }
   async sendCommand(code) {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     const result = await sendMessage({ type: "send", code, platform: _platform });
-    if (result.success)
-      return true;
+    if (result.success) return true;
     throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
   }
   async sendCommandWithResult(code, encoding = null) {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
     if (result.success) {
       return result.result || "";
@@ -354,8 +374,7 @@ var CadConnection = class {
     return this.product;
   }
   async isBusy() {
-    if (!this.connected)
-      return false;
+    if (!this.connected) return false;
     try {
       const result = await sendMessage({ type: "isBusy", platform: _platform });
       return result && result.isBusy;
@@ -364,8 +383,7 @@ var CadConnection = class {
     }
   }
   async hasDoc() {
-    if (!this.connected)
-      return { hasDoc: false, docCount: 0 };
+    if (!this.connected) return { hasDoc: false, docCount: 0 };
     try {
       const result = await sendMessage({ type: "hasdoc", platform: _platform });
       return result || { hasDoc: false, docCount: 0 };
@@ -374,8 +392,7 @@ var CadConnection = class {
     }
   }
   async newDoc() {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "newdoc", platform: _platform });
       return result && result.success;
@@ -384,8 +401,7 @@ var CadConnection = class {
     }
   }
   async bringToFront() {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "bringToFront", platform: _platform });
       return result && result.success;
@@ -394,8 +410,7 @@ var CadConnection = class {
     }
   }
   async getInfo() {
-    if (!this.connected)
-      return "CAD \u672A\u8FDE\u63A5";
+    if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
     return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
   }
   async disconnect() {
@@ -428,9 +443,35 @@ import fs from "fs";
 import path2 from "path";
 import os from "os";
 var DEBUG_FILE = process.env.DEBUG_FILE || path2.join(os.tmpdir(), "mcp-server-debug.log");
+var MAX_LOG_SIZE = 10 * 1024 * 1024;
+var MAX_LOG_FILES = 5;
 var stream = null;
+function rotateLog() {
+  if (!fs.existsSync(DEBUG_FILE)) return;
+  const stat = fs.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 (fs.existsSync(oldPath)) {
+      try {
+        fs.renameSync(oldPath, newPath);
+      } catch {
+      }
+    }
+  }
+  try {
+    fs.renameSync(DEBUG_FILE, `${DEBUG_FILE}.1`);
+  } catch {
+  }
+}
 function getStream() {
   if (!stream) {
+    rotateLog();
     stream = fs.createWriteStream(DEBUG_FILE, { flags: "a" });
   }
   return stream;
@@ -448,11 +489,11 @@ function closeLog() {
 }
 
 // src/handlers/cad-handlers.js
-async function connectCad() {
-  log("connect_cad called, cad.connected before: " + cad.connected);
+async function connectCad(platform = null) {
+  log(`connect_cad called${platform ? ` (target: ${platform})` : ""}, cad.connected before: ${cad.connected}`);
   try {
     log("calling cad.connect()...");
-    const connected = await cad.connect();
+    const connected = await cad.connect(platform);
     log("cad.connect() returned: " + connected + ", cad.connected: " + cad.connected);
     if (connected) {
       return { content: [{ type: "text", text: `\u5DF2\u8FDE\u63A5\u5230 ${cad.getPlatform()} ${cad.getVersion()}` }] };
@@ -470,8 +511,7 @@ async function evalLisp(code, withResult = false, encoding = null) {
     return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   }
   const trimmed = (code || "").trim();
-  if (!trimmed)
-    return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
+  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   try {
     if (withResult) {
       const result = await cad.sendCommandWithResult(trimmed, encoding);
@@ -491,17 +531,14 @@ async function getCadInfo() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
+  if (!cad.connected) return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
   const info = await cad.getInfo();
   return { content: [{ type: "text", text: info }] };
 }
 async function atCommand(command) {
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
   const trimmed = (command || "").trim();
-  if (!trimmed)
-    return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
+  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   await cad.sendCommand(trimmed + "\n");
   return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001\u547D\u4EE4" }] };
 }
@@ -509,8 +546,7 @@ async function newDocument() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.newDoc();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863" }] };
@@ -521,8 +557,7 @@ async function bringToFront() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.bringToFront();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0" }] };
@@ -533,8 +568,7 @@ async function installAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const installCode = `(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o'send)(v o'WaitforResponse 1000)(e(r(vlax-get-property o'ResponseText))))`;
   await cad.sendCommand(installCode + "\n");
   return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001 @lisp \u5B89\u88C5\u4EE3\u7801\u5230 CAD" }] };
@@ -543,12 +577,10 @@ async function listFunctionsInCad() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   try {
     const result = await cad.sendCommandWithResult("(atoms-family 0)", null);
-    if (result)
-      return { content: [{ type: "text", text: result }] };
+    if (result) return { content: [{ type: "text", text: result }] };
     return { content: [{ type: "text", text: "CAD \u51FD\u6570\u5217\u8868\u4E3A\u7A7A" }] };
   } catch (e) {
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
@@ -603,8 +635,7 @@ async function initAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const code = `(if (null @::load-module)
 	   (progn
 	     (vl-load-com)
@@ -641,38 +672,46 @@ async function fetchPackages() {
     }
   } catch (e) {
   }
-  return null;
+  return cachedPackages || MOCK_PACKAGES;
+}
+function flattenPackages(data) {
+  if (Array.isArray(data)) return data;
+  if (data && Array.isArray(data.packages)) return data.packages;
+  return [];
 }
 async function listPackages() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) {
+    const data2 = await fetchPackages();
+    const items2 = flattenPackages(data2);
+    const text2 = items2.length ? items2.map((p) => `${p.name} v${p.version || ""} - ${p.description || ""}`).join("\n") : "\u65E0\u53EF\u7528\u5305";
+    return { content: [{ type: "text", text: text2 }] };
+  }
   const result = await cad.sendCommandWithResult("(@::package-list-in-local)");
-  if (result && result !== "nil")
-    return { content: [{ type: "text", text: result }] };
-  const packages = MOCK_PACKAGES.map((p) => `${p.name} v${p.version} - ${p.description}`);
+  if (result && result !== "nil") return { content: [{ type: "text", text: result }] };
+  const data = await fetchPackages();
+  const items = flattenPackages(data);
+  const text = items.length ? `\u4ECE\u6CE8\u518C\u8868\u83B7\u53D6\u7684 @lisp \u5305:
+${items.map((p) => `${p.name} v${p.version || ""} - ${p.description || ""}`).join("\n")}` : MOCK_PACKAGES.map((p) => `${p.name} v${p.version} - ${p.description}`).join("\n");
   return { content: [{ type: "text", text: `\u5DF2\u5B89\u88C5\u7684 @lisp \u5305:
-${packages.join("\n")}` }] };
+${text}` }] };
 }
 async function searchPackages(query) {
   const data = await fetchPackages();
   if (!data) {
     return { content: [{ type: "text", text: "\u65E0\u6CD5\u83B7\u53D6\u5305\u5217\u8868" }], isError: true };
   }
+  const items = flattenPackages(data);
   const results = [];
-  const items = Array.isArray(data) ? data : data.packages || [];
   if (query) {
     const q = query.toLowerCase();
     for (const p of items) {
       const name = (p.name || "").toLowerCase();
       const desc = (p.description || "").toLowerCase();
-      if (name.includes(q) || desc.includes(q))
-        results.push(p);
+      if (name.includes(q) || desc.includes(q)) results.push(p);
     }
   } else {
-    for (const p of items)
-      results.push(p);
+    for (const p of items) results.push(p);
   }
   if (results.length === 0) {
     return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5305\u542B "${query}" \u7684\u5305` }] };
@@ -681,7 +720,9 @@ async function searchPackages(query) {
 ${results.map((p) => `${p.name} v${p.version || ""} - ${p.description || ""}`).join("\n")}` }] };
 }
 async function installPackage(packageName) {
-  const pkg = MOCK_PACKAGES.find((p) => p.name === packageName);
+  const data = await fetchPackages();
+  const items = flattenPackages(data);
+  const pkg = items.find((p) => p.name === packageName);
   if (!pkg) {
     return { content: [{ type: "text", text: `\u9519\u8BEF: \u5305 "${packageName}" \u4E0D\u5B58\u5728` }], isError: true };
   }
@@ -693,41 +734,67 @@ async function installPackage(packageName) {
 }
 
 // src/handlers/function-handlers.js
-import fs2 from "fs/promises";
+import fs2 from "fs";
 import path3 from "path";
+import os2 from "os";
 var FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
 var FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
-async function fileExists(filePath) {
+var CACHE_DIR = path3.join(os2.homedir(), ".atlisp", "cache");
+var FUNCLIB_CACHE_FILE = path3.join(CACHE_DIR, "functions.json");
+var FUNCLIB_CACHE_TTL = 24 * 60 * 60 * 1e3;
+function readCacheFromDisk() {
   try {
-    await fs2.access(filePath);
-    return true;
+    const stat = fs2.statSync(FUNCLIB_CACHE_FILE);
+    if (Date.now() - stat.mtimeMs < FUNCLIB_CACHE_TTL) {
+      const raw = fs2.readFileSync(FUNCLIB_CACHE_FILE, "utf-8");
+      return JSON.parse(raw);
+    }
   } catch {
-    return false;
   }
+  return null;
+}
+function writeCacheToDisk(data) {
+  try {
+    fs2.mkdirSync(CACHE_DIR, { recursive: true });
+    fs2.writeFileSync(FUNCLIB_CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch (e) {
+    log(`function-handlers writeCache error: ${e.message}`);
+  }
+}
+async function fetchFunctions() {
+  const diskCache = readCacheFromDisk();
+  if (diskCache) return diskCache;
+  try {
+    const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+    if (response.ok) {
+      const data = await response.json();
+      writeCacheToDisk(data);
+      return data;
+    }
+  } catch (e) {
+    log(`function-handlers fetch error: ${e.message}`);
+  }
+  return diskCache;
 }
 async function getFunctionUsage(funcName, packageName) {
   try {
     let results = [];
-    try {
-      const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
-      if (response.ok) {
-        const data = await response.json();
-        const funcs = Object.values(data.all_functions || {});
-        const func = funcs.find((f2) => f2.name === funcName || f2.name === `${packageName}:${funcName}`);
-        if (func)
-          results.push(func);
-      }
-    } catch (e) {
-      log(`function-handlers fetch error: ${e.message}`);
+    const data = await fetchFunctions();
+    if (data) {
+      const funcs = Object.values(data.all_functions || {});
+      const func = funcs.find((f2) => f2.name === funcName || f2.name === `${packageName}:${funcName}`);
+      if (func) results.push(func);
     }
-    if (results.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
-      const files = (await fs2.readdir(FUNCTIONS_DIR)).filter((f2) => f2.endsWith(".json"));
-      for (const file of files) {
-        const raw = await fs2.readFile(path3.join(FUNCTIONS_DIR, file), "utf-8");
-        const data = JSON.parse(raw);
-        const func = data.functions?.find((f2) => f2.name === funcName);
-        if (func)
-          results.push(func);
+    if (results.length === 0 && FUNCTIONS_DIR) {
+      try {
+        const files = fs2.readdirSync(FUNCTIONS_DIR).filter((f2) => f2.endsWith(".json"));
+        for (const file of files) {
+          const raw = fs2.readFileSync(path3.join(FUNCTIONS_DIR, file), "utf-8");
+          const data2 = JSON.parse(raw);
+          const func = data2.functions?.find((f2) => f2.name === funcName);
+          if (func) results.push(func);
+        }
+      } catch {
       }
     }
     if (results.length === 0) {
@@ -747,27 +814,22 @@ async function getFunctionUsage(funcName, packageName) {
 async function listSymbols(packageName) {
   try {
     let allFuncs = [];
-    try {
-      const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
-      if (response.ok) {
-        const data = await response.json();
-        const funcs = Object.values(data.all_functions || {});
-        if (packageName) {
-          allFuncs = funcs.filter((f) => f.name.startsWith(`${packageName}:`));
-        } else {
-          allFuncs = funcs.map((f) => `${f.name}: ${f.description || "-"}`);
-        }
+    const data = await fetchFunctions();
+    if (data) {
+      const funcs = Object.values(data.all_functions || {});
+      if (packageName) {
+        allFuncs = funcs.filter((f) => f.name.startsWith(`${packageName}:`));
+      } else {
+        allFuncs = funcs.map((f) => `${f.name}: ${f.description || "-"}`);
       }
-    } catch (e) {
-      log(`function-handlers list fetch error: ${e.message}`);
     }
-    if (allFuncs.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
-      const files = (await fs2.readdir(FUNCTIONS_DIR)).filter((f) => f.endsWith(".json"));
-      for (const file of files) {
-        try {
-          const raw = await fs2.readFile(path3.join(FUNCTIONS_DIR, file), "utf-8");
-          const data = JSON.parse(raw);
-          const funcs = Object.values(data.all_functions || {});
+    if (allFuncs.length === 0 && FUNCTIONS_DIR) {
+      try {
+        const files = fs2.readdirSync(FUNCTIONS_DIR).filter((f) => f.endsWith(".json"));
+        for (const file of files) {
+          const raw = fs2.readFileSync(path3.join(FUNCTIONS_DIR, file), "utf-8");
+          const data2 = JSON.parse(raw);
+          const funcs = Object.values(data2.all_functions || {});
           if (packageName) {
             allFuncs = funcs.filter((f) => f.name.startsWith(`${packageName}:`));
           } else {
@@ -775,9 +837,9 @@ async function listSymbols(packageName) {
               allFuncs.push(`${f.name}: ${f.description || "-"}`);
             }
           }
-        } catch (err) {
-          log(`read file ${file} error: ${err.message}`);
         }
+      } catch (err) {
+        log(`listSymbols readDir error: ${err.message}`);
       }
     }
     if (allFuncs.length === 0) {
@@ -794,6 +856,11 @@ ${allFuncs.map((f) => f.name).join("\n")}` }] };
 }
 
 // src/handlers/resource-handlers.js
+import fs3 from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var STANDARDS_DIR = path4.join(__dirname2, "..", "standards");
 var CACHE_TTL2 = config_default.resourceCacheTtl;
 var resourceCache = /* @__PURE__ */ new Map();
 function getCached(key) {
@@ -819,14 +886,11 @@ function clearCache(uri) {
   }
 }
 function parseLispList(str) {
-  if (!str || typeof str !== "string")
-    return null;
+  if (!str || typeof str !== "string") return null;
   const trimmed = str.trim();
-  if (!trimmed.startsWith("(") || !trimmed.endsWith(")"))
-    return null;
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return null;
   const content = trimmed.slice(1, -1).trim();
-  if (!content)
-    return [];
+  if (!content) return [];
   const result = [];
   let depth = 0;
   let current = "";
@@ -868,45 +932,262 @@ function parseLispList(str) {
     }
     current += ch;
   }
-  if (current.trim())
-    result.push(current.trim());
+  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;
+    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);
+    if (!isNaN(num) && t !== "") return num;
+    if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
     return t;
   });
 }
+function parseLispRecursive(str) {
+  if (!str || typeof str !== "string") return null;
+  str = str.trim();
+  if (!str) return null;
+  let pos = 0;
+  function skipWs() {
+    while (pos < str.length && /\s/.test(str[pos])) pos++;
+  }
+  function parseValue() {
+    skipWs();
+    if (pos >= str.length) return null;
+    const ch = str[pos];
+    if (ch === "(") return parseList();
+    if (ch === '"') return parseString();
+    if (ch === "'") {
+      pos++;
+      return parseValue();
+    }
+    return parseAtom();
+  }
+  function parseString() {
+    pos++;
+    let r = "";
+    while (pos < str.length && str[pos] !== '"') {
+      if (str[pos] === "\\" && pos + 1 < str.length) {
+        pos++;
+        if (str[pos] === '"') r += '"';
+        else if (str[pos] === "n") r += "\n";
+        else if (str[pos] === "t") r += "	";
+        else if (str[pos] === "\\") r += "\\";
+        else r += str[pos];
+      } else {
+        r += str[pos];
+      }
+      pos++;
+    }
+    pos++;
+    return r;
+  }
+  function parseAtom() {
+    const start = pos;
+    while (pos < str.length && !/\s/.test(str[pos]) && str[pos] !== ")" && str[pos] !== "(") pos++;
+    const atom = str.slice(start, pos);
+    if (atom === "nil" || atom === "NIL") return null;
+    if (atom === "t" || atom === "T") return true;
+    const num = Number(atom);
+    if (!isNaN(num) && atom !== "") return num;
+    return atom;
+  }
+  function parseList() {
+    pos++;
+    const items = [];
+    while (pos < str.length) {
+      skipWs();
+      if (pos >= str.length) break;
+      if (str[pos] === ")") {
+        pos++;
+        return items;
+      }
+      const left = parseValue();
+      if (left === void 0) break;
+      skipWs();
+      if (str[pos] === "." && (pos + 1 >= str.length || /\s/.test(str[pos + 1]) || str[pos + 1] === ")")) {
+        pos++;
+        skipWs();
+        if (pos < str.length && str[pos] !== ")") {
+          const right = parseValue();
+          items.push([left, right]);
+          skipWs();
+        } else {
+          items.push(left);
+        }
+      } else {
+        items.push(left);
+      }
+    }
+    return items;
+  }
+  return parseValue();
+}
+function lispPairsToObject(pairs) {
+  if (!Array.isArray(pairs)) return pairs;
+  const obj = {};
+  for (let i = 0; i < pairs.length - 1; i += 2) {
+    const key = pairs[i];
+    const val = pairs[i + 1];
+    if (typeof key === "string" || typeof key === "number") {
+      obj[String(key)] = Array.isArray(val) ? lispPairsToObject(val) : val;
+    }
+  }
+  return obj;
+}
+var ENTITY_SCHEMAS = {
+  LINE: { fields: ["x1", "y1", "z1", "x2", "y2", "z2", "length"], strings: [] },
+  CIRCLE: { fields: ["cx", "cy", "cz", "radius"], strings: [] },
+  ARC: { fields: ["cx", "cy", "cz", "radius", "startAngle", "endAngle"], strings: [] },
+  LWPOLYLINE: { fields: ["vertices", "closed"], strings: [] },
+  TEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
+  MTEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
+  ATTRIB: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
+  TCH_TEXT: { fields: ["x", "y", "z", "text", "height", "rotation"], strings: ["text"] },
+  INSERT: { fields: ["x", "y", "z", "blockName", "rotation", "scaleX", "scaleY"], strings: ["blockName"] },
+  POINT: { fields: ["x", "y", "z"], strings: [] }
+};
+function parseEntity(arr) {
+  if (!Array.isArray(arr) || arr.length < 5) return null;
+  const [type, handle, layer, color, linetype, ...rest] = arr;
+  const schema = ENTITY_SCHEMAS[String(type)] || { fields: [], strings: [] };
+  const props = {};
+  schema.fields.forEach((name, i) => {
+    if (i < rest.length) {
+      let val = rest[i];
+      if (schema.strings.includes(name) && val !== null && val !== void 0) val = String(val);
+      props[name] = val;
+    }
+  });
+  return { type: String(type), handle: String(handle), layer: String(layer), color, linetype: String(linetype), ...props };
+}
+function buildEntityCode({ type, layer, bbox, offset, limit }) {
+  const items = [];
+  if (type) items.push(`(cons 0 "${type.replace(/"/g, '\\"')}")`);
+  if (layer) items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
+  if (bbox) {
+    const parts = bbox.split(",").map((s) => parseFloat(s.trim()));
+    if (parts.length === 4) {
+      const [x1, y1, x2, y2] = parts;
+      items.push(
+        `'(-4 . "<AND")`,
+        `'(-4 . ">=,>=,*") (list 10 ${x1} ${y1} 0.0)`,
+        `'(-4 . "<=,<=,*") (list 10 ${x2} ${y2} 0.0)`,
+        `'(-4 . "AND>")`
+      );
+    }
+  }
+  const filterExpr = items.length ? `(list ${items.join(" ")})` : "nil";
+  const ssgetExpr = items.length ? `(ssget "_X" ${filterExpr})` : '(ssget "_X")';
+  return `(progn
+(defun @e:props (ent / ed typ result item s e c verts closed ins)
+  (setq ed (entget ent) typ (cdr (assoc 0 ed)))
+  (setq result (list (vl-prin1-to-string (cdr (assoc 5 ed))) (vl-prin1-to-string (cdr (assoc 8 ed)))
+    (if (setq item (assoc 62 ed)) (cdr item) "ByLayer")
+    (vl-prin1-to-string (if (setq item (assoc 6 ed)) (cdr item) "ByLayer"))))
+  (cond
+    ((= typ "LINE")
+      (setq s (cdr (assoc 10 ed)) e (cdr (assoc 11 ed)))
+      (append result (list (car s) (cadr s) (caddr s) (car e) (cadr e) (caddr e) (distance s e))))
+    ((= typ "CIRCLE")
+      (setq c (cdr (assoc 10 ed)))
+      (append result (list (car c) (cadr c) (caddr c) (cdr (assoc 40 ed)))))
+    ((= typ "ARC")
+      (setq c (cdr (assoc 10 ed)))
+      (append result (list (car c) (cadr c) (caddr c) (cdr (assoc 40 ed)) (cdr (assoc 50 ed)) (cdr (assoc 51 ed)))))
+    ((= typ "LWPOLYLINE")
+      (setq verts nil closed nil)
+      (foreach g ed
+        (if (= (car g) 10) (setq verts (append verts (list (list (cadr g) (caddr g))))))
+        (if (= (car g) 70) (setq closed (= (logand (cdr g) 1) 1))))
+      (append result (list verts (if closed "T" nil))))
+    ((= typ "TEXT")
+      (setq ins (cdr (assoc 10 ed)))
+      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 1 ed))) (cdr (assoc 40 ed)) (cdr (assoc 50 ed))))))
+    ((= typ "MTEXT")
+      (setq ins (cdr (assoc 10 ed)))
+      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 1 ed))) (cdr (assoc 40 ed)) (cdr (assoc 50 ed))))))
+    ((= typ "INSERT")
+      (setq ins (cdr (assoc 10 ed)))
+      (append result (list (car ins) (cadr ins) (caddr ins) (vl-prin1-to-string (cdr (assoc 2 ed))) (cdr (assoc 50 ed)) (cdr (assoc 41 ed)) (cdr (assoc 42 ed))))))
+    ((= typ "POINT")
+      (setq p (cdr (assoc 10 ed)))
+      (append result (list (car p) (cadr p) (caddr p))))
+    (t result)))
+(defun @e:run nil
+  (setq ss ${ssgetExpr})
+  (if (null ss)
+    (list "total" 0 "offset" ${offset} "limit" ${limit})
+    (progn
+      (setq total (sslength ss) entities nil i ${offset})
+      (while (and (< i total) (< (length entities) ${limit}))
+        (setq entities (append entities (list (@e:props (ssname ss i)))) i (1+ i)))
+      (list "total" total "offset" ${offset} "limit" ${limit} "entities" entities))))
+(@e:run))
+`;
+}
+function buildTextCode({ layer, bbox, offset, limit }) {
+  const items = [`'(0 . "TEXT,MTEXT,ATTRIB,TCH_TEXT")`];
+  if (layer) items.push(`(cons 8 "${layer.replace(/"/g, '\\"')}")`);
+  if (bbox) {
+    const parts = bbox.split(",").map((s) => parseFloat(s.trim()));
+    if (parts.length === 4) {
+      const [x1, y1, x2, y2] = parts;
+      items.push(
+        `'(-4 . "<AND")`,
+        `'(-4 . ">=,>=,*") (list 10 ${x1} ${y1} 0.0)`,
+        `'(-4 . "<=,<=,*") (list 10 ${x2} ${y2} 0.0)`,
+        `'(-4 . "AND>")`
+      );
+    }
+  }
+  const filterExpr = `(list ${items.join(" ")})`;
+  return `(progn
+(defun @t:props (ent / ed typ result item ins)
+  (setq ed (entget ent) typ (cdr (assoc 0 ed)))
+  (setq result (list (vl-prin1-to-string typ) (vl-prin1-to-string (cdr (assoc 5 ed))) (vl-prin1-to-string (cdr (assoc 8 ed)))
+    (if (setq item (assoc 62 ed)) (cdr item) "ByLayer")
+    (vl-prin1-to-string (if (setq item (assoc 6 ed)) (cdr item) "ByLayer"))))
+  (setq ins (cdr (assoc 10 ed)))
+  (append result (list (car ins) (cadr ins) (caddr ins)
+    (vl-prin1-to-string (cdr (assoc 1 ed))) (cdr (assoc 40 ed)) (cdr (assoc 50 ed))
+    (vl-prin1-to-string (if (setq item (assoc 7 ed)) (cdr item) "Standard")))))
+(defun @t:run nil
+  (setq ss (ssget "_X" ${filterExpr}))
+  (if (null ss)
+    (list "total" 0 "offset" ${offset} "limit" ${limit})
+    (progn
+      (setq total (sslength ss) texts nil i ${offset})
+      (while (and (< i total) (< (length texts) ${limit}))
+        (setq texts (append texts (list (@t:props (ssname ss i)))) i (1+ i)))
+      (list "total" total "offset" ${offset} "limit" ${limit} "texts" texts))))
+(@t:run))
+`;
+}
 var RESOURCES = [
   { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://cad/layers", name: "Layers", description: "\u56FE\u5C42\u5217\u8868", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://cad/entities", name: "Entities", description: "\u5B9E\u4F53\u7EDF\u8BA1", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://dwg/layers", name: "Layers", description: "\u56FE\u5C42\u5217\u8868", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://dwg/entities", name: "Entities", description: "\u5B9E\u4F53\u5C5E\u6027\u5217\u8868\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100&limit=100&offset=0", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://dwg/texts", name: "Texts", description: "\u6587\u672C\u5B9E\u4F53\u5185\u5BB9\u5217\u8868 (TEXT/MTEXT/ATTRIB/TCH_TEXT)\uFF0C\u652F\u6301 ?layer=0&bbox=0,0,100,100&limit=500&offset=0", mimeType: "application/json", subscribable: true },
   { uri: "atlisp://dwg/name", name: "DWG Name", description: "\u5F53\u524D DWG \u6587\u4EF6\u540D", mimeType: "application/json", subscribable: true },
   { uri: "atlisp://dwg/path", name: "DWG Path", description: "\u6587\u4EF6\u5B8C\u6574\u8DEF\u5F84", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://cad/dwgs", name: "DWG List", description: "\u6240\u6709\u6253\u5F00\u7684 DWG \u6587\u4EF6\u5217\u8868", mimeType: "application/json", subscribable: true },
   { uri: "atlisp://packages", name: "Packages", description: "\u5DF2\u5B89\u88C5\u5305\u5217\u8868", mimeType: "application/json", subscribable: true },
-  { uri: "atlisp://platforms", name: "Platforms", description: "\u652F\u6301\u7684\u5E73\u53F0\u4FE1\u606F", mimeType: "application/json", subscribable: false }
+  { uri: "atlisp://platforms", name: "Platforms", description: "\u652F\u6301\u7684\u5E73\u53F0\u4FE1\u606F", mimeType: "application/json", subscribable: false },
+  { uri: "atlisp://standards/drafting", name: "Drafting Standards", description: "CAD \u5236\u56FE\u89C4\u8303", mimeType: "application/json", subscribable: false },
+  { uri: "atlisp://standards/coding", name: "Coding Standards", description: "@lisp \u7F16\u7801\u89C4\u8303", mimeType: "application/json", subscribable: false }
 ];
 function parseQuery(uri) {
   const qIdx = uri.indexOf("?");
-  if (qIdx === -1)
-    return { base: uri, params: {} };
+  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);
+    if (k) params[k] = decodeURIComponent(v);
   });
   return { base, params };
 }
@@ -924,26 +1205,33 @@ async function readResource(uri) {
   switch (base) {
     case "atlisp://cad/info":
       return await getCadInfo2();
-    case "atlisp://cad/layers":
+    case "atlisp://dwg/layers":
       return await getLayers(params.name);
-    case "atlisp://cad/entities":
-      return await getEntities(params.type);
+    case "atlisp://dwg/entities":
+      return await getEntities(params);
+    case "atlisp://dwg/texts":
+      return await getTexts(params);
     case "atlisp://dwg/name":
       return await getDwgName();
     case "atlisp://dwg/path":
       return await getDwgPath();
+    case "atlisp://cad/dwgs":
+      return await getDwgList();
     case "atlisp://packages":
       return await getPackages(params.name);
     case "atlisp://platforms":
       return getPlatforms();
+    case "atlisp://standards/drafting":
+      return getDraftingStandards();
+    case "atlisp://standards/coding":
+      return getCodingStandards();
     default:
       throw new Error(`\u8D44\u6E90\u4E0D\u5B58\u5728: ${uri}`);
   }
 }
 async function getCadInfo2() {
   const cached = getCached("cad:info");
-  if (cached)
-    return cached;
+  if (cached) return cached;
   if (!cad.connected) {
     await cad.connect();
   }
@@ -968,14 +1256,11 @@ async function getCadInfo2() {
   return result;
 }
 async function getLayers(filterName = null) {
-  const cacheKey = filterName ? `layers:${filterName}` : "layers:all";
+  const cacheKey = filterName ? `dwg:layers:${filterName}` : "dwg:layers:all";
   const cached = getCached(cacheKey);
-  if (cached)
-    return cached;
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return [];
+  if (cached) return cached;
+  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);
@@ -1019,70 +1304,97 @@ async function getLayers(filterName = null) {
     return [];
   }
 }
-async function getEntities(filterType = null) {
-  const cacheKey = filterType ? `entities:${filterType}` : "entities:all";
+async function getEntities(params = {}) {
+  const cacheKey = `dwg:entities:${JSON.stringify(params)}`;
   const cached = getCached(cacheKey);
-  if (cached)
-    return cached;
-  if (!cad.connected)
-    await cad.connect();
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
   if (!cad.connected) {
-    const result = { total: 0, byType: {} };
+    const result = { total: 0, entities: [] };
     setCache(cacheKey, result);
     return result;
   }
+  const offset = Math.max(0, parseInt(params.offset) || 0);
+  const limit = Math.min(Math.max(1, parseInt(params.limit) || 100), 1e3);
   try {
-    let code;
-    if (filterType) {
-      code = `(sslength (ssget "_X" (list (cons 0 "${filterType}"))))`;
-      const count = await cad.sendCommandWithResult(code);
-      const result = { type: filterType, count: parseInt(count) || 0 };
+    const code = buildEntityCode({
+      type: params.type || null,
+      layer: params.layer || null,
+      bbox: params.bbox || null,
+      offset,
+      limit
+    });
+    const resultStr = await cad.sendCommandWithResult(code);
+    if (!resultStr || resultStr === "" || resultStr === "nil" || resultStr === "0") {
+      const result = { total: 0, offset, limit, entities: [] };
       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 resultStr = await cad.sendCommandWithResult(code);
-      if (!resultStr || resultStr === "" || resultStr === "nil") {
-        const result2 = { total: 0, byType: {} };
-        setCache(cacheKey, result2);
-        return result2;
-      }
-      let statResult = [];
-      try {
-        statResult = JSON.parse(resultStr);
-      } catch (e) {
-        const parsed = parseLispList(resultStr);
-        if (parsed) {
-          statResult = parsed;
-        }
-      }
-      if (!Array.isArray(statResult)) {
-        const result2 = { total: 0, byType: {} };
-        setCache(cacheKey, result2);
-        return result2;
-      }
-      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);
-      const result = { total, byType };
+    }
+    const parsed = parseLispRecursive(resultStr);
+    if (!parsed || !Array.isArray(parsed)) {
+      const result = { total: 0, offset, limit, entities: [] };
+      setCache(cacheKey, result);
+      return result;
+    }
+    const entitiesIdx = parsed.indexOf("entities");
+    const rawEntities = entitiesIdx !== -1 && Array.isArray(parsed[entitiesIdx + 1]) ? parsed[entitiesIdx + 1] : [];
+    const data = lispPairsToObject(parsed);
+    data.entities = rawEntities.length > 0 ? rawEntities.map(parseEntity).filter(Boolean) : [];
+    data.offset = offset;
+    data.limit = limit;
+    setCache(cacheKey, data);
+    return data;
+  } catch (e) {
+    log(`getEntities error: ${e.message}`);
+    const result = { total: 0, offset, limit, entities: [] };
+    setCache(cacheKey, result);
+    return result;
+  }
+}
+async function getTexts(params = {}) {
+  const cacheKey = `dwg:texts:${JSON.stringify(params)}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) {
+    const result = { total: 0, texts: [] };
+    setCache(cacheKey, result);
+    return result;
+  }
+  const offset = Math.max(0, parseInt(params.offset) || 0);
+  const limit = Math.min(Math.max(1, parseInt(params.limit) || 500), 5e3);
+  try {
+    const code = buildTextCode({
+      layer: params.layer || null,
+      bbox: params.bbox || null,
+      offset,
+      limit
+    });
+    const resultStr = await cad.sendCommandWithResult(code);
+    if (!resultStr || resultStr === "" || resultStr === "nil" || resultStr === "0") {
+      const result = { total: 0, offset, limit, texts: [] };
       setCache(cacheKey, result);
       return result;
     }
+    const parsed = parseLispRecursive(resultStr);
+    const textsIdx = parsed.indexOf("texts");
+    const rawTexts = textsIdx !== -1 && Array.isArray(parsed[textsIdx + 1]) ? parsed[textsIdx + 1] : [];
+    const data = lispPairsToObject(parsed);
+    data.texts = rawTexts.length > 0 ? rawTexts.map(parseEntity).filter(Boolean) : [];
+    data.offset = offset;
+    data.limit = limit;
+    setCache(cacheKey, data);
+    return data;
   } catch (e) {
-    const result = { total: 0, byType: {} };
+    log(`getTexts error: ${e.message}`);
+    const result = { total: 0, offset, limit, texts: [] };
     setCache(cacheKey, result);
     return result;
   }
 }
 async function getDwgName() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { name: null };
+  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);
@@ -1092,10 +1404,8 @@ async function getDwgName() {
   }
 }
 async function getDwgPath() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { path: null, name: null };
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { path: null, name: null };
   try {
     const code = `(progn
           (setq prefix (vl-princ-to-string (getvar "dwgprefix")))
@@ -1113,8 +1423,7 @@ async function getDwgPath() {
     }
     if (!parsed) {
       const listResult = parseLispList(result);
-      if (listResult && listResult.length >= 2)
-        parsed = listResult;
+      if (listResult && listResult.length >= 2) parsed = listResult;
     }
     if (parsed && Array.isArray(parsed) && parsed.length >= 2) {
       return { path: String(parsed[0]), name: String(parsed[1]) };
@@ -1127,12 +1436,9 @@ async function getDwgPath() {
 async function getPackages(filterName = null) {
   const cacheKey = filterName ? `packages:${filterName}` : "packages:all";
   const cached = getCached(cacheKey);
-  if (cached)
-    return cached;
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return [];
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return [];
   try {
     const code = `(mapcar 'cdr @::*local-pkgs*)`;
     const result = await cad.sendCommandWithResult(code);
@@ -1146,8 +1452,7 @@ async function getPackages(filterName = null) {
     } catch {
       raw = parseLispList(result) || [];
     }
-    if (!Array.isArray(raw))
-      raw = [];
+    if (!Array.isArray(raw)) raw = [];
     const packages = raw.map((item) => {
       if (Array.isArray(item)) {
         const pkg = { name: "", version: "0.0.0", description: "", loaded: true };
@@ -1156,20 +1461,13 @@ async function getPackages(filterName = null) {
             const [[key, val]] = Object.entries(entry);
             const k = String(key);
             const v = String(val);
-            if (k === ":NAME")
-              pkg.name = v;
-            else if (k === ":VERSION")
-              pkg.version = v;
-            else if (k === ":DESCRIPTION")
-              pkg.description = v;
-            else if (k === ":FULL-NAME")
-              pkg.fullName = v;
-            else if (k === ":AUTHOR")
-              pkg.author = v;
-            else if (k === ":CATEGORY")
-              pkg.category = v;
-            else if (k === ":URL")
-              pkg.url = v;
+            if (k === ":NAME") pkg.name = v;
+            else if (k === ":VERSION") pkg.version = v;
+            else if (k === ":DESCRIPTION") pkg.description = v;
+            else if (k === ":FULL-NAME") pkg.fullName = v;
+            else if (k === ":AUTHOR") pkg.author = v;
+            else if (k === ":CATEGORY") pkg.category = v;
+            else if (k === ":URL") pkg.url = v;
           }
         }
         return pkg;
@@ -1177,6 +1475,20 @@ async function getPackages(filterName = null) {
       if (typeof item === "string" || typeof item === "number") {
         return { name: String(item), version: "0.0.0", loaded: true };
       }
+      if (item && typeof item === "object") {
+        const pkg = { name: "", version: "0.0.0", description: "", loaded: true };
+        const nameVal = item.name || item.Name || item.NAME || item[":NAME"];
+        if (nameVal) pkg.name = String(nameVal);
+        const verVal = item.version || item.Version || item.VERSION || item[":VERSION"];
+        if (verVal) pkg.version = String(verVal);
+        const descVal = item.description || item.Description || item.DESCRIPTION || item[":DESCRIPTION"];
+        if (descVal) pkg.description = String(descVal);
+        if (item.fullName || item.full_name) pkg.fullName = String(item.fullName || item.full_name);
+        if (item.author || item.Author) pkg.author = String(item.author || item.Author);
+        if (item.category || item.Category) pkg.category = String(item.category || item.Category);
+        if (item.url || item.Url || item.URL) pkg.url = String(item.url || item.Url || item.URL);
+        return pkg;
+      }
       return null;
     }).filter(Boolean);
     if (filterName) {
@@ -1197,26 +1509,123 @@ function getPlatforms() {
     extensions: FILE_EXTENSIONS[name] || []
   }));
 }
+async function getDwgList() {
+  const cacheKey = "cad:dwgs";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return [];
+  try {
+    const code = `(progn
+          (vl-load-com)
+          (setq result nil)
+          (vlax-for doc (vla-get-Documents (vla-get-Application (vlax-get-acad-object)))
+            (setq result (cons (list (vla-get-Name doc) (vla-get-FullName doc)) result))
+          )
+          (reverse result)
+        )`;
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === "" || result === "nil") {
+      setCache(cacheKey, []);
+      return [];
+    }
+    let parsed = [];
+    try {
+      parsed = JSON.parse(result);
+    } catch (e) {
+      const listResult = parseLispList(result);
+      if (listResult) {
+        parsed = listResult;
+      }
+    }
+    if (!Array.isArray(parsed)) parsed = [];
+    const dwgList = parsed.map((item) => {
+      if (Array.isArray(item) && item.length >= 2) {
+        return { name: String(item[0]), path: String(item[1]) };
+      }
+      return null;
+    }).filter(Boolean);
+    setCache(cacheKey, dwgList);
+    return dwgList;
+  } catch (e) {
+    setCache(cacheKey, []);
+    return [];
+  }
+}
+function loadStandardsFile(filename) {
+  const filePath = path4.join(STANDARDS_DIR, filename);
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (e) {
+    log(`Error loading standards file ${filename}: ${e.message}`);
+    return null;
+  }
+}
+var standardsCache = /* @__PURE__ */ new Map();
+function getCachedStandards(key) {
+  const entry = standardsCache.get(key);
+  if (entry && Date.now() - entry.timestamp < 3e4) return entry.data;
+  standardsCache.delete(key);
+  return null;
+}
+function setCachedStandards(key, data) {
+  standardsCache.set(key, { data, timestamp: Date.now() });
+}
+function getDraftingStandards() {
+  const cached = getCachedStandards("drafting");
+  if (cached) return cached;
+  const data = loadStandardsFile("drafting.json");
+  if (data) setCachedStandards("drafting", data);
+  return data || { error: "\u5236\u56FE\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
+}
+function getCodingStandards() {
+  const cached = getCachedStandards("coding");
+  if (cached) return cached;
+  const data = loadStandardsFile("coding.json");
+  if (data) setCachedStandards("coding", data);
+  return data || { error: "\u7F16\u7801\u89C4\u8303\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25" };
+}
 
 // src/handlers/prompt-handlers.js
+import fs4 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+var PROMPTS_DIR = path5.join(__dirname3, "..", "prompts");
+var externalPrompts = null;
+var externalPromptsAt = 0;
+var EXTERNAL_PROMPTS_TTL = 3e4;
+function loadExternalPrompts() {
+  const now = Date.now();
+  if (externalPrompts && now - externalPromptsAt < EXTERNAL_PROMPTS_TTL) {
+    return externalPrompts;
+  }
+  externalPrompts = [];
+  try {
+    if (!fs4.existsSync(PROMPTS_DIR)) {
+      fs4.mkdirSync(PROMPTS_DIR, { recursive: true });
+      return externalPrompts;
+    }
+    const files = fs4.readdirSync(PROMPTS_DIR).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const raw = fs4.readFileSync(path5.join(PROMPTS_DIR, file), "utf-8");
+        const prompt = JSON.parse(raw);
+        if (prompt && prompt.name) {
+          externalPrompts.push(prompt);
+        }
+      } catch (e) {
+        console.error(`Error loading prompt file ${file}: ${e.message}`);
+      }
+    }
+  } catch (e) {
+    console.error(`Error reading prompts directory: ${e.message}`);
+  }
+  externalPromptsAt = now;
+  return externalPrompts;
+}
 var PROMPTS = [
-  {
-    name: "draw-residential",
-    description: "\u751F\u6210\u519C\u6751\u6C11\u5C45\u5E73\u9762\u5E03\u7F6E\u56FE",
-    arguments: [
-      { name: "width", description: "\u5EFA\u7B51\u5BBD\u5EA6 (mm)", required: true },
-      { name: "depth", description: "\u5EFA\u7B51\u6DF1\u5EA6 (mm)", required: true },
-      { name: "rooms", description: "\u623F\u95F4\u6570\u91CF", required: false }
-    ]
-  },
-  {
-    name: "draw-floor-plan",
-    description: "\u751F\u6210\u5EFA\u7B51\u697C\u5C42\u5E73\u9762\u56FE",
-    arguments: [
-      { name: "floor", description: "\u697C\u5C42\u540D\u79F0", required: true },
-      { name: "scale", description: "\u56FE\u7EB8\u6BD4\u4F8B", required: false }
-    ]
-  },
   {
     name: "analyze-drawing",
     description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
@@ -1331,15 +1740,24 @@ var PROMPTS = [
     ]
   }
 ];
+function findExternalPrompt(name) {
+  const ext = loadExternalPrompts();
+  return ext.find((p) => p.name === name);
+}
 async function listPrompts() {
-  return PROMPTS;
+  const ext = loadExternalPrompts();
+  const extNames = new Set(ext.map((p) => p.name));
+  const builtIn = PROMPTS.filter((p) => !extNames.has(p.name));
+  return [...builtIn, ...ext];
 }
 async function getPrompt(name, arguments_ = {}) {
+  const extPrompt = findExternalPrompt(name);
+  if (extPrompt) {
+    return {
+      messages: extPrompt.messages || []
+    };
+  }
   switch (name) {
-    case "draw-residential":
-      return generateResidentialPrompt(arguments_);
-    case "draw-floor-plan":
-      return generateFloorPlanPrompt(arguments_);
     case "analyze-drawing":
       return generateAnalyzePrompt();
     case "batch-draw-lines":
@@ -1372,65 +1790,6 @@ async function getPrompt(name, arguments_ = {}) {
       throw new Error(`Unknown prompt: ${name}`);
   }
 }
-async function generateResidentialPrompt(args) {
-  const { width = 15e3, depth = 12e3, rooms = 6 } = args;
-  const code = `(defun c:draw-residential (/ old-layer p)
-  (setq old-layer (getvar "clayer"))
-  (setvar "clayer" "0")
-  (setq p (list 0 0))
-  (command "_.rectangle" p (list ${width} ${depth}))
-  ${generateRoomLayout(width, depth, rooms)}
-  (setvar "clayer" old-layer)
-  (princ)
-)
-(c:draw-residential)`;
-  return {
-    messages: [{
-      role: "user",
-      content: {
-        type: "text",
-        text: `\u8BF7\u5728 CAD \u4E2D\u7ED8\u5236\u519C\u6751\u6C11\u5C45\u5E73\u9762\u56FE\uFF0C\u5C3A\u5BF8 ${width}x${depth}mm\uFF0C${rooms} \u4E2A\u623F\u95F4\u3002
-
-\u751F\u6210\u7684 AutoLISP \u4EE3\u7801\uFF1A
-\`\`\`lisp
-${code}
-\`\`\`
-
-\u76F4\u63A5\u6267\u884C\u6B64\u4EE3\u7801\u5373\u53EF\u751F\u6210\u56FE\u7EB8\u3002`
-      }
-    }]
-  };
-}
-function generateRoomLayout(width, depth, rooms) {
-  if (rooms === 6) {
-    return `(command "_.line" (list 5000 0) (list 5000 ${depth}) "")
-               (command "_.line" (list 0 4000) (list ${width} 4000) "")
-               (command "_.text" "j" "c" "2500,2000" 800 0 "\u5BA2\u5385")
-               (command "_.text" "j" "c" "7500,6000" 800 0 "\u9910\u5385")
-               (command "_.text" "j" "c" "12500,2000" 800 0 "\u4E3B\u5367")`;
-  }
-  return `(command "_.text" "j" "c" (list (/ ${width} 2) (/ ${depth} 2)) 800 0 "\u623F\u95F4")`;
-}
-async function generateFloorPlanPrompt(args) {
-  const { floor = "\u4E00\u5C42", scale = "1:100" } = args;
-  return {
-    messages: [{
-      role: "user",
-      content: {
-        type: "text",
-        text: `\u751F\u6210 ${floor} \u5E73\u9762\u56FE\uFF0C\u6BD4\u4F8B ${scale}\u3002
-
-\u63D0\u793A\uFF1A
-1. \u4F7F\u7528 RECTANGLE \u547D\u4EE4\u7ED8\u5236\u5916\u5899
-2. \u4F7F\u7528 LINE \u547D\u4EE4\u7ED8\u5236\u5185\u90E8\u9694\u5899
-3. \u4F7F\u7528 TEXT \u547D\u4EE4\u6DFB\u52A0\u623F\u95F4\u6807\u6CE8
-4. \u4F7F\u7528 DIMLINEAR \u6216 DIMALIGNED \u6DFB\u52A0\u5C3A\u5BF8\u6807\u6CE8
-
-\u9700\u8981\u6211\u6267\u884C\u54EA\u4E9B\u64CD\u4F5C\uFF1F`
-      }
-    }]
-  };
-}
 async function generateAnalyzePrompt() {
   let entities = { total: 0, byType: {} };
   let layers = [];
@@ -1478,14 +1837,10 @@ ${generateSuggestions(entities, layers)}`
 }
 function generateSuggestions(entities, layers) {
   const suggestions = [];
-  if (entities.total > 1e3)
-    suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
-  if (layers.length > 20)
-    suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
-  if (entities.byType.LINE && entities.byType.LINE > 500)
-    suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
-  if (!entities.byType.DIMENSION)
-    suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
+  if (entities.total > 1e3) suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
+  if (layers.length > 20) suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
+  if (entities.byType.LINE && entities.byType.LINE > 500) suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
+  if (!entities.byType.DIMENSION) suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
   return suggestions.length ? suggestions.join("\n") : "- \u56FE\u7EB8\u7ED3\u6784\u826F\u597D";
 }
 async function generateBatchLinesPrompt(args) {
@@ -2213,11 +2568,9 @@ var SseSession = class {
     return lines.join("\n") + "\n\n";
   }
   _setupDrain() {
-    if (typeof this.#res.on !== "function")
-      return;
+    if (typeof this.#res.on !== "function") return;
     this.#drainHandler = () => {
-      if (!this.#active)
-        return;
+      if (!this.#active) return;
       if (this.#backpressureBuffer.length > 0) {
         this._drainBuffer();
       }
@@ -2239,8 +2592,7 @@ var SseSession = class {
     }
   }
   _write(content) {
-    if (!this.#active)
-      return false;
+    if (!this.#active) return false;
     try {
       if (this.#backpressureBuffer.length > 0) {
         this.#backpressureBuffer.push(content);
@@ -2289,8 +2641,8 @@ var SseSession = class {
   sendMessage(data) {
     return this.sendEvent(SSE_EVENTS.MESSAGE, data);
   }
-  sendEndpoint(path5) {
-    return this.sendEvent(SSE_EVENTS.ENDPOINT, path5);
+  sendEndpoint(path8) {
+    return this.sendEvent(SSE_EVENTS.ENDPOINT, path8);
   }
   sendError(code, message, id = null) {
     return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
@@ -2344,6 +2696,42 @@ var SseSession = class {
 };
 
 // src/sse-session-manager.js
+import fs5 from "fs";
+import path6 from "path";
+import os3 from "os";
+var SESSION_STORE_DIR = path6.join(os3.homedir(), ".atlisp", "sessions");
+var SESSION_STORE_TTL = 24 * 60 * 60 * 1e3;
+function getSessionStorePath(clientId) {
+  return path6.join(SESSION_STORE_DIR, `${clientId}.json`);
+}
+function persistSessionData(clientId, sessionData) {
+  try {
+    fs5.mkdirSync(SESSION_STORE_DIR, { recursive: true });
+    const store = {
+      clientId,
+      sessionData,
+      savedAt: Date.now()
+    };
+    fs5.writeFileSync(getSessionStorePath(clientId), JSON.stringify(store), "utf-8");
+  } catch (e) {
+    console.error("Failed to persist session:", e.message);
+  }
+}
+function loadPersistedSessionData(clientId) {
+  try {
+    const filePath = getSessionStorePath(clientId);
+    if (!fs5.existsSync(filePath)) return null;
+    const raw = fs5.readFileSync(filePath, "utf-8");
+    const store = JSON.parse(raw);
+    if (Date.now() - store.savedAt > SESSION_STORE_TTL) {
+      fs5.unlinkSync(filePath);
+      return null;
+    }
+    return store.sessionData || {};
+  } catch (e) {
+    return null;
+  }
+}
 var SseSessionManager = class {
   #sessions = /* @__PURE__ */ new Map();
   #eventHandlers = /* @__PURE__ */ new Map();
@@ -2355,12 +2743,19 @@ var SseSessionManager = class {
     if (!(session instanceof SseSession)) {
       throw new Error("session must be an SseSession instance");
     }
+    const persisted = loadPersistedSessionData(clientId);
+    if (persisted) {
+      for (const [key, value] of Object.entries(persisted)) {
+        session.setSessionData(key, value);
+      }
+    }
     this.#sessions.set(clientId, session);
     session.startHeartbeat();
   }
   remove(clientId) {
     const session = this.#sessions.get(clientId);
     if (session) {
+      persistSessionData(clientId, session.sessionData);
       session.close();
       this.#sessions.delete(clientId);
       return true;
@@ -2449,6 +2844,7 @@ var SseSessionManager = class {
   }
   closeAll() {
     for (const [clientId, session] of this.#sessions) {
+      persistSessionData(clientId, session.sessionData);
       session.close();
     }
     this.#sessions.clear();
@@ -2456,9 +2852,12 @@ var SseSessionManager = class {
 };
 
 // src/atlisp-mcp.js
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var __dirname4 = path7.dirname(fileURLToPath4(import.meta.url));
 var require2 = createRequire(import.meta.url);
-var { version } = require2(path4.join(__dirname2, "..", "package.json"));
+var { version } = require2(path7.join(__dirname4, "..", "package.json"));
+var CACHE_DIR2 = path7.join(os4.homedir(), ".atlisp", "cache");
+var FUNCLIB_CACHE_FILE2 = path7.join(CACHE_DIR2, "functions.json");
+var FUNCLIB_CACHE_TTL2 = 24 * 60 * 60 * 1e3;
 var isMcpScript = process.argv[1]?.includes("atlisp-mcp");
 if (isMcpScript) {
   const args = process.argv.slice(2);
@@ -2510,8 +2909,7 @@ var SERVER_CAPABILITIES = {
   prompts: {}
 };
 var { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config_default;
-if (apiKey)
-  log("API Key authentication enabled");
+if (apiKey) log("API Key authentication enabled");
 var mcpLimiter = rateLimit({
   windowMs: rateLimitWindow,
   max: rateLimitMax,
@@ -2523,26 +2921,52 @@ var FUNCTION_LIB_URL = process.env.FUNCTION_LIB_URL || "http://s3.atlisp.cn/json
 var cachedFunctionLib = null;
 var cachedAt2 = null;
 var CACHE_TTL3 = 5 * 60 * 1e3;
+async function readCacheFromDisk2() {
+  try {
+    const stat = fs6.statSync(FUNCLIB_CACHE_FILE2);
+    if (Date.now() - stat.mtimeMs < FUNCLIB_CACHE_TTL2) {
+      const raw = fs6.readFileSync(FUNCLIB_CACHE_FILE2, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCacheToDisk2(data) {
+  try {
+    fs6.mkdirSync(CACHE_DIR2, { recursive: true });
+    fs6.writeFileSync(FUNCLIB_CACHE_FILE2, JSON.stringify(data), "utf-8");
+  } catch (e) {
+    log(`writeCacheToDisk error: ${e.message}`);
+  }
+}
 async function loadAtlibFunctionLib() {
   const now = Date.now();
   if (cachedFunctionLib && cachedAt2 && now - cachedAt2 < CACHE_TTL3) {
     return cachedFunctionLib;
   }
+  const diskCache = await readCacheFromDisk2();
+  if (diskCache) {
+    cachedFunctionLib = diskCache;
+    cachedAt2 = now;
+    return diskCache;
+  }
   try {
     const response = await fetch(FUNCTION_LIB_URL, { headers: { "User-Agent": "atlisp-mcp" } });
     if (response.ok) {
       const data = await response.json();
       cachedFunctionLib = data;
       cachedAt2 = now;
+      writeCacheToDisk2(data);
       return data;
     }
   } catch (e) {
     log(`loadAtlibFunctionLib error: ${e.message}`);
   }
-  return null;
+  return cachedFunctionLib;
 }
 var TOOL_HANDLERS = {
-  connect_cad: () => connectCad(),
+  connect_cad: (a) => connectCad(a?.platform),
   eval_lisp: (a) => evalLisp(a.code),
   eval_lisp_with_result: (a) => evalLisp(a.code, true, a.encoding),
   get_cad_info: () => getCadInfo(),
@@ -2560,10 +2984,17 @@ ${CAD_PLATFORMS.join("\n")}
   get_function_usage: (a) => getFunctionUsage(a.name, a.package),
   list_symbols: (a) => listSymbols(a.package),
   get_system_status: () => getSystemStatus(),
+  list_prompts: async () => {
+    const prompts = await listPrompts();
+    return { content: [{ type: "text", text: JSON.stringify(prompts) }] };
+  },
+  get_prompt: async (a) => {
+    const prompt = await getPrompt(a.name, a.args || {});
+    return { content: prompt.messages.map((m) => ({ type: "text", text: m.content.text || m.content })) };
+  },
   import_funlib: async (a) => {
     const data = await loadAtlibFunctionLib();
-    if (!data)
-      return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
+    if (!data) return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
     if (a.format === "list") {
       const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
       return { content: [{ type: "text", text: items.join("\n") }] };
@@ -2579,7 +3010,7 @@ function getOrCreateSessionServer(sessionId) {
     server.connect(transport2);
     entry = { server, transport: transport2 };
     sessionServers.set(sessionId, entry);
-    sessionTranports.set(sessionId, transport2);
+    sessionTransports.set(sessionId, transport2);
   }
   return entry;
 }
@@ -2591,7 +3022,7 @@ function removeSessionServer(sessionId) {
     entry.server.close().catch(() => {
     });
     sessionServers.delete(sessionId);
-    sessionTranports.delete(sessionId);
+    sessionTransports.delete(sessionId);
   }
 }
 function broadcastToAllSessions(uri) {
@@ -2605,7 +3036,12 @@ var tools = [
   {
     name: "connect_cad",
     description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
-    inputSchema: { type: "object", properties: {} }
+    inputSchema: {
+      type: "object",
+      properties: {
+        platform: { type: "string", description: "\u6307\u5B9A CAD \u5E73\u53F0: AutoCAD, ZWCAD, GStarCAD, BricsCAD\uFF08\u53EF\u9009\uFF0C\u81EA\u52A8\u68C0\u6D4B\uFF09" }
+      }
+    }
   },
   {
     name: "eval_lisp",
@@ -2726,12 +3162,28 @@ var tools = [
     name: "get_system_status",
     description: "\u83B7\u53D6\u5B8C\u6574\u7CFB\u7EDF\u8BCA\u65AD\u4FE1\u606F\uFF1AMCP \u72B6\u6001\u3001CAD \u8FDE\u63A5\u3001Lisp \u6267\u884C\u3001\u5305\u5217\u8868",
     inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "list_prompts",
+    description: "\u5217\u51FA\u6240\u6709\u53EF\u7528\u7684 @lisp \u63D0\u793A\u6A21\u677F",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_prompt",
+    description: "\u83B7\u53D6\u6307\u5B9A\u63D0\u793A\u6A21\u677F\u7684\u5185\u5BB9",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "\u63D0\u793A\u6A21\u677F\u540D\u79F0" },
+        args: { type: "object", description: "\u6A21\u677F\u53C2\u6570\uFF08\u53EF\u9009\uFF09" }
+      },
+      required: ["name"]
+    }
   }
 ];
 async function handleToolCall(name, args) {
   const handler = TOOL_HANDLERS[name];
-  if (!handler)
-    return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
+  if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
   try {
     const result = await handler(args || {});
     notifyResourceChanges(name);
@@ -2743,8 +3195,8 @@ async function handleToolCall(name, args) {
 }
 function notifyResourceChanges(toolName) {
   const resourceMap = {
-    connect_cad: ["atlisp://cad/info", "atlisp://cad/layers", "atlisp://dwg/name", "atlisp://dwg/path", "atlisp://packages"],
-    new_document: ["atlisp://dwg/name", "atlisp://dwg/path", "atlisp://cad/layers", "atlisp://cad/entities"],
+    connect_cad: ["atlisp://cad/info", "atlisp://dwg/layers", "atlisp://dwg/name", "atlisp://dwg/path", "atlisp://cad/dwgs", "atlisp://packages"],
+    new_document: ["atlisp://dwg/name", "atlisp://dwg/path", "atlisp://cad/dwgs", "atlisp://dwg/layers", "atlisp://dwg/entities", "atlisp://dwg/texts"],
     install_package: ["atlisp://packages"],
     install_atlisp: ["atlisp://packages", "atlisp://cad/info"],
     init_atlisp: ["atlisp://packages", "atlisp://cad/info"]
@@ -2774,7 +3226,7 @@ async function initCadConnection() {
   }
 }
 var sessionServers = /* @__PURE__ */ new Map();
-var sessionTranports = /* @__PURE__ */ new Map();
+var sessionTransports = /* @__PURE__ */ new Map();
 function createMcpServer() {
   const server = new Server(
     { name: SERVER_NAME, version: SERVER_VERSION },
@@ -2854,8 +3306,7 @@ async function startServer() {
     const JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
     app.use(async (req, res, next) => {
       const ct = (req.headers["content-type"] || "").toLowerCase();
-      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t)))
-        return next();
+      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t))) return next();
       try {
         const buf = await rawBody(req, { limit: "10mb" });
         const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
@@ -2876,11 +3327,9 @@ async function startServer() {
     const PUBLIC_PATHS = ["/health"];
     if (apiKey) {
       app.use((req, res, next) => {
-        if (PUBLIC_PATHS.includes(req.path))
-          return next();
+        if (PUBLIC_PATHS.includes(req.path)) return next();
         const auth = req.get("Authorization");
-        if (auth === `Bearer ${apiKey}`)
-          return next();
+        if (auth === `Bearer ${apiKey}`) return next();
         res.status(401).json({ error: "Unauthorized" });
       });
     }
@@ -2895,8 +3344,7 @@ async function startServer() {
         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();
+        if (req.method === "OPTIONS") return res.status(204).end();
         next();
       });
     }