@atlisp/mcp 1.8.16 → 1.8.18

package/dist/handlers/viewport-handlers.js

@@ -0,0 +1,150 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+export async function createViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (setvar "CTAB" "${escapeLispString(params.layout)}")
+            (command "_.MVIEW" "${escapeLispString(params.corner1)}" "${escapeLispString(params.corner2)}")
+            (entlast)
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: `已在布局 ${params.layout} 创建视口，句柄: ${result}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function createPolygonalViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const pts = params.points.split(/\s+/).filter(Boolean);
+        const pointArgs = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
+        const code = `(progn
+            (vl-load-com)
+            (setvar "CTAB" "${escapeLispString(params.layout)}")
+            (command "_.MVIEW" "P" ${pointArgs} "C")
+            (entlast)
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: `已在布局 ${params.layout} 创建多边形视口，句柄: ${result}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setViewportScale(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq vp (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setvar "CVPORT" (cdr (assoc 69 (entget vp))))
+                    (command "_.ZOOM" (strcat (rtos (/ 1.0 ${params.scale}) 2 8) "XP"))
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置视口比例: 1:${params.scale}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置比例失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function lockViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq vp (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setq ed (entget vp))
+                    (entmod (subst '(90 . 16384) (assoc 90 ed) ed))
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已锁定视口: ${params.handle}` }] };
+        }
+        return { content: [{ type: 'text', text: `锁定视口失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function unlockViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq vp (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setq ed (entget vp))
+                    (setq val (cdr (assoc 90 ed)))
+                    (entmod (subst (cons 90 (logand val (~ 16384))) (assoc 90 ed) ed))
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已解锁视口: ${params.handle}` }] };
+        }
+        return { content: [{ type: 'text', text: `解锁视口失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function maximizeViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq vp (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (command "_.VPMAX" vp)
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已最大化视口: ${params.handle}` }] };
+        }
+        return { content: [{ type: 'text', text: `最大化视口失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function minimizeViewport(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(command "_.VPMIN")`;
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: '已最小化视口' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}

package/dist/handlers/xdata-handlers.js

@@ -0,0 +1,148 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected, escapeLispString } from '../handler-utils.js';
+
+export async function getXdata(handle, appName = 'ACAD') {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (setq xdata (assoc -3 (entget ent (list "${escapeLispString(appName)}"))))
+    (if xdata (princ (vl-prin1-to-string (cdr xdata))) (princ "nil"))
+  ) (princ "nil"))
+)`);
+    let xdata = null;
+    if (result && result !== 'nil' && result.trim()) { try { xdata = JSON.parse(result.trim()); } catch { xdata = result.trim(); } }
+    return mcpSuccess(JSON.stringify({ handle, appName, xdata }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function setXdata(handle, appName, data) {
+  try {
+    await ensureCadConnected();
+    const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+    const result = await cad.sendCommandWithResult(`(progn
+  (regapp "${escapeLispString(appName)}")
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (setq oldxdata (assoc -3 (entget ent (list "${escapeLispString(appName)}"))))
+    (setq entlist (if oldxdata (subst (cons -3 (list "${escapeLispString(appName)}" ${dataStr})) oldxdata (entget ent)) (append (entget ent) (list (cons -3 (list "${escapeLispString(appName)}" ${dataStr}))))))
+    (entmod entlist) (princ "ok"))
+  (princ "nil"))
+)`);
+    return mcpSuccess(JSON.stringify({ handle, appName, data: dataStr, set: result?.includes('ok') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function deleteXdata(handle, appName) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (setq oldxdata (assoc -3 (entget ent (list "${escapeLispString(appName)}"))))
+    (if oldxdata (progn (entmod (vl-remove oldxdata (entget ent))) (princ "deleted")) (princ "notfound"))
+  ) (princ "nil"))
+)`);
+    return mcpSuccess(JSON.stringify({ handle, appName, deleted: result?.includes('deleted') || result?.includes('notfound') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listXdataApps(handle) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (setq apps nil)
+    (foreach x (entget ent) (if (= (car x) -3) (setq apps (cons (cadr x) apps))))
+    (princ (vl-prin1-to-string (reverse apps)))
+  ) (princ "nil"))
+)`);
+    let apps = [];
+    if (result && result !== 'nil' && result.trim()) { try { apps = JSON.parse(result.trim()); } catch { apps = result.trim().replace(/[()]/g, '').split(' ').filter(Boolean); } }
+    return mcpSuccess(JSON.stringify({ handle, apps }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function getAllEntityXdata(handle) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (setq result nil)
+    (foreach x (entget ent) (if (= (car x) -3) (setq result (cons (list (cadr x) (cddr x)) result))))
+    (princ (vl-prin1-to-string (reverse result)))
+  ) (princ "nil"))
+)`);
+    let xdata = {};
+    if (result && result !== 'nil' && result.trim()) { try { xdata = JSON.parse(result.trim()); } catch { xdata = {}; } }
+    return mcpSuccess(JSON.stringify({ handle, xdata }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function copyXdata(sourceHandle, targetHandle, appName = null) {
+  try {
+    await ensureCadConnected();
+    if (appName) {
+      const xdataResult = await getXdata(sourceHandle, appName);
+      if (xdataResult.content?.[0]) {
+        const parsed = JSON.parse(xdataResult.content[0].text);
+        if (parsed.xdata) return await setXdata(targetHandle, appName, parsed.xdata);
+      }
+      return mcpError('源实体未找到扩展数据');
+    } else {
+      const allXdata = await getAllEntityXdata(sourceHandle);
+      if (allXdata.content?.[0]) {
+        const parsed = JSON.parse(allXdata.content[0].text);
+        if (parsed.xdata) {
+          for (const [app, data] of Object.entries(parsed.xdata)) { await setXdata(targetHandle, app, data); }
+          return mcpSuccess(JSON.stringify({ handles: [sourceHandle, targetHandle], copiedApps: Object.keys(parsed.xdata) }));
+        }
+      }
+      return mcpError('未找到扩展数据');
+    }
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function searchByXdata(appName, key, value) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq i -1 results nil ss (ssget "X" (list (cons -3 (list "${escapeLispString(appName)}" (list (cons 1000 "${escapeLispString(key)}") (cons 1000 "${escapeLispString(value)}")))))))
+  (if ss (repeat (sslength ss) (setq results (cons (cdr (assoc -1 (entget (ssname ss (setq i (1+ i)))))) results))))
+  (princ (vl-prin1-to-string (reverse results)))
+)`);
+    let handles = [];
+    if (result && result !== 'nil' && result.trim()) { try { handles = JSON.parse(result.trim()); } catch { handles = []; } }
+    return mcpSuccess(JSON.stringify({ appName, key, value, handles, count: handles.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function exportXdataToFile(handle, filePath) {
+  try {
+    await ensureCadConnected();
+    const xdataResult = await getAllEntityXdata(handle);
+    const parsed = JSON.parse(xdataResult.content[0].text);
+    const fs = await import('fs');
+    fs.writeFileSync(filePath, JSON.stringify(parsed.xdata, null, 2));
+    return mcpSuccess(JSON.stringify({ handle, filePath }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function importXdataFromFile(handle, filePath, appName) {
+  try {
+    await ensureCadConnected();
+    const fs = await import('fs');
+    const data = fs.readFileSync(filePath, 'utf8');
+    const xdata = JSON.parse(data);
+    if (appName && xdata[appName]) {
+      return await setXdata(handle, appName, xdata[appName]);
+    } else {
+      for (const [app, data] of Object.entries(xdata)) { await setXdata(handle, app, data); }
+      return mcpSuccess(JSON.stringify({ handle, imported: Object.keys(xdata) }));
+    }
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}

package/dist/handlers/xref-handlers.js

@@ -0,0 +1,334 @@
+import { cad } from '../cad.js';
+import { mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
+
+function esc(s) {
+  return escapeLispString(String(s));
+}
+
+function lispPoint(pt) {
+  if (!pt || pt === '0,0,0') return '(list 0 0 0)';
+  const parts = pt.split(',').map(Number);
+  return `(list ${parts[0] || 0} ${parts[1] || 0} ${parts[2] || 0})`;
+}
+
+export async function attachXref(args) {
+  try {
+    const path = esc(args.path);
+    const point = lispPoint(args.point);
+    const scale = args.scale || 1;
+    const rotation = args.rotation || 0;
+    const overlay = args.overlay ? '_O' : '_A';
+    const result = await cad.sendCommandWithResult(
+      `(command "_.XATTACH" "${path}" "${overlay}" "${point}" "${scale}" "${rotation}") (princ)`
+    );
+    return mcpSuccess(`外部参照已附着: ${args.path}`);
+  } catch (e) {
+    return mcpError(`附着外部参照失败: ${e.message}`);
+  }
+}
+
+export async function detachXref(args) {
+  try {
+    const name = esc(args.name);
+    await cad.sendCommand(
+      `(command "_.XREF" "_D" "${name}" "") (princ)`
+    );
+    return mcpSuccess(`外部参照已拆离: ${args.name}`);
+  } catch (e) {
+    return mcpError(`拆离外部参照失败: ${e.message}`);
+  }
+}
+
+export async function reloadXref(args) {
+  try {
+    const name = esc(args.name);
+    await cad.sendCommand(
+      `(command "_.XREF" "_R" "${name}" "") (princ)`
+    );
+    return mcpSuccess(`外部参照已重载: ${args.name}`);
+  } catch (e) {
+    return mcpError(`重载外部参照失败: ${e.message}`);
+  }
+}
+
+export async function unloadXref(args) {
+  try {
+    const name = esc(args.name);
+    await cad.sendCommand(
+      `(command "_.XREF" "_U" "${name}" "") (princ)`
+    );
+    return mcpSuccess(`外部参照已卸载: ${args.name}`);
+  } catch (e) {
+    return mcpError(`卸载外部参照失败: ${e.message}`);
+  }
+}
+
+export async function listXrefs() {
+  try {
+    const result = await cad.sendCommandWithResult(
+      `(progn
+  (setq xrefs (vla-get-blocks (vla-get-activedocument (vlax-get-acad-object))))
+  (setq res nil)
+  (vlax-for b xrefs
+    (if (and (= (vla-get-isxref b) :vlax-true) (/= (vla-get-name b) "*U*"))
+      (setq res (cons
+        (list
+          (cons "name" (vla-get-name b))
+          (cons "path" (vla-get-path b))
+          (cons "xref" T)
+        )
+        res)
+      )
+    )
+  )
+  (if res (vl-princ-to-string res) "[]")
+)`
+    );
+    return mcpSuccess(result || '[]');
+  } catch (e) {
+    return mcpError(`获取外部参照列表失败: ${e.message}`);
+  }
+}
+
+export async function bindXref(args) {
+  try {
+    const name = esc(args.name);
+    const bindType = args.bindType === 'insert' ? '_I' : '_B';
+    await cad.sendCommand(
+      `(command "_.XREF" "_B" "${name}" "${bindType}") (princ)`
+    );
+    return mcpSuccess(`外部参照已绑定: ${args.name}`);
+  } catch (e) {
+    return mcpError(`绑定外部参照失败: ${e.message}`);
+  }
+}
+
+export async function clipXref(args) {
+  try {
+    const name = esc(args.name);
+    const pts = String(args.points).trim();
+    await cad.sendCommandWithResult(
+      `(command "_.XCLIP" "_N" "${name}" "_P" "_P" "${pts}" "") (princ)`
+    );
+    return mcpSuccess(`外部参照已裁剪: ${args.name}`);
+  } catch (e) {
+    return mcpError(`裁剪外部参照失败: ${e.message}`);
+  }
+}
+
+export async function pathXref(args) {
+  try {
+    const name = esc(args.name);
+    const newPath = esc(args.newPath);
+    const result = await cad.sendCommandWithResult(
+      `(progn
+  (setq blocks (vla-get-blocks (vla-get-activedocument (vlax-get-acad-object))))
+  (vlax-for b blocks
+    (if (and (= (vla-get-isxref b) :vlax-true) (= (vla-get-name b) "${name}"))
+      (progn
+        (vla-put-path b "${newPath}")
+        (vla-reload b)
+        (princ "ok")
+      )
+    )
+  )
+  (princ "not found")
+)`
+    );
+    if (result.includes('ok')) {
+      return mcpSuccess(`外部参照路径已更新: ${args.name} → ${args.newPath}`);
+    }
+    return mcpError(`未找到外部参照: ${args.name}`);
+  } catch (e) {
+    return mcpError(`修改外部参照路径失败: ${e.message}`);
+  }
+}
+
+export async function xrefNotifications(args) {
+  try {
+    const val = args.enable;
+    if (val === undefined || val === null) {
+      const result = await cad.sendCommandWithResult(`(getvar "XREFNOTIFY")`);
+      const current = parseInt(result?.trim() || '0');
+      return mcpSuccess(JSON.stringify({
+        enabled: current > 0,
+        value: current,
+        balloonNotification: current === 2
+      }));
+    }
+    const newVal = val === true ? 1 : val === false ? 0 : Number(val);
+    await cad.sendCommand(`(setvar "XREFNOTIFY" ${newVal})`);
+    return mcpSuccess(JSON.stringify({ enabled: newVal > 0, value: newVal }));
+  } catch (e) {
+    return mcpError(`设置外部参照通知失败: ${e.message}`);
+  }
+}
+
+export async function xrefCompare(args) {
+  try {
+    const xrefName = esc(args.xrefName || '');
+    const handle = esc(args.handle || '');
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq blocks (vla-get-blocks doc))
+  (setq target nil)
+  (vlax-for b blocks
+    (if (or ${xrefName ? `(= (vla-get-name b) "${xrefName}")` : 'nil'} ${handle ? `(= (vla-get-handle b) "${handle}")` : 'nil'})
+      (setq target b)
+    )
+  )
+  (if (and target (= (vla-get-isxref target) :vlax-true))
+    (progn
+      (setq ents nil)
+      (vlax-for e target
+        (setq ents (cons (list
+          (cons "handle" (vla-get-handle e))
+          (cons "type" (vla-get-objectname e))
+        ) ents))
+      )
+      (princ (vl-princ-to-string (list
+        (cons "name" (vla-get-name target))
+        (cons "path" (vla-get-path target))
+        (cons "loaded" (vla-get-isloaded target))
+        (cons "entities" (reverse ents))
+      )))
+    )
+    (princ "null")
+  )
+)`);
+    if (result === 'null' || !result) {
+      return mcpError(`外部参照未找到: ${args.xrefName || args.handle}`);
+    }
+    return mcpSuccess(result);
+  } catch (e) {
+    return mcpError(`比较外部参照失败: ${e.message}`);
+  }
+}
+
+export async function xrefConvertToBlock(args) {
+  try {
+    const xrefName = esc(args.xrefName || args.handle || '');
+    const bindType = args.bindType === 'insert' ? 1 : 0;
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq blocks (vla-get-blocks doc))
+  (setq done nil)
+  (vlax-for b blocks
+    (if (and (= (vla-get-isxref b) :vlax-true) (= (vla-get-name b) "${xrefName}"))
+      (progn
+        (vla-bind b ${bindType})
+        (setq done T)
+      )
+    )
+  )
+  (princ (if done "ok" "not found"))
+)`);
+    if (result && result.trim() === 'ok') {
+      return mcpSuccess(JSON.stringify({
+        name: args.xrefName || args.handle,
+        converted: true,
+        bindType: bindType === 0 ? 'bind' : 'insert'
+      }));
+    }
+    return mcpError(`未找到外部参照: ${xrefName}`);
+  } catch (e) {
+    return mcpError(`转换外部参照为块失败: ${e.message}`);
+  }
+}
+
+export async function xrefDemote(args) {
+  try {
+    const parentXref = esc(args.parentXref || '');
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq blocks (vla-get-blocks doc))
+  (setq parent nil)
+  (vlax-for b blocks
+    (if (or (= (vla-get-name b) "${parentXref}") (= (vla-get-handle b) "${parentXref}"))
+      (setq parent b)
+    )
+  )
+  (if (and parent (= (vla-get-isxref parent) :vlax-true))
+    (progn
+      (setq demoted nil)
+      (vlax-for e parent
+        (if (= (vla-get-objectname e) "AcDbBlockReference")
+          (progn
+            (setq refName (vla-get-name e))
+            (setq refBlock (vlax-catch-apply (function (lambda (n) (vla-item blocks n))) (list refName)))
+            (if (and refBlock (= (vla-get-isxref refBlock) :vlax-true))
+              (progn
+                (setq already nil)
+                (vlax-for b2 blocks
+                  (if (and (= (vla-get-isxref b2) :vlax-true) (= (vla-get-name b2) refName) (not (eq b2 parent)))
+                    (setq already T)
+                  )
+                )
+                (if (not already)
+                  (progn
+                    (command "_.XREF" "_A" (vla-get-path refBlock) "0,0,0" "1" "0")
+                    (setq demoted (cons refName demoted))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+      (princ (vl-princ-to-string (list (cons "demoted" (reverse demoted)))))
+    )
+    (princ "null")
+  )
+)`);
+    if (result === 'null' || !result) {
+      return mcpError(`父外部参照未找到或不是外部参照: ${args.parentXref}`);
+    }
+    return mcpSuccess(result);
+  } catch (e) {
+    return mcpError(`降级外部参照失败: ${e.message}`);
+  }
+}
+
+export async function xrefPathRelative(args) {
+  try {
+    const names = args.xrefNames;
+    const isAll = names === 'all';
+    const nameList = isAll ? [] : (Array.isArray(names) ? names : [names]);
+    const nameListStr = nameList.map(n => `"${esc(n)}"`).join(' ');
+
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq blocks (vla-get-blocks doc))
+  (setq dwgPrefix (getvar "DWGPREFIX"))
+  (setq results nil)
+  (vlax-for b blocks
+    (if (and (= (vla-get-isxref b) :vlax-true)
+             (or ${isAll ? 'T' : `(member (vla-get-name b) (list ${nameListStr}))`}))
+      (progn
+        (setq curPath (vla-get-path b))
+        (setq name (vla-get-name b))
+        (setq dwgDir (vl-string-right-trim "\\\\/" (strcase dwgPrefix)))
+        (setq xp (strcase curPath))
+        (if (and (> (strlen xp) (strlen dwgDir)) (= (substr xp 1 (strlen dwgDir)) dwgDir))
+          (progn
+            (setq newPath (strcat ".\\\\" (substr xp (+ (strlen dwgDir) 2))))
+            (vla-put-path b newPath)
+            (vla-reload b)
+          )
+          (setq newPath curPath)
+        )
+        (setq results (cons (list (cons "name" name) (cons "oldPath" curPath) (cons "newPath" newPath)) results))
+      )
+    )
+  )
+  (princ (vl-princ-to-string (reverse results)))
+)`);
+    return mcpSuccess(result || '[]');
+  } catch (e) {
+    return mcpError(`转换外部参照路径为相对路径失败: ${e.message}`);
+  }
+}

package/dist/lisp-security.js

@@ -35,9 +35,14 @@ export function stripStringsAndComments(code) {
 
 export function validateLispCodeWorker(code) {
   const clean = stripStringsAndComments(code);
-  for (const { re, msg } of SECURITY_RULES) {
+  for (const { re, severity, msg } of SECURITY_RULES) {
     if (re.test(clean)) {
-      return { valid: false, error: msg };
+      if (severity === THREAT_BLOCK) {
+        return { valid: false, error: msg };
+      }
+      if (severity === THREAT_WARN) {
+        log('WARN: ' + msg);
+      }
     }
   }
   return { valid: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/mcp",
-  "version": "1.8.16",
+  "version": "1.8.18",
   "description": "MCP Server for @lisp on CAD,support AutoCAD/GstarCAD/ZWCAD/BricsCAD or CAD platform compatible with AutoLISP",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "start": "node src/atlisp-mcp.js",
     "build": "npm run build:main && npm run build:worker",
     "build:main": "esbuild src/atlisp-mcp.js --bundle --platform=node --target=node18 --format=esm --outdir=dist --external:edge-js --packages=external --banner:js=\"#!/usr/bin/env node\"",
-    "build:worker": "node -e \"const fs=require('fs');const path=require('path');for(const f of ['cad-worker.js','lisp-security.js','logger.js','config.js'])fs.copyFileSync('src/'+f,'dist/'+f);if(!fs.existsSync('dist/html'))fs.mkdirSync('dist/html');for(const f of fs.readdirSync('src/html'))fs.copyFileSync('src/html/'+f,'dist/html/'+f)\"",
+    "build:worker": "node -e \"const fs=require('fs');const path=require('path');for(const f of ['cad-worker.js','lisp-security.js','logger.js','config.js'])fs.copyFileSync('src/'+f,'dist/'+f);if(!fs.existsSync('dist/html'))fs.mkdirSync('dist/html');for(const f of fs.readdirSync('src/html'))fs.copyFileSync('src/html/'+f,'dist/html/'+f);if(!fs.existsSync('dist/handlers'))fs.mkdirSync('dist/handlers');for(const f of fs.readdirSync('src/handlers'))fs.copyFileSync('src/handlers/'+f,'dist/handlers/'+f)\"",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest"