@atlisp/mcp 1.8.15 → 1.8.17

package/dist/handlers/external-handlers.js

@@ -0,0 +1,218 @@
+import { cad } from '../cad.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log, error as logError } from '../logger.js';
+import { escapeLispString } from '../handler-utils.js';
+
+const DATA_DIR = path.join(os.homedir(), '.atlisp', 'data');
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function validateSourcePath(source) {
+  const sanitized = source.replace(/[^a-zA-Z0-9_\-]/g, '_');
+  if (sanitized !== source) {
+    logError(`external-handlers: sanitized source "${source}" -> "${sanitized}"`);
+  }
+  const filePath = path.resolve(DATA_DIR, sanitized);
+  if (!filePath.startsWith(path.resolve(DATA_DIR) + path.sep) && filePath !== path.resolve(DATA_DIR)) {
+    throw new Error('路径穿越检测: 数据源路径必须位于 DATA_DIR 内');
+  }
+  return filePath;
+}
+
+function checkFileSize(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size > MAX_FILE_SIZE) {
+      throw new Error(`文件过大 (${(stat.size / 1024 / 1024).toFixed(1)}MB)，最大允许 ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+    }
+  } catch (e) {
+    if (e.code === 'ENOENT') return;
+    throw e;
+  }
+}
+
+function scanDataSources() {
+  ensureDataDir();
+  const sources = [];
+  try {
+    const files = fs.readdirSync(DATA_DIR);
+    for (const file of files) {
+      const ext = path.extname(file).toLowerCase();
+      if (['.csv', '.json', '.db', '.sqlite'].includes(ext)) {
+        sources.push({ name: file.replace(ext, ''), file, type: ext.slice(1) });
+      }
+    }
+  } catch (e) { logError(`external-handlers: scanDataSources error: ${e.message}`); }
+  return sources;
+}
+
+function queryCSV(filePath, filters = {}) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.trim().split('\n');
+  if (lines.length < 2) return [];
+  const headers = lines[0].split(',').map(h => h.trim());
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(',').map(v => v.trim());
+    const row = {};
+    headers.forEach((h, idx) => { row[h] = values[idx] || ''; });
+
+    let match = true;
+    for (const [key, val] of Object.entries(filters)) {
+      if (row[key] !== undefined && String(row[key]) !== String(val)) { match = false; break; }
+    }
+    if (match) rows.push(row);
+  }
+  return rows;
+}
+
+export function externalDbQuery(args) {
+  const { source, query, filters } = args;
+  ensureDataDir();
+
+  if (!source) {
+    const sources = scanDataSources();
+    return { content: [{ type: 'text', text: JSON.stringify({ sources }) }] };
+  }
+
+  let filePath;
+  try { filePath = validateSourcePath(source); } catch (e) { return { content: [{ type: 'text', text: e.message }], isError: true }; }
+  checkFileSize(filePath);
+  if (!fs.existsSync(filePath)) {
+    for (const ext of ['.csv', '.json']) {
+      const altPath = validateSourcePath(source + ext);
+      if (fs.existsSync(altPath)) {
+        checkFileSize(altPath);
+        const ext2 = path.extname(altPath).toLowerCase();
+        if (ext2 === '.csv') {
+          const rows = queryCSV(altPath, filters || {});
+          return { content: [{ type: 'text', text: JSON.stringify({ source, rows, count: rows.length }) }] };
+        } else if (ext2 === '.json') {
+          const data = JSON.parse(fs.readFileSync(altPath, 'utf-8'));
+          return { content: [{ type: 'text', text: JSON.stringify({ source, data }) }] };
+        }
+      }
+    }
+    return { content: [{ type: 'text', text: `数据源 "${source}" 未找到` }], isError: true };
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.csv') {
+    checkFileSize(filePath);
+    const rows = queryCSV(filePath, filters || {});
+    return { content: [{ type: 'text', text: JSON.stringify({ source, rows, count: rows.length }) }] };
+  } else if (ext === '.json') {
+    checkFileSize(filePath);
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return { content: [{ type: 'text', text: JSON.stringify({ source, data }) }] };
+  }
+
+  return { content: [{ type: 'text', text: `不支持的数据源类型: ${ext}` }], isError: true };
+}
+
+export function importExternalData(args) {
+  const { source, targetLayer, mapping } = args;
+  ensureDataDir();
+
+  let filePath;
+  try { filePath = validateSourcePath(source); } catch (e) { return { content: [{ type: 'text', text: e.message }], isError: true }; }
+  if (!fs.existsSync(filePath)) {
+    for (const ext of ['.csv', '.json']) {
+      try {
+        const altPath = validateSourcePath(source + ext);
+        if (fs.existsSync(altPath)) { filePath = altPath; break; }
+      } catch {}
+    }
+  }
+  if (!fs.existsSync(filePath)) {
+    return { content: [{ type: 'text', text: `数据源 "${source}" 未找到` }], isError: true };
+  }
+
+  let rows = [];
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.csv') {
+    rows = queryCSV(filePath);
+  } else if (ext === '.json') {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    rows = Array.isArray(data) ? data : (data.rows || data.data || []);
+  }
+
+  if (rows.length === 0) {
+    return { content: [{ type: 'text', text: '数据为空' }] };
+  }
+
+  const layer = targetLayer || 'ImportedData';
+  const createEntities = [];
+
+  for (const row of rows) {
+    const x = parseFloat(row[mapping?.x || 'x' || 'X']);
+    const y = parseFloat(row[mapping?.y || 'y' || 'Y']);
+    const z = parseFloat(row[mapping?.z || 'z' || 'Z'] || '0');
+    const label = row[mapping?.label || 'label' || 'name'] || '';
+
+    if (!isNaN(x) && !isNaN(y)) {
+      if (label) {
+        createEntities.push(`(entmakex (list (cons 0 "POINT") (cons 10 (list ${x} ${y} ${z})) (cons 8 "${escapeLispString(layer)}") (cons 1 "${escapeLispString(label)}")))`);
+      } else {
+        createEntities.push(`(entmakex (list (cons 0 "POINT") (cons 10 (list ${x} ${y} ${z})) (cons 8 "${escapeLispString(layer)}")))`);
+      }
+    }
+  }
+
+  if (createEntities.length === 0) {
+    return { content: [{ type: 'text', text: '没有有效的坐标数据可以导入' }] };
+  }
+
+  return cad.sendCommandWithResult(`(progn ${createEntities.join('\n')} (princ (strcat "导入了 " (itoa ${createEntities.length}) " 个实体到图层 ${layer}")))`).then(result => {
+    return { content: [{ type: 'text', text: result || `导入了 ${createEntities.length} 个实体到图层 "${layer}"` }] };
+  });
+}
+
+export function exportToExternal(args) {
+  const { format, outputFile, filter } = args;
+  ensureDataDir();
+
+  const lisp = `(progn
+    (setq ss (ssget "_X" '(${filter ? `(8 . "${escapeLispString(filter.layer || '*')}")` : ''}))
+    (setq n (sslength ss))
+    (setq result nil)
+    (setq i 0)
+    (while (< i n)
+      (setq e (ssname ss i))
+      (setq elist (entget e))
+      (setq result (cons (list (cdr (assoc 0 elist)) (cdr (assoc 5 elist)) (cdr (assoc 8 elist)) (cdr (assoc 10 elist))) result))
+      (setq i (1+ i)))
+    (reverse result))`;
+
+  return cad.sendCommandWithResult(lisp).then(raw => {
+    let entities;
+    try { entities = JSON.parse(raw); } catch { entities = []; }
+
+    const exportData = entities.map(e => ({
+      type: e[0], handle: e[1], layer: e[2], point: e[3]
+    }));
+
+    const outFile = outputFile || path.join(DATA_DIR, `export_${Date.now()}.${format || 'json'}`);
+    const dir = path.dirname(outFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    if (format === 'csv') {
+      const csv = 'type,handle,layer,point\n' + exportData.map(e => `"${e.type}","${e.handle}","${e.layer}","${e.point}"`).join('\n');
+      fs.writeFileSync(outFile, csv, 'utf-8');
+    } else {
+      fs.writeFileSync(outFile, JSON.stringify(exportData, null, 2), 'utf-8');
+    }
+
+    return { content: [{ type: 'text', text: JSON.stringify({ exported: exportData.length, file: outFile, format: format || 'json' }) }] };
+  });
+}
+
+export function listDataSources() {
+  const sources = scanDataSources();
+  return { content: [{ type: 'text', text: JSON.stringify({ sources }) }] };
+}

package/dist/handlers/file-handlers.js

@@ -0,0 +1,172 @@
+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;
+}
+
+export async function openDwg(filePath) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    try {
+      validateFilePath(filePath);
+    } catch (e) {
+      return { content: [{ type: 'text', text: e.message }], isError: true };
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (if (vl-file-directory-p (vl-filename-directory "${escapeLispString(filePath)}"))
+            (progn
+                (if (findfile "${escapeLispString(filePath)}")
+                    (progn
+                        (command "._OPEN" "${escapeLispString(filePath)}")
+                        "OPENED"
+                    )
+                    "NOTFOUND"
+                )
+            )
+            "INVALIDPATH"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OPENED' || result === '"OPENED"') {
+            return { content: [{ type: 'text', text: `已打开文件: ${filePath}` }] };
+        }
+        if (result === 'NOTFOUND' || result === '"NOTFOUND"') {
+            return { content: [{ type: 'text', text: `文件不存在: ${filePath}` }], isError: true };
+        }
+        if (result === 'INVALIDPATH' || result === '"INVALIDPATH"') {
+            return { content: [{ type: 'text', text: `路径无效: ${filePath}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: `打开失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function saveDwg(filePath = null) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    if (filePath) {
+      try {
+        validateFilePath(filePath);
+      } catch (e) {
+        return { content: [{ type: 'text', text: e.message }], isError: true };
+      }
+    }
+
+    const code = filePath
+        ? `(progn
+            (vl-load-com)
+            (command "._SAVEAS" "${escapeLispString(filePath)}")
+            "SAVED"
+        )`
+        : `(progn
+            (vl-load-com)
+            (command "._QSAVE")
+            "SAVED"
+        )`;
+
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'SAVED' || result === '"SAVED"') {
+            return { content: [{ type: 'text', text: filePath ? `已保存为: ${filePath}` : '已保存当前文件' }] };
+        }
+        return { content: [{ type: 'text', text: `保存失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function exportPdf(outputPath, layout = 'Model') {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    try {
+      validateFilePath(outputPath);
+    } catch (e) {
+      return { content: [{ type: 'text', text: e.message }], isError: true };
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (vlax-for doc (vla-get-Documents (vla-get-Application (vlax-get-acad-object)))
+            (if (or (eq (vla-get-Name doc) "${escapeLispString(layout)}") (eq "${escapeLispString(layout)}" "Model"))
+                (progn
+                    (vla-Export doc "${escapeLispString(outputPath)}" "pdf")
+                    (setq exported T)
+                )
+            )
+        )
+        (if exported "EXPORTED" "FAILED")
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'EXPORTED' || result === '"EXPORTED"') {
+            return { content: [{ type: 'text', text: `已导出 PDF: ${outputPath}` }] };
+        }
+        return { content: [{ type: 'text', text: `导出失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function closeDwg(save = false) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if ${save ? 'T' : 'nil'}
+            (command "._CLOSE" "Y")
+            (command "._CLOSE")
+        )
+        "CLOSED"
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: '已关闭图形' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function exportSvg(outputPath, layout = 'Model') {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        validateFilePath(outputPath);
+        const code = `(progn (vl-load-com) (setq doc (vla-get-activedocument (vlax-get-acad-object))) (setq layouts (vla-get-layouts doc)) (setq lay (vla-item layouts "${escapeLispString(layout)}")) (vla-Export lay "${escapeLispString(outputPath)}" "svg") (princ))`;
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: `已导出 SVG: ${outputPath}` }] };
+    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function exportBmp(outputPath) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        validateFilePath(outputPath);
+        await cad.sendCommand(`(command "_.SAVEIMG" "${escapeLispString(outputPath)}" "b")\n`);
+        return { content: [{ type: 'text', text: `已导出 BMP: ${outputPath}` }] };
+    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function exportStl(outputPath, handle = null) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        validateFilePath(outputPath);
+        const sel = handle ? `(ssadd (handent "${escapeLispString(handle)}"))` : '(ssget "_X" \'((0 . "3DSOLID")))';
+        await cad.sendCommand(`(command "_.EXPORT" "${escapeLispString(outputPath)}" "" ${sel})\n`);
+        return { content: [{ type: 'text', text: `已导出 STL: ${outputPath}` }] };
+    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}

package/dist/handlers/function-handlers.js

@@ -0,0 +1,158 @@
+import fs from 'fs';
+import path from 'path';
+import { log } from '../logger.js';
+import * as cadHandlers from './cad-handlers.js';
+import os from 'os';
+import config from '../config.js';
+
+const FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || '';
+const FUNCTIONS_URL = process.env.FUNCTIONS_URL || config.functionLibUrl || 'http://s3.atlisp.cn/json/functions.json';
+const CACHE_DIR = path.join(os.homedir(), '.atlisp', 'cache');
+const FUNCLIB_CACHE_FILE = path.join(CACHE_DIR, 'functions.json');
+const FUNCLIB_CACHE_TTL = config.functionLibCacheTtl || 24 * 60 * 60 * 1000;
+
+let cachedFunctionLib = null;
+let cachedAt = null;
+
+function readCacheFromDisk() {
+    try {
+        const stat = fs.statSync(FUNCLIB_CACHE_FILE);
+        if (Date.now() - stat.mtimeMs < FUNCLIB_CACHE_TTL) {
+            const raw = fs.readFileSync(FUNCLIB_CACHE_FILE, 'utf-8');
+            return JSON.parse(raw);
+        }
+    } catch (e) { log(`function-handlers: readCache error: ${e.message}`); }
+    return null;
+}
+
+function writeCacheToDisk(data) {
+    try {
+        fs.mkdirSync(CACHE_DIR, { recursive: true });
+        fs.writeFileSync(FUNCLIB_CACHE_FILE, JSON.stringify(data), 'utf-8');
+    } catch (e) {
+        log(`function-handlers writeCache error: ${e.message}`);
+    }
+}
+
+async function fetchFunctions() {
+    const now = Date.now();
+    if (cachedFunctionLib && cachedAt && (now - cachedAt) < FUNCLIB_CACHE_TTL) {
+        return cachedFunctionLib;
+    }
+
+    const diskCache = readCacheFromDisk();
+    if (diskCache) {
+        cachedFunctionLib = diskCache;
+        cachedAt = now;
+        return diskCache;
+    }
+
+    try {
+        const response = await fetch(FUNCTIONS_URL, {
+            headers: { 'User-Agent': 'atlisp-mcp' },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            cachedFunctionLib = data;
+            cachedAt = now;
+            writeCacheToDisk(data);
+            return data;
+        }
+    } catch (e) {
+        log(`function-handlers fetch error: ${e.message}`);
+    }
+    return cachedFunctionLib;
+}
+
+export async function loadAtlibFunctionLib() {
+    return await fetchFunctions();
+}
+
+export async function getFunctionUsage(funcName, packageName) {
+    try {
+        let results = [];
+
+        const data = await fetchFunctions();
+        if (data) {
+            const funcs = Object.values(data.all_functions || {});
+            const func = funcs.find(f => f.name === funcName || f.name === `${packageName}:${funcName}`);
+            if (func) results.push(func);
+        }
+
+        if (results.length === 0 && FUNCTIONS_DIR) {
+            try {
+                const files = fs.readdirSync(FUNCTIONS_DIR).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    const raw = fs.readFileSync(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    const func = data.functions?.find(f => f.name === funcName);
+                    if (func) results.push(func);
+                }
+            } catch (e) { log(`function-handlers: FUNCTIONS_DIR read error: ${e.message}`); }
+        }
+
+        if (results.length === 0) {
+            return { content: [{ type: 'text', text: `未找到函数: ${funcName}` }], isError: true };
+        }
+
+        const f = results[0];
+        const text = `函数: ${f.name}
+描述: ${f.description || '-'}
+参数: ${f.params?.join(', ') || '-'}
+返回值: ${f.return || '-'}
+示例: ${f.usage || '-'}`;
+
+        return { content: [{ type: 'text', text }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function listSymbols(packageName) {
+    try {
+        let allFuncs = [];
+
+        const data = await fetchFunctions();
+        if (data) {
+            const funcs = Object.values(data.all_functions || {});
+            if (packageName) {
+                allFuncs = funcs.filter(f => f.name.startsWith(`${packageName}:`));
+            } else {
+                allFuncs = funcs.map(f => `${f.name}: ${f.description || '-'}`);
+            }
+        }
+
+        if (allFuncs.length === 0 && FUNCTIONS_DIR) {
+            try {
+                const files = fs.readdirSync(FUNCTIONS_DIR).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    const raw = fs.readFileSync(path.join(FUNCTIONS_DIR, file), 'utf-8');
+                    const data = JSON.parse(raw);
+                    const funcs = Object.values(data.all_functions || {});
+                    if (packageName) {
+                        allFuncs = funcs.filter(f => f.name.startsWith(`${packageName}:`));
+                    } else {
+                        for (const f of funcs) {
+                            allFuncs.push(`${f.name}: ${f.description || '-'}`);
+                        }
+                    }
+                }
+            } catch (err) {
+                log(`listSymbols readDir error: ${err.message}`);
+            }
+        }
+
+        if (allFuncs.length === 0) {
+            return await cadHandlers.listFunctionsInCad();
+        }
+
+        if (packageName) {
+            return { content: [{ type: 'text', text: `${packageName} 包函数 (${allFuncs.length}):\n${allFuncs.map(f => f.name).join('\n')}` }] };
+        }
+
+        return { content: [{ type: 'text', text: allFuncs.join('\n') }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}