@atlisp/mcp 1.3.0 → 1.3.1

package/dist/atlisp-mcp.js

@@ -0,0 +1,2314 @@
+#!/usr/bin/env node
+
+// src/atlisp-mcp.js
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createRequire } from "module";
+import express from "express";
+import rawBody from "raw-body";
+import iconv from "iconv-lite";
+import rateLimit from "express-rate-limit";
+import { randomUUID as randomUUID4 } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/session-transport.js
+import { randomUUID } from "crypto";
+var SESSION_TIMEOUT = 30 * 60 * 1e3;
+var SessionTransport = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId || randomUUID();
+    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/atlisp-mcp.js
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/cad.js
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/constants.js
+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.1.2";
+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
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { transport: "http", port: "8110", host: "0.0.0.0" };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--transport" && args[i + 1]) {
+      result.transport = args[i + 1];
+      i++;
+    } else if (args[i] === "--stdio") {
+      result.transport = "stdio";
+    } else if (args[i] === "--port" && args[i + 1]) {
+      result.port = args[i + 1];
+      i++;
+    } else if (args[i] === "--host" && args[i + 1]) {
+      result.host = args[i + 1];
+      i++;
+    }
+  }
+  return result;
+}
+var cliArgs = parseArgs();
+var config = {
+  port: parseInt(process.env.PORT || cliArgs.port, 10),
+  host: process.env.HOST || cliArgs.host,
+  transport: process.env.TRANSPORT || cliArgs.transport,
+  apiKey: process.env.MCP_API_KEY || "",
+  enableSse: process.env.ENABLE_SSE !== "false",
+  messageTimeout: parseInt(process.env.MESSAGE_TIMEOUT || "60000", 10),
+  heartbeatInterval: parseInt(process.env.HEARTBEAT_INTERVAL || "30000", 10),
+  busyRetries: parseInt(process.env.BUSY_RETRIES || "10", 10),
+  busyDelay: parseInt(process.env.BUSY_DELAY || "500", 10),
+  enableCors: process.env.ENABLE_CORS !== "false",
+  corsOrigin: process.env.CORS_ORIGIN || "*",
+  rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW || "60000", 10),
+  rateLimitMax: parseInt(process.env.RATE_LIMIT_MAX || "100", 10),
+  resourceCacheTtl: parseInt(process.env.RESOURCE_CACHE_TTL || "5000", 10),
+  debug: process.env.DEBUG === "true",
+  debugFile: process.env.DEBUG_FILE || ""
+};
+var config_default = config;
+
+// src/cad.js
+var MESSAGE_TIMEOUT = config_default.messageTimeout;
+var HEARTBEAT_INTERVAL = config_default.heartbeatInterval;
+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;
+function resetWorker() {
+  for (const [id, { reject, timeout }] of pendingRequests) {
+    clearTimeout(timeout);
+    reject(new Error("Worker reset"));
+  }
+  pendingRequests.clear();
+  stdoutHandlerSetup = false;
+  if (worker) {
+    worker.kill();
+    worker = null;
+  }
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+function setupStdoutHandler(w) {
+  let buffer = "";
+  stdoutHandlerSetup = true;
+  w.stdout.on("data", (data) => {
+    try {
+      buffer += data.toString();
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        buffer = buffer.slice(-MAX_BUFFER_SIZE);
+      }
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const result = JSON.parse(line);
+          const rid = result.requestId;
+          if (rid && pendingRequests.has(rid)) {
+            const { resolve, reject, timeout } = pendingRequests.get(rid);
+            clearTimeout(timeout);
+            pendingRequests.delete(rid);
+            if (result.error) {
+              reject(new Error(result.error));
+            } else {
+              resolve(result);
+            }
+          }
+        } catch (parseErr) {
+          console.error("JSON parse error in worker output:", parseErr.message);
+        }
+      }
+    } catch (e) {
+      console.error("Unexpected error in worker stdout handler:", e.message);
+    }
+  });
+}
+function getWorker() {
+  if (!worker || !worker.connected) {
+    if (worker) worker.kill();
+    worker = spawn("node", [workerPath], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    worker.connected = true;
+    worker.stderr.on("data", (d) => console.error("worker stderr:", d.toString()));
+    const w = worker;
+    w.on("exit", (code) => {
+      console.error("worker exited:", code);
+      if (w !== worker) return;
+      w.connected = false;
+      for (const [id, { reject, timeout }] of pendingRequests) {
+        clearTimeout(timeout);
+        reject(new Error(`Worker exited with code ${code}`));
+      }
+      pendingRequests.clear();
+      stdoutHandlerSetup = false;
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+    });
+    setupStdoutHandler(w);
+    startHeartbeat();
+  }
+  return worker;
+}
+function startHeartbeat() {
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  heartbeatTimer = setInterval(async () => {
+    try {
+      const result = await sendMessage({ type: "ping" });
+      if (!result?.pong) {
+        console.error("heartbeat failed, worker may be dead");
+        resetWorker();
+      }
+    } catch (e) {
+      console.error("heartbeat error:", e.message);
+      resetWorker();
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+function sendMessage(msg) {
+  const w = getWorker();
+  const requestId = randomUUID2();
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        pendingRequests.delete(requestId);
+        reject(new Error("Timeout waiting for worker"));
+      }
+    }, MESSAGE_TIMEOUT);
+    pendingRequests.set(requestId, { resolve, reject, timeout });
+    try {
+      w.stdin.write(JSON.stringify({ ...msg, requestId }) + "\n");
+    } catch (e) {
+      clearTimeout(timeout);
+      pendingRequests.delete(requestId);
+      reject(new Error(`Failed to write to worker: ${e.message}`));
+    }
+  });
+}
+var CadConnection = class {
+  constructor() {
+    this.connected = false;
+    this.version = null;
+    this.product = null;
+  }
+  isAvailable() {
+    return process.platform === "win32";
+  }
+  async connect() {
+    if (!this.isAvailable()) return false;
+    try {
+      const result = await sendMessage({ type: "connect" });
+      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 cad = new CadConnection();
+
+// src/logger.js
+import fs from "fs";
+import path2 from "path";
+import os from "os";
+var DEBUG_FILE = process.env.DEBUG_FILE || path2.join(os.tmpdir(), "mcp-server-debug.log");
+var stream = null;
+function getStream() {
+  if (!stream) {
+    stream = fs.createWriteStream(DEBUG_FILE, { flags: "a" });
+  }
+  return stream;
+}
+function log(msg) {
+  const entry = `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`;
+  getStream().write(entry);
+}
+function closeLog() {
+  if (stream) {
+    stream.end();
+    stream = null;
+  }
+}
+
+// src/handlers/cad-handlers.js
+async function connectCad() {
+  log("connect_cad called, cad.connected before: " + cad.connected);
+  try {
+    log("calling cad.connect()...");
+    const connected = await cad.connect();
+    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 };
+  }
+  try {
+    if (withResult) {
+      const result = await cad.sendCommandWithResult(code, 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("\x1B\x1B" + code + "\n");
+      return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4: ${code}` }] };
+    }
+  } catch (e) {
+    return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
+  }
+}
+async function getCadInfo() {
+  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 };
+  await cad.sendCommand("\x1B\x1B" + command + "\n");
+  return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4: ${command}` }] };
+}
+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("\x1B\x1B" + 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 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("\x1B\x1B" + 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 };
+  }
+}
+
+// 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_TTL = 10 * 60 * 1e3;
+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 null;
+}
+async function listPackages() {
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  const result = await cad.sendCommandWithResult("(@::package-list-in-local)");
+  if (result && result !== "nil") return { content: [{ type: "text", text: result }] };
+  const packages = MOCK_PACKAGES.map((p) => `${p.name} v${p.version} - ${p.description}`);
+  return { content: [{ type: "text", text: `\u5DF2\u5B89\u88C5\u7684 @lisp \u5305:
+${packages.join("\n")}` }] };
+}
+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 results = [];
+  const items = Array.isArray(data) ? data : data.packages || [];
+  if (query) {
+    const q = query.toLowerCase();
+    for (const p of items) {
+      const name = (p.name || "").toLowerCase();
+      const desc = (p.description || "").toLowerCase();
+      if (name.includes(q) || desc.includes(q)) results.push(p);
+    }
+  } 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 pkg = MOCK_PACKAGES.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` }] };
+}
+
+// src/handlers/function-handlers.js
+import fs2 from "fs/promises";
+import path3 from "path";
+var FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || "";
+var FUNCTIONS_URL = process.env.FUNCTIONS_URL || "http://s3.atlisp.cn/json/functions.json";
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getFunctionUsage(funcName, packageName) {
+  try {
+    let results = [];
+    try {
+      const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+      if (response.ok) {
+        const data = await response.json();
+        const funcs = data.functions || [];
+        const func = funcs.find((f2) => f2.name === funcName || f2.name === `${packageName}:${funcName}`);
+        if (func) results.push(func);
+      }
+    } catch (e) {
+      log(`function-handlers fetch error: ${e.message}`);
+    }
+    if (results.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
+      const files = (await fs2.readdir(FUNCTIONS_DIR)).filter((f2) => f2.endsWith(".json"));
+      for (const file of files) {
+        const raw = await fs2.readFile(path3.join(FUNCTIONS_DIR, file), "utf-8");
+        const data = JSON.parse(raw);
+        const func = data.functions?.find((f2) => f2.name === funcName);
+        if (func) results.push(func);
+      }
+    }
+    if (results.length === 0) {
+      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 listFunctions(packageName) {
+  try {
+    let allFuncs = [];
+    try {
+      const response = await fetch(FUNCTIONS_URL, { headers: { "User-Agent": "atlisp-mcp" } });
+      if (response.ok) {
+        const data = await response.json();
+        const funcs = data.functions || [];
+        if (packageName) {
+          allFuncs = funcs.filter((f) => f.name.startsWith(`${packageName}:`));
+        } else {
+          allFuncs = funcs.map((f) => `${f.name}: ${f.description || "-"}`);
+        }
+      }
+    } catch (e) {
+      log(`function-handlers list fetch error: ${e.message}`);
+    }
+    if (allFuncs.length === 0 && FUNCTIONS_DIR && await fileExists(FUNCTIONS_DIR)) {
+      const files = (await fs2.readdir(FUNCTIONS_DIR)).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const raw = await fs2.readFile(path3.join(FUNCTIONS_DIR, file), "utf-8");
+          const data = JSON.parse(raw);
+          const funcs = data.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(`read file ${file} 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 };
+  }
+}
+
+// src/handlers/resource-handlers.js
+var CACHE_TTL2 = config_default.resourceCacheTtl;
+var resourceCache = /* @__PURE__ */ new Map();
+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 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;
+  });
+}
+var RESOURCES = [
+  { uri: "atlisp://cad/info", name: "CAD Info", description: "CAD \u8FDE\u63A5\u4FE1\u606F", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://cad/layers", name: "Layers", description: "\u56FE\u5C42\u5217\u8868", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://cad/entities", name: "Entities", description: "\u5B9E\u4F53\u7EDF\u8BA1", mimeType: "application/json", subscribable: true },
+  { uri: "atlisp://dwg/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://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 }
+];
+function parseQuery(uri) {
+  const qIdx = uri.indexOf("?");
+  if (qIdx === -1) return { base: uri, params: {} };
+  const base = uri.substring(0, qIdx);
+  const params = {};
+  uri.substring(qIdx + 1).split("&").forEach((p) => {
+    const eqIdx = p.indexOf("=");
+    const k = eqIdx === -1 ? p : p.substring(0, eqIdx);
+    const v = eqIdx === -1 ? "" : p.substring(eqIdx + 1);
+    if (k) params[k] = decodeURIComponent(v);
+  });
+  return { base, params };
+}
+async function listResources(subscribedUris = []) {
+  return RESOURCES.map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    description: r.description,
+    mimeType: r.mimeType,
+    subscribed: subscribedUris.includes(r.uri)
+  }));
+}
+async function readResource(uri) {
+  const { base, params } = parseQuery(uri);
+  switch (base) {
+    case "atlisp://cad/info":
+      return await getCadInfo2();
+    case "atlisp://cad/layers":
+      return await getLayers(params.name);
+    case "atlisp://cad/entities":
+      return await getEntities(params.type);
+    case "atlisp://dwg/name":
+      return await getDwgName();
+    case "atlisp://dwg/path":
+      return await getDwgPath();
+    case "atlisp://packages":
+      return await getPackages(params.name);
+    case "atlisp://platforms":
+      return getPlatforms();
+    default:
+      throw new Error(`\u8D44\u6E90\u4E0D\u5B58\u5728: ${uri}`);
+  }
+}
+async function getCadInfo2() {
+  const cached = getCached("cad:info");
+  if (cached) return cached;
+  if (!cad.connected) {
+    await cad.connect();
+  }
+  if (!cad.connected) {
+    const result2 = { connected: false, platform: null, version: null, busy: false };
+    setCache("cad:info", result2);
+    return result2;
+  }
+  let busy = false;
+  try {
+    busy = await cad.isBusy();
+  } catch (e) {
+    log(`Error checking CAD busy status: ${e.message}`);
+  }
+  const result = {
+    connected: true,
+    platform: cad.getPlatform(),
+    version: cad.getVersion(),
+    busy
+  };
+  setCache("cad:info", result);
+  return result;
+}
+async function getLayers(filterName = null) {
+  const cacheKey = filterName ? `layers:${filterName}` : "layers:all";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return [];
+  try {
+    const code = filterName ? `(tblnext "LAYER" T)` : `(progn (setq res nil)(while (setq e (tblnext "LAYER" (null res)))(setq res (cons (list (cdr (assoc 2 e)) (cdr (assoc 62 e)) (cdr (assoc 70 e))) res))) (reverse res))`;
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === "" || result === "nil") {
+      setCache(cacheKey, []);
+      return [];
+    }
+    let layers = [];
+    try {
+      layers = JSON.parse(result);
+    } catch (e) {
+      const parsed = parseLispList(result);
+      if (parsed) {
+        layers = parsed;
+      } else {
+        layers = [];
+      }
+    }
+    if (!Array.isArray(layers)) {
+      if (typeof layers === "number") {
+        layers = [[result, layers, 0]];
+      } else if (typeof layers === "string") {
+        layers = [[layers, 7, 0]];
+      }
+    }
+    const mapped = layers.map((l) => {
+      const name = Array.isArray(l) ? l[0] : l;
+      const color = Array.isArray(l) && l[1] !== void 0 ? l[1] : 7;
+      const flags = Array.isArray(l) && l[2] !== void 0 ? l[2] : 0;
+      return {
+        name: String(name),
+        color,
+        locked: (flags & 4) !== 0,
+        frozen: (flags & 1) !== 0
+      };
+    });
+    setCache(cacheKey, mapped);
+    return mapped;
+  } catch (e) {
+    setCache(cacheKey, []);
+    return [];
+  }
+}
+async function getEntities(filterType = null) {
+  const cacheKey = filterType ? `entities:${filterType}` : "entities:all";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) {
+    const result = { total: 0, byType: {} };
+    setCache(cacheKey, result);
+    return result;
+  }
+  try {
+    let code;
+    if (filterType) {
+      code = `(sslength (ssget "_X" (list (cons 0 "${filterType}"))))`;
+      const count = await cad.sendCommandWithResult(code);
+      const result = { type: filterType, count: parseInt(count) || 0 };
+      setCache(cacheKey, result);
+      return result;
+    } else {
+      code = `(progn(setq ss(ssget "_X"))(if ss(progn(setq elst(mapcar (quote(lambda(x)(cdr(assoc 0 (entget x))))) (pickset:to-list ss)))(stat:stat elst))))`;
+      const resultStr = await cad.sendCommandWithResult(code);
+      if (!resultStr || resultStr === "" || resultStr === "nil") {
+        const result2 = { total: 0, byType: {} };
+        setCache(cacheKey, result2);
+        return result2;
+      }
+      let statResult = [];
+      try {
+        statResult = JSON.parse(resultStr);
+      } catch (e) {
+        const parsed = parseLispList(resultStr);
+        if (parsed) {
+          statResult = parsed;
+        }
+      }
+      if (!Array.isArray(statResult)) {
+        const result2 = { total: 0, byType: {} };
+        setCache(cacheKey, result2);
+        return result2;
+      }
+      const byType = {};
+      statResult.forEach((item) => {
+        if (Array.isArray(item) && item.length >= 2) {
+          byType[item[0]] = item[1];
+        }
+      });
+      const total = Object.values(byType).reduce((sum, n) => sum + n, 0);
+      const result = { total, byType };
+      setCache(cacheKey, result);
+      return result;
+    }
+  } catch (e) {
+    const result = { total: 0, byType: {} };
+    setCache(cacheKey, result);
+    return result;
+  }
+}
+async function getDwgName() {
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { name: null };
+  try {
+    const code = `(vl-princ-to-string (getvar "dwgname"))`;
+    const name = await cad.sendCommandWithResult(code);
+    return { name: name || null };
+  } catch (e) {
+    return { name: null };
+  }
+}
+async function getDwgPath() {
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { path: null, name: null };
+  try {
+    const code = `(progn
+          (setq prefix (vl-princ-to-string (getvar "dwgprefix")))
+          (setq name (vl-princ-to-string (getvar "dwgname")))
+          (list (strcat prefix name) name)
+        )`;
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === "nil" || result === "") {
+      return { path: null, name: null };
+    }
+    let parsed = null;
+    try {
+      parsed = JSON.parse(result);
+    } catch {
+    }
+    if (!parsed) {
+      const listResult = parseLispList(result);
+      if (listResult && listResult.length >= 2) parsed = listResult;
+    }
+    if (parsed && Array.isArray(parsed) && parsed.length >= 2) {
+      return { path: String(parsed[0]), name: String(parsed[1]) };
+    }
+    return { path: result, name: result };
+  } catch (e) {
+    return { path: null, name: null };
+  }
+}
+async function getPackages(filterName = null) {
+  const packages = MOCK_PACKAGES.map((p) => ({
+    name: p.name,
+    version: p.version,
+    description: p.description,
+    loaded: true
+  }));
+  if (filterName) {
+    const pkg = packages.find((p) => p.name === filterName);
+    return pkg ? [pkg] : [];
+  }
+  return packages;
+}
+function getPlatforms() {
+  return CAD_PLATFORMS.map((name) => ({
+    name,
+    extensions: FILE_EXTENSIONS[name] || []
+  }));
+}
+
+// src/handlers/prompt-handlers.js
+var PROMPTS = [
+  {
+    name: "draw-residential",
+    description: "\u751F\u6210\u519C\u6751\u6C11\u5C45\u5E73\u9762\u5E03\u7F6E\u56FE",
+    arguments: [
+      { name: "width", description: "\u5EFA\u7B51\u5BBD\u5EA6 (mm)", required: true },
+      { name: "depth", description: "\u5EFA\u7B51\u6DF1\u5EA6 (mm)", required: true },
+      { name: "rooms", description: "\u623F\u95F4\u6570\u91CF", required: false }
+    ]
+  },
+  {
+    name: "draw-floor-plan",
+    description: "\u751F\u6210\u5EFA\u7B51\u697C\u5C42\u5E73\u9762\u56FE",
+    arguments: [
+      { name: "floor", description: "\u697C\u5C42\u540D\u79F0", required: true },
+      { name: "scale", description: "\u56FE\u7EB8\u6BD4\u4F8B", required: false }
+    ]
+  },
+  {
+    name: "analyze-drawing",
+    description: "\u5206\u6790\u5F53\u524D\u56FE\u7EB8\u7EDF\u8BA1\u4FE1\u606F",
+    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 }
+    ]
+  }
+];
+async function listPrompts() {
+  return PROMPTS;
+}
+async function getPrompt(name, arguments_ = {}) {
+  switch (name) {
+    case "draw-residential":
+      return generateResidentialPrompt(arguments_);
+    case "draw-floor-plan":
+      return generateFloorPlanPrompt(arguments_);
+    case "analyze-drawing":
+      return generateAnalyzePrompt();
+    case "batch-draw-lines":
+      return generateBatchLinesPrompt(arguments_);
+    case "generate-dimension":
+      return generateDimensionPrompt(arguments_);
+    case "export-entities":
+      return generateExportPrompt(arguments_);
+    default:
+      throw new Error(`Unknown prompt: ${name}`);
+  }
+}
+async function generateResidentialPrompt(args) {
+  const { width = 15e3, depth = 12e3, rooms = 6 } = args;
+  const code = `(defun c:draw-residential (/ old-layer p)
+  (setq old-layer (getvar "clayer"))
+  (setvar "clayer" "0")
+  (setq p (list 0 0))
+  (command "_.rectangle" p (list ${width} ${depth}))
+  ${generateRoomLayout(width, depth, rooms)}
+  (setvar "clayer" old-layer)
+  (princ)
+)
+(c:draw-residential)`;
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u8BF7\u5728 CAD \u4E2D\u7ED8\u5236\u519C\u6751\u6C11\u5C45\u5E73\u9762\u56FE\uFF0C\u5C3A\u5BF8 ${width}x${depth}mm\uFF0C${rooms} \u4E2A\u623F\u95F4\u3002
+
+\u751F\u6210\u7684 AutoLISP \u4EE3\u7801\uFF1A
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u76F4\u63A5\u6267\u884C\u6B64\u4EE3\u7801\u5373\u53EF\u751F\u6210\u56FE\u7EB8\u3002`
+      }
+    }]
+  };
+}
+function generateRoomLayout(width, depth, rooms) {
+  if (rooms === 6) {
+    return `(command "_.line" (list 5000 0) (list 5000 ${depth}) "")
+               (command "_.line" (list 0 4000) (list ${width} 4000) "")
+               (command "_.text" "j" "c" "2500,2000" 800 0 "\u5BA2\u5385")
+               (command "_.text" "j" "c" "7500,6000" 800 0 "\u9910\u5385")
+               (command "_.text" "j" "c" "12500,2000" 800 0 "\u4E3B\u5367")`;
+  }
+  return `(command "_.text" "j" "c" (list (/ ${width} 2) (/ ${depth} 2)) 800 0 "\u623F\u95F4")`;
+}
+async function generateFloorPlanPrompt(args) {
+  const { floor = "\u4E00\u5C42", scale = "1:100" } = args;
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u751F\u6210 ${floor} \u5E73\u9762\u56FE\uFF0C\u6BD4\u4F8B ${scale}\u3002
+
+\u63D0\u793A\uFF1A
+1. \u4F7F\u7528 RECTANGLE \u547D\u4EE4\u7ED8\u5236\u5916\u5899
+2. \u4F7F\u7528 LINE \u547D\u4EE4\u7ED8\u5236\u5185\u90E8\u9694\u5899
+3. \u4F7F\u7528 TEXT \u547D\u4EE4\u6DFB\u52A0\u623F\u95F4\u6807\u6CE8
+4. \u4F7F\u7528 DIMLINEAR \u6216 DIMALIGNED \u6DFB\u52A0\u5C3A\u5BF8\u6807\u6CE8
+
+\u9700\u8981\u6211\u6267\u884C\u54EA\u4E9B\u64CD\u4F5C\uFF1F`
+      }
+    }]
+  };
+}
+async function generateAnalyzePrompt() {
+  let entities = { total: 0, byType: {} };
+  let layers = [];
+  try {
+    if (cad.connected) {
+      const entResult = await cad.sendCommandWithResult(
+        `(progn(setq ss(ssget "_X"))(if ss(progn(setq elst(mapcar(quote(lambda(x)(cdr(assoc 0(entget x))))) (pickset:to-list ss)))(stat:stat elst))))`
+      );
+      if (entResult) {
+        try {
+          entities = JSON.parse(entResult);
+        } catch {
+        }
+      }
+      const layerResult = await cad.sendCommandWithResult(
+        `(progn(setq res nil)(while(setq e(tblnext "LAYER"(null res)))(setq res(cons(cdr(assoc 2 e))res)))(reverse res))`
+      );
+      if (layerResult) {
+        try {
+          layers = JSON.parse(layerResult);
+        } catch {
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u56FE\u7EB8\u5206\u6790\u62A5\u544A\uFF1A
+
+**\u5B9E\u4F53\u7EDF\u8BA1\uFF1A** ${entities.total} \u4E2A
+${Object.entries(entities.byType).map(([t, c]) => `- ${t}: ${c}`).join("\n")}
+
+**\u56FE\u5C42\u5217\u8868\uFF1A** ${layers.length} \u4E2A
+${layers.slice(0, 10).join(", ")}${layers.length > 10 ? "..." : ""}
+
+**\u5EFA\u8BAE\uFF1A**
+${generateSuggestions(entities, layers)}`
+      }
+    }]
+  };
+}
+function generateSuggestions(entities, layers) {
+  const suggestions = [];
+  if (entities.total > 1e3) suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
+  if (layers.length > 20) suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
+  if (entities.byType.LINE && entities.byType.LINE > 500) suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
+  if (!entities.byType.DIMENSION) suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
+  return suggestions.length ? suggestions.join("\n") : "- \u56FE\u7EB8\u7ED3\u6784\u826F\u597D";
+}
+async function generateBatchLinesPrompt(args) {
+  const { count = 5, length = 1e3 } = args;
+  const code = `(defun c:batch-lines (/ i)
+  (setq i 0)
+  (repeat ${count}
+    (command "_.line" (list (* i ${length}) 0) (list (* (1+ i) ${length}) 0) "")
+    (setq i (1+ i))
+  )
+  (princ)
+)
+(c:batch-lines)`;
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u6279\u91CF\u7ED8\u5236 ${count} \u6761\u957F\u5EA6\u4E3A ${length} \u7684\u6C34\u5E73\u7EBF\u6BB5\uFF1A
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u6B64\u4EE3\u7801\u5C06\u7ED8\u5236 ${count} \u6761\u9996\u5C3E\u76F8\u8FDE\u7684\u6C34\u5E73\u7EBF\u6BB5\u3002`
+      }
+    }]
+  };
+}
+async function generateDimensionPrompt(args) {
+  const { style = "aligned" } = args;
+  let dimStyle = "aligned";
+  let lispStyle = "DIMALIGNED";
+  if (style === "horizontal") {
+    dimStyle = "\u6C34\u5E73";
+    lispStyle = "DIMLINEAR";
+  }
+  if (style === "vertical") {
+    dimStyle = "\u5782\u76F4";
+    lispStyle = "DIMLINEAR";
+  }
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u751F\u6210 ${dimStyle} \u5C3A\u5BF8\u6807\u6CE8\u4EE3\u7801\uFF1A
+
+\`\`\`lisp
+(command "_${lispStyle}" "0,0" "1000,0" "500,200" "")
+\`\`\`
+
+\u53C2\u6570\u8BF4\u660E\uFF1A
+- \u8D77\u70B9: 0,0
+- \u7EC8\u70B9: 1000,0
+- \u6807\u6CE8\u4F4D\u7F6E: 500,200
+
+\u6267\u884C\u540E\u5C06\u521B\u5EFA ${dimStyle} \u5C3A\u5BF8\u6807\u6CE8\u3002`
+      }
+    }]
+  };
+}
+async function generateExportPrompt(args) {
+  const { format = "json" } = args;
+  const code = format === "json" ? `(progn
+  (setq ss(ssget "_X"))
+  (if ss
+    (progn
+      (setq elst(mapcar(quote(lambda(x)(list(cdr(assoc 0(entget x)))(vlax-get x 'ObjectName))))(pickset:to-list ss)))
+      (stat:stat(mapcar(quote car)elst))
+    )
+  )
+)` : `(progn
+  (princ "\\n\u5B9E\u4F53\u7EDF\u8BA1:\\n")
+  (princ "\u7C7B\u578B              \u6570\u91CF\\n")
+  (princ "---------------------\\n")
+  (setq ss(ssget "_X"))
+  (if ss
+    (progn
+      (setq elst(mapcar(quote(lambda(x)(cdr(assoc 0(entget x))))) (pickset:to-list ss)))
+      (foreach t '("LINE" "CIRCLE" "ARC" "TEXT" "MTEXT" "POLYLINE" "LWPOLYLINE" "INSERT")
+        (setq cnt(length(member t elst)))
+        (if(> cnt 0)(princ(strcat t "           "(itoa cnt) "\\n")))
+      )
+    )
+  )
+)`;
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u5BFC\u51FA\u5B9E\u4F53\u7EDF\u8BA1 (${format} \u683C\u5F0F)\uFF1A
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u6267\u884C\u540E\u5C06\u8F93\u51FA\u5B9E\u4F53\u7EDF\u8BA1\u4FE1\u606F\u3002`
+      }
+    }]
+  };
+}
+
+// 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 randomUUID3 } 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 || randomUUID3();
+    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(path5) {
+    return this.sendEvent(SSE_EVENTS.ENDPOINT, path5);
+  }
+  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
+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");
+    }
+    this.#sessions.set(clientId, session);
+    session.startHeartbeat();
+  }
+  remove(clientId) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      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) {
+        }
+      }
+    }
+  }
+  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) {
+      session.close();
+    }
+    this.#sessions.clear();
+  }
+};
+
+// src/atlisp-mcp.js
+var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var require2 = createRequire(import.meta.url);
+var { version } = require2(path4.join(__dirname2, "..", "package.json"));
+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++;
+    }
+  }
+}
+var { decode: charsetDecode, encodingExists } = iconv;
+var mcpContext = new AsyncLocalStorage();
+var sseSessionManager = new SseSessionManager();
+var SERVER_CAPABILITIES = {
+  tools: {},
+  resources: { subscribe: true, listChanged: true },
+  prompts: {}
+};
+var { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config_default;
+if (apiKey) log("API Key authentication enabled");
+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 FUNCTION_LIB_URL = process.env.FUNCTION_LIB_URL || "http://s3.atlisp.cn/json/functions.json";
+var cachedFunctionLib = null;
+var cachedAt2 = null;
+var CACHE_TTL3 = 5 * 60 * 1e3;
+async function loadAtlibFunctionLib() {
+  const now = Date.now();
+  if (cachedFunctionLib && cachedAt2 && now - cachedAt2 < CACHE_TTL3) {
+    return cachedFunctionLib;
+  }
+  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;
+      return data;
+    }
+  } catch (e) {
+    log(`loadAtlibFunctionLib error: ${e.message}`);
+  }
+  return null;
+}
+var TOOL_HANDLERS = {
+  connect_cad: () => connectCad(),
+  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) => listFunctions(a.package),
+  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 = data.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) }] };
+  }
+};
+function getOrCreateSessionServer(sessionId) {
+  let entry = sessionServers.get(sessionId);
+  if (!entry) {
+    const server = createMcpServer();
+    const transport2 = new SessionTransport(sessionId);
+    server.connect(transport2);
+    entry = { server, transport: transport2 };
+    sessionServers.set(sessionId, entry);
+    sessionTranports.set(sessionId, transport2);
+  }
+  return entry;
+}
+function removeSessionServer(sessionId) {
+  const entry = sessionServers.get(sessionId);
+  if (entry) {
+    entry.transport.close().catch(() => {
+    });
+    entry.server.close().catch(() => {
+    });
+    sessionServers.delete(sessionId);
+    sessionTranports.delete(sessionId);
+  }
+}
+function broadcastToAllSessions(uri) {
+  for (const [sid, entry] of sessionServers) {
+    entry.server.sendResourceUpdated({ uri }).catch((err) => {
+      log(`Failed to send resource update to session ${sid}: ${err.message}`);
+    });
+  }
+}
+var tools = [
+  {
+    name: "connect_cad",
+    description: "\u8FDE\u63A5\u5230 CAD (AutoCAD/ZWCAD/GStarCAD/BricsCAD)",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    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\uFF0C\u5982 string\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" }
+      }
+    }
+  }
+];
+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 {
+    const result = await handler(args || {});
+    notifyResourceChanges(name);
+    return result;
+  } catch (e) {
+    log(`Tool call error [${name}]: ${e.message}`);
+    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"],
+    new_document: ["atlisp://dwg/name", "atlisp://dwg/path", "atlisp://cad/layers", "atlisp://cad/entities"],
+    install_package: ["atlisp://packages"],
+    install_atlisp: ["atlisp://packages"]
+  };
+  const uris = resourceMap[toolName];
+  if (uris) {
+    for (const uri of uris) {
+      if (isSubscribed(uri)) {
+        notify(uri, null);
+      }
+    }
+  }
+}
+async function initCadConnection() {
+  log("Attempting to connect to CAD on startup...");
+  try {
+    const connected = await cad.connect();
+    if (connected) {
+      log("Auto-connected to CAD: " + cad.getPlatform() + " " + cad.getVersion());
+      console.error("\u5DF2\u81EA\u52A8\u8FDE\u63A5\u5230 CAD: " + cad.getPlatform() + " " + cad.getVersion());
+    } else {
+      log("No CAD found on startup");
+    }
+  } catch (e) {
+    log("Auto-connect failed: " + e.message);
+  }
+}
+var sessionServers = /* @__PURE__ */ new Map();
+var sessionTranports = /* @__PURE__ */ new Map();
+function createMcpServer() {
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: SERVER_CAPABILITIES }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await handleToolCall(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;
+}
+async function startServer() {
+  if (config_default.transport === "stdio") {
+    await initCadConnection();
+    const mcpServer = createMcpServer();
+    const transport2 = new StdioServerTransport();
+    const sessionId = "stdio-session";
+    sessionManager.createSession(sessionId);
+    await mcpContext.run({ sessionId }, async () => {
+      await mcpServer.connect(transport2);
+    });
+    console.error(`${SERVER_NAME} \u8FD0\u884C\u5728 stdio \u6A21\u5F0F`);
+    setNotify((uri, data) => {
+      mcpServer.sendResourceUpdated({ uri }).catch((err) => {
+        log(`Failed to send resource update: ${err.message}`);
+      });
+    });
+  } else {
+    const app = express();
+    const JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
+    app.use(async (req, res, next) => {
+      const ct = (req.headers["content-type"] || "").toLowerCase();
+      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t))) return next();
+      try {
+        const buf = await rawBody(req, { limit: "10mb" });
+        const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
+        let charset = m ? m[1].toLowerCase() : "utf-8";
+        const charsetMap = { "gb2312": "gbk", "gb18030": "gbk", "gbk": "gbk", "936": "gbk" };
+        charset = charsetMap[charset] || charset;
+        const str = encodingExists(charset) ? charsetDecode(buf, charset) : buf.toString("utf-8");
+        req.body = JSON.parse(str);
+        next();
+      } catch (e) {
+        res.status(400).json({ error: "Invalid JSON body", message: e.message });
+      }
+    });
+    app.use((req, res, next) => {
+      log(`${req.method} ${req.path}`);
+      next();
+    });
+    const PUBLIC_PATHS = ["/health"];
+    if (apiKey) {
+      app.use((req, res, next) => {
+        if (PUBLIC_PATHS.includes(req.path)) return next();
+        const auth = req.get("Authorization");
+        if (auth === `Bearer ${apiKey}`) return next();
+        res.status(401).json({ error: "Unauthorized" });
+      });
+    }
+    app.get("/health", (req, res) => {
+      res.json({ status: "ok", cad: cad.connected ? "connected" : "disconnected" });
+    });
+    if (config_default.enableCors) {
+      app.use((req, res, next) => {
+        res.setHeader("Access-Control-Allow-Origin", config_default.corsOrigin);
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, CONNECT");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept, mcp-session-id, last-event-id");
+        res.setHeader("Access-Control-Expose-Headers", "mcp-session-id, content-type, x-accel-buffering");
+        res.setHeader("Access-Control-Max-Age", "86400");
+        res.setHeader("Vary", "Accept");
+        if (req.method === "OPTIONS") return res.status(204).end();
+        next();
+      });
+    }
+    setNotify((uri, data) => {
+      broadcastToAllSessions(uri);
+      for (const session of sseSessionManager.listActive()) {
+        sseSessionManager.sendToClient(session.clientId, "resource_updated", { uri });
+      }
+    });
+    async function handleMcpPost(req, res) {
+      const sessionId = req.headers["mcp-session-id"] || req.query.sessionId || randomUUID4();
+      sessionManager.createSession(sessionId);
+      const body = req.body;
+      if (!body || !body.method) {
+        return res.status(400).json({ error: "Invalid request" });
+      }
+      const { server, transport: transport2 } = getOrCreateSessionServer(sessionId);
+      transport2.resetCleanupTimer();
+      await mcpContext.run({ sessionId }, async () => {
+        try {
+          const response = await transport2.handleRequest(body);
+          if (response) {
+            const headers = { "Content-Type": "application/json" };
+            if (transport2.sessionId) {
+              headers["mcp-session-id"] = transport2.sessionId;
+            }
+            res.writeHead(200, headers);
+            res.end(JSON.stringify(response));
+          } else {
+            if (!res.headersSent) {
+              res.status(202).end();
+            }
+          }
+        } catch (error) {
+          log(`Transport error [${sessionId}]: ${error.message}`);
+          if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error", message: error.message });
+          }
+        }
+      });
+    }
+    app.all("/mcp", mcpLimiter, handleMcpPost);
+    app.all("/mcp/:path", mcpLimiter, handleMcpPost);
+    app.get("/mcp/stream", mcpLimiter, handleMcpPost);
+    const sseEndpoint = "/sse";
+    app.get(sseEndpoint, async (req, res) => {
+      const sessionId = randomUUID4();
+      sessionManager.createSession(sessionId);
+      getOrCreateSessionServer(sessionId);
+      const sseSession = new SseSession(res, { clientId: sessionId });
+      sseSessionManager.add(sessionId, sseSession);
+      sseSession.sendEndpoint(`/message?sessionId=${sessionId}`);
+      req.on("close", () => {
+        sseSessionManager.remove(sessionId);
+        removeSessionServer(sessionId);
+      });
+    });
+    app.post("/message", mcpLimiter, async (req, res) => {
+      const sessionId = req.query.sessionId;
+      if (!sessionId) {
+        return res.status(400).json({ error: "Missing sessionId" });
+      }
+      const sseSession = sseSessionManager.get(sessionId);
+      if (!sseSession) {
+        return res.status(404).json({ error: "Session not found" });
+      }
+      sessionManager.createSession(sessionId);
+      const { server, transport: transport2 } = getOrCreateSessionServer(sessionId);
+      transport2.resetCleanupTimer();
+      const body = req.body;
+      if (body && body.method) {
+        try {
+          const response = await transport2.handleRequest(body);
+          if (response) {
+            sseSession.sendResponse(response);
+          }
+          if (!res.headersSent) {
+            res.status(202).end();
+          }
+        } catch (error) {
+          log(`SSE message error [${sessionId}]: ${error.message}`);
+          if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error" });
+          }
+        }
+      } else {
+        res.status(400).json({ error: "Invalid request" });
+      }
+    });
+    const httpServer = app.listen(config_default.port, config_default.host, async () => {
+      await initCadConnection();
+      console.error(`@lisp MCP Server \u542F\u52A8 - http://${config_default.host}:${config_default.port} (\u591A\u4F1A\u8BDD\u6A21\u5F0F)`);
+    });
+    async function shutdown(signal) {
+      console.error(`
+\u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u4F18\u96C5\u5173\u95ED...`);
+      sseSessionManager.closeAll();
+      sessionManager.clear();
+      for (const [sid] of sessionServers) {
+        removeSessionServer(sid);
+      }
+      await cad.disconnect();
+      closeLog();
+      httpServer.close(() => process.exit(0));
+      setTimeout(() => process.exit(1), 5e3);
+    }
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+  }
+}
+if (!process.env.VITEST) {
+  await startServer();
+}
+export {
+  CAD_PLATFORMS,
+  FILE_EXTENSIONS,
+  MOCK_PACKAGES,
+  createMcpServer,
+  handleToolCall,
+  loadAtlibFunctionLib,
+  startServer,
+  tools
+};