@atlisp/mcp 1.8.18 → 1.8.20

package/dist/cad-worker.js

@@ -13,19 +13,30 @@ const BUSY_DELAY = parseInt(process.env.BUSY_DELAY || '500', 10);
 const LISP_CACHE = new Map();
 const LISP_CACHE_MAX = parseInt(process.env.LISP_CACHE_MAX || '500', 10);
 
+const CACHE_TTL = parseInt(process.env.LISP_CACHE_TTL || '300000', 10);
+
 function getCachedLisp(code) {
   const hash = crypto.createHash('sha256').update(code).digest('hex');
-  if (LISP_CACHE.has(hash)) return LISP_CACHE.get(hash);
-  return null;
+  const entry = LISP_CACHE.get(hash);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > CACHE_TTL) {
+    LISP_CACHE.delete(hash);
+    return null;
+  }
+  entry.ts = Date.now();
+  return entry.compiled;
 }
 
 function setCachedLisp(code, compiled) {
   const hash = crypto.createHash('sha256').update(code).digest('hex');
   if (LISP_CACHE.size >= LISP_CACHE_MAX) {
-    const firstKey = LISP_CACHE.keys().next().value;
-    LISP_CACHE.delete(firstKey);
+    let oldest = null;
+    for (const [k, v] of LISP_CACHE) {
+      if (!oldest || v.ts < oldest.ts) oldest = { k, ts: v.ts };
+    }
+    if (oldest) LISP_CACHE.delete(oldest.k);
   }
-  LISP_CACHE.set(hash, compiled);
+  LISP_CACHE.set(hash, { compiled, ts: Date.now() });
   return compiled;
 }
 
