@atlisp/mcp 1.5.1 → 1.5.2

package/dist/atlisp-mcp.js

@@ -1,43 +1,62 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+
+// src/atlisp-mcp.js
+import path8 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { createRequire } from "module";
+import express2 from "express";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/cad.js
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { randomUUID } from "crypto";
 
 // src/constants.js
-var CAD_PLATFORMS, FILE_EXTENSIONS, SERVER_NAME, SERVER_VERSION, MOCK_PACKAGES;
-var init_constants = __esm({
-  "src/constants.js"() {
-    CAD_PLATFORMS = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
-    FILE_EXTENSIONS = {
-      "AutoCAD": [".fas", ".vlx"],
-      "ZWCAD": [".zelx", ".vls"],
-      "GStarCAD": [".fas", ".vlx"],
-      "BricsCAD": [".des"]
-    };
-    SERVER_NAME = "atlisp-mcp-server";
-    SERVER_VERSION = "1.5.0";
-    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" },
-      { name: "network", description: "\u7F51\u7EDC\u529F\u80FD\u6A21\u5757", version: "1.5.0" },
-      { name: "userman", description: "\u7528\u6237\u7BA1\u7406", version: "1.2.0" },
-      { name: "pkgman", description: "\u5305\u7BA1\u7406\u5668", version: "2.0.0" },
-      { name: "sidebar", description: "\u4FA7\u8FB9\u680F\u5DE5\u5177", version: "1.0.0" },
-      { name: "aibot", description: "AI \u52A9\u624B", version: "0.9.0" },
-      { name: "tips", description: "\u6BCF\u65E5\u63D0\u793A", version: "1.0.0" },
-      { name: "function", description: "\u51FD\u6570\u5E93", version: "3.0.0" }
-    ];
-  }
-});
+var CAD_PLATFORMS = ["AutoCAD", "ZWCAD", "GStarCAD", "BricsCAD"];
+var FILE_EXTENSIONS = {
+  "AutoCAD": [".fas", ".vlx"],
+  "ZWCAD": [".zelx", ".vls"],
+  "GStarCAD": [".fas", ".vlx"],
+  "BricsCAD": [".des"]
+};
+var SERVER_NAME = "atlisp-mcp-server";
+var SERVER_VERSION = "1.5.0";
+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" },
+  { name: "network", description: "\u7F51\u7EDC\u529F\u80FD\u6A21\u5757", version: "1.5.0" },
+  { name: "userman", description: "\u7528\u6237\u7BA1\u7406", version: "1.2.0" },
+  { name: "pkgman", description: "\u5305\u7BA1\u7406\u5668", version: "2.0.0" },
+  { name: "sidebar", description: "\u4FA7\u8FB9\u680F\u5DE5\u5177", version: "1.0.0" },
+  { name: "aibot", description: "AI \u52A9\u624B", version: "0.9.0" },
+  { name: "tips", description: "\u6BCF\u65E5\u63D0\u793A", version: "1.0.0" },
+  { name: "function", description: "\u51FD\u6570\u5E93", version: "3.0.0" }
+];
 
 // src/config.js
 import { z } from "zod";
+var envSchema = z.object({
+  PORT: z.string().optional().default("8110"),
+  HOST: z.string().optional().default("0.0.0.0"),
+  TRANSPORT: z.enum(["http", "stdio"]).optional().default("http"),
+  MCP_API_KEY: z.string().optional().default(""),
+  ENABLE_SSE: z.string().optional().default("true"),
+  MESSAGE_TIMEOUT: z.string().optional().default("60000"),
+  HEARTBEAT_INTERVAL: z.string().optional().default("30000"),
+  BUSY_RETRIES: z.string().optional().default("10"),
+  BUSY_DELAY: z.string().optional().default("500"),
+  ENABLE_CORS: z.string().optional().default("true"),
+  CORS_ORIGIN: z.string().optional().default("*"),
+  RATE_LIMIT_WINDOW: z.string().optional().default("60000"),
+  RATE_LIMIT_MAX: z.string().optional().default("100"),
+  RESOURCE_CACHE_TTL: z.string().optional().default("5000"),
+  FUNCTION_LIB_CACHE_TTL: z.string().optional().default("300000"),
+  DEBUG: z.string().optional().default("false"),
+  DEBUG_FILE: z.string().optional().default(""),
+  FUNCTION_LIB_URL: z.string().optional().default("http://s3.atlisp.cn/json/functions.json")
+});
 function parseArgs() {
   const args = process.argv.slice(2);
   const result = { transport: "http", port: "8110", host: "0.0.0.0" };
@@ -57,65 +76,50 @@ function parseArgs() {
   }
   return result;
 }
-var envSchema, cliArgs, envResult, env, config, config_default;
-var init_config = __esm({
-  "src/config.js"() {
-    envSchema = z.object({
-      PORT: z.string().optional().default("8110"),
-      HOST: z.string().optional().default("0.0.0.0"),
-      TRANSPORT: z.enum(["http", "stdio"]).optional().default("http"),
-      MCP_API_KEY: z.string().optional().default(""),
-      ENABLE_SSE: z.string().optional().default("true"),
-      MESSAGE_TIMEOUT: z.string().optional().default("60000"),
-      HEARTBEAT_INTERVAL: z.string().optional().default("30000"),
-      BUSY_RETRIES: z.string().optional().default("10"),
-      BUSY_DELAY: z.string().optional().default("500"),
-      ENABLE_CORS: z.string().optional().default("true"),
-      CORS_ORIGIN: z.string().optional().default("*"),
-      RATE_LIMIT_WINDOW: z.string().optional().default("60000"),
-      RATE_LIMIT_MAX: z.string().optional().default("100"),
-      RESOURCE_CACHE_TTL: z.string().optional().default("5000"),
-      FUNCTION_LIB_CACHE_TTL: z.string().optional().default("300000"),
-      DEBUG: z.string().optional().default("false"),
-      DEBUG_FILE: z.string().optional().default(""),
-      FUNCTION_LIB_URL: z.string().optional().default("http://s3.atlisp.cn/json/functions.json")
-    });
-    cliArgs = parseArgs();
-    envResult = envSchema.safeParse(process.env);
-    if (!envResult.success) {
-      console.error("\u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u9519\u8BEF:", envResult.error.flatten().fieldErrors);
-      process.exit(1);
-    }
-    env = envResult.data;
-    config = {
-      port: parseInt(env.PORT || cliArgs.port, 10),
-      host: env.HOST || cliArgs.host,
-      transport: process.env.TRANSPORT ? env.TRANSPORT : cliArgs.transport,
-      apiKey: env.MCP_API_KEY,
-      enableSse: env.ENABLE_SSE === "true",
-      messageTimeout: parseInt(env.MESSAGE_TIMEOUT, 10),
-      heartbeatInterval: parseInt(env.HEARTBEAT_INTERVAL, 10),
-      busyRetries: parseInt(env.BUSY_RETRIES, 10),
-      busyDelay: parseInt(env.BUSY_DELAY, 10),
-      enableCors: env.ENABLE_CORS === "true",
-      corsOrigin: env.CORS_ORIGIN,
-      rateLimitWindow: parseInt(env.RATE_LIMIT_WINDOW, 10),
-      rateLimitMax: parseInt(env.RATE_LIMIT_MAX, 10),
-      resourceCacheTtl: parseInt(env.RESOURCE_CACHE_TTL, 10),
-      functionLibCacheTtl: parseInt(env.FUNCTION_LIB_CACHE_TTL, 10),
-      debug: env.DEBUG === "true",
-      debugFile: env.DEBUG_FILE,
-      functionLibUrl: env.FUNCTION_LIB_URL
-    };
-    config_default = config;
-  }
-});
+var cliArgs = parseArgs();
+var envResult = envSchema.safeParse(process.env);
+if (!envResult.success) {
+  console.error("\u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u9519\u8BEF:", envResult.error.flatten().fieldErrors);
+  process.exit(1);
+}
+var env = envResult.data;
+var config = {
+  port: parseInt(env.PORT || cliArgs.port, 10),
+  host: env.HOST || cliArgs.host,
+  transport: process.env.TRANSPORT && env.TRANSPORT ? env.TRANSPORT : cliArgs.transport,
+  apiKey: env.MCP_API_KEY,
+  enableSse: env.ENABLE_SSE === "true",
+  messageTimeout: parseInt(env.MESSAGE_TIMEOUT, 10),
+  heartbeatInterval: parseInt(env.HEARTBEAT_INTERVAL, 10),
+  busyRetries: parseInt(env.BUSY_RETRIES, 10),
+  busyDelay: parseInt(env.BUSY_DELAY, 10),
+  enableCors: env.ENABLE_CORS === "true",
+  corsOrigin: env.CORS_ORIGIN,
+  rateLimitWindow: parseInt(env.RATE_LIMIT_WINDOW, 10),
+  rateLimitMax: parseInt(env.RATE_LIMIT_MAX, 10),
+  resourceCacheTtl: parseInt(env.RESOURCE_CACHE_TTL, 10),
+  functionLibCacheTtl: parseInt(env.FUNCTION_LIB_CACHE_TTL, 10),
+  debug: env.DEBUG === "true",
+  debugFile: env.DEBUG_FILE,
+  functionLibUrl: env.FUNCTION_LIB_URL
+};
+var config_default = config;
 
 // src/cad.js
-import { spawn } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-import { randomUUID } from "crypto";
+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;
+var _platform = null;
+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);
@@ -255,142 +259,125 @@ 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, CadConnection, cad;
-var init_cad = __esm({
-  "src/cad.js"() {
-    init_constants();
-    init_config();
-    MESSAGE_TIMEOUT = config_default.messageTimeout;
-    HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
-    MAX_RESTART_ATTEMPTS = 5;
-    RESTART_BACKOFF_BASE = 1e3;
-    __dirname = path.dirname(fileURLToPath(import.meta.url));
-    workerPath = path.join(__dirname, "cad-worker.js");
-    worker = null;
-    _platform = null;
-    heartbeatTimer = null;
-    pendingRequests = /* @__PURE__ */ new Map();
-    stdoutHandlerSetup = false;
-    MAX_BUFFER_SIZE = 1024 * 1024;
-    restartCount = 0;
-    restartTimer = null;
-    CadConnection = class {
-      constructor() {
-        this.connected = false;
-        this.version = null;
-        this.product = null;
-      }
-      isAvailable() {
-        return process.platform === "win32";
-      }
-      async connect(platform = null) {
-        if (!this.isAvailable()) return false;
-        try {
-          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;
-            _platform = result.platform;
-            this.connected = true;
-            return true;
-          }
-        } catch (e) {
-          console.error("CAD connect error:", e.message);
-        }
-        return false;
-      }
-      async sendCommand(code) {
-        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-        const result = await sendMessage({ type: "send", code, platform: _platform });
-        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");
-        const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
-        if (result.success) {
-          return result.result || "";
-        }
-        throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
-      }
-      getVersion() {
-        return this.version;
-      }
-      getPlatform() {
-        return this.product;
-      }
-      async isBusy() {
-        if (!this.connected) return false;
-        try {
-          const result = await sendMessage({ type: "isBusy", platform: _platform });
-          return result && result.isBusy;
-        } catch (e) {
-          return false;
-        }
-      }
-      async hasDoc() {
-        if (!this.connected) return { hasDoc: false, docCount: 0 };
-        try {
-          const result = await sendMessage({ type: "hasdoc", platform: _platform });
-          return result || { hasDoc: false, docCount: 0 };
-        } catch (e) {
-          return { hasDoc: false, docCount: 0 };
-        }
-      }
-      async newDoc() {
-        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-        try {
-          const result = await sendMessage({ type: "newdoc", platform: _platform });
-          return result && result.success;
-        } catch (e) {
-          return false;
-        }
-      }
-      async bringToFront() {
-        if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
-        try {
-          const result = await sendMessage({ type: "bringToFront", platform: _platform });
-          return result && result.success;
-        } catch (e) {
-          return false;
-        }
-      }
-      async getInfo() {
-        if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
-        return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
-      }
-      async disconnect() {
-        this.connected = false;
-        this.version = null;
-        this.product = null;
-        _platform = null;
-        resetWorker();
-      }
-      async ping() {
-        try {
-          const result = await sendMessage({ type: "ping" });
-          return result && result.pong;
-        } catch (e) {
-          return false;
-        }
-      }
-      _reset() {
-        this.connected = false;
-        this.version = null;
-        this.product = null;
-        _platform = null;
-        resetWorker();
+var CadConnection = class {
+  constructor() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+  }
+  isAvailable() {
+    return process.platform === "win32";
+  }
+  async connect(platform = null) {
+    if (!this.isAvailable()) return false;
+    try {
+      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;
+        _platform = result.platform;
+        this.connected = true;
+        return true;
       }
-    };
-    cad = new CadConnection();
+    } catch (e) {
+      console.error("CAD connect error:", e.message);
+    }
+    return false;
   }
-});
+  async sendCommand(code) {
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    const result = await sendMessage({ type: "send", code, platform: _platform });
+    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");
+    const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
+    if (result.success) {
+      return result.result || "";
+    }
+    throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
+  }
+  getVersion() {
+    return this.version;
+  }
+  getPlatform() {
+    return this.product;
+  }
+  async isBusy() {
+    if (!this.connected) return false;
+    try {
+      const result = await sendMessage({ type: "isBusy", platform: _platform });
+      return result && result.isBusy;
+    } catch (e) {
+      return false;
+    }
+  }
+  async hasDoc() {
+    if (!this.connected) return { hasDoc: false, docCount: 0 };
+    try {
+      const result = await sendMessage({ type: "hasdoc", platform: _platform });
+      return result || { hasDoc: false, docCount: 0 };
+    } catch (e) {
+      return { hasDoc: false, docCount: 0 };
+    }
+  }
+  async newDoc() {
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    try {
+      const result = await sendMessage({ type: "newdoc", platform: _platform });
+      return result && result.success;
+    } catch (e) {
+      return false;
+    }
+  }
+  async bringToFront() {
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
+    try {
+      const result = await sendMessage({ type: "bringToFront", platform: _platform });
+      return result && result.success;
+    } catch (e) {
+      return false;
+    }
+  }
+  async getInfo() {
+    if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
+    return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+    _platform = null;
+    resetWorker();
+  }
+  async ping() {
+    try {
+      const result = await sendMessage({ type: "ping" });
+      return result && result.pong;
+    } catch (e) {
+      return false;
+    }
+  }
+  _reset() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+    _platform = null;
+    resetWorker();
+  }
+};
+var cad = new CadConnection();
 
 // src/logger.js
 import fs from "fs";
 import path2 from "path";
 import os from "os";
