@atlisp/mcp 1.3.0 → 1.3.2

package/src/cad.js

@@ -1,271 +0,0 @@
-import { spawn } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
-import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
-import config from './config.js';
-
-const MESSAGE_TIMEOUT = config.messageTimeout;
-const HEARTBEAT_INTERVAL = config.heartbeatInterval;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const workerPath = path.join(__dirname, 'cad-worker.js');
-
-let worker = null;
-let _platform = null;
-let _version = null;
-
-let heartbeatTimer = null;
-const pendingRequests = new Map();
-let stdoutHandlerSetup = false;
-
-const MAX_BUFFER_SIZE = 1024 * 1024;
-
-export 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);
-    }
-  });
-}
-
-export 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);
-}
-
-export function sendMessage(msg) {
-  const w = getWorker();
-  const requestId = randomUUID();
-
-  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}`));
-    }
-  });
-}
-
-class CadConnection {
-  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('未连接 CAD');
-    const result = await sendMessage({ type: 'send', code: code, platform: _platform });
-    if (result.success) return true;
-    throw new Error(result.error || '发送失败');
-  }
-
-  async sendCommandWithResult(code, encoding = null) {
-    if (!this.connected) throw new Error('未连接 CAD');
-    const result = await sendMessage({ type: 'sendResult', code: code, platform: _platform, encoding: encoding || '' });
-    if (result.success) {
-      return result.result || '';
-    }
-    throw new Error(result.error || '发送失败');
-  }
-
-  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('未连接 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('未连接 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 未连接';
-    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();
-  }
-}
-
-export const cad = new CadConnection();
-export default CadConnection;

package/src/config.js

@@ -1,50 +0,0 @@
-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;
-}
-
-const cliArgs = parseArgs();
-
-const 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 || '',
-};
-
-export function getConfig(key) {
-    return config[key];
-}
-
-export function getAllConfig() {
-    return { ...config };
-}
-
-export default config;

package/src/constants.js

@@ -1,23 +0,0 @@
-export const CAD_PLATFORMS = ['AutoCAD', 'ZWCAD', 'GStarCAD', 'BricsCAD'];
-export const FILE_EXTENSIONS = {
-    'AutoCAD': ['.fas', '.vlx'],
-    'ZWCAD': ['.zelx', '.vls'],
-    'GStarCAD': ['.fas', '.vlx'],
-    'BricsCAD': ['.des']
-};
-
-export const PROTOCOL_VERSION = '2024-11-05';
-export const SERVER_NAME = 'atlisp-mcp-server';
-export const SERVER_VERSION = '1.1.2';
-
-export const MOCK_PACKAGES = [
-    { name: 'base', description: '基础函数库', version: '1.0.0' },
-    { name: 'at-pm', description: '工程项目管理', version: '2.1.0' },
-    { name: 'network', description: '网络功能模块', version: '1.5.0' },
-    { name: 'userman', description: '用户管理', version: '1.2.0' },
-    { name: 'pkgman', description: '包管理器', version: '2.0.0' },
-    { name: 'sidebar', description: '侧边栏工具', version: '1.0.0' },
-    { name: 'aibot', description: 'AI 助手', version: '0.9.0' },
-    { name: 'tips', description: '每日提示', version: '1.0.0' },
-    { name: 'function', description: '函数库', version: '3.0.0' }
-];

package/src/errors.js

@@ -1,55 +0,0 @@
-export const ERROR_CODES = {
-    CAD_NOT_CONNECTED: 'CAD_NOT_CONNECTED',
-    CAD_BUSY: 'CAD_BUSY',
-    CAD_NO_DOCUMENT: 'CAD_NO_DOCUMENT',
-    LISP_PAREN_MISMATCH: 'LISP_PAREN_MISMATCH',
-    TIMEOUT: 'TIMEOUT',
-    INVALID_PARAMS: 'INVALID_PARAMS',
-    METHOD_NOT_FOUND: 'METHOD_NOT_FOUND',
-    RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
-    PACKAGE_NOT_FOUND: 'PACKAGE_NOT_FOUND',
-    INTERNAL_ERROR: 'INTERNAL_ERROR',
-};
-
-export const ERROR_MESSAGES = {
-    [ERROR_CODES.CAD_NOT_CONNECTED]: '未连接 CAD，请先调用 connect_cad',
-    [ERROR_CODES.CAD_BUSY]: 'CAD 忙碌，请稍后重试',
-    [ERROR_CODES.CAD_NO_DOCUMENT]: 'CAD 中没有打开的文档',
-    [ERROR_CODES.LISP_PAREN_MISMATCH]: 'LISP 代码括号不匹配',
-    [ERROR_CODES.TIMEOUT]: '操作超时',
-    [ERROR_CODES.INVALID_PARAMS]: '无效的参数',
-    [ERROR_CODES.METHOD_NOT_FOUND]: '方法不存在',
-    [ERROR_CODES.RESOURCE_NOT_FOUND]: '资源不存在',
-    [ERROR_CODES.PACKAGE_NOT_FOUND]: '包不存在',
-    [ERROR_CODES.INTERNAL_ERROR]: '内部错误',
-};
-
-export class MCPError extends Error {
-    constructor(code, message, details = {}) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'MCPError';
-    }
-
-    toJSON() {
-        return {
-            code: this.code,
-            message: this.message,
-            details: this.details
-        };
-    }
-}
-
-export function createError(code, details = {}) {
-    const message = ERROR_MESSAGES[code] || ERROR_MESSAGES[ERROR_CODES.INTERNAL_ERROR];
-    return new MCPError(code, message, details);
-}
-
-export function toMcpError(error) {
-    if (error instanceof MCPError) return error;
-    if (error instanceof Error) {
-        return new MCPError(ERROR_CODES.INTERNAL_ERROR, error.message, { stack: error.stack });
-    }
-    return new MCPError(ERROR_CODES.INTERNAL_ERROR, String(error));
-}

package/src/handlers/cad-handlers.js

@@ -1,110 +0,0 @@
-import { cad } from '../cad.js';
-import { log } from '../logger.js';
-
-export 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: `已连接到 ${cad.getPlatform()} ${cad.getVersion()}` }] };
-        }
-    } catch (e) {
-        log('connect_cad error: ' + e.message);
-    }
-    return { content: [{ type: 'text', text: '未能连接或启动 CAD，请确保 CAD 已安装' }], isError: true };
-}
-
-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 };
-    }
-    try {
-        if (withResult) {
-            const result = await cad.sendCommandWithResult(code, encoding);
-            if (result !== null) {
-                return { content: [{ type: 'text', text: result }] };
-            }
-            return { content: [{ type: 'text', text: '执行失败或无返回值' }], isError: true };
-        } else {
-            await cad.sendCommand(code + '\n');
-            return { content: [{ type: 'text', text: `已发送命令: ${code}` }] };
-        }
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function getCadInfo() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: 'CAD 未连接' }] };
-    const info = await cad.getInfo();
-    return { content: [{ type: 'text', text: info }] };
-}
-
-export async function atCommand(command) {
-    if (!cad.connected) return { content: [{ type: 'text', text: '请先连接 CAD' }], isError: true };
-    await cad.sendCommand(`${command}\n`);
-    return { content: [{ type: 'text', text: `已发送命令: ${command}` }] };
-}
-
-export async function newDocument() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    const result = await cad.newDoc();
-    if (result) {
-        return { content: [{ type: 'text', text: '已在 CAD 中新建空白文档' }] };
-    }
-    return { content: [{ type: 'text', text: '新建文档失败' }], isError: true };
-}
-
-export async function bringToFront() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    const result = await cad.bringToFront();
-    if (result) {
-        return { content: [{ type: 'text', text: '已将 CAD 窗口切换到前台' }] };
-    }
-    return { content: [{ type: 'text', text: '切换前台失败' }], isError: true };
-}
-
-export async function installAtlisp() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 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(installCode + '\n');
-    return { content: [{ type: 'text', text: '已发送 @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 async function initAtlisp() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 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(code + '\n');
-        return { content: [{ type: 'text', text: '已发送 @lisp 函数库加载代码到 CAD' }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}

package/src/handlers/function-handlers.js

@@ -1,107 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { log } from '../logger.js';
-import * as cadHandlers from './cad-handlers.js';
-
-const FUNCTIONS_DIR = process.env.FUNCTIONS_DIR || '';
-const FUNCTIONS_URL = process.env.FUNCTIONS_URL || 'http://s3.atlisp.cn/json/functions.json';
-
-async function fileExists(filePath) {
-    try { await fs.access(filePath); return true; } catch { return false; }
-}
-
-export 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(f => f.name === funcName || f.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 fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
-            for (const file of files) {
-                const raw = await fs.readFile(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);
-            }
-        }
-
-        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 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 fs.readdir(FUNCTIONS_DIR)).filter(f => f.endsWith('.json'));
-            for (const file of files) {
-                try {
-                    const raw = await fs.readFile(path.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 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 };
-    }
-}

package/src/handlers/package-handlers.js

@@ -1,66 +0,0 @@
-const PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || 'http://s3.atlisp.cn/packages-list?fmt=json';
-import { cad } from '../cad.js';
-import { MOCK_PACKAGES } from '../constants.js';
-let cachedPackages = null;
-let cachedAt = null;
-const CACHE_TTL = 10 * 60 * 1000;
-
-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;
-}
-
-export async function listPackages() {
-    if (!cad.connected) await cad.connect();
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 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: `已安装的 @lisp 包:\n${packages.join('\n')}` }] };
-}
-
-export async function searchPackages(query) {
-    const data = await fetchPackages();
-    if (!data) {
-        return { content: [{ type: 'text', text: '无法获取包列表' }], 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: `未找到包含 "${query}" 的包` }] };
-    }
-    return { content: [{ type: 'text', text: `搜索结果 (${results.length}):\n${results.map(p => `${p.name} v${p.version || ''} - ${p.description || ''}`).join('\n')}` }] };
-}
-
-export async function installPackage(packageName) {
-    const pkg = MOCK_PACKAGES.find(p => p.name === packageName);
-    if (!pkg) {
-        return { content: [{ type: 'text', text: `错误: 包 "${packageName}" 不存在` }], isError: true };
-    }
-    if (cad.connected) {
-        await cad.sendCommand(`(@::load-module '${packageName})\n`);
-    }
-    return { content: [{ type: 'text', text: `包 "${packageName}" 安装命令已发送！` }] };
-}