@@ -151,16 +162,34 @@ const cadSendWithResult = edge.func(function() {/*
           string code = d.code.ToString();
           string platform = d.platform.ToString();
 string encoding = d.encoding != null ? d.encoding.ToString() : "";
+          string codeHash = d.codeHash != null ? d.codeHash.ToString() : "";
+          bool cacheEnabled = d.cacheEnabled != null && d.cacheEnabled.ToString() == "True";
+          bool hasCacheKey = cacheEnabled && !string.IsNullOrEmpty(codeHash);
            string progId = platform == "BricsCAD" ? "BricscadApp.AcadApplication" : platform + ".Application";
            string tempDir = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "@lisp", "tmp");
           System.IO.Directory.CreateDirectory(tempDir);
           
+          // 结果文件始终使用 GUID 命名（每次调用唯一）
           tempFile = System.IO.Path.Combine(tempDir, "atlisp_result_" + System.Guid.NewGuid().ToString("N") + ".txt");
-          lispFile = System.IO.Path.Combine(tempDir, "atlisp_code_" + System.Guid.NewGuid().ToString("N") + ".lsp");
-          userCodeFile = System.IO.Path.Combine(tempDir, "atlisp_user_" + System.Guid.NewGuid().ToString("N") + ".lsp");
           
-          // 用户代码单独写入文件，避免拼接注入风险
-          System.IO.File.WriteAllText(userCodeFile, code, System.Text.Encoding.GetEncoding(System.Globalization.CultureInfo.CurrentCulture.TextInfo.ANSICodePage));
+          // 代码文件：启用缓存时使用 hash 命名，否则使用 GUID 命名
+          string fileKey = hasCacheKey ? codeHash : System.Guid.NewGuid().ToString("N");
+          userCodeFile = System.IO.Path.Combine(tempDir, "atlisp_user_" + fileKey + ".lsp");
+          lispFile = System.IO.Path.Combine(tempDir, "atlisp_code_" + fileKey + ".lsp");
+          
+          bool useCachedUserCode = false;
+          if (hasCacheKey) {
+              if (System.IO.File.Exists(userCodeFile)) {
+                  var userFileInfo = new System.IO.FileInfo(userCodeFile);
+                  if ((DateTime.Now - userFileInfo.LastWriteTime).TotalHours < 1) {
+                      useCachedUserCode = true;
+                  }
+              }
+          }
+          
+          if (!useCachedUserCode) {
+              System.IO.File.WriteAllText(userCodeFile, code, System.Text.Encoding.GetEncoding(System.Globalization.CultureInfo.CurrentCulture.TextInfo.ANSICodePage));
+          }
           
           string lispCode = "(progn"
               + "(setq f(open \"" + tempFile.Replace("\\", "\\\\") + "\" \"w\"))"
@@ -171,7 +200,6 @@ string encoding = d.encoding != null ? d.encoding.ToString() : "";
               + "(close f)"
               + "(princ))";
             
-            // 使用系统 ANSI 编码以兼容 GstarCAD / ZWCAD
             System.IO.File.WriteAllText(lispFile, lispCode, System.Text.Encoding.GetEncoding(System.Globalization.CultureInfo.CurrentCulture.TextInfo.ANSICodePage));
           
           dynamic cad = System.Runtime.InteropServices.Marshal.GetActiveObject(progId);
@@ -193,11 +221,9 @@ string encoding = d.encoding != null ? d.encoding.ToString() : "";
                               byte[] bytes = System.IO.File.ReadAllBytes(tempFile);
                               System.Text.Encoding enc;
                               
-                              // 优先使用指定的编码
                               if (!string.IsNullOrEmpty(encoding)) {
                                   enc = System.Text.Encoding.GetEncoding(encoding);
                               } else {
-                                  // 自动检测编码：先尝试 UTF-8，如果失败则使用 GBK
                                   try {
                                       string utf8Result = System.Text.Encoding.UTF8.GetString(bytes);
                                       if (!utf8Result.Contains("\ufffd")) {
@@ -216,14 +242,13 @@ string encoding = d.encoding != null ? d.encoding.ToString() : "";
                               
                               result = enc.GetString(bytes).Trim();
                               
-                              // 检查是否有错误前缀
                               if (result.StartsWith("ERROR:")) {
                                   return new { success = false, error = result.Substring(6).Trim() };
                               }
                               
                               try { System.IO.File.Delete(tempFile); } catch {}
                               try { System.IO.File.Delete(lispFile); } catch {}
-                              try { System.IO.File.Delete(userCodeFile); } catch {}
+                              if (!hasCacheKey) { try { if (System.IO.File.Exists(userCodeFile)) System.IO.File.Delete(userCodeFile); } catch {} }
                               break;
                           } catch (System.IO.IOException) {
                               System.Threading.Thread.Sleep(200);
@@ -471,8 +496,6 @@ async function waitForIdle(platform) {
   return false;
 }
 
-export { checkParens } from './lisp-security.js';
-
 async function connectToPlatform(targetPlatform) {
   return new Promise((resolve, reject) => {
     cadConnectByName(targetPlatform, (e, r) => {
@@ -482,6 +505,13 @@ async function connectToPlatform(targetPlatform) {
   });
 }
 
+function computeCodeHash(code, cacheEnabled) {
+  if (cacheEnabled) {
+    return crypto.createHash('sha256').update(code).digest('hex');
+  }
+  return '';
+}
+
 async function handleMessage(msg) {
   if (msg.type === 'ping') {
     return { pong: true };
@@ -554,9 +584,11 @@ async function handleMessage(msg) {
       return { success: false, error: `安全限制: ${injectionCheck.error}` };
     }
     if (msg.code.length > 255) {
-      log(`send (long code ${msg.code.length} chars, fallback to sendResult): ${msg.code.substring(0, 80)}...`);
+      const cacheEnabled = process.env.LONG_CODE_CACHE === '1';
+      const codeHash = computeCodeHash(msg.code, cacheEnabled);
+      log(`send (long code ${msg.code.length} chars, fallback to sendResult, cache=${cacheEnabled}): ${msg.code.substring(0, 80)}...`);
       const r = await new Promise((resolve, reject) => {
-        cadSendWithResult({ code: msg.code, platform: msg.platform || 'AutoCAD', encoding: '' }, (e, r) => {
+        cadSendWithResult({ code: msg.code, platform: msg.platform || 'AutoCAD', encoding: '', codeHash, cacheEnabled }, (e, r) => {
           if (e) reject(e);
           else resolve(r);
         });
@@ -606,6 +638,8 @@ async function handleMessage(msg) {
     if (!injectionCheck.valid) {
       return { success: false, error: `安全限制: ${injectionCheck.error}` };
     }
+    const cacheEnabled = process.env.LONG_CODE_CACHE === '1';
+    const codeHash = computeCodeHash(msg.code, cacheEnabled);
     const maxRetriesResult = 3;
     let lastErrorResult = null;
     for (let i = 0; i < maxRetriesResult; i++) {
@@ -614,7 +648,7 @@ async function handleMessage(msg) {
         log(`sendResult: ${msg.code}`);
         try {
           const r = await new Promise((resolve, reject) => {
-            cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || '' }, (e, r) => {
+            cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || '', codeHash, cacheEnabled }, (e, r) => {
               if (e) reject(e);
               else resolve(r);
             });

package/dist/config.js

@@ -33,6 +33,11 @@ const envSchema = z.object({
     LLM_MODEL: z.string().optional().default('gpt-4o-mini'),
     LLM_MAX_TOKENS: z.string().optional().default('4096'),
     LLM_TEMPERATURE: z.string().optional().default('0.7'),
+    WORKER_POOL_SIZE: z.string().optional().default('2'),
+    LINT_PRESET: z.string().optional().default(''),
+    LINT_CONFIG_PATH: z.string().optional().default(''),
+    LINT_LEVEL: z.string().optional().default(''),
+    NO_LINT: z.string().optional().default(''),
 });
 
 const configSchema = z.object({
@@ -71,6 +76,11 @@ const configSchema = z.object({
     llmMaxTokens: z.number().optional(),
     llmTemperature: z.number().optional(),
     maxPoolSize: z.number().optional(),
+    workerPoolSize: z.number().optional(),
+    lintPreset: z.string().optional(),
+    lintConfigPath: z.string().optional(),
+    lintLevel: z.string().optional(),
+    noLint: z.boolean().optional(),
 });
 
 function parseArgs() {
@@ -101,6 +111,17 @@ function parseArgs() {
             i++;
         } else if (args[i] === '--debug') {
             result.debug = true;
+        } else if (args[i] === '--lint-preset' && args[i + 1]) {
+            result.lintPreset = args[i + 1];
+            i++;
+        } else if (args[i] === '--lint-config' && args[i + 1]) {
+            result.lintConfigPath = args[i + 1];
+            i++;
+        } else if (args[i] === '--lint-level' && args[i + 1]) {
+            result.lintLevel = args[i + 1];
+            i++;
+        } else if (args[i] === '--no-lint' || args[i] === '--lint-off') {
+            result.noLint = true;
         }
     }
     return result;
@@ -171,8 +192,18 @@ const config = {
     llmMaxTokens: fileConfig?.llmMaxTokens || parseInt(env.LLM_MAX_TOKENS, 10),
     llmTemperature: fileConfig?.llmTemperature || parseFloat(env.LLM_TEMPERATURE),
     maxPoolSize: fileConfig?.maxPoolSize || 3,
+    workerPoolSize: fileConfig?.workerPoolSize || parseInt(env.WORKER_POOL_SIZE, 10),
+    lintPreset: fileConfig?.lintPreset || cliArgs.lintPreset || env.LINT_PRESET || undefined,
+    lintConfigPath: fileConfig?.lintConfigPath || cliArgs.lintConfigPath || env.LINT_CONFIG_PATH || undefined,
+    lintLevel: fileConfig?.lintLevel || cliArgs.lintLevel || env.LINT_LEVEL || undefined,
+    noLint: fileConfig?.noLint ?? cliArgs.noLint ?? (env.NO_LINT === 'true'),
 };
 
+if (config.lintConfigPath) process.env.LINT_CONFIG_PATH = config.lintConfigPath;
+if (config.lintPreset) process.env.LINT_PRESET = config.lintPreset;
+if (config.lintLevel) process.env.LINT_LEVEL = config.lintLevel;
+if (config.noLint) process.env.NO_LINT = 'true';
+
 export function validateConfig() {
     const errors = [];
     if (config.transport === 'http' || config.transport === 'ws') {
@@ -201,16 +232,20 @@ export function validateConfig() {
 }
 
 let configWatchers = [];
+let configReloadLock = false;
 
 if (configFilePath && fs.existsSync(configFilePath)) {
     try {
         fs.watch(configFilePath, (eventType) => {
             if (eventType === 'change') {
+                if (configReloadLock) return;
+                configReloadLock = true;
                 const newFileConfig = loadConfigFile(configFilePath);
                 if (newFileConfig) {
                     Object.assign(config, newFileConfig);
-                    configWatchers.forEach(fn => fn(config));
+                    configWatchers.forEach(fn => { try { fn(config); } catch {} });
                 }
+                configReloadLock = false;
             }
         });
     } catch (e) { console.error(`Config file watch error: ${e.message}`); }
@@ -225,12 +260,16 @@ export function getAllConfig() {
 }
 
 export function reloadConfig() {
+    if (configReloadLock) return false;
+    configReloadLock = true;
     const newFileConfig = loadConfigFile(config.configFile);
     if (newFileConfig) {
         Object.assign(config, newFileConfig);
-        configWatchers.forEach(fn => fn(config));
+        configWatchers.forEach(fn => { try { fn(config); } catch {} });
+        configReloadLock = false;
         return true;
     }
+    configReloadLock = false;
     return false;
 }
 

package/dist/handlers/batch-transaction-handlers.js

@@ -0,0 +1,70 @@
+import { cad } from '../cad.js';
+import { log, error as logError } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected } from '../handler-utils.js';
+import { handleToolCall } from '../mcp-tools.js';
+
+export async function batchTransaction({ operations }) {
+  try {
+    await ensureCadConnected();
+
+    if (!operations || !Array.isArray(operations) || operations.length === 0) {
+      return mcpError('operations 必须是非空数组');
+    }
+
+    log(`batch_transaction: starting ${operations.length} operations`);
+
+    await cad.sendCommand('(command "_.UNDO" "_BEGIN")');
+
+    const results = [];
+    let hasError = false;
+
+    for (let i = 0; i < operations.length; i++) {
+      const op = operations[i];
+      log(`batch_transaction: step ${i + 1}/${operations.length} -> ${op.tool}`);
+
+      try {
+        const result = await handleToolCall(op.tool, op.args || {});
+        results.push({
+          step: i,
+          tool: op.tool,
+          success: !result.isError,
+          result,
+        });
+        if (result.isError) {
+          hasError = true;
+        }
+      } catch (e) {
+        logError(`batch_transaction: step ${i} (${op.tool}) threw: ${e.message}`);
+        results.push({
+          step: i,
+          tool: op.tool,
+          success: false,
+          error: e.message,
+        });
+        hasError = true;
+      }
+    }
+
+    try {
+      await cad.sendCommand('(command "_.UNDO" "_END")');
+    } catch (e) {
+      logError(`batch_transaction: UNDO _END failed: ${e.message}`);
+    }
+
+    if (hasError) {
+      try {
+        await cad.sendCommand('(command "_.UNDO" "1")');
+        log('batch_transaction: rolled back due to errors');
+      } catch (e) {
+        logError(`batch_transaction: UNDO rollback failed: ${e.message}`);
+      }
+      return mcpError(`批量事务部分操作失败，已回滚: ${JSON.stringify(results)}`);
+    }
+
+    log(`batch_transaction: all ${operations.length} operations succeeded`);
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) {
+    logError(`batch_transaction: outer error: ${e.message}`);
+    return mcpError(`批量事务错误: ${e.message}`);
+  }
+}

package/dist/handlers/cad-handlers.js

@@ -1,6 +1,7 @@
 import { cad } from '../cad.js';
 import { log } from '../logger.js';
-import { escapeLispString } from '../handler-utils.js';
+import { withCadConnection, mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
+import { analyzeLispCode } from '../lint-analyzer.js';
 
 export async function connectCad(platform = null) {
     log(`connect_cad called${platform ? ` (target: ${platform})` : ''}, cad.connected before: ${cad.connected}`);
@@ -11,92 +12,82 @@ export async function connectCad(platform = null) {
         if (connected) {
             const messages = [`已连接到 ${cad.getPlatform()} ${cad.getVersion()}`];
             initAtlisp().catch(e => log(`connect_cad: initAtlisp failed: ${e.message}`));
-            return { content: [{ type: 'text', text: messages.join('；') }] };
+            return mcpSuccess(messages.join('；'));
         }
-        return { content: [{ type: 'text', text: '未能连接或启动 CAD，请确保 CAD 已安装' }], isError: true };
+        return mcpError('未能连接或启动 CAD，请确保 CAD 已安装');
     } catch (e) {
         log('connect_cad error: ' + e.message);
-        return { content: [{ type: 'text', text: `连接 CAD 失败: ${e.message}` }], isError: true };
+        return mcpError(`连接 CAD 失败: ${e.message}`);
     }
 }
 
-export async function evalLisp(code, withResult = false, encoding = null) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) {
-        return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    }
+export const evalLisp = withCadConnection(async (code, withResult = false, encoding = null) => {
     const trimmed = (code || '').trim();
-    if (!trimmed) return { content: [{ type: 'text', text: '命令为空，未发送' }] };
-    try {
-        if (withResult) {
-            const result = await cad.sendCommandWithResult(trimmed, encoding);
-            if (result !== null) {
-                return { content: [{ type: 'text', text: result }] };
-            }
-            return { content: [{ type: 'text', text: '执行失败或无返回值' }], isError: true };
-        } else {
-            await cad.sendCommand(trimmed + '\n');
-            return { content: [{ type: 'text', text: `已发送命令` }] };
+    if (!trimmed) return mcpSuccess('命令为空，未发送');
+
+    const analysis = analyzeLispCode(trimmed);
+    if (!analysis.valid) {
+        const detail = analysis.errors.map(e => `  L${e.line}: [${e.rule}] ${e.message}`).join('\n');
+        return mcpError(`代码存在安全问题:\n${detail}`);
+    }
+
+    if (withResult) {
+        const result = await cad.sendCommandWithResult(trimmed, encoding);
+        if (result !== null) {
+            return mcpSuccess(result);
         }
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+        return mcpError('执行失败或无返回值');
     }
-}
+    await cad.sendCommand(trimmed + '\n');
+    return mcpSuccess('已发送命令');
+});
 
-export async function getCadInfo() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: 'CAD 未连接' }] };
+export const getCadInfo = withCadConnection(async () => {
     const info = await cad.getInfo();
-    return { content: [{ type: 'text', text: info }] };
-}
+    return mcpSuccess(info);
+});
 
-export async function atCommand(command) {
-    if (!cad.connected) return { content: [{ type: 'text', text: '请先连接 CAD' }], isError: true };
+export const atCommand = withCadConnection(async (command) => {
     const trimmed = (command || '').trim();
-    if (!trimmed) return { content: [{ type: 'text', text: '命令为空，未发送' }] };
+    if (!trimmed) return mcpSuccess('命令为空，未发送');
+
+    const analysis = analyzeLispCode(trimmed);
+    if (!analysis.valid) {
+        const detail = analysis.errors.map(e => `  L${e.line}: [${e.rule}] ${e.message}`).join('\n');
+        return mcpError(`代码存在安全问题:\n${detail}`);
+    }
+
     await cad.sendCommand(trimmed + '\n');
-    return { content: [{ type: 'text', text: '已发送命令' }] };
-}
+    return mcpSuccess('已发送命令');
+});
 
-export async function newDocument() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+export const newDocument = withCadConnection(async () => {
     const result = await cad.newDoc();
     if (result) {
-        return { content: [{ type: 'text', text: '已在 CAD 中新建空白文档' }] };
+        return mcpSuccess('已在 CAD 中新建空白文档');
     }
-    return { content: [{ type: 'text', text: '新建文档失败' }], isError: true };
-}
+    return mcpError('新建文档失败');
+});
 
-export async function bringToFront() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+export const bringToFront = withCadConnection(async () => {
     const result = await cad.bringToFront();
     if (result) {
-        return { content: [{ type: 'text', text: '已将 CAD 窗口切换到前台' }] };
+        return mcpSuccess('已将 CAD 窗口切换到前台');
     }
-    return { content: [{ type: 'text', text: '切换前台失败' }], isError: true };
-}
+    return mcpError('切换前台失败');
+});
 
-export async function installAtlisp() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+export const installAtlisp = withCadConnection(async () => {
     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: '已发送 @lisp 安装代码到 CAD' }] };
-}
+    return mcpSuccess('已发送 @lisp 安装代码到 CAD');
+});
 
-export async function listFunctionsInCad() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 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 函数列表为空' }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
+export const listFunctionsInCad = withCadConnection(async () => {
+    const result = await cad.sendCommandWithResult('(atoms-family 0)', null);
+    if (result) return mcpSuccess(result);
+    return mcpError('CAD 函数列表为空');
+});
 
 export async function getSystemStatus() {
   const status = {
@@ -140,9 +131,7 @@ export async function getSystemStatus() {
   return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
 }
 
-export async function initAtlisp() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+export const initAtlisp = withCadConnection(async () => {
     const code = `(if (null @::load-module)
 	   (progn
 	     (vl-load-com)
@@ -151,30 +140,16 @@ export async function initAtlisp() {
 		   (v o'send)
 		   (v o'WaitforResponse 1000)
 		   (e(r(vlax-get o'ResponseText)))))`;
-    try {
-        await cad.sendCommand(code + '\n');
-        return { content: [{ type: 'text', text: '已发送 @lisp 函数库加载代码到 CAD' }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-export async function getSystemVariable(name) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const result = await cad.sendCommandWithResult(`(vl-princ-to-string (getvar "${escapeLispString(name)}"))`);
-        return { content: [{ type: 'text', text: result || 'nil' }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-export async function setSystemVariable(name, value) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        await cad.sendCommand(`(setvar "${escapeLispString(name)}" ${value})\n`);
-        return { content: [{ type: 'text', text: `已设置 ${name} = ${value}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
+    await cad.sendCommand(code + '\n');
+    return mcpSuccess('已发送 @lisp 函数库加载代码到 CAD');
+});
+
+export const getSystemVariable = withCadConnection(async (name) => {
+    const result = await cad.sendCommandWithResult(`(vl-princ-to-string (getvar "${escapeLispString(name)}"))`);
+    return mcpSuccess(result || 'nil');
+});
+
+export const setSystemVariable = withCadConnection(async (name, value) => {
+    await cad.sendCommand(`(setvar "${escapeLispString(name)}" ${value})\n`);
+    return mcpSuccess(`已设置 ${name} = ${value}`);
+});