+var DEBUG_FILE = config_default.debugFile || 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);
@@ -433,8 +420,9 @@ function formatMessage(level, message, meta = {}) {
   return JSON.stringify(entry);
 }
 function log(message, meta = {}) {
+  getStream().write(formatMessage("INFO", message, meta) + "\n");
   if (config_default.debug) {
-    getStream().write(formatMessage("INFO", message, meta) + "\n");
+    console.log(`[INFO] ${message}`, meta);
   }
 }
 function error(message, meta = {}) {
@@ -449,508 +437,115 @@ function closeLog() {
     stream = null;
   }
 }
-var DEBUG_FILE, MAX_LOG_SIZE, MAX_LOG_FILES, stream;
-var init_logger = __esm({
-  "src/logger.js"() {
-    init_config();
-    DEBUG_FILE = config_default.debugFile || path2.join(os.tmpdir(), "mcp-server-debug.log");
-    MAX_LOG_SIZE = 10 * 1024 * 1024;
-    MAX_LOG_FILES = 5;
-    stream = null;
-  }
-});
 
-// src/handlers/cad-handlers.js
-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(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()}` }] };
-    }
-  } catch (e) {
-    log("connect_cad error: " + e.message);
+// src/handlers/resource-handlers.js
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
+var STANDARDS_DIR = path3.join(__dirname2, "..", "standards");
+var CACHE_TTL = config_default.resourceCacheTtl;
+var resourceCache = /* @__PURE__ */ new Map();
+function getCached(key) {
+  const entry = resourceCache.get(key);
+  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+    return entry.data;
   }
-  return { content: [{ type: "text", text: "\u672A\u80FD\u8FDE\u63A5\u6216\u542F\u52A8 CAD\uFF0C\u8BF7\u786E\u4FDD CAD \u5DF2\u5B89\u88C5" }], isError: true };
+  resourceCache.delete(key);
+  return null;
 }
-async function evalLisp(code, withResult = false, encoding = null) {
-  if (!cad.connected) {
-    await cad.connect();
-  }
-  if (!cad.connected) {
-    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" }] };
-  try {
-    if (withResult) {
-      const result = await cad.sendCommandWithResult(trimmed, encoding);
-      if (result !== null) {
-        return { content: [{ type: "text", text: result }] };
+function setCache(key, data) {
+  resourceCache.set(key, { data, timestamp: Date.now() });
+}
+function clearCache(uri) {
+  if (uri) {
+    for (const key of resourceCache.keys()) {
+      if (key.startsWith(uri.split("://")[1]?.split("/")[0] + ":")) {
+        resourceCache.delete(key);
       }
-      return { content: [{ type: "text", text: "\u6267\u884C\u5931\u8D25\u6216\u65E0\u8FD4\u56DE\u503C" }], isError: true };
-    } else {
-      await cad.sendCommand(trimmed + "\n");
-      return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4` }] };
     }
-  } catch (e) {
-    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+  } else {
+    resourceCache.clear();
   }
 }
