@atlisp/mcp 1.8.31 → 1.8.32

package/dist/cad-worker.js

@@ -616,6 +616,36 @@ async function executeWithRetry(fn, label) {
   return { success: false, error: lastError?.message || '发送失败' };
 }
 
+async function executeLongCode(msg) {
+  const cacheEnabled = process.env.LONG_CODE_CACHE === '1';
+  const codeHash = computeCodeHash(msg.code, cacheEnabled);
+  log(`sendResult (${msg.code.length} chars, cache=${cacheEnabled}): ${msg.code.substring(0, 80)}...`);
+  return await executeWithRetry(async () => {
+    const r = await new Promise((resolve, reject) => {
+      cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || '', codeHash, cacheEnabled }, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    log(`sendResult result: ${JSON.stringify(r)}`);
+    return r;
+  }, 'sendResult');
+}
+
+async function executeShortCode(msg) {
+  log(`send: ${msg.code}`);
+  return await executeWithRetry(async () => {
+    const r = await new Promise((resolve, reject) => {
+      cadSend({ code: msg.code, platform: msg.platform }, (e, r) => {
+        if (e) reject(e);
+        else resolve(r);
+      });
+    });
+    log(`send result: ${JSON.stringify(r)}`);
+    return r;
+  }, 'send');
+}
+
 async function executeLisp(msg, withResult) {
   if (!msg.code.endsWith('\n')) {
     msg.code += '\n';
@@ -636,32 +666,10 @@ async function executeLisp(msg, withResult) {
   }
 
   if (withResult || msg.code.length > 255) {
-    const cacheEnabled = process.env.LONG_CODE_CACHE === '1';
-    const codeHash = computeCodeHash(msg.code, cacheEnabled);
-    log(`sendResult (${msg.code.length} chars, cache=${cacheEnabled}): ${msg.code.substring(0, 80)}...`);
-    return await executeWithRetry(async () => {
-      const r = await new Promise((resolve, reject) => {
-        cadSendWithResult({ code: msg.code, platform: msg.platform, encoding: msg.encoding || '', codeHash, cacheEnabled }, (e, r) => {
-          if (e) reject(e);
-          else resolve(r);
-        });
-      });
-      log(`sendResult result: ${JSON.stringify(r)}`);
-      return r;
-    }, 'sendResult');
+    return await executeLongCode(msg);
   }
 
-  log(`send: ${msg.code}`);
-  return await executeWithRetry(async () => {
-    const r = await new Promise((resolve, reject) => {
-      cadSend({ code: msg.code, platform: msg.platform }, (e, r) => {
-        if (e) reject(e);
-        else resolve(r);
-      });
-    });
-    log(`send result: ${JSON.stringify(r)}`);
-    return r;
-  }, 'send');
+  return await executeShortCode(msg);
 }
 
 const MESSAGE_HANDLERS = {
@@ -756,4 +764,4 @@ export async function handleMessage(msg) {
 }
 
 // Exported for testing
-export { validateCode, computeCodeHash, getCachedLisp, setCachedLisp, MESSAGE_HANDLERS, executeLisp };
+export { validateCode, computeCodeHash, getCachedLisp, setCachedLisp, MESSAGE_HANDLERS, executeLisp, executeLongCode, executeShortCode };

package/dist/config.js

@@ -40,6 +40,12 @@ const envSchema = z.object({
     NO_LINT: z.coerce.boolean().optional().default(false),
     SECURITY_LEVEL: z.string().optional().default('strict'),
     CLIENT_ID: z.string().optional().default(''),
+    MAX_ENTITY_LIMIT: z.coerce.number().optional().default(20000),
+    READ_BATCH_WINDOW: z.coerce.number().optional().default(50),
+    READ_BATCH_SIZE: z.coerce.number().optional().default(10),
+    AUTO_CONNECT: z.coerce.boolean().optional().default(false),
+    AUTO_LAUNCH: z.coerce.boolean().optional().default(true),
+    LAUNCH_TIMEOUT: z.coerce.number().optional().default(30000),
 });
 
 const configSchema = z.object({
@@ -85,6 +91,12 @@ const configSchema = z.object({
     noLint: z.boolean().optional(),
     securityLevel: z.enum(['strict', 'standard', 'relaxed']).optional(),
     clientId: z.string().optional(),
+    maxEntityLimit: z.number().optional(),
+    readBatchWindow: z.number().optional(),
+    readBatchSize: z.number().optional(),
+    autoConnect: z.boolean().optional(),
+    autoLaunch: z.boolean().optional(),
+    launchTimeout: z.number().optional(),
 });
 
 function parseArgs() {
@@ -206,6 +218,12 @@ const config = {
     noLint: fileConfig?.noLint ?? cliArgs.noLint ?? env.NO_LINT,
     securityLevel: fileConfig?.securityLevel ?? cliArgs.securityLevel ?? (env.SECURITY_LEVEL || 'strict'),
     clientId: fileConfig?.clientId ?? (env.CLIENT_ID || ''),
+    maxEntityLimit: fileConfig?.maxEntityLimit ?? env.MAX_ENTITY_LIMIT,
+    readBatchWindow: fileConfig?.readBatchWindow ?? env.READ_BATCH_WINDOW,
+    readBatchSize: fileConfig?.readBatchSize ?? env.READ_BATCH_SIZE,
+    autoConnect: fileConfig?.autoConnect ?? env.AUTO_CONNECT,
+    autoLaunch: fileConfig?.autoLaunch ?? env.AUTO_LAUNCH,
+    launchTimeout: fileConfig?.launchTimeout ?? env.LAUNCH_TIMEOUT,
 };
 
 if (config.lintConfigPath) process.env.LINT_CONFIG_PATH = config.lintConfigPath;

package/dist/handlers/dim-hatch-handlers.js

@@ -314,27 +314,3 @@ export async function exportDwf(outputPath) {
         return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
     }
 }
-
-export async function batchSetLayer(handles, layerName) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-
-    if (!Array.isArray(handles) || handles.length === 0) {
-        return { content: [{ type: 'text', text: '句柄列表为空' }], isError: true };
-    }
-
-    const handlesStr = handles.map(h => `"${escapeLispString(h)}"`).join(' ');
-    const code = `(progn
-        (vl-load-com)
-        (setq ss (ssadd))
-        ${handlesStr.split('\n').map(h => `(ssadd (handent ${h}) ss)`).join('\n')}
-        (command "._CHPROP" ss "" "LA" "${escapeLispString(layerName)}" "")
-        (strcat "Updated " (itoa ${handles.length}) " entities")
-    )`;
-    try {
-        const result = await cad.sendCommandWithResult(code);
-        return { content: [{ type: 'text', text: result || `已批量设置 ${handles.length} 个实体图层为 ${layerName}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}

package/dist/handlers/file-handlers.js

@@ -1,15 +1,5 @@
 import { cad } from '../cad.js';
-import { escapeLispString } from '../handler-utils.js';
-import path from 'path';
-
-function validateFilePath(filePath) {
-  const normalized = path.normalize(filePath);
-  if (normalized.includes('..')) {
-    throw new Error(`路径不允许包含 "..": ${filePath}`);
-  }
-  const resolved = path.resolve(normalized);
-  return resolved;
-}
+import { escapeLispString, validateFilePath } from '../handler-utils.js';
 
 export async function openDwg(filePath) {
     if (!cad.connected) { await cad.connect(); }

package/dist/handlers/pipeline-handlers.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { handleToolCall } from '../mcp-tools.js';
+import { mcpSuccess, mcpError, ensureCadConnected } from '../handler-utils.js';
+import { log, error as logError } from '../logger.js';
+
+const PIPELINES_DIR = path.join(os.homedir(), '.atlisp', 'pipelines');
+
+function ensureDir() {
+  if (!fs.existsSync(PIPELINES_DIR)) {
+    fs.mkdirSync(PIPELINES_DIR, { recursive: true });
+  }
+}
+
+function pipelinePath(name) {
+  return path.join(PIPELINES_DIR, `${name}.json`);
+}
+
+export async function pipelineExecute({ steps }) {
+  try {
+    if (!steps || !Array.isArray(steps) || steps.length === 0) {
+      return mcpError('steps 必须是非空数组');
+    }
+
+    log(`pipeline_execute: starting ${steps.length} steps`);
+    const results = [];
+
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      log(`pipeline_execute: step ${i + 1}/${steps.length} -> ${step.tool}`);
+
+      try {
+        const result = await handleToolCall(step.tool, step.args || {});
+        results.push({ step: i, tool: step.tool, success: !result.isError, result });
+      } catch (e) {
+        logError(`pipeline_execute: step ${i} threw: ${e.message}`);
+        results.push({ step: i, tool: step.tool, success: false, error: e.message });
+      }
+    }
+
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) {
+    logError(`pipeline_execute: outer error: ${e.message}`);
+    return mcpError(`管道执行错误: ${e.message}`);
+  }
+}
+
+export async function pipelineSave({ name, steps }) {
+  if (!name || typeof name !== 'string' || !name.trim()) {
+    return mcpError('管道名称不能为空');
+  }
+  if (!steps || !Array.isArray(steps) || steps.length === 0) {
+    return mcpError('管道步骤不能为空');
+  }
+
+  try {
+    ensureDir();
+    const safeName = name.trim().replace(/[<>:"/\\|?*]/g, '_');
+    const data = { name: safeName, steps, createdAt: new Date().toISOString() };
+    fs.writeFileSync(pipelinePath(safeName), JSON.stringify(data, null, 2), 'utf-8');
+    log(`pipeline_save: saved "${safeName}" (${steps.length} steps)`);
+    return mcpSuccess(`管道 "${safeName}" 已保存 (${steps.length} 步)`);
+  } catch (e) {
+    logError(`pipeline_save error: ${e.message}`);
+    return mcpError(`保存管道失败: ${e.message}`);
+  }
+}
+
+export async function pipelineList() {
+  try {
+    ensureDir();
+    const files = fs.readdirSync(PIPELINES_DIR).filter(f => f.endsWith('.json'));
+    const pipelines = files.map(f => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(PIPELINES_DIR, f), 'utf-8'));
+        return { name: data.name, steps: data.steps?.length || 0, createdAt: data.createdAt };
+      } catch {
+        return { name: f.replace(/\.json$/, ''), steps: 0 };
+      }
+    });
+    if (pipelines.length === 0) {
+      return mcpSuccess('暂无已保存的管道。使用 pipeline_save 保存管道定义。');
+    }
+    const text = pipelines.map(p => `  ${p.name} (${p.steps} 步)`).join('\n');
+    return mcpSuccess(`已保存的管道 (${pipelines.length}):\n${text}`);
+  } catch (e) {
+    logError(`pipeline_list error: ${e.message}`);
+    return mcpError(`列出管道失败: ${e.message}`);
+  }
+}
+
+export async function pipelineRun({ name }) {
+  if (!name || typeof name !== 'string' || !name.trim()) {
+    return mcpError('管道名称不能为空');
+  }
+
+  try {
+    ensureDir();
+    const safeName = name.trim().replace(/[<>:"/\\|?*]/g, '_');
+    const filePath = pipelinePath(safeName);
+    if (!fs.existsSync(filePath)) {
+      return mcpError(`管道 "${safeName}" 不存在。使用 pipeline_list 查看可用管道。`);
+    }
+
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    log(`pipeline_run: executing "${safeName}" (${data.steps.length} steps)`);
+
+    return await pipelineExecute({ steps: data.steps });
+  } catch (e) {
+    logError(`pipeline_run error: ${e.message}`);
+    return mcpError(`运行管道失败: ${e.message}`);
+  }
+}
+
+export async function pipelineDelete({ name }) {
+  if (!name || typeof name !== 'string' || !name.trim()) {
+    return mcpError('管道名称不能为空');
+  }
+
+  try {
+    ensureDir();
+    const safeName = name.trim().replace(/[<>:"/\\|?*]/g, '_');
+    const filePath = pipelinePath(safeName);
+    if (!fs.existsSync(filePath)) {
+      return mcpError(`管道 "${safeName}" 不存在。使用 pipeline_list 查看可用管道。`);
+    }
+    fs.unlinkSync(filePath);
+    log(`pipeline_delete: deleted "${safeName}"`);
+    return mcpSuccess(`管道 "${safeName}" 已删除`);
+  } catch (e) {
+    logError(`pipeline_delete error: ${e.message}`);
+    return mcpError(`删除管道失败: ${e.message}`);
+  }
+}

package/dist/lisp-security.js

@@ -50,7 +50,7 @@ export function refreshConfig() {
 
 try {
   onConfigChange(() => { _cachedLevel = null; });
-} catch (_) {}
+} catch (e) { logError('[lisp-security]', e?.message || e); }
 
 function resolveSeverity(rule) {
   if (_cachedLevel) return _cachedLevel;
@@ -117,8 +117,6 @@ export function checkParens(code) {
   return { valid: true };
 }
 
-// === Session Sandbox (merged from lisp-sandbox.js) ===
-
 export const RULES = SECURITY_RULES;
 
 const sessionAllowlist = new Map();

package/package.json

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