-async function getCadInfo() {
-  if (!cad.connected) {
-    await cad.connect();
+function parseLispList(str) {
+  if (!str || typeof str !== "string") return null;
+  const trimmed = str.trim();
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return null;
+  const content = trimmed.slice(1, -1).trim();
+  if (!content) return [];
+  const result = [];
+  let depth = 0;
+  let current = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      current += ch;
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      current += ch;
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      current += ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[") {
+      current += ch;
+      depth++;
+    } else if (ch === ")" || ch === "]") {
+      current += ch;
+      depth--;
+    } else if (ch === " " && depth === 0) {
+      if (current.trim()) {
+        result.push(current.trim());
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
   }
-  if (!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 };
-  const trimmed = (command || "").trim();
-  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" }] };
+  if (current.trim()) result.push(current.trim());
+  return result.map((item) => {
+    const t = item.trim();
+    if (t === "nil") return null;
+    if (t === "t") return true;
+    if (t === "T") return true;
+    const num = Number(t);
+    if (!isNaN(num) && t !== "") return num;
+    if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
+    return t;
+  });
 }
-async function newDocument() {
-  if (!cad.connected) {
-    await cad.connect();
+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++;
   }
-  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" }] };
-  }
-  return { content: [{ type: "text", text: "\u65B0\u5EFA\u6587\u6863\u5931\u8D25" }], isError: true };
-}
-async function bringToFront() {
-  if (!cad.connected) {
-    await cad.connect();
-  }
-  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" }] };
-  }
-  return { content: [{ type: "text", text: "\u5207\u6362\u524D\u53F0\u5931\u8D25" }], isError: true };
-}
-async function installAtlisp() {
-  if (!cad.connected) {
-    await cad.connect();
-  }
-  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" }] };
-}
-async function listFunctionsInCad() {
-  if (!cad.connected) {
-    await cad.connect();
-  }
-  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 }] };
-    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 };
-  }
-}
-async function getSystemStatus() {
-  const status = {
-    mcp: { version: process.env.npm_package_version || "unknown" },
-    worker: { alive: false },
-    cad: { connected: false, platform: null, version: null, busy: false, hasDoc: false },
-    lisp: { available: false, testResult: null, error: null },
-    packages: null
-  };
-  try {
-    status.worker.alive = await cad.ping();
-  } catch {
-    status.worker.alive = false;
-  }
-  status.cad.connected = cad.connected;
-  if (cad.connected) {
-    status.cad.platform = cad.getPlatform();
-    status.cad.version = cad.getVersion();
-    try {
-      status.cad.busy = await cad.isBusy();
-    } catch {
-    }
-    try {
-      const doc = await cad.hasDoc();
-      status.cad.hasDoc = doc.hasDoc;
-    } catch {
-    }
-    try {
-      const r = await cad.sendCommandWithResult("(+ 1 2)");
-      if (r !== null && r !== void 0) {
-        status.lisp.available = true;
-        status.lisp.testResult = String(r).trim();
-      }
-    } catch (e) {
-      status.lisp.error = e.message;
-    }
-    try {
-      const pkgResult = await cad.sendCommandWithResult("(@::package-list-in-local)");
-      if (pkgResult && pkgResult !== "nil") {
-        status.packages = pkgResult;
-      }
-    } catch {
-    }
-  }
-  return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
-}
-async function initAtlisp() {
-  if (!cad.connected) {
-    await cad.connect();
-  }
-  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
-  const code = `(if (null @::load-module)
-	   (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/cloud"):vlax-true)
-		   (v o'send)
-		   (v o'WaitforResponse 1000)
-		   (e(r(vlax-get o'ResponseText)))))`;
-  try {
-    await cad.sendCommand(code + "\n");
-    return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001 @lisp \u51FD\u6570\u5E93\u52A0\u8F7D\u4EE3\u7801\u5230 CAD" }] };
-  } catch (e) {
-    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
-  }
-}
-var init_cad_handlers = __esm({
-  "src/handlers/cad-handlers.js"() {
-    init_cad();
-    init_logger();
-  }
-});
-
-// src/handlers/package-handlers.js
-async function fetchPackages() {
-  const now = Date.now();
-  if (cachedPackages && cachedAt && now - cachedAt < CACHE_TTL) {
-    return cachedPackages;
-  }
-  try {
-    const response = await fetch(PACKAGES_LIST_URL, { headers: { "User-Agent": "atlisp-mcp" } });
-    if (response.ok) {
-      const data = await response.json();
-      cachedPackages = data;
-      cachedAt = now;
-      return data;
-    }
-  } catch (e) {
-  }
-  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) {
-    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 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:
-${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 = [];
-  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);
-    }
-  } else {
-    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` }] };
-  }
-  return { content: [{ type: "text", text: `\u641C\u7D22\u7ED3\u679C (${results.length}):
-${results.map((p) => `${p.name} v${p.version || ""} - ${p.description || ""}`).join("\n")}` }] };
-}
-async function installPackage(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 };
-  }
-  if (cad.connected) {
-    await cad.sendCommand(`(@::load-module '${packageName})
-`);
-  }
-  return { content: [{ type: "text", text: `\u5305 "${packageName}" \u5B89\u88C5\u547D\u4EE4\u5DF2\u53D1\u9001\uFF01` }] };
-}
-var PACKAGES_LIST_URL, cachedPackages, cachedAt, CACHE_TTL;
-var init_package_handlers = __esm({
-  "src/handlers/package-handlers.js"() {
-    init_cad();
-    init_constants();
-    PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || "http://s3.atlisp.cn/packages-list?fmt=json";
-    cachedPackages = null;
-    cachedAt = null;
-    CACHE_TTL = 10 * 60 * 1e3;
-  }
-});
-
-// src/handlers/function-handlers.js
-import fs2 from "fs";
-import path3 from "path";
-import os2 from "os";
-function readCacheFromDisk() {
-  try {
-    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 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 = [];
-    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) {
-      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) {
-      return { content: [{ type: "text", text: `\u672A\u627E\u5230\u51FD\u6570: ${funcName}` }], isError: true };
-    }
-    const f = results[0];
-    const text = `\u51FD\u6570: ${f.name}
-\u63CF\u8FF0: ${f.description || "-"}
-\u53C2\u6570: ${f.params?.join(", ") || "-"}
-\u8FD4\u56DE\u503C: ${f.return || "-"}
-\u793A\u4F8B: ${f.usage || "-"}`;
-    return { content: [{ type: "text", text }] };
-  } catch (e) {
-    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
-  }
-}
-async function listSymbols(packageName) {
-  try {
-    let allFuncs = [];
-    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 || "-"}`);
-      }
-    }
-    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 {
-            for (const f of funcs) {
-              allFuncs.push(`${f.name}: ${f.description || "-"}`);
-            }
-          }
-        }
-      } catch (err) {
-        log(`listSymbols readDir error: ${err.message}`);
-      }
-    }
-    if (allFuncs.length === 0) {
-      return await listFunctionsInCad();
-    }
-    if (packageName) {
-      return { content: [{ type: "text", text: `${packageName} \u5305\u51FD\u6570 (${allFuncs.length}):
-${allFuncs.map((f) => f.name).join("\n")}` }] };
-    }
-    return { content: [{ type: "text", text: allFuncs.join("\n") }] };
-  } catch (e) {
-    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
-  }
-}
-var FUNCTIONS_DIR, FUNCTIONS_URL, CACHE_DIR, FUNCLIB_CACHE_FILE, FUNCLIB_CACHE_TTL;
-var init_function_handlers = __esm({
-  "src/handlers/function-handlers.js"() {
-    init_logger();
-    init_cad_handlers();
-    FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
-    FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
-    CACHE_DIR = path3.join(os2.homedir(), ".atlisp", "cache");
-    FUNCLIB_CACHE_FILE = path3.join(CACHE_DIR, "functions.json");
-    FUNCLIB_CACHE_TTL = 24 * 60 * 60 * 1e3;
-  }
-});
-
-// src/handlers/resource-handlers.js
-import fs3 from "fs";
-import path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function getCached(key) {
-  const entry = resourceCache.get(key);
-  if (entry && Date.now() - entry.timestamp < CACHE_TTL2) {
-    return entry.data;
-  }
-  resourceCache.delete(key);
-  return null;
-}
-function setCache(key, data) {
-  resourceCache.set(key, { data, timestamp: Date.now() });
-}
-function clearCache(uri) {
-  if (uri) {
-    for (const key of resourceCache.keys()) {
-      if (key.startsWith(uri.split("://")[1]?.split("/")[0] + ":")) {
-        resourceCache.delete(key);
-      }
-    }
-  } else {
-    resourceCache.clear();
-  }
-}
-function parseLispList(str) {
-  if (!str || typeof str !== "string") return null;
-  const trimmed = str.trim();
-  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return null;
-  const content = trimmed.slice(1, -1).trim();
-  if (!content) return [];
-  const result = [];
-  let depth = 0;
-  let current = "";
-  let inString = false;
-  let escaped = false;
-  for (let i = 0; i < content.length; i++) {
-    const ch = content[i];
-    if (escaped) {
-      current += ch;
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      current += ch;
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      current += ch;
-      inString = !inString;
-      continue;
-    }
-    if (inString) {
-      current += ch;
-      continue;
-    }
-    if (ch === "(" || ch === "[") {
-      current += ch;
-      depth++;
-    } else if (ch === ")" || ch === "]") {
-      current += ch;
-      depth--;
-    } else if (ch === " " && depth === 0) {
-      if (current.trim()) {
-        result.push(current.trim());
-        current = "";
-      }
-      continue;
-    }
-    current += ch;
-  }
-  if (current.trim()) result.push(current.trim());
-  return result.map((item) => {
-    const t = item.trim();
-    if (t === "nil") return null;
-    if (t === "t") return true;
-    if (t === "T") return true;
-    const num = Number(t);
-    if (!isNaN(num) && t !== "") return num;
-    if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
-    return t;
-  });
-}
-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 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++;
@@ -1131,6 +726,19 @@ function buildTextCode({ layer, bbox, offset, limit }) {
 (@t:run))
 `;
 }
+var RESOURCES = [
+  { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", 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: "\u56FE\u5143\u5217\u8868\uFF0C\u8FD4\u56DE\u603B\u6570\u548C\u524D3000\u4E2A\u56FE\u5143\uFF0C\u6587\u672C\u9644\u52A0 text \u5B57\u6BB5\uFF0C\u66F2\u7EBF\u9644\u52A0 points \u6570\u7EC4\uFF0CINSERT \u9644\u52A0 blockName\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100 \u8FC7\u6EE4", 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=5000&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://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: {} };
@@ -1157,7 +765,7 @@ async function readResource(uri) {
   const { base, params } = parseQuery(uri);
   switch (base) {
     case "atlisp://cad/info":
-      return await getCadInfo2();
+      return await getCadInfo();
     case "atlisp://dwg/layers":
       return await getLayers(params.name);
     case "atlisp://dwg/entities":
@@ -1182,7 +790,7 @@ async function readResource(uri) {
       throw new Error(`\u8D44\u6E90\u4E0D\u5B58\u5728: ${uri}`);
   }
 }
-async function getCadInfo2() {
+async function getCadInfo() {
   const cached = getCached("cad:info");
   if (cached) return cached;
   if (!cad.connected) {
@@ -1476,94 +1084,666 @@ async function getDwgList() {
       setCache(cacheKey, []);
       return [];
     }
-    let parsed = [];
-    try {
-      parsed = JSON.parse(result);
-    } catch (e) {
-      const listResult = parseLispList(result);
-      if (listResult) {
-        parsed = listResult;
+    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 = path3.join(STANDARDS_DIR, filename);
+  try {
+    const raw = fs2.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/session-manager.js
+var Session = class {
+  constructor(clientId) {
+    this.clientId = clientId;
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.createdAt = Date.now();
+    this.connected = false;
+  }
+};
+var SessionManager = class {
+  #sessions = /* @__PURE__ */ new Map();
+  createSession(clientId) {
+    let session = this.#sessions.get(clientId);
+    if (!session) {
+      session = new Session(clientId);
+      this.#sessions.set(clientId, session);
+    }
+    return session;
+  }
+  getSession(clientId) {
+    return this.#sessions.get(clientId) || null;
+  }
+  hasSession(clientId) {
+    return this.#sessions.has(clientId);
+  }
+  removeSession(clientId) {
+    return this.#sessions.delete(clientId);
+  }
+  subscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      session.subscriptions.add(uri);
+      return true;
+    }
+    return false;
+  }
+  unsubscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      return session.subscriptions.delete(uri);
+    }
+    return false;
+  }
+  getSubscriptions(clientId) {
+    const session = this.#sessions.get(clientId);
+    return session ? Array.from(session.subscriptions) : [];
+  }
+  isSubscribed(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    return session ? session.subscriptions.has(uri) : false;
+  }
+  getAllSubscribedUris() {
+    const all = /* @__PURE__ */ new Set();
+    for (const session of this.#sessions.values()) {
+      for (const uri of session.subscriptions) {
+        all.add(uri);
+      }
+    }
+    return all;
+  }
+  list() {
+    return Array.from(this.#sessions.entries()).map(([id, s]) => ({
+      clientId: id,
+      subscriptions: Array.from(s.subscriptions),
+      createdAt: s.createdAt,
+      connected: s.connected
+    }));
+  }
+  count() {
+    return this.#sessions.size;
+  }
+  clear() {
+    this.#sessions.clear();
+  }
+};
+
+// src/subscription-manager.js
+var sessionManager = new SessionManager();
+var _notifyFn = null;
+function setNotify(fn) {
+  _notifyFn = fn;
+}
+function subscribe(uri, sessionId) {
+  if (sessionId) {
+    return sessionManager.subscribe(sessionId, uri);
+  }
+  return true;
+}
+function unsubscribe(uri, sessionId) {
+  if (sessionId) {
+    return sessionManager.unsubscribe(sessionId, uri);
+  }
+  return true;
+}
+function list(sessionId) {
+  if (sessionId) {
+    return sessionManager.getSubscriptions(sessionId);
+  }
+  return Array.from(sessionManager.getAllSubscribedUris());
+}
+function isSubscribed(uri, sessionId) {
+  if (sessionId) {
+    return sessionManager.isSubscribed(sessionId, uri);
+  }
+  return sessionManager.getAllSubscribedUris().has(uri);
+}
+function notify(uri, data) {
+  if (_notifyFn) {
+    _notifyFn(uri, data);
+  }
+}
+
+// src/sse-session.js
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
+var DEFAULT_RETRY_INTERVAL = 3e4;
+var MAX_SENT_MESSAGES = 1e3;
+var SSE_EVENTS = {
+  MESSAGE: "message",
+  ENDPOINT: "endpoint",
+  PING: "ping",
+  ERROR: "error",
+  PROGRESS: "progress",
+  CAPABILITIES: "capabilities"
+};
+var SseSession = class {
+  #res;
+  #clientId;
+  #active = true;
+  #heartbeatTimer = null;
+  #lastEventId = 0;
+  #heartbeatInterval;
+  #retryInterval;
+  #sessionData = {};
+  #sentMessages = [];
+  #backpressureBuffer = [];
+  #drainHandler = null;
+  constructor(res, options = {}) {
+    this.#res = res;
+    this.#clientId = options.clientId || randomUUID2();
+    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() {
+    return this.#clientId;
+  }
+  get isActive() {
+    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;
+  }
+  getSessionData(key) {
+    return this.#sessionData[key];
+  }
+  get retryInterval() {
+    return this.#retryInterval;
+  }
+  setRetryInterval(ms) {
+    this.#retryInterval = ms;
+  }
+  _sendRetry() {
+    this._write(`retry: ${this.#retryInterval}
+
+`);
+  }
+  _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) {
+    const lines = [];
+    if (id !== null) {
+      lines.push(`id: ${id}`);
+    }
+    lines.push(`event: ${event}`);
+    if (data !== null && data !== void 0) {
+      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.#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) {
+    }
+  }
+  flushBackpressure() {
+    if (this.#backpressureBuffer.length > 0) {
+      this._drainBuffer();
+    }
+  }
+  sendEvent(event, data, id = null) {
+    this.#lastEventId++;
+    const eventId = id !== null ? id : this.#lastEventId;
+    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) {
+    return this.sendEvent(SSE_EVENTS.MESSAGE, data);
+  }
+  sendEndpoint(path9) {
+    return this.sendEvent(SSE_EVENTS.ENDPOINT, path9);
+  }
+  sendError(code, message, id = null) {
+    return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
+  }
+  sendPing() {
+    return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
+  }
+  sendProgress(current, total, message = "") {
+    return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
+  }
+  sendCapabilities(capabilities) {
+    return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
+  }
+  sendResponse(jsonrpcResponse, id = null) {
+    const eventId = id !== null ? id : this.#lastEventId;
+    return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
+  }
+  startHeartbeat(interval = null) {
+    this.stopHeartbeat();
+    const ms = interval || this.#heartbeatInterval;
+    this.#heartbeatTimer = setInterval(() => {
+      if (!this.#active) {
+        this.stopHeartbeat();
+        return;
+      }
+      if (!this.sendPing()) {
+        this.stopHeartbeat();
+        this.close();
+      }
+    }, ms);
+  }
+  stopHeartbeat() {
+    if (this.#heartbeatTimer) {
+      clearInterval(this.#heartbeatTimer);
+      this.#heartbeatTimer = null;
+    }
+  }
+  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) {
+    }
+  }
+};
+
+// src/sse-session-manager.js
+import fs3 from "fs";
+import path4 from "path";
+import os2 from "os";
+var SESSION_STORE_DIR = path4.join(os2.homedir(), ".atlisp", "sessions");
+var SESSION_STORE_TTL = 24 * 60 * 60 * 1e3;
+function getSessionStorePath(clientId) {
+  return path4.join(SESSION_STORE_DIR, `${clientId}.json`);
+}
+function persistSessionData(clientId, sessionData) {
+  try {
+    fs3.mkdirSync(SESSION_STORE_DIR, { recursive: true });
+    const store = {
+      clientId,
+      sessionData,
+      savedAt: Date.now()
+    };
+    fs3.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 (!fs3.existsSync(filePath)) return null;
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const store = JSON.parse(raw);
+    if (Date.now() - store.savedAt > SESSION_STORE_TTL) {
+      fs3.unlinkSync(filePath);
+      return null;
+    }
+    return store.sessionData || {};
+  } catch (e) {
+    return null;
+  }
+}
+var SseSessionManager = class {
+  #sessions = /* @__PURE__ */ new Map();
+  #eventHandlers = /* @__PURE__ */ new Map();
+  constructor() {
+    this.#sessions = /* @__PURE__ */ new Map();
+    this.#eventHandlers = /* @__PURE__ */ new Map();
+  }
+  add(clientId, session) {
+    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;
+    }
+    return false;
+  }
+  get(clientId) {
+    return this.#sessions.get(clientId) || null;
+  }
+  has(clientId) {
+    return this.#sessions.has(clientId);
+  }
+  list() {
+    return Array.from(this.#sessions.keys()).map((id) => ({
+      clientId: id,
+      isActive: this.#sessions.get(id)?.isActive ?? false
+    }));
+  }
+  listActive() {
+    return this.list().filter((s) => s.isActive);
+  }
+  count() {
+    return this.#sessions.size;
+  }
+  sendToClient(clientId, event, data, id = null) {
+    const session = this.#sessions.get(clientId);
+    if (!session || !session.isActive) {
+      return false;
+    }
+    return session.sendEvent(event, data, id);
+  }
+  sendMessageToClient(clientId, data) {
+    return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
+  }
+  sendErrorToClient(clientId, code, message, id = null) {
+    return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
+  }
+  sendProgressToClient(clientId, current, total, message = "") {
+    return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
+  }
+  broadcast(event, data) {
+    let successCount = 0;
+    for (const [clientId, session] of this.#sessions) {
+      if (session.isActive && session.sendEvent(event, data)) {
+        successCount++;
+      }
+    }
+    return successCount;
+  }
+  broadcastMessage(data) {
+    return this.broadcast(SSE_EVENTS.MESSAGE, data);
+  }
+  broadcastError(code, message) {
+    return this.broadcast(SSE_EVENTS.ERROR, { code, message });
+  }
+  on(event, handler) {
+    if (!this.#eventHandlers.has(event)) {
+      this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.#eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    const handlers = this.#eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  emit(event, data) {
+    const handlers = this.#eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch (e) {
+        }
       }
     }
-    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]) };
+  }
+  cleanupInactive() {
+    for (const [clientId, session] of this.#sessions) {
+      if (!session.isActive) {
+        session.close();
+        this.#sessions.delete(clientId);
       }
+    }
+  }
+  closeAll() {
+    for (const [clientId, session] of this.#sessions) {
+      persistSessionData(clientId, session.sessionData);
+      session.close();
+    }
+    this.#sessions.clear();
+  }
+};
+
+// src/routes.js
+import express from "express";
+import { randomUUID as randomUUID4 } from "crypto";
+import iconv from "iconv-lite";
+import rateLimit from "express-rate-limit";
+
+// src/mcp-server-state.js
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/session-transport.js
+import { randomUUID as randomUUID3 } from "crypto";
+var SESSION_TIMEOUT = 30 * 60 * 1e3;
+var SessionTransport = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId || randomUUID3();
+    this.onclose = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this._pendingRequest = null;
+    this._started = false;
+    this._closed = false;
+    this._cleanupTimer = null;
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("Transport already started");
+    }
+    this._started = true;
+  }
+  async send(message) {
+    if (this._closed) return;
+    if (this._pendingRequest) {
+      const { resolve, reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      resolve(message);
+    }
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pendingRequest) {
+      const { reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      reject(new Error("Transport closed"));
+    }
+    this._clearCleanupTimer();
+    this.onclose?.();
+  }
+  async handleRequest(message, timeoutMs = 6e4) {
+    if (this._closed) {
+      throw new Error("Transport closed");
+    }
+    if (!message || !message.method) {
+      throw new Error("Invalid message");
+    }
+    if (!message.id) {
+      this.onmessage?.(message);
       return null;
-    }).filter(Boolean);
-    setCache(cacheKey, dwgList);
-    return dwgList;
-  } catch (e) {
-    setCache(cacheKey, []);
-    return [];
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this._pendingRequest?.resolve === resolve) {
+          this._pendingRequest = null;
+          reject(new Error("Request timeout"));
+        }
+      }, timeoutMs);
+      this._pendingRequest = { resolve, reject, timeout };
+      this.onmessage?.(message);
+    });
   }
-}
-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;
+  resetCleanupTimer() {
+    this._clearCleanupTimer();
+    this._cleanupTimer = setTimeout(() => {
+      this.close();
+    }, SESSION_TIMEOUT);
   }
-}
-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" };
-}
-var __dirname2, STANDARDS_DIR, CACHE_TTL2, resourceCache, RESOURCES, standardsCache;
-var init_resource_handlers = __esm({
-  "src/handlers/resource-handlers.js"() {
-    init_cad();
-    init_constants();
-    init_logger();
-    init_config();
-    __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
-    STANDARDS_DIR = path4.join(__dirname2, "..", "standards");
-    CACHE_TTL2 = config_default.resourceCacheTtl;
-    resourceCache = /* @__PURE__ */ new Map();
-    RESOURCES = [
-      { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", 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: "\u56FE\u5143\u5217\u8868\uFF0C\u8FD4\u56DE\u603B\u6570\u548C\u524D3000\u4E2A\u56FE\u5143\uFF0C\u6587\u672C\u9644\u52A0 text \u5B57\u6BB5\uFF0C\u66F2\u7EBF\u9644\u52A0 points \u6570\u7EC4\uFF0CINSERT \u9644\u52A0 blockName\uFF0C\u652F\u6301 ?type=LINE&layer=0&bbox=0,0,100,100 \u8FC7\u6EE4", 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=5000&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://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 }
-    ];
-    standardsCache = /* @__PURE__ */ new Map();
+  _clearCleanupTimer() {
+    if (this._cleanupTimer) {
+      clearTimeout(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
   }
-});
+};
+
+// src/mcp-handlers.js
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
 // 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) {
@@ -1593,6 +1773,121 @@ function loadExternalPrompts() {
   externalPromptsAt = now;
   return externalPrompts;
 }
+var PROMPTS = [
+  {
+    name: "analyze-drawing",
+    description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
+    arguments: []
+  },
+  {
+    name: "batch-draw-lines",
+    description: "\u6279\u91CF\u7ED8\u5236\u7EBF\u6BB5",
+    arguments: [
+      { name: "count", description: "\u7EBF\u6BB5\u6570\u91CF", required: true },
+      { name: "length", description: "\u7EBF\u6BB5\u957F\u5EA6", required: false }
+    ]
+  },
+  {
+    name: "generate-dimension",
+    description: "\u751F\u6210\u5C3A\u5BF8\u6807\u6CE8",
+    arguments: [
+      { name: "style", description: "\u6807\u6CE8\u6837\u5F0F (horizontal/vertical/aligned)", required: false }
+    ]
+  },
+  {
+    name: "export-entities",
+    description: "\u5BFC\u51FA\u56FE\u7EB8\u5B9E\u4F53\u7EDF\u8BA1",
+    arguments: [
+      { name: "format", description: "\u5BFC\u51FA\u683C\u5F0F (json/list)", required: false }
+    ]
+  },
+  {
+    name: "manage-layers",
+    description: "\u56FE\u5C42\u7BA1\u7406\uFF1A\u521B\u5EFA\u3001\u51BB\u7ED3\u3001\u9501\u5B9A\u3001\u5220\u9664\u56FE\u5C42",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/freeze/lock/off/make/delete)", required: true },
+      { name: "layers", description: "\u56FE\u5C42\u540D\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694", required: false },
+      { name: "color", description: '\u56FE\u5C42\u989C\u8272 (ACI\u53F7\u6216RGB\u5982 "1,2,3")', required: false }
+    ]
+  },
+  {
+    name: "manage-blocks",
+    description: "\u5757\u64CD\u4F5C\uFF1A\u63D2\u5165\u5757\u3001\u5217\u51FA\u5757\u3001\u83B7\u53D6/\u8BBE\u7F6E\u5C5E\u6027",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/insert/attributes/dynprops)", required: true },
+      { name: "blockName", description: "\u5757\u540D", required: false },
+      { name: "insertPoint", description: '\u63D2\u5165\u70B9 "x,y"', required: false },
+      { name: "scale", description: "\u7F29\u653E\u6BD4\u4F8B", required: false }
+    ]
+  },
+  {
+    name: "curve-analysis",
+    description: "\u66F2\u7EBF\u5206\u6790\uFF1A\u4EA4\u70B9\u3001\u6700\u8FD1\u70B9\u3001\u5B50\u6BB5\u3001\u7F13\u51B2\u533A",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (inters/subsegments/closestpoint/join)", required: true },
+      { name: "distance", description: "\u8FDE\u63A5\u5BB9\u5DEE/\u504F\u79FB\u8DDD\u79BB", required: false }
+    ]
+  },
+  {
+    name: "geometry-calc",
+    description: "\u51E0\u4F55\u8BA1\u7B97\uFF1A\u51F8\u5305\u3001\u70B9\u5230\u7EBF\u8DDD\u79BB\u3001\u9762\u5185\u6D4B\u8BD5\u3001\u53D8\u6362",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (convexhull/dist-point-line/in-curve-p/transform/centroid)", required: true },
+      { name: "points", description: '\u70B9\u96C6 "x1,y1;x2,y2;..."', required: false }
+    ]
+  },
+  {
+    name: "text-process",
+    description: "\u6587\u672C\u5904\u7406\uFF1AMTEXT\u89E3\u6790\u3001Markdown\u8F6CMTEXT\u3001\u53BB\u683C\u5F0F",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (parse-mtext/remove-fmt/from-markdown/mtext2text)", required: true },
+      { name: "markdown", description: "Markdown\u6587\u672C\uFF08from-markdown\u64CD\u4F5C\u65F6\u7528\uFF09", required: false }
+    ]
+  },
+  {
+    name: "pickset-filter",
+    description: "\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A\u8FC7\u6EE4\u3001\u8F6C\u6362\u3001\u6279\u91CF\u64CD\u4F5C",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (by-layer/by-type/by-box/erase/zoom)", required: true },
+      { name: "dxfType", description: 'DXF\u7C7B\u578B "LINE, CIRCLE, LWPOLYLINE, INSERT, TEXT"', required: false },
+      { name: "layerName", description: "\u56FE\u5C42\u540D", required: false }
+    ]
+  },
+  {
+    name: "color-convert",
+    description: "\u989C\u8272\u8F6C\u6362\uFF1AACI/RGB/TrueColor/CSS\u4E92\u8F6C",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (aci2rgb/rgb2css/truecolor2rgb/rgb2truecolor)", required: true },
+      { name: "value", description: "\u989C\u8272\u503C", required: true }
+    ]
+  },
+  {
+    name: "json-exchange",
+    description: "JSON\u6570\u636E\u4EA4\u6362\uFF1A\u4ECE\u5B57\u7B26\u4E32\u89E3\u6790JSON alist\uFF0C\u4ECEalist\u751F\u6210JSON",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (encode/decode)", required: true },
+      { name: "data", description: "JSON\u5B57\u7B26\u4E32\u6216Lisp alist\u6587\u672C", required: true }
+    ]
+  },
+  {
+    name: "excel-report",
+    description: "Excel\u62A5\u8868\uFF1A\u5BFC\u51FACAD\u5B9E\u4F53\u6570\u636E\u5230Excel",
+    arguments: [
+      { name: "visible", description: "\u662F\u5426\u663E\u793AExcel\u7A97\u53E3 (true/false)", required: false },
+      { name: "savePath", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF0C\u4E0D\u586B\u5219\u4E0D\u4FDD\u5B58", required: false }
+    ]
+  },
+  {
+    name: "string-process",
+    description: "\u5B57\u7B26\u4E32\u5904\u7406\uFF1A\u683C\u5F0F\u5316\u3001\u62C6\u5206\u3001\u66FF\u6362\u3001\u6B63\u5219",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (format/split/subst-all/regexp/trim/number2chinese)", required: true },
+      { name: "input", description: "\u8F93\u5165\u5B57\u7B26\u4E32", required: true },
+      { name: "arg1", description: "\u53C2\u65701\uFF08\u683C\u5F0F\u53C2\u6570/\u5206\u9694\u7B26/\u65E7\u4E32\uFF09", required: false },
+      { name: "arg2", description: "\u53C2\u65702\uFF08\u65B0\u4E32/\u6B63\u5219\u6A21\u5F0F\uFF09", required: false }
+    ]
+  }
+];
 function findExternalPrompt(name) {
   const ext = loadExternalPrompts();
   return ext.find((p) => p.name === name);
@@ -2209,825 +2504,766 @@ ${code}
     }]
   };
 }
-var __dirname3, PROMPTS_DIR, externalPrompts, externalPromptsAt, EXTERNAL_PROMPTS_TTL, PROMPTS;
-var init_prompt_handlers = __esm({
-  "src/handlers/prompt-handlers.js"() {
-    init_cad();
-    __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
-    PROMPTS_DIR = path5.join(__dirname3, "..", "prompts");
-    externalPrompts = null;
-    externalPromptsAt = 0;
-    EXTERNAL_PROMPTS_TTL = 3e4;
-    PROMPTS = [
-      {
-        name: "analyze-drawing",
-        description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
-        arguments: []
-      },
-      {
-        name: "batch-draw-lines",
-        description: "\u6279\u91CF\u7ED8\u5236\u7EBF\u6BB5",
-        arguments: [
-          { name: "count", description: "\u7EBF\u6BB5\u6570\u91CF", required: true },
-          { name: "length", description: "\u7EBF\u6BB5\u957F\u5EA6", required: false }
-        ]
-      },
-      {
-        name: "generate-dimension",
-        description: "\u751F\u6210\u5C3A\u5BF8\u6807\u6CE8",
-        arguments: [
-          { name: "style", description: "\u6807\u6CE8\u6837\u5F0F (horizontal/vertical/aligned)", required: false }
-        ]
-      },
-      {
-        name: "export-entities",
-        description: "\u5BFC\u51FA\u56FE\u7EB8\u5B9E\u4F53\u7EDF\u8BA1",
-        arguments: [
-          { name: "format", description: "\u5BFC\u51FA\u683C\u5F0F (json/list)", required: false }
-        ]
-      },
-      {
-        name: "manage-layers",
-        description: "\u56FE\u5C42\u7BA1\u7406\uFF1A\u521B\u5EFA\u3001\u51BB\u7ED3\u3001\u9501\u5B9A\u3001\u5220\u9664\u56FE\u5C42",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/freeze/lock/off/make/delete)", required: true },
-          { name: "layers", description: "\u56FE\u5C42\u540D\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694", required: false },
-          { name: "color", description: '\u56FE\u5C42\u989C\u8272 (ACI\u53F7\u6216RGB\u5982 "1,2,3")', required: false }
-        ]
-      },
-      {
-        name: "manage-blocks",
-        description: "\u5757\u64CD\u4F5C\uFF1A\u63D2\u5165\u5757\u3001\u5217\u51FA\u5757\u3001\u83B7\u53D6/\u8BBE\u7F6E\u5C5E\u6027",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/insert/attributes/dynprops)", required: true },
-          { name: "blockName", description: "\u5757\u540D", required: false },
-          { name: "insertPoint", description: '\u63D2\u5165\u70B9 "x,y"', required: false },
-          { name: "scale", description: "\u7F29\u653E\u6BD4\u4F8B", required: false }
-        ]
-      },
-      {
-        name: "curve-analysis",
-        description: "\u66F2\u7EBF\u5206\u6790\uFF1A\u4EA4\u70B9\u3001\u6700\u8FD1\u70B9\u3001\u5B50\u6BB5\u3001\u7F13\u51B2\u533A",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (inters/subsegments/closestpoint/join)", required: true },
-          { name: "distance", description: "\u8FDE\u63A5\u5BB9\u5DEE/\u504F\u79FB\u8DDD\u79BB", required: false }
-        ]
-      },
-      {
-        name: "geometry-calc",
-        description: "\u51E0\u4F55\u8BA1\u7B97\uFF1A\u51F8\u5305\u3001\u70B9\u5230\u7EBF\u8DDD\u79BB\u3001\u9762\u5185\u6D4B\u8BD5\u3001\u53D8\u6362",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (convexhull/dist-point-line/in-curve-p/transform/centroid)", required: true },
-          { name: "points", description: '\u70B9\u96C6 "x1,y1;x2,y2;..."', required: false }
-        ]
-      },
-      {
-        name: "text-process",
-        description: "\u6587\u672C\u5904\u7406\uFF1AMTEXT\u89E3\u6790\u3001Markdown\u8F6CMTEXT\u3001\u53BB\u683C\u5F0F",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (parse-mtext/remove-fmt/from-markdown/mtext2text)", required: true },
-          { name: "markdown", description: "Markdown\u6587\u672C\uFF08from-markdown\u64CD\u4F5C\u65F6\u7528\uFF09", required: false }
-        ]
-      },
-      {
-        name: "pickset-filter",
-        description: "\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A\u8FC7\u6EE4\u3001\u8F6C\u6362\u3001\u6279\u91CF\u64CD\u4F5C",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (by-layer/by-type/by-box/erase/zoom)", required: true },
-          { name: "dxfType", description: 'DXF\u7C7B\u578B "LINE, CIRCLE, LWPOLYLINE, INSERT, TEXT"', required: false },
-          { name: "layerName", description: "\u56FE\u5C42\u540D", required: false }
-        ]
-      },
-      {
-        name: "color-convert",
-        description: "\u989C\u8272\u8F6C\u6362\uFF1AACI/RGB/TrueColor/CSS\u4E92\u8F6C",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (aci2rgb/rgb2css/truecolor2rgb/rgb2truecolor)", required: true },
-          { name: "value", description: "\u989C\u8272\u503C", required: true }
-        ]
-      },
-      {
-        name: "json-exchange",
-        description: "JSON\u6570\u636E\u4EA4\u6362\uFF1A\u4ECE\u5B57\u7B26\u4E32\u89E3\u6790JSON alist\uFF0C\u4ECEalist\u751F\u6210JSON",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (encode/decode)", required: true },
-          { name: "data", description: "JSON\u5B57\u7B26\u4E32\u6216Lisp alist\u6587\u672C", required: true }
-        ]
-      },
-      {
-        name: "excel-report",
-        description: "Excel\u62A5\u8868\uFF1A\u5BFC\u51FACAD\u5B9E\u4F53\u6570\u636E\u5230Excel",
-        arguments: [
-          { name: "visible", description: "\u662F\u5426\u663E\u793AExcel\u7A97\u53E3 (true/false)", required: false },
-          { name: "savePath", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF0C\u4E0D\u586B\u5219\u4E0D\u4FDD\u5B58", required: false }
-        ]
-      },
-      {
-        name: "string-process",
-        description: "\u5B57\u7B26\u4E32\u5904\u7406\uFF1A\u683C\u5F0F\u5316\u3001\u62C6\u5206\u3001\u66FF\u6362\u3001\u6B63\u5219",
-        arguments: [
-          { name: "action", description: "\u64CD\u4F5C (format/split/subst-all/regexp/trim/number2chinese)", required: true },
-          { name: "input", description: "\u8F93\u5165\u5B57\u7B26\u4E32", required: true },
-          { name: "arg1", description: "\u53C2\u65701\uFF08\u683C\u5F0F\u53C2\u6570/\u5206\u9694\u7B26/\u65E7\u4E32\uFF09", required: false },
-          { name: "arg2", description: "\u53C2\u65702\uFF08\u65B0\u4E32/\u6B63\u5219\u6A21\u5F0F\uFF09", required: false }
-        ]
-      }
-    ];
+
+// src/mcp-handlers.js
+var SERVER_CAPABILITIES = {
+  tools: {},
+  resources: { subscribe: true, listChanged: true },
+  prompts: {}
+};
+function createMcpServer(handlers = {}) {
+  const { tools: tools2 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: SERVER_CAPABILITIES }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools2 }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await handleToolCall2(name, args || {});
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+    const ctx = mcpContext.getStore();
+    const sessionId = ctx?.sessionId;
+    const subscribedUris = sessionId ? list(sessionId) : list();
+    return {
+      resources: await listResources(subscribedUris)
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    try {
+      const data = await readResource(uri);
+      return {
+        contents: [{
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(data)
+        }]
+      };
+    } catch (e) {
+      return {
+        contents: [],
+        isError: true,
+        error: { code: -32603, message: e.message }
+      };
+    }
+  });
+  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const ctx = mcpContext.getStore();
+    subscribe(uri, ctx?.sessionId);
+    return { success: true };
+  });
+  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const ctx = mcpContext.getStore();
+    unsubscribe(uri, ctx?.sessionId);
+    return { success: true };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: await listPrompts()
+  }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await getPrompt(name, args || {});
+  });
+  return server;
+}
+
+// src/handlers/cad-handlers.js
+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(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()}` }] };
+    }
+  } catch (e) {
+    log("connect_cad error: " + e.message);
+  }
+  return { content: [{ type: "text", text: "\u672A\u80FD\u8FDE\u63A5\u6216\u542F\u52A8 CAD\uFF0C\u8BF7\u786E\u4FDD CAD \u5DF2\u5B89\u88C5" }], isError: true };
+}
+async function evalLisp(code, withResult = false, encoding = null) {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  if (!cad.connected) {
+    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" }] };
+  try {
+    if (withResult) {
+      const result = await cad.sendCommandWithResult(trimmed, encoding);
+      if (result !== null) {
+        return { content: [{ type: "text", text: result }] };
+      }
+      return { content: [{ type: "text", text: "\u6267\u884C\u5931\u8D25\u6216\u65E0\u8FD4\u56DE\u503C" }], isError: true };
+    } else {
+      await cad.sendCommand(trimmed + "\n");
+      return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4` }] };
+    }
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+  }
+}
+async function getCadInfo2() {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  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 };
+  const trimmed = (command || "").trim();
+  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" }] };
+}
+async function newDocument() {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  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" }] };
+  }
+  return { content: [{ type: "text", text: "\u65B0\u5EFA\u6587\u6863\u5931\u8D25" }], isError: true };
+}
+async function bringToFront() {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  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" }] };
+  }
+  return { content: [{ type: "text", text: "\u5207\u6362\u524D\u53F0\u5931\u8D25" }], isError: true };
+}
+async function installAtlisp() {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  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" }] };
+}
+async function listFunctionsInCad() {
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  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 }] };
+    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 };
+  }
+}
+async function getSystemStatus() {
+  const status = {
+    mcp: { version: process.env.npm_package_version || "unknown" },
+    worker: { alive: false },
+    cad: { connected: false, platform: null, version: null, busy: false, hasDoc: false },
+    lisp: { available: false, testResult: null, error: null },
+    packages: null
+  };
+  try {
+    status.worker.alive = await cad.ping();
+  } catch {
+    status.worker.alive = false;
   }
-});
-
-// src/session-manager.js
-var Session, SessionManager;
-var init_session_manager = __esm({
-  "src/session-manager.js"() {
-    Session = class {
-      constructor(clientId) {
-        this.clientId = clientId;
-        this.subscriptions = /* @__PURE__ */ new Set();
-        this.createdAt = Date.now();
-        this.connected = false;
-      }
-    };
-    SessionManager = class {
-      #sessions = /* @__PURE__ */ new Map();
-      createSession(clientId) {
-        let session = this.#sessions.get(clientId);
-        if (!session) {
-          session = new Session(clientId);
-          this.#sessions.set(clientId, session);
-        }
-        return session;
-      }
-      getSession(clientId) {
-        return this.#sessions.get(clientId) || null;
-      }
-      hasSession(clientId) {
-        return this.#sessions.has(clientId);
-      }
-      removeSession(clientId) {
-        return this.#sessions.delete(clientId);
-      }
-      subscribe(clientId, uri) {
-        const session = this.#sessions.get(clientId);
-        if (session) {
-          session.subscriptions.add(uri);
-          return true;
-        }
-        return false;
-      }
-      unsubscribe(clientId, uri) {
-        const session = this.#sessions.get(clientId);
-        if (session) {
-          return session.subscriptions.delete(uri);
-        }
-        return false;
-      }
-      getSubscriptions(clientId) {
-        const session = this.#sessions.get(clientId);
-        return session ? Array.from(session.subscriptions) : [];
-      }
-      isSubscribed(clientId, uri) {
-        const session = this.#sessions.get(clientId);
-        return session ? session.subscriptions.has(uri) : false;
-      }
-      getAllSubscribedUris() {
-        const all = /* @__PURE__ */ new Set();
-        for (const session of this.#sessions.values()) {
-          for (const uri of session.subscriptions) {
-            all.add(uri);
-          }
-        }
-        return all;
-      }
-      list() {
-        return Array.from(this.#sessions.entries()).map(([id, s]) => ({
-          clientId: id,
-          subscriptions: Array.from(s.subscriptions),
-          createdAt: s.createdAt,
-          connected: s.connected
-        }));
-      }
-      count() {
-        return this.#sessions.size;
+  status.cad.connected = cad.connected;
+  if (cad.connected) {
+    status.cad.platform = cad.getPlatform();
+    status.cad.version = cad.getVersion();
+    try {
+      status.cad.busy = await cad.isBusy();
+    } catch {
+    }
+    try {
+      const doc = await cad.hasDoc();
+      status.cad.hasDoc = doc.hasDoc;
+    } catch {
+    }
+    try {
+      const r = await cad.sendCommandWithResult("(+ 1 2)");
+      if (r !== null && r !== void 0) {
+        status.lisp.available = true;
+        status.lisp.testResult = String(r).trim();
       }
-      clear() {
-        this.#sessions.clear();
+    } catch (e) {
+      status.lisp.error = e.message;
+    }
+    try {
+      const pkgResult = await cad.sendCommandWithResult("(@::package-list-in-local)");
+      if (pkgResult && pkgResult !== "nil") {
+        status.packages = pkgResult;
       }
-    };
+    } catch {
+    }
   }
-});
-
-// src/subscription-manager.js
-function setNotify(fn) {
-  _notifyFn = fn;
+  return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
 }
-function subscribe(uri, sessionId) {
-  if (sessionId) {
-    return sessionManager.subscribe(sessionId, uri);
+async function initAtlisp() {
+  if (!cad.connected) {
+    await cad.connect();
   }
-  return true;
-}
-function unsubscribe(uri, sessionId) {
-  if (sessionId) {
-    return sessionManager.unsubscribe(sessionId, uri);
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  const code = `(if (null @::load-module)
+	   (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/cloud"):vlax-true)
+		   (v o'send)
+		   (v o'WaitforResponse 1000)
+		   (e(r(vlax-get o'ResponseText)))))`;
+  try {
+    await cad.sendCommand(code + "\n");
+    return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001 @lisp \u51FD\u6570\u5E93\u52A0\u8F7D\u4EE3\u7801\u5230 CAD" }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
   }
-  return true;
 }
-function list(sessionId) {
-  if (sessionId) {
-    return sessionManager.getSubscriptions(sessionId);
+
+// src/handlers/package-handlers.js
+var PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || "http://s3.atlisp.cn/packages-list?fmt=json";
+var cachedPackages = null;
+var cachedAt = null;
+var CACHE_TTL2 = 10 * 60 * 1e3;
+async function fetchPackages() {
+  const now = Date.now();
+  if (cachedPackages && cachedAt && now - cachedAt < CACHE_TTL2) {
+    return cachedPackages;
   }
-  return Array.from(sessionManager.getAllSubscribedUris());
+  try {
+    const response = await fetch(PACKAGES_LIST_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+    if (response.ok) {
+      const data = await response.json();
+      cachedPackages = data;
+      cachedAt = now;
+      return data;
+    }
+  } catch (e) {
+  }
+  return cachedPackages || MOCK_PACKAGES;
 }
-function isSubscribed(uri, sessionId) {
-  if (sessionId) {
-    return sessionManager.isSubscribed(sessionId, uri);
+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) {
+    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 }] };
   }
-  return sessionManager.getAllSubscribedUris().has(uri);
+  const result = await cad.sendCommandWithResult("(@::package-list-in-local)");
+  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:
+${text}` }] };
 }
-function notify(uri, data) {
-  if (_notifyFn) {
-    _notifyFn(uri, data);
+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 = [];
+  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);
+    }
+  } else {
+    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` }] };
   }
+  return { content: [{ type: "text", text: `\u641C\u7D22\u7ED3\u679C (${results.length}):
+${results.map((p) => `${p.name} v${p.version || ""} - ${p.description || ""}`).join("\n")}` }] };
 }
-var sessionManager, _notifyFn;
-var init_subscription_manager = __esm({
-  "src/subscription-manager.js"() {
-    init_session_manager();
-    sessionManager = new SessionManager();
-    _notifyFn = null;
+async function installPackage(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 };
   }
-});
-
-// src/sse-session.js
-import { randomUUID as randomUUID2 } from "crypto";
-var DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_RETRY_INTERVAL, MAX_SENT_MESSAGES, SSE_EVENTS, SseSession;
-var init_sse_session = __esm({
-  "src/sse-session.js"() {
-    DEFAULT_HEARTBEAT_INTERVAL = 3e4;
-    DEFAULT_RETRY_INTERVAL = 3e4;
-    MAX_SENT_MESSAGES = 1e3;
-    SSE_EVENTS = {
-      MESSAGE: "message",
-      ENDPOINT: "endpoint",
-      PING: "ping",
-      ERROR: "error",
-      PROGRESS: "progress",
-      CAPABILITIES: "capabilities"
-    };
-    SseSession = class {
-      #res;
-      #clientId;
-      #active = true;
-      #heartbeatTimer = null;
-      #lastEventId = 0;
-      #heartbeatInterval;
-      #retryInterval;
-      #sessionData = {};
-      #sentMessages = [];
-      #backpressureBuffer = [];
-      #drainHandler = null;
-      constructor(res, options = {}) {
-        this.#res = res;
-        this.#clientId = options.clientId || randomUUID2();
-        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() {
-        return this.#clientId;
-      }
-      get isActive() {
-        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;
-      }
-      getSessionData(key) {
-        return this.#sessionData[key];
-      }
-      get retryInterval() {
-        return this.#retryInterval;
-      }
-      setRetryInterval(ms) {
-        this.#retryInterval = ms;
-      }
-      _sendRetry() {
-        this._write(`retry: ${this.#retryInterval}
-
+  if (cad.connected) {
+    await cad.sendCommand(`(@::load-module '${packageName})
 `);
-      }
-      _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) {
-        const lines = [];
-        if (id !== null) {
-          lines.push(`id: ${id}`);
-        }
-        lines.push(`event: ${event}`);
-        if (data !== null && data !== void 0) {
-          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.#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) {
-        }
-      }
-      flushBackpressure() {
-        if (this.#backpressureBuffer.length > 0) {
-          this._drainBuffer();
-        }
-      }
-      sendEvent(event, data, id = null) {
-        this.#lastEventId++;
-        const eventId = id !== null ? id : this.#lastEventId;
-        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) {
-        return this.sendEvent(SSE_EVENTS.MESSAGE, data);
-      }
-      sendEndpoint(path8) {
-        return this.sendEvent(SSE_EVENTS.ENDPOINT, path8);
-      }
-      sendError(code, message, id = null) {
-        return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
-      }
-      sendPing() {
-        return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
-      }
-      sendProgress(current, total, message = "") {
-        return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
-      }
-      sendCapabilities(capabilities) {
-        return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
-      }
-      sendResponse(jsonrpcResponse, id = null) {
-        const eventId = id !== null ? id : this.#lastEventId;
-        return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
-      }
-      startHeartbeat(interval = null) {
-        this.stopHeartbeat();
-        const ms = interval || this.#heartbeatInterval;
-        this.#heartbeatTimer = setInterval(() => {
-          if (!this.#active) {
-            this.stopHeartbeat();
-            return;
-          }
-          if (!this.sendPing()) {
-            this.stopHeartbeat();
-            this.close();
-          }
-        }, ms);
-      }
-      stopHeartbeat() {
-        if (this.#heartbeatTimer) {
-          clearInterval(this.#heartbeatTimer);
-          this.#heartbeatTimer = null;
-        }
-      }
-      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) {
-        }
-      }
-    };
   }
-});
+  return { content: [{ type: "text", text: `\u5305 "${packageName}" \u5B89\u88C5\u547D\u4EE4\u5DF2\u53D1\u9001\uFF01` }] };
+}
 
-// src/sse-session-manager.js
+// src/handlers/function-handlers.js
 import fs5 from "fs";
 import path6 from "path";
 import os3 from "os";
-function getSessionStorePath(clientId) {
-  return path6.join(SESSION_STORE_DIR, `${clientId}.json`);
+var FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
+var FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
+var CACHE_DIR = path6.join(os3.homedir(), ".atlisp", "cache");
+var FUNCLIB_CACHE_FILE = path6.join(CACHE_DIR, "functions.json");
+var FUNCLIB_CACHE_TTL = 24 * 60 * 60 * 1e3;
+function readCacheFromDisk() {
+  try {
+    const stat = fs5.statSync(FUNCLIB_CACHE_FILE);
+    if (Date.now() - stat.mtimeMs < FUNCLIB_CACHE_TTL) {
+      const raw = fs5.readFileSync(FUNCLIB_CACHE_FILE, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return null;
 }
-function persistSessionData(clientId, sessionData) {
+function writeCacheToDisk(data) {
   try {
-    fs5.mkdirSync(SESSION_STORE_DIR, { recursive: true });
-    const store = {
-      clientId,
-      sessionData,
-      savedAt: Date.now()
-    };
-    fs5.writeFileSync(getSessionStorePath(clientId), JSON.stringify(store), "utf-8");
+    fs5.mkdirSync(CACHE_DIR, { recursive: true });
+    fs5.writeFileSync(FUNCLIB_CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (e) {
-    console.error("Failed to persist session:", e.message);
+    log(`function-handlers writeCache error: ${e.message}`);
   }
 }
-function loadPersistedSessionData(clientId) {
+async function fetchFunctions() {
+  const diskCache = readCacheFromDisk();
+  if (diskCache) return diskCache;
   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;
+    const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+    if (response.ok) {
+      const data = await response.json();
+      writeCacheToDisk(data);
+      return data;
     }
-    return store.sessionData || {};
   } catch (e) {
-    return null;
+    log(`function-handlers fetch error: ${e.message}`);
   }
+  return diskCache;
 }
-var SESSION_STORE_DIR, SESSION_STORE_TTL, SseSessionManager;
-var init_sse_session_manager = __esm({
-  "src/sse-session-manager.js"() {
-    init_sse_session();
-    SESSION_STORE_DIR = path6.join(os3.homedir(), ".atlisp", "sessions");
-    SESSION_STORE_TTL = 24 * 60 * 60 * 1e3;
-    SseSessionManager = class {
-      #sessions = /* @__PURE__ */ new Map();
-      #eventHandlers = /* @__PURE__ */ new Map();
-      constructor() {
-        this.#sessions = /* @__PURE__ */ new Map();
-        this.#eventHandlers = /* @__PURE__ */ new Map();
-      }
-      add(clientId, session) {
-        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;
-        }
-        return false;
-      }
-      get(clientId) {
-        return this.#sessions.get(clientId) || null;
-      }
-      has(clientId) {
-        return this.#sessions.has(clientId);
-      }
-      list() {
-        return Array.from(this.#sessions.keys()).map((id) => ({
-          clientId: id,
-          isActive: this.#sessions.get(id)?.isActive ?? false
-        }));
-      }
-      listActive() {
-        return this.list().filter((s) => s.isActive);
-      }
-      count() {
-        return this.#sessions.size;
-      }
-      sendToClient(clientId, event, data, id = null) {
-        const session = this.#sessions.get(clientId);
-        if (!session || !session.isActive) {
-          return false;
-        }
-        return session.sendEvent(event, data, id);
-      }
-      sendMessageToClient(clientId, data) {
-        return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
-      }
-      sendErrorToClient(clientId, code, message, id = null) {
-        return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
-      }
-      sendProgressToClient(clientId, current, total, message = "") {
-        return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
-      }
-      broadcast(event, data) {
-        let successCount = 0;
-        for (const [clientId, session] of this.#sessions) {
-          if (session.isActive && session.sendEvent(event, data)) {
-            successCount++;
-          }
-        }
-        return successCount;
-      }
-      broadcastMessage(data) {
-        return this.broadcast(SSE_EVENTS.MESSAGE, data);
-      }
-      broadcastError(code, message) {
-        return this.broadcast(SSE_EVENTS.ERROR, { code, message });
-      }
-      on(event, handler) {
-        if (!this.#eventHandlers.has(event)) {
-          this.#eventHandlers.set(event, /* @__PURE__ */ new Set());
+async function getFunctionUsage(funcName, packageName) {
+  try {
+    let results = [];
+    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) {
+      try {
+        const files = fs5.readdirSync(FUNCTIONS_DIR).filter((f2) => f2.endsWith(".json"));
+        for (const file of files) {
+          const raw = fs5.readFileSync(path6.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);
         }
-        this.#eventHandlers.get(event).add(handler);
+      } catch {
       }
-      off(event, handler) {
-        const handlers = this.#eventHandlers.get(event);
-        if (handlers) {
-          handlers.delete(handler);
-        }
+    }
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: `\u672A\u627E\u5230\u51FD\u6570: ${funcName}` }], isError: true };
+    }
+    const f = results[0];
+    const text = `\u51FD\u6570: ${f.name}
+\u63CF\u8FF0: ${f.description || "-"}
+\u53C2\u6570: ${f.params?.join(", ") || "-"}
+\u8FD4\u56DE\u503C: ${f.return || "-"}
+\u793A\u4F8B: ${f.usage || "-"}`;
+    return { content: [{ type: "text", text }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+  }
+}
+async function listSymbols(packageName) {
+  try {
+    let allFuncs = [];
+    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 || "-"}`);
       }
-      emit(event, data) {
-        const handlers = this.#eventHandlers.get(event);
-        if (handlers) {
-          for (const handler of handlers) {
-            try {
-              handler(data);
-            } catch (e) {
+    }
+    if (allFuncs.length === 0 && FUNCTIONS_DIR) {
+      try {
+        const files = fs5.readdirSync(FUNCTIONS_DIR).filter((f) => f.endsWith(".json"));
+        for (const file of files) {
+          const raw = fs5.readFileSync(path6.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 {
+            for (const f of funcs) {
+              allFuncs.push(`${f.name}: ${f.description || "-"}`);
             }
           }
         }
+      } catch (err) {
+        log(`listSymbols readDir error: ${err.message}`);
       }
-      cleanupInactive() {
-        for (const [clientId, session] of this.#sessions) {
-          if (!session.isActive) {
-            session.close();
-            this.#sessions.delete(clientId);
-          }
-        }
-      }
-      closeAll() {
-        for (const [clientId, session] of this.#sessions) {
-          persistSessionData(clientId, session.sessionData);
-          session.close();
-        }
-        this.#sessions.clear();
-      }
-    };
+    }
+    if (allFuncs.length === 0) {
+      return await listFunctionsInCad();
+    }
+    if (packageName) {
+      return { content: [{ type: "text", text: `${packageName} \u5305\u51FD\u6570 (${allFuncs.length}):
+${allFuncs.map((f) => f.name).join("\n")}` }] };
+    }
+    return { content: [{ type: "text", text: allFuncs.join("\n") }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
   }
-});
+}
 
-// src/session-transport.js
-import { randomUUID as randomUUID3 } from "crypto";
-var SESSION_TIMEOUT, SessionTransport;
-var init_session_transport = __esm({
-  "src/session-transport.js"() {
-    SESSION_TIMEOUT = 30 * 60 * 1e3;
-    SessionTransport = class {
-      constructor(sessionId) {
-        this.sessionId = sessionId || randomUUID3();
-        this.onclose = null;
-        this.onerror = null;
-        this.onmessage = null;
-        this._pendingRequest = null;
-        this._started = false;
-        this._closed = false;
-        this._cleanupTimer = null;
-      }
-      async start() {
-        if (this._started) {
-          throw new Error("Transport already started");
-        }
-        this._started = true;
-      }
-      async send(message) {
-        if (this._closed) return;
-        if (this._pendingRequest) {
-          const { resolve, reject, timeout } = this._pendingRequest;
-          clearTimeout(timeout);
-          this._pendingRequest = null;
-          resolve(message);
-        }
-      }
-      async close() {
-        if (this._closed) return;
-        this._closed = true;
-        if (this._pendingRequest) {
-          const { reject, timeout } = this._pendingRequest;
-          clearTimeout(timeout);
-          this._pendingRequest = null;
-          reject(new Error("Transport closed"));
-        }
-        this._clearCleanupTimer();
-        this.onclose?.();
-      }
-      async handleRequest(message, timeoutMs = 6e4) {
-        if (this._closed) {
-          throw new Error("Transport closed");
-        }
-        if (!message || !message.method) {
-          throw new Error("Invalid message");
-        }
-        if (!message.id) {
-          this.onmessage?.(message);
-          return null;
-        }
-        return new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            if (this._pendingRequest?.resolve === resolve) {
-              this._pendingRequest = null;
-              reject(new Error("Request timeout"));
-            }
-          }, timeoutMs);
-          this._pendingRequest = { resolve, reject, timeout };
-          this.onmessage?.(message);
-        });
-      }
-      resetCleanupTimer() {
-        this._clearCleanupTimer();
-        this._cleanupTimer = setTimeout(() => {
-          this.close();
-        }, SESSION_TIMEOUT);
-      }
-      _clearCleanupTimer() {
-        if (this._cleanupTimer) {
-          clearTimeout(this._cleanupTimer);
-          this._cleanupTimer = null;
-        }
-      }
-    };
+// src/function-lib.js
+import path7 from "path";
+import fs6 from "fs";
+import os4 from "os";
+var CACHE_DIR2 = path7.join(os4.homedir(), ".atlisp", "cache");
+var FUNCLIB_CACHE_FILE2 = path7.join(CACHE_DIR2, "functions.json");
+var CACHE_TTL3 = config_default.functionLibCacheTtl || 5 * 60 * 1e3;
+var FUNCTION_LIB_URL = config_default.functionLibUrl || "http://s3.atlisp.cn/json/functions.json";
+var cachedFunctionLib = null;
+var cachedAt2 = null;
+async function readCacheFromDisk2() {
+  try {
+    const stat = fs6.statSync(FUNCLIB_CACHE_FILE2);
+    if (Date.now() - stat.mtimeMs < CACHE_TTL3) {
+      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) {
+    error(`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) {
+    error(`loadAtlibFunctionLib error: ${e.message}`);
+  }
+  return cachedFunctionLib;
+}
 
-// src/mcp-handlers.js
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  SubscribeRequestSchema,
-  UnsubscribeRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-function createMcpServer(handlers = {}) {
-  const { tools: tools2 = [], handleToolCall: handleToolCall2 = () => ({ content: [] }) } = handlers;
-  const server = new Server(
-    { name: SERVER_NAME, version: SERVER_VERSION },
-    { capabilities: SERVER_CAPABILITIES }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools2 }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return await handleToolCall2(name, args || {});
-  });
-  server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
-    const ctx = mcpContext.getStore();
-    const sessionId = ctx?.sessionId;
-    const subscribedUris = sessionId ? list(sessionId) : list();
-    return {
-      resources: await listResources(subscribedUris)
-    };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const { uri } = request.params;
-    try {
-      const data = await readResource(uri);
-      return {
-        contents: [{
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(data)
-        }]
-      };
-    } catch (e) {
-      return {
-        contents: [],
-        isError: true,
-        error: { code: -32603, message: e.message }
-      };
+// src/mcp-tools.js
+var toolInputSchema = {
+  connect_cad: { platform: "string?" },
+  eval_lisp: { code: "string" },
+  eval_lisp_with_result: { code: "string", encoding: "string?" },
+  get_cad_info: {},
+  list_packages: {},
+  search_packages: { query: "string" },
+  install_package: { packageName: "string" },
+  get_platform_info: {},
+  at_command: { command: "string" },
+  new_document: {},
+  bring_to_front: {},
+  install_atlisp: {},
+  init_atlisp: {},
+  get_function_usage: { name: "string", package: "string?" },
+  list_symbols: { package: "string?" },
+  get_system_status: {},
+  import_funlib: { format: "string?" },
+  list_prompts: {},
+  get_prompt: { name: "string", args: "object?" }
+};
+function validateToolArgs(name, args) {
+  const schema = toolInputSchema[name];
+  if (!schema) {
+    throw new Error(`Unknown tool: ${name}`);
+  }
+  for (const [key, type] of Object.entries(schema)) {
+    const isOptional = type.endsWith("?");
+    const baseType = type.replace("?", "");
+    if (!args[key]) {
+      if (isOptional) continue;
+      throw new Error(`Missing required argument: ${key}`);
+    }
+    const actualType = typeof args[key];
+    if (baseType === "string" && actualType !== "string") {
+      throw new Error(`Invalid type for argument ${key}: expected string, got ${actualType}`);
+    }
+    if (baseType === "object" && (actualType !== "object" || actualType === null)) {
+      throw new Error(`Invalid type for argument ${key}: expected object, got ${actualType}`);
+    }
+    if (baseType === "number" && actualType !== "number") {
+      throw new Error(`Invalid type for argument ${key}: expected number, got ${actualType}`);
     }
-  });
-  server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    const ctx = mcpContext.getStore();
-    subscribe(uri, ctx?.sessionId);
-    return { success: true };
-  });
-  server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-    const { uri } = request.params;
-    const ctx = mcpContext.getStore();
-    unsubscribe(uri, ctx?.sessionId);
-    return { success: true };
-  });
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: await listPrompts()
-  }));
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    return await getPrompt(name, args || {});
-  });
-  return server;
+  }
+  return true;
 }
-var SERVER_CAPABILITIES;
-var init_mcp_handlers = __esm({
-  "src/mcp-handlers.js"() {
-    init_resource_handlers();
-    init_prompt_handlers();
-    init_constants();
-    init_subscription_manager();
-    init_mcp_server_state();
-    SERVER_CAPABILITIES = {
-      tools: {},
-      resources: { subscribe: true, listChanged: true },
-      prompts: {}
-    };
+var TOOL_HANDLERS = {
+  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: () => getCadInfo2(),
+  list_packages: () => listPackages(),
+  search_packages: (a) => searchPackages(a.query),
+  install_package: (a) => installPackage(a.packageName),
+  get_platform_info: () => ({ content: [{ type: "text", text: `\u652F\u6301\u7684 CAD \u5E73\u53F0:
+${CAD_PLATFORMS.join("\n")}
+\u5F53\u524D\u8FDE\u63A5: ${cad.connected ? "\u5DF2\u8FDE\u63A5" : "\u672A\u8FDE\u63A5"}` }] }),
+  at_command: (a) => atCommand(a.command),
+  new_document: () => newDocument(),
+  bring_to_front: () => bringToFront(),
+  install_atlisp: () => installAtlisp(),
+  init_atlisp: () => initAtlisp(),
+  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 (a.format === "list") {
+      const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
+      return { content: [{ type: "text", text: items.join("\n") }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
   }
-});
+};
+var tools = [
+  {
+    name: "connect_cad",
+    description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
+    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",
+    description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\uFF08\u4E0D\u8FD4\u56DE\u7ED3\u679C\uFF09",
+    inputSchema: {
+      type: "object",
+      properties: { code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" } },
+      required: ["code"]
+    }
+  },
+  {
+    name: "eval_lisp_with_result",
+    description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\u5E76\u8FD4\u56DE\u7ED3\u679C",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" },
+        encoding: { type: "string", description: "\u7ED3\u679C\u7F16\u7801\uFF0C\u5982 utf-8, gbk, gb2312, gb18030\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4\u81EA\u52A8\u68C0\u6D4B\uFF09" }
+      },
+      required: ["code"]
+    }
+  },
+  {
+    name: "get_cad_info",
+    description: "\u83B7\u53D6\u5F53\u524D CAD \u4FE1\u606F",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "list_packages",
+    description: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 @lisp \u5305",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "search_packages",
+    description: "\u641C\u7D22 @lisp \u5305",
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD" } },
+      required: ["query"]
+    }
+  },
+  {
+    name: "install_package",
+    description: "\u5B89\u88C5 @lisp \u5305\u5230 CAD",
+    inputSchema: {
+      type: "object",
+      properties: { packageName: { type: "string", description: "\u5305\u540D\u79F0" } },
+      required: ["packageName"]
+    }
+  },
+  {
+    name: "get_platform_info",
+    description: "\u83B7\u53D6 CAD \u5E73\u53F0\u4FE1\u606F",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "at_command",
+    description: "\u6267\u884C @lisp \u547D\u4EE4",
+    inputSchema: {
+      type: "object",
+      properties: { command: { type: "string", description: "@lisp \u547D\u4EE4" } },
+      required: ["command"]
+    }
+  },
+  {
+    name: "new_document",
+    description: "\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "bring_to_front",
+    description: "\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0\uFF08\u4ECE\u540E\u53F0\u8FD0\u884C\u72B6\u6001\u5524\u9192\uFF09",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "install_atlisp",
+    description: "\u5728 CAD \u4E2D\u5B89\u88C5 @lisp",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "init_atlisp",
+    description: "\u521D\u59CB\u5316 CAD \u4E2D\u7684 @lisp \u73AF\u5883\uFF0C\u52A0\u8F7D\u51FD\u6570\u5E93\u548C\u521D\u59CB\u53D8\u91CF",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_function_usage",
+    description: "\u83B7\u53D6 @lisp \u51FD\u6570\u7528\u6CD5",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "\u51FD\u6570\u540D\uFF0C\u5982 string:length" },
+        package: { type: "string", description: "\u5305\u540D\uFF0C\u5982 string\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u81EA\u52A8\u641C\u7D22\uFF09" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "list_symbols",
+    description: "\u5217\u51FA @lisp \u6240\u6709\u7B26\u53F7\uFF0C\u7528\u4E8E\u68C0\u67E5\u51FD\u6570\u548C\u53D8\u91CF",
+    inputSchema: {
+      type: "object",
+      properties: {
+        package: { type: "string", description: "\u5305\u540D\uFF08\u53EF\u9009\uFF09" }
+      }
+    }
+  },
+  {
+    name: "import_funlib",
+    description: "\u4ECE\u7F51\u7EDC\u5BFC\u5165 @lisp \u51FD\u6570\u5E93\u6570\u636E\u5230 AI Agent",
+    inputSchema: {
+      type: "object",
+      properties: {
+        format: { type: "string", enum: ["json", "list"], description: "\u8FD4\u56DE\u683C\u5F0F\uFF1Ajson\uFF08\u5B8C\u6574JSON\uFF09\u6216 list\uFF08\u51FD\u6570\u540D:\u63CF\u8FF0 \u5217\u8868\uFF09\uFF0C\u9ED8\u8BA4 json" }
+      }
+    }
+  },
+  {
+    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"]
+    }
+  }
+];
+function notifyResourceChanges(toolName) {
+  const resourceMap = {
+    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"]
+  };
+  const uris = resourceMap[toolName];
+  if (uris) {
+    for (const uri of uris) {
+      clearCache(uri);
+      if (isSubscribed(uri)) {
+        notify(uri, null);
+      }
+    }
+  }
+}
+async function handleToolCall(name, args) {
+  const handler = TOOL_HANDLERS[name];
+  if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
+  try {
+    validateToolArgs(name, args || {});
+    const result = await handler(args || {});
+    notifyResourceChanges(name);
+    return result;
+  } catch (e) {
+    error(`Tool call error [${name}]: ${e.message}`, { tool: name, args });
+    return { content: [{ type: "text", text: `\u5DE5\u5177\u6267\u884C\u9519\u8BEF: ${e.message}` }], isError: true };
+  }
+}
 
 // src/mcp-server-state.js
-import { AsyncLocalStorage } from "async_hooks";
+var mcpContext = new AsyncLocalStorage();
+var sessionServers = /* @__PURE__ */ new Map();
+var sessionTransports = /* @__PURE__ */ new Map();
+var mcpHandlers = { tools, handleToolCall };
 async function getOrCreateSessionServer(sessionId) {
-  if (!mcpHandlers) {
-    const { tools: tools2, handleToolCall: handleToolCall2 } = await init_atlisp_mcp().then(() => atlisp_mcp_exports);
-    mcpHandlers = { tools: tools2, handleToolCall: handleToolCall2 };
-  }
   let entry = sessionServers.get(sessionId);
   if (!entry) {
     const server = createMcpServer(mcpHandlers);
@@ -3061,24 +3297,18 @@ function broadcastToAllSessions(uri) {
     });
   }
 }
-var mcpContext, sessionServers, sessionTransports, mcpHandlers;
-var init_mcp_server_state = __esm({
-  "src/mcp-server-state.js"() {
-    init_session_transport();
-    init_mcp_handlers();
-    init_logger();
-    mcpContext = new AsyncLocalStorage();
-    sessionServers = /* @__PURE__ */ new Map();
-    sessionTransports = /* @__PURE__ */ new Map();
-    mcpHandlers = null;
-  }
-});
 
 // src/routes.js
-import express from "express";
-import { randomUUID as randomUUID4 } from "crypto";
-import iconv from "iconv-lite";
-import rateLimit from "express-rate-limit";
+var sseSessionManager = new SseSessionManager();
+var { apiKey, enableCors, corsOrigin, rateLimitWindow, rateLimitMax } = config_default;
+var mcpLimiter = rateLimit({
+  windowMs: rateLimitWindow,
+  max: rateLimitMax,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { error: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" }
+});
+var JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
 function createJsonBodyParser() {
   return async (req, res, next) => {
     const ct = (req.headers["content-type"] || "").toLowerCase();
@@ -3246,132 +3476,55 @@ async function handleMessage(req, res) {
     res.status(400).json({ error: "Invalid request" });
   }
 }
-var sseSessionManager, apiKey, enableCors, corsOrigin, rateLimitWindow, rateLimitMax, mcpLimiter, JSON_CONTENT_TYPES;
-var init_routes = __esm({
-  "src/routes.js"() {
-    init_config();
-    init_logger();
-    init_cad();
-    init_subscription_manager();
-    init_sse_session_manager();
-    init_mcp_server_state();
-    init_sse_session();
-    sseSessionManager = new SseSessionManager();
-    ({ apiKey, enableCors, corsOrigin, rateLimitWindow, rateLimitMax } = config_default);
-    mcpLimiter = rateLimit({
-      windowMs: rateLimitWindow,
-      max: rateLimitMax,
-      standardHeaders: true,
-      legacyHeaders: false,
-      message: { error: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5" }
-    });
-    JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
-  }
-});
 
 // src/atlisp-mcp.js
-var atlisp_mcp_exports = {};
-__export(atlisp_mcp_exports, {
-  CAD_PLATFORMS: () => CAD_PLATFORMS,
-  FILE_EXTENSIONS: () => FILE_EXTENSIONS,
-  handleToolCall: () => handleToolCall,
-  loadAtlibFunctionLib: () => loadAtlibFunctionLib,
-  startServer: () => startServer,
-  tools: () => tools
-});
-import path7 from "path";
-import fs6 from "fs";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { createRequire } from "module";
-import os4 from "os";
-import express2 from "express";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-async function readCacheFromDisk2() {
-  try {
-    const stat = fs6.statSync(FUNCLIB_CACHE_FILE2);
-    if (Date.now() - stat.mtimeMs < CACHE_TTL3) {
-      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) {
-    error(`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) {
-    error(`loadAtlibFunctionLib error: ${e.message}`);
-  }
-  return cachedFunctionLib;
-}
-function validateToolArgs(name, args) {
-  const schema = toolInputSchema[name];
-  if (!schema) return true;
-  for (const [key, type] of Object.entries(schema)) {
-    if (type.endsWith("?")) continue;
-    if (!args[key]) {
-      throw new Error(`Missing required argument: ${key}`);
-    }
-  }
-  return true;
-}
-async function handleToolCall(name, args) {
-  const handler = TOOL_HANDLERS[name];
-  if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
-  try {
-    validateToolArgs(name, args || {});
-    const result = await handler(args || {});
-    notifyResourceChanges(name);
-    return result;
-  } catch (e) {
-    error(`Tool call error [${name}]: ${e.message}`, { tool: name, args });
-    return { content: [{ type: "text", text: `\u5DE5\u5177\u6267\u884C\u9519\u8BEF: ${e.message}` }], isError: true };
-  }
-}
-function notifyResourceChanges(toolName) {
-  const resourceMap = {
-    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"]
-  };
-  const uris = resourceMap[toolName];
-  if (uris) {
-    for (const uri of uris) {
-      clearCache(uri);
-      if (isSubscribed(uri)) {
-        notify(uri, null);
-      }
+var __dirname4 = path8.dirname(fileURLToPath4(import.meta.url));
+var require2 = createRequire(import.meta.url);
+var { version } = require2(path8.join(__dirname4, "..", "package.json"));
+var sseSessionManager2 = new SseSessionManager();
+var isMcpScript = process.argv[1]?.includes("atlisp-mcp");
+if (isMcpScript) {
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--version" || args[i] === "-v") {
+      console.log(`atlisp-mcp v${version}`);
+      process.exit(0);
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      console.log(`
+@lisp MCP Server v${version}
+
+Usage: atlisp-mcp [options]
+
+Options:
+  -v, --version         Show version number
+  --transport <type>   Transport type: http or stdio (default: http)
+  --port <port>        HTTP port (default: 8110)
+  --host <host>        HTTP host (default: 0.0.0.0)
+  --stdio              Shorthand for --transport stdio
+  -h, --help           Show this help message
+
+Examples:
+  atlisp-mcp                       # Start HTTP server on port 8110
+  atlisp-mcp --port 3000           # Start HTTP server on port 3000
+  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
+  atlisp-mcp --transport stdio     # Same as --stdio
+`);
+      process.exit(0);
+    } else if (args[i] === "--transport" && args[i + 1]) {
+      process.env.TRANSPORT = args[i + 1];
+      i++;
+    } else if (args[i] === "--stdio") {
+      process.env.TRANSPORT = "stdio";
+    } else if (args[i] === "--port" && args[i + 1]) {
+      process.env.PORT = args[i + 1];
+      i++;
+    } else if (args[i] === "--host" && args[i + 1]) {
+      process.env.HOST = args[i + 1];
+      i++;
     }
   }
 }
+if (config_default.apiKey) log("API Key authentication enabled");
 async function initCadConnection() {
   log("Attempting to connect to CAD on startup...");
   try {
@@ -3432,282 +3585,9 @@ async function startServer() {
     process.on("SIGTERM", () => shutdown("SIGTERM"));
   }
 }
-var __dirname4, require2, version, sseSessionManager2, isMcpScript, CACHE_DIR2, FUNCLIB_CACHE_FILE2, CACHE_TTL3, FUNCTION_LIB_URL, cachedFunctionLib, cachedAt2, toolInputSchema, TOOL_HANDLERS, tools;
-var init_atlisp_mcp = __esm({
-  async "src/atlisp-mcp.js"() {
-    init_cad();
-    init_constants();
-    init_logger();
-    init_cad_handlers();
-    init_package_handlers();
-    init_function_handlers();
-    init_resource_handlers();
-    init_prompt_handlers();
-    init_subscription_manager();
-    init_subscription_manager();
-    init_sse_session_manager();
-    init_sse_session();
-    init_config();
-    init_routes();
-    init_mcp_server_state();
-    init_constants();
-    __dirname4 = path7.dirname(fileURLToPath4(import.meta.url));
-    require2 = createRequire(import.meta.url);
-    ({ version } = require2(path7.join(__dirname4, "..", "package.json")));
-    sseSessionManager2 = new SseSessionManager();
-    isMcpScript = process.argv[1]?.includes("atlisp-mcp");
-    if (isMcpScript) {
-      const args = process.argv.slice(2);
-      for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--version" || args[i] === "-v") {
-          console.log(`atlisp-mcp v${version}`);
-          process.exit(0);
-        } else if (args[i] === "--help" || args[i] === "-h") {
-          console.log(`
-@lisp MCP Server v${version}
-
-Usage: atlisp-mcp [options]
-
-Options:
-  -v, --version         Show version number
-  --transport <type>   Transport type: http or stdio (default: http)
-  --port <port>        HTTP port (default: 8110)
-  --host <host>        HTTP host (default: 0.0.0.0)
-  --stdio              Shorthand for --transport stdio
-  -h, --help           Show this help message
-
-Examples:
-  atlisp-mcp                       # Start HTTP server on port 8110
-  atlisp-mcp --port 3000           # Start HTTP server on port 3000
-  atlisp-mcp --stdio               # Start in stdio mode for MCP clients
-  atlisp-mcp --transport stdio     # Same as --stdio
-`);
-          process.exit(0);
-        } else if (args[i] === "--transport" && args[i + 1]) {
-          process.env.TRANSPORT = args[i + 1];
-          i++;
-        } else if (args[i] === "--stdio") {
-          process.env.TRANSPORT = "stdio";
-        } else if (args[i] === "--port" && args[i + 1]) {
-          process.env.PORT = args[i + 1];
-          i++;
-        } else if (args[i] === "--host" && args[i + 1]) {
-          process.env.HOST = args[i + 1];
-          i++;
-        }
-      }
-    }
-    if (config_default.apiKey) log("API Key authentication enabled");
-    CACHE_DIR2 = path7.join(os4.homedir(), ".atlisp", "cache");
-    FUNCLIB_CACHE_FILE2 = path7.join(CACHE_DIR2, "functions.json");
-    CACHE_TTL3 = config_default.functionLibCacheTtl || 5 * 60 * 1e3;
-    FUNCTION_LIB_URL = config_default.functionLibUrl || "http://s3.atlisp.cn/json/functions.json";
-    cachedFunctionLib = null;
-    cachedAt2 = null;
-    toolInputSchema = {
-      connect_cad: { platform: "string?" },
-      eval_lisp: { code: "string" },
-      eval_lisp_with_result: { code: "string", encoding: "string?" },
-      search_packages: { query: "string" },
-      install_package: { packageName: "string" },
-      at_command: { command: "string" },
-      get_function_usage: { name: "string", package: "string?" },
-      list_symbols: { package: "string?" },
-      import_funlib: { format: "string?" },
-      get_prompt: { name: "string", args: "object?" }
-    };
-    TOOL_HANDLERS = {
-      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(),
-      list_packages: () => listPackages(),
-      search_packages: (a) => searchPackages(a.query),
-      install_package: (a) => installPackage(a.packageName),
-      get_platform_info: () => ({ content: [{ type: "text", text: `\u652F\u6301\u7684 CAD \u5E73\u53F0:
-${CAD_PLATFORMS.join("\n")}
-\u5F53\u524D\u8FDE\u63A5: ${cad.connected ? "\u5DF2\u8FDE\u63A5" : "\u672A\u8FDE\u63A5"}` }] }),
-      at_command: (a) => atCommand(a.command),
-      new_document: () => newDocument(),
-      bring_to_front: () => bringToFront(),
-      install_atlisp: () => installAtlisp(),
-      init_atlisp: () => initAtlisp(),
-      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 (a.format === "list") {
-          const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
-          return { content: [{ type: "text", text: items.join("\n") }] };
-        }
-        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-      }
-    };
-    tools = [
-      {
-        name: "connect_cad",
-        description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
-        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",
-        description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\uFF08\u4E0D\u8FD4\u56DE\u7ED3\u679C\uFF09",
-        inputSchema: {
-          type: "object",
-          properties: { code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" } },
-          required: ["code"]
-        }
-      },
-      {
-        name: "eval_lisp_with_result",
-        description: "\u5728 CAD \u4E2D\u6267\u884C AutoLISP \u4EE3\u7801\u5E76\u8FD4\u56DE\u7ED3\u679C",
-        inputSchema: {
-          type: "object",
-          properties: {
-            code: { type: "string", description: "\u8981\u6267\u884C\u7684 LISP \u4EE3\u7801" },
-            encoding: { type: "string", description: "\u7ED3\u679C\u7F16\u7801\uFF0C\u5982 utf-8, gbk, gb2312, gb18030\uFF08\u53EF\u9009\uFF0C\u9ED8\u8BA4\u81EA\u52A8\u68C0\u6D4B\uFF09" }
-          },
-          required: ["code"]
-        }
-      },
-      {
-        name: "get_cad_info",
-        description: "\u83B7\u53D6\u5F53\u524D CAD \u4FE1\u606F",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "list_packages",
-        description: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 @lisp \u5305",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "search_packages",
-        description: "\u641C\u7D22 @lisp \u5305",
-        inputSchema: {
-          type: "object",
-          properties: { query: { type: "string", description: "\u641C\u7D22\u5173\u952E\u8BCD" } },
-          required: ["query"]
-        }
-      },
-      {
-        name: "install_package",
-        description: "\u5B89\u88C5 @lisp \u5305\u5230 CAD",
-        inputSchema: {
-          type: "object",
-          properties: { packageName: { type: "string", description: "\u5305\u540D\u79F0" } },
-          required: ["packageName"]
-        }
-      },
-      {
-        name: "get_platform_info",
-        description: "\u83B7\u53D6 CAD \u5E73\u53F0\u4FE1\u606F",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "at_command",
-        description: "\u6267\u884C @lisp \u547D\u4EE4",
-        inputSchema: {
-          type: "object",
-          properties: { command: { type: "string", description: "@lisp \u547D\u4EE4" } },
-          required: ["command"]
-        }
-      },
-      {
-        name: "new_document",
-        description: "\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "bring_to_front",
-        description: "\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0\uFF08\u4ECE\u540E\u53F0\u8FD0\u884C\u72B6\u6001\u5524\u9192\uFF09",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "install_atlisp",
-        description: "\u5728 CAD \u4E2D\u5B89\u88C5 @lisp",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "init_atlisp",
-        description: "\u521D\u59CB\u5316 CAD \u4E2D\u7684 @lisp \u73AF\u5883\uFF0C\u52A0\u8F7D\u51FD\u6570\u5E93\u548C\u521D\u59CB\u53D8\u91CF",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "get_function_usage",
-        description: "\u83B7\u53D6 @lisp \u51FD\u6570\u7528\u6CD5",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: { type: "string", description: "\u51FD\u6570\u540D\uFF0C\u5982 string:length" },
-            package: { type: "string", description: "\u5305\u540D\uFF0C\u5982 string\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u81EA\u52A8\u641C\u7D22\uFF09" }
-          },
-          required: ["name"]
-        }
-      },
-      {
-        name: "list_symbols",
-        description: "\u5217\u51FA @lisp \u6240\u6709\u7B26\u53F7\uFF0C\u7528\u4E8E\u68C0\u67E5\u51FD\u6570\u548C\u53D8\u91CF",
-        inputSchema: {
-          type: "object",
-          properties: {
-            package: { type: "string", description: "\u5305\u540D\uFF08\u53EF\u9009\uFF09" }
-          }
-        }
-      },
-      {
-        name: "import_funlib",
-        description: "\u4ECE\u7F51\u7EDC\u5BFC\u5165 @lisp \u51FD\u6570\u5E93\u6570\u636E\u5230 AI Agent",
-        inputSchema: {
-          type: "object",
-          properties: {
-            format: { type: "string", enum: ["json", "list"], description: "\u8FD4\u56DE\u683C\u5F0F\uFF1Ajson\uFF08\u5B8C\u6574JSON\uFF09\u6216 list\uFF08\u51FD\u6570\u540D:\u63CF\u8FF0 \u5217\u8868\uFF09\uFF0C\u9ED8\u8BA4 json" }
-          }
-        }
-      },
-      {
-        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"]
-        }
-      }
-    ];
-    if (!process.env.VITEST) {
-      await startServer();
-    }
-  }
-});
-await init_atlisp_mcp();
+if (!process.env.VITEST) {
+  await startServer();
+}
 export {
   CAD_PLATFORMS,
   FILE_EXTENSIONS,