ms-vite-plugin 1.1.16 → 1.1.18

package/dist/mcp/tools.js

@@ -1,935 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DEVICE_PORT = void 0;
 exports.createMcpServer = createMcpServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const z = __importStar(require("zod/v4"));
-const fsExtra = __importStar(require("fs-extra"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const packager_1 = require("../packager");
-const project_1 = require("../project");
-const project_2 = require("./project");
+const version_1 = require("../version");
 const device_config_1 = require("./device-config");
 Object.defineProperty(exports, "DEFAULT_DEVICE_PORT", { enumerable: true, get: function () { return device_config_1.DEFAULT_DEVICE_PORT; } });
-const docs_service_1 = require("./docs-service");
-const types_1 = require("./types");
-const version_1 = require("../version");
-/**
- * 设备日志内存缓存上限
- * - 采用环形窗口思路，仅保留最新 5000 条，避免 MCP 进程长期运行时内存无限增长
- */
-const DEVICE_LOG_MEMORY_LIMIT = 5000;
-/**
- * SSE 重连等待时间（毫秒）
- * - 当设备日志流异常断开时，后台会自动尝试重连
- */
-const DEVICE_LOG_RECONNECT_DELAY_MS = 1500;
-/**
- * 视为“仍在工作中”的日志订阅状态集合
- * - 用于判断同一设备是否可以直接复用已有后台连接
- */
-const ACTIVE_DEVICE_LOG_SUBSCRIPTION_STATUSES = new Set([
-    "connecting",
-    "connected",
-    "reconnecting",
-]);
-/**
- * 进程级设备日志订阅状态
- * - 当前 MCP 仅维护单设备日志缓存
- * - MCP Tool 处理函数会复用同一份内存缓存
- */
-const deviceLogSubscriptionState = {
-    target: null,
-    status: "idle",
-    lastError: null,
-    lastEventAt: null,
-    startedAt: null,
-    logs: [],
-    runtimeStatus: [],
-    generation: 0,
-    controller: null,
-    reconnectTimer: null,
-};
-/**
- * 向环形缓冲区追加数据
- * @param buffer 目标数组
- * @param entry 待写入的数据
- * @param limit 数组最大长度
- * @returns 无返回值
- * @example
- * pushRingBuffer([1, 2], 3, 2)
- */
-function pushRingBuffer(buffer, entry, limit) {
-    if (buffer.length >= limit) {
-        buffer.splice(0, buffer.length - limit + 1);
-    }
-    buffer.push(entry);
-}
-/**
- * 创建标准 MCP 文本内容对象
- * @param text 返回文本
- * @returns 返回 `{ type: "text", text }` 结构
- * @example
- * createTextContent("ok")
- */
-function createTextContent(text) {
-    return {
-        type: "text",
-        text,
-    };
-}
-/**
- * 创建标准 MCP 文本工具返回值
- * @param text 返回文本
- * @param isError 是否标记为错误响应
- * @returns 返回包含单条文本内容的 MCP Tool 结果
- * @example
- * createTextToolResult("done")
- */
-function createTextToolResult(text, isError = false) {
-    return {
-        content: [createTextContent(text)],
-        ...(isError ? { isError: true } : {}),
-    };
-}
-/**
- * 构建运行时 HTTP 请求参数
- * @param target 已解析的设备目标
- * @returns 返回项目内部设备请求参数
- * @example
- * const options = createRuntimeHttpRequestOptions(target)
- */
-function createRuntimeHttpRequestOptions(target) {
-    return {
-        ip: target.ip,
-        port: target.port,
-        transport: "http",
-    };
-}
-/**
- * 重置当前日志缓存快照
- * @returns 无返回值
- * @example
- * resetDeviceLogSnapshotState()
- */
-function resetDeviceLogSnapshotState() {
-    deviceLogSubscriptionState.lastError = null;
-    deviceLogSubscriptionState.lastEventAt = null;
-    deviceLogSubscriptionState.startedAt = new Date().toISOString();
-    deviceLogSubscriptionState.logs = [];
-    deviceLogSubscriptionState.runtimeStatus = [];
-}
-/**
- * 判断日志订阅是否仍然活跃
- * @returns 活跃返回 true，否则返回 false
- * @example
- * const active = isDeviceLogSubscriptionActive()
- */
-function isDeviceLogSubscriptionActive() {
-    return (ACTIVE_DEVICE_LOG_SUBSCRIPTION_STATUSES.has(deviceLogSubscriptionState.status) || deviceLogSubscriptionState.reconnectTimer !== null);
-}
-/**
- * 解析单个 SSE 文本块
- * @param rawBlock 原始 SSE 文本块
- * @returns 返回事件名与 data 字符串
- * @example
- * parseSseEventBlock("event: log\ndata: {\"message\":\"ok\"}")
- */
-function parseSseEventBlock(rawBlock) {
-    const lines = rawBlock.split(/\r?\n/);
-    let eventName = "message";
-    const dataLines = [];
-    for (const line of lines) {
-        if (line.startsWith("event:")) {
-            eventName = line.slice(6).trim() || "message";
-            continue;
-        }
-        if (line.startsWith("data:")) {
-            dataLines.push(line.slice(5).trimStart());
-        }
-    }
-    return {
-        event: eventName,
-        data: dataLines.join("\n"),
-    };
-}
-/**
- * 将原始日志对象标准化为统一结构
- * @param payload 日志原始对象
- * @returns 返回标准化后的日志
- * @example
- * normalizeBufferedLogEntry({ level: "info", message: "started" })
- */
-function normalizeBufferedLogEntry(payload) {
-    const levelText = String(payload.level ?? "info").toLowerCase();
-    const messageText = String(payload.message ?? "");
-    const timestampText = typeof payload.timestamp === "string" && payload.timestamp
-        ? payload.timestamp
-        : new Date().toISOString();
-    return {
-        level: levelText,
-        message: messageText,
-        timestamp: timestampText,
-    };
-}
-/**
- * 清理当前后台日志订阅
- * @returns 无返回值
- * @example
- * stopDeviceLogSubscription()
- */
-function stopDeviceLogSubscription() {
-    if (deviceLogSubscriptionState.reconnectTimer) {
-        clearTimeout(deviceLogSubscriptionState.reconnectTimer);
-        deviceLogSubscriptionState.reconnectTimer = null;
-    }
-    if (deviceLogSubscriptionState.controller) {
-        deviceLogSubscriptionState.controller.abort();
-        deviceLogSubscriptionState.controller = null;
-    }
-}
-/**
- * 安排后台重连
- * @param generation 当前订阅代次
- * @returns 无返回值
- * @example
- * scheduleDeviceLogReconnect(1)
- */
-function scheduleDeviceLogReconnect(generation) {
-    if (generation !== deviceLogSubscriptionState.generation ||
-        !deviceLogSubscriptionState.target) {
-        return;
-    }
-    if (deviceLogSubscriptionState.reconnectTimer) {
-        return;
-    }
-    deviceLogSubscriptionState.status = "reconnecting";
-    deviceLogSubscriptionState.reconnectTimer = setTimeout(() => {
-        deviceLogSubscriptionState.reconnectTimer = null;
-        void startDeviceLogSubscriptionLoop(generation);
-    }, DEVICE_LOG_RECONNECT_DELAY_MS);
-}
-/**
- * 启动一次 SSE 读取循环
- * - 该函数仅负责单次连接；若连接中断，会由外层自动调度重连
- * @param generation 当前订阅代次
- * @returns 读取流程结束后返回 Promise<void>
- * @example
- * await startDeviceLogSubscriptionLoop(1)
- */
-async function startDeviceLogSubscriptionLoop(generation) {
-    if (generation !== deviceLogSubscriptionState.generation ||
-        !deviceLogSubscriptionState.target) {
-        return;
-    }
-    const { ip, port } = deviceLogSubscriptionState.target;
-    const controller = new AbortController();
-    const url = `http://${ip}:${port}/logger/sse`;
-    deviceLogSubscriptionState.controller = controller;
-    deviceLogSubscriptionState.status =
-        deviceLogSubscriptionState.lastEventAt === null
-            ? "connecting"
-            : "reconnecting";
-    try {
-        const response = await fetch(url, {
-            method: "GET",
-            signal: controller.signal,
-            headers: {
-                Accept: "text/event-stream",
-            },
-        });
-        if (!response.ok || !response.body) {
-            throw new Error(`连接日志流失败: ${response.status} ${response.statusText || "unknown"}`);
-        }
-        deviceLogSubscriptionState.status = "connected";
-        deviceLogSubscriptionState.lastError = null;
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder("utf-8");
-        let buffer = "";
-        while (generation === deviceLogSubscriptionState.generation) {
-            const { value, done } = await reader.read();
-            if (done) {
-                break;
-            }
-            buffer += decoder.decode(value, { stream: true });
-            let splitIndex = buffer.search(/\r?\n\r?\n/);
-            while (splitIndex >= 0) {
-                const rawBlock = buffer.slice(0, splitIndex);
-                buffer = buffer.slice(splitIndex + (buffer[splitIndex] === "\r" ? 4 : 2));
-                const event = parseSseEventBlock(rawBlock);
-                if (event.data) {
-                    try {
-                        const parsed = JSON.parse(event.data);
-                        deviceLogSubscriptionState.lastEventAt = new Date().toISOString();
-                        if (event.event === "log") {
-                            pushRingBuffer(deviceLogSubscriptionState.logs, normalizeBufferedLogEntry(parsed), DEVICE_LOG_MEMORY_LIMIT);
-                        }
-                        else if (event.event === "runtime_status") {
-                            pushRingBuffer(deviceLogSubscriptionState.runtimeStatus, {
-                                raw: parsed,
-                                timestamp: new Date().toISOString(),
-                            }, DEVICE_LOG_MEMORY_LIMIT);
-                        }
-                    }
-                    catch {
-                        // 忽略单条非法 JSON，避免因为异常日志阻塞整个后台连接
-                    }
-                }
-                splitIndex = buffer.search(/\r?\n\r?\n/);
-            }
-        }
-        if (generation === deviceLogSubscriptionState.generation) {
-            scheduleDeviceLogReconnect(generation);
-        }
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            (error.name === "AbortError" ||
-                error.message === "The operation was aborted.")) {
-            return;
-        }
-        if (generation === deviceLogSubscriptionState.generation) {
-            deviceLogSubscriptionState.status = "error";
-            deviceLogSubscriptionState.lastError =
-                error instanceof Error ? error.message : String(error);
-            scheduleDeviceLogReconnect(generation);
-        }
-    }
-    finally {
-        if (deviceLogSubscriptionState.controller === controller) {
-            deviceLogSubscriptionState.controller = null;
-        }
-    }
-}
-/**
- * 确保后台日志订阅处于目标设备上
- * - 若目标未变化且订阅仍在运行，则直接复用已有连接
- * - 若目标发生变化，则重置缓存并重新建立订阅
- * @param ip 设备 IP
- * @param port 设备端口
- * @returns 返回是否复用了现有订阅
- * @example
- * const reused = ensureDeviceLogSubscription("192.168.1.10", 9800)
- */
-function ensureDeviceLogSubscription(ip, port) {
-    const sameTarget = deviceLogSubscriptionState.target?.ip === ip &&
-        deviceLogSubscriptionState.target?.port === port;
-    const isActive = isDeviceLogSubscriptionActive();
-    if (sameTarget && isActive) {
-        return true;
-    }
-    stopDeviceLogSubscription();
-    deviceLogSubscriptionState.generation += 1;
-    deviceLogSubscriptionState.target = { ip, port };
-    deviceLogSubscriptionState.status = "connecting";
-    resetDeviceLogSnapshotState();
-    void startDeviceLogSubscriptionLoop(deviceLogSubscriptionState.generation);
-    return false;
-}
-/**
- * 生成日志缓存快照文本
- * @param limit 需要返回的日志条数
- * @param runtimeStatusLimit 需要返回的 runtime_status 条数
- * @returns 返回用于 MCP 文本响应的快照内容
- * @example
- * const text = buildDeviceLogSnapshotText(100, 20)
- */
-function buildDeviceLogSnapshotText(limit, runtimeStatusLimit) {
-    const recentLogs = deviceLogSubscriptionState.logs
-        .slice(-limit)
-        .map((log) => `[${formatDisplayTimestamp(log.timestamp)}] [${log.level.toUpperCase()}] ${log.message}`);
-    const recentRuntimeStatus = deviceLogSubscriptionState.runtimeStatus
-        .slice(-runtimeStatusLimit)
-        .map((entry) => formatRuntimeStatusEntry(entry));
-    return [
-        `设备: ${deviceLogSubscriptionState.target
-            ? `${deviceLogSubscriptionState.target.ip}:${deviceLogSubscriptionState.target.port}`
-            : "未订阅"}`,
-        `状态: ${formatDeviceLogSubscriptionStatus(deviceLogSubscriptionState.status)}`,
-        ...(deviceLogSubscriptionState.lastError
-            ? [`最近错误: ${deviceLogSubscriptionState.lastError}`]
-            : []),
-        "",
-        `最新日志（最多 ${limit} 条）:`,
-        recentLogs.length > 0 ? recentLogs.join("\n") : "无日志",
-        "",
-        `最新运行状态（最多 ${runtimeStatusLimit} 条）:`,
-        recentRuntimeStatus.length > 0
-            ? recentRuntimeStatus.join("\n")
-            : "无运行状态",
-    ].join("\n");
-}
-/**
- * 按日志页面风格格式化时间
- * @param value ISO 时间字符串
- * @returns 返回 `yyyy/mm/dd hh:mm:ss.xxx` 风格文本，异常时回退原值
- * @example
- * formatDisplayTimestamp("2026-05-07T11:34:48.776Z")
- */
-function formatDisplayTimestamp(value) {
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) {
-        return value;
-    }
-    const pad = (number, length = 2) => String(number).padStart(length, "0");
-    return `${date.getFullYear()}/${pad(date.getMonth() + 1)}/${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`;
-}
-/**
- * 将日志订阅连接状态转为中文文本
- * @param status 原始连接状态
- * @returns 返回中文状态说明
- * @example
- * formatDeviceLogSubscriptionStatus("connected")
- */
-function formatDeviceLogSubscriptionStatus(status) {
-    switch (status) {
-        case "idle":
-            return "未订阅";
-        case "connecting":
-            return "连接中";
-        case "connected":
-            return "已连接";
-        case "reconnecting":
-            return "重连中";
-        case "error":
-            return "连接异常";
-        default:
-            return status;
-    }
-}
-/**
- * 将 runtime_status 中的内存数值格式化为可读文本
- * @param value 原始数值
- * @param suffix 数值单位后缀
- * @returns 数值存在时返回格式化结果，否则返回 unknown
- * @example
- * formatRuntimeMetricText(12.3456, " MB")
- */
-function formatRuntimeMetricText(value, suffix = "") {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return `${value.toFixed(2)}${suffix}`;
-    }
-    return "未知";
-}
-/**
- * 将单条 runtime_status 事件格式化为中文运行状态摘要
- * @param entry runtime_status 条目
- * @returns 返回更易读的状态文本
- * @example
- * formatRuntimeStatusEntry({ raw: { isRunning: false }, timestamp: "2026-01-01T00:00:00.000Z" })
- */
-function formatRuntimeStatusEntry(entry) {
-    const raw = entry.raw;
-    const memory = raw.memory && typeof raw.memory === "object"
-        ? raw.memory
-        : {};
-    return [
-        `[${formatDisplayTimestamp(entry.timestamp)}]`,
-        `UI: ${typeof raw.isUIShowing === "boolean"
-            ? raw.isUIShowing
-                ? "显示中"
-                : "未显示"
-            : "未知"}`,
-        `脚本: ${typeof raw.isRunning === "boolean"
-            ? raw.isRunning
-                ? "运行中"
-                : "未运行"
-            : "未知"}`,
-        `总内存: ${formatRuntimeMetricText(memory.total, " MB")}`,
-        `可用: ${formatRuntimeMetricText(memory.available, " MB")}`,
-        `已用: ${formatRuntimeMetricText(memory.used, " MB")}`,
-        `占用: ${formatRuntimeMetricText(memory.usagePercentage, "%")}`,
-    ].join(" | ");
-}
-/**
- * 格式化单条 API 文档摘要
- * @param language 文档语言
- * @param title 文档标题
- * @param slug 文档 slug
- * @param index 列表序号
- * @returns 返回用于列表展示的文本块
- * @example
- * formatApiDocSummary("js", "Tap", "tap", 0)
- */
-function formatApiDocSummary(language, title, slug, index) {
-    return `${index + 1}. ${title}\nslug: ${slug}\nuri: ${(0, docs_service_1.getDocUri)(language, slug)}`;
-}
-/**
- * 注册文档资源
- * @param server MCP 服务实例
- * @returns 无返回值
- * @example
- * registerDocResources(server)
- */
-function registerDocResources(server) {
-    server.registerResource("current-language", "kuaijs://docs/current-language", {
-        title: "Current KuaiJS API language",
-        mimeType: "application/json",
-    }, async () => {
-        const language = (0, docs_service_1.getCurrentDocsLanguage)();
-        return {
-            contents: [
-                {
-                    uri: "kuaijs://docs/current-language",
-                    mimeType: "application/json",
-                    text: JSON.stringify({
-                        currentLanguage: language,
-                        label: types_1.DOC_LANGUAGE_LABELS[language],
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-    server.registerResource("api-doc", new mcp_js_1.ResourceTemplate("kuaijs://docs/current/{slug}", {
-        list: async () => {
-            const language = (0, docs_service_1.getCurrentDocsLanguage)();
-            const docs = await (0, docs_service_1.getApiDocsByLanguage)(language);
-            return {
-                resources: docs.map((doc) => ({
-                    uri: `kuaijs://docs/current/${doc.slug}`,
-                    name: doc.title,
-                    description: `[${types_1.DOC_LANGUAGE_LABELS[language]}] ${doc.slug}`,
-                    mimeType: "text/markdown",
-                })),
-            };
-        },
-    }), {
-        title: "KuaiJS API documents",
-        mimeType: "text/markdown",
-    }, async (_uri, variables) => {
-        const language = (0, docs_service_1.getCurrentDocsLanguage)();
-        const docs = await (0, docs_service_1.getApiDocsByLanguage)(language);
-        const slug = String(variables.slug || "");
-        const target = docs.find((doc) => doc.slug === slug);
-        if (!target) {
-            throw new Error(`文档不存在: ${slug}`);
-        }
-        return {
-            contents: [
-                {
-                    uri: `kuaijs://docs/current/${target.slug}`,
-                    mimeType: "text/markdown",
-                    text: target.content,
-                },
-            ],
-        };
-    });
-}
-/**
- * 注册文档工具
- * @param server MCP 服务实例
- * @returns 无返回值
- * @example
- * registerDocTools(server)
- */
-function registerDocTools(server) {
-    server.registerTool("get_docs_language", {
-        title: "Get Docs Language",
-        description: "获取当前 KuaiJS API 文档语言。",
-        inputSchema: {},
-    }, async () => {
-        const language = (0, docs_service_1.getCurrentDocsLanguage)();
-        return createTextToolResult(`当前文档语言: ${language} (${types_1.DOC_LANGUAGE_LABELS[language]})`);
-    });
-    server.registerTool("set_docs_language", {
-        title: "Set Docs Language",
-        description: "设置当前 KuaiJS API 文档语言，影响后续文档查询与读取。",
-        inputSchema: {
-            language: z
-                .enum(["js", "js_zh", "python"])
-                .describe("文档语言：js | js_zh | python"),
-        },
-    }, async ({ language }) => {
-        const active = (0, docs_service_1.setCurrentDocsLanguage)(language);
-        const docsDir = (0, docs_service_1.getDocsDirByLanguage)(active);
-        return createTextToolResult(`文档语言已切换为 ${active} (${types_1.DOC_LANGUAGE_LABELS[active]})\n目录: ${docsDir}`);
-    });
-    server.registerTool("list_api_docs", {
-        title: "List API Docs",
-        description: "列出当前（或指定）语言下可用的 API 文档。",
-        inputSchema: {
-            language: z
-                .enum(["js", "js_zh", "python"])
-                .optional()
-                .describe("可选语言，不传则使用当前语言"),
-        },
-    }, async ({ language }) => {
-        const activeLanguage = (0, docs_service_1.resolveDocsLanguage)(language);
-        const docs = await (0, docs_service_1.getApiDocsByLanguage)(activeLanguage);
-        const lines = docs.map((doc, index) => formatApiDocSummary(activeLanguage, doc.title, doc.slug, index));
-        return createTextToolResult(lines.length === 0
-            ? `当前语言 ${activeLanguage} 下没有可用文档。`
-            : [
-                `当前语言: ${activeLanguage} (${types_1.DOC_LANGUAGE_LABELS[activeLanguage]})`,
-                "",
-                ...lines,
-            ].join("\n"));
-    });
-    server.registerTool("search_api_docs", {
-        title: "Search API Docs",
-        description: "在当前（或指定）语言文档中按关键字搜索。",
-        inputSchema: {
-            query: z.string().min(1).describe("搜索关键字"),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(20)
-                .optional()
-                .default(5)
-                .describe("返回条数上限，默认 5"),
-            language: z
-                .enum(["js", "js_zh", "python"])
-                .optional()
-                .describe("可选语言，不传则使用当前语言"),
-        },
-    }, async ({ query, limit, language }) => {
-        const activeLanguage = (0, docs_service_1.resolveDocsLanguage)(language);
-        const docs = await (0, docs_service_1.getApiDocsByLanguage)(activeLanguage);
-        const normalizedQuery = query.toLowerCase();
-        const matches = docs
-            .map((doc) => ({ doc, score: (0, docs_service_1.scoreApiDoc)(doc, normalizedQuery) }))
-            .filter((item) => item.score > 0)
-            .sort((a, b) => b.score - a.score || a.doc.slug.localeCompare(b.doc.slug))
-            .slice(0, limit)
-            .map((item) => item.doc);
-        const text = matches.length === 0
-            ? `当前语言: ${activeLanguage} (${types_1.DOC_LANGUAGE_LABELS[activeLanguage]})\n未找到与 "${query}" 匹配的文档。`
-            : [
-                `当前语言: ${activeLanguage} (${types_1.DOC_LANGUAGE_LABELS[activeLanguage]})`,
-                "",
-                ...matches.map((doc, index) => formatApiDocSummary(activeLanguage, doc.title, doc.slug, index)),
-            ].join("\n");
-        return createTextToolResult(text);
-    });
-    server.registerTool("read_api_doc", {
-        title: "Read API Doc",
-        description: "读取当前（或指定）语言下某个文档的完整 markdown 内容。",
-        inputSchema: {
-            slug: z.string().min(1).describe("文档 slug（文件名，不含 .md）"),
-            language: z
-                .enum(["js", "js_zh", "python"])
-                .optional()
-                .describe("可选语言，不传则使用当前语言"),
-        },
-    }, async ({ slug, language }) => {
-        const activeLanguage = (0, docs_service_1.resolveDocsLanguage)(language);
-        const docs = await (0, docs_service_1.getApiDocsByLanguage)(activeLanguage);
-        const target = docs.find((doc) => doc.slug === slug);
-        if (!target) {
-            return createTextToolResult(`未找到文档 ${slug}.md（语言: ${activeLanguage}）。`, true);
-        }
-        return createTextToolResult(`标题: ${target.title}\n语言: ${activeLanguage}\nURI: ${(0, docs_service_1.getDocUri)(activeLanguage, target.slug)}\n\n${target.content}`);
-    });
-}
-/**
- * 注册设备与项目执行工具
- * @param server MCP 服务实例
- * @returns 无返回值
- * @example
- * registerRuntimeTools(server)
- */
-function registerRuntimeTools(server) {
-    /**
-     * MCP 进程内当前工作目录（仅内存态，不落盘）
-     * 说明：用于同一轮 MCP 进程内复用目录，进程重启后需由 AI 再次调用 set_workspace 设置。
-     */
-    let currentWorkspacePath;
-    /**
-     * 解析本次调用使用的工作目录
-     * 优先级：workspacePath 参数 > set_workspace 记忆值
-     * @param workspacePath 可选工作目录
-     * @returns 返回生效的绝对路径
-     * @example
-     * const workspace = resolveWorkspacePath("/Users/demo/project")
-     */
-    function resolveWorkspacePath(workspacePath) {
-        if (workspacePath && workspacePath.trim()) {
-            currentWorkspacePath = path.resolve(workspacePath.trim());
-            return currentWorkspacePath;
-        }
-        if (currentWorkspacePath) {
-            return currentWorkspacePath;
-        }
-        throw new Error("未设置工作目录：请先调用 set_workspace，或在本次工具调用时传 workspacePath。");
-    }
-    /**
-     * 校验并返回有效工作目录
-     * @param workspacePath 可选工作目录
-     * @returns 返回校验通过的绝对路径
-     * @example
-     * const workspace = await ensureWorkspacePath("/Users/demo/project")
-     */
-    async function ensureWorkspacePath(workspacePath) {
-        const workspace = resolveWorkspacePath(workspacePath);
-        await (0, project_2.ensureValidKuaiJSProject)(workspace);
-        return workspace;
-    }
-    server.registerTool("set_workspace", {
-        title: "Set Workspace",
-        description: "设置当前 MCP 进程内的默认工作目录。后续 build/run/package 优先使用该目录。",
-        inputSchema: {
-            workspacePath: z
-                .string()
-                .min(1)
-                .describe("快点JS 项目目录绝对路径（需包含 package.json 与 scripts）"),
-        },
-    }, async ({ workspacePath }) => {
-        const workspace = await ensureWorkspacePath(workspacePath);
-        return createTextToolResult(`默认工作目录已设置为: ${workspace}`);
-    });
-    server.registerTool("get_workspace", {
-        title: "Get Workspace",
-        description: "查看当前 MCP 进程内记忆的工作目录。",
-        inputSchema: {},
-    }, async () => {
-        if (!currentWorkspacePath) {
-            return createTextToolResult("当前未设置工作目录，请先调用 set_workspace。");
-        }
-        return createTextToolResult(`当前工作目录: ${currentWorkspacePath}`);
-    });
-    /**
-     * 解析当前默认 HTTP 设备
-     * - 当前 MCP 仅支持单设备模型
-     * - 所有设备工具默认复用 set_device 保存的连接信息
-     * @returns 返回标准化后的 HTTP 请求目标
-     * @example
-     * const target = await resolveRuntimeHttpTarget()
-     */
-    async function resolveRuntimeHttpTarget() {
-        let device;
-        try {
-            device = await (0, device_config_1.resolveDeviceConfig)();
-        }
-        catch {
-            throw new Error("未设置设备：请先调用 set_device。");
-        }
-        return {
-            ip: device.ip,
-            port: (0, device_config_1.normalizePort)(device.port),
-            label: `${device.ip}:${device.port}`,
-        };
-    }
-    server.registerTool("set_device", {
-        title: "Set Device",
-        description: "设置当前唯一设备连接信息。设置后其余设备工具均复用该设备。",
-        inputSchema: {
-            ip: z.string().min(1).describe("设备 IP 地址，例如 192.168.1.100"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-        },
-    }, async ({ ip, port }) => {
-        const config = await (0, device_config_1.setDeviceConfig)(ip, port);
-        const reusedSubscription = ensureDeviceLogSubscription(config.ip, config.port);
-        return createTextToolResult([
-            `默认设备已设置为 ${config.ip}:${config.port}`,
-            reusedSubscription
-                ? "SSE 日志后台订阅已复用现有连接"
-                : `SSE 日志后台订阅已启动，内存缓存上限 ${DEVICE_LOG_MEMORY_LIMIT} 条`,
-        ].join("\n"));
-    });
-    server.registerTool("get_device", {
-        title: "Get Device",
-        description: "查看当前默认设备配置。",
-        inputSchema: {},
-    }, async () => {
-        const config = await (0, device_config_1.readDeviceConfig)();
-        if (!config) {
-            return createTextToolResult("当前未设置默认设备，请先调用 set_device。");
-        }
-        return createTextToolResult(`当前默认设备: ${config.ip}:${config.port}`);
-    });
-    server.registerTool("take_screenshot", {
-        title: "Take Screenshot",
-        description: "获取当前默认设备截图。可返回 base64，或落地到文件后返回文件路径（默认写入系统临时目录）。",
-        inputSchema: {
-            format: z
-                .enum(["file", "base64"])
-                .optional()
-                .default("file")
-                .describe("截图返回格式：file=文件路径，base64=图片 base64"),
-            outputPath: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("当 format=file 时可指定输出路径，不传则写入系统临时目录"),
-        },
-    }, async ({ format, outputPath }) => {
-        const target = await resolveRuntimeHttpTarget();
-        const requestOptions = createRuntimeHttpRequestOptions(target);
-        if (format === "base64") {
-            const base64 = await (0, project_1.getScreenshotBase64OnDevice)(requestOptions);
-            return createTextToolResult(`截图成功: ${target.label}\nformat: base64\n${base64}`);
-        }
-        const image = await (0, project_1.getScreenshotOnDevice)(requestOptions);
-        const targetPath = outputPath && outputPath.trim()
-            ? path.resolve(outputPath.trim())
-            : path.join(os.tmpdir(), `ms-mcp-screenshot-${Date.now()}-${Math.random()
-                .toString(36)
-                .slice(2, 8)}.jpg`);
-        await fsExtra.ensureDir(path.dirname(targetPath));
-        await fsExtra.writeFile(targetPath, image);
-        return createTextToolResult(`截图成功: ${target.label}\nformat: file\npath: ${targetPath}\nsize: ${image.length} bytes`);
-    });
-    server.registerTool("get_node_source", {
-        title: "Get Node Source",
-        description: "获取当前默认设备页面节点 XML（/api/source）。",
-        inputSchema: {
-            maxDepth: z
-                .number()
-                .int()
-                .min(1)
-                .max(200)
-                .optional()
-                .default(50)
-                .describe("节点树最大深度，默认 50"),
-            timeout: z
-                .number()
-                .int()
-                .min(1)
-                .max(600)
-                .optional()
-                .default(120)
-                .describe("设备端节点抓取超时秒数，默认 120"),
-        },
-    }, async ({ maxDepth, timeout }) => {
-        const target = await resolveRuntimeHttpTarget();
-        const requestOptions = createRuntimeHttpRequestOptions(target);
-        const source = await (0, project_1.getSourceOnDevice)(requestOptions, maxDepth, timeout);
-        return createTextToolResult(`节点获取成功: ${target.label}\nmaxDepth: ${maxDepth}\ntimeout: ${timeout}\n\n${source}`);
-    });
-    server.registerTool("get_logs", {
-        title: "Get Device Logs",
-        description: "获取当前默认设备的日志缓存快照。调用 set_device 后会自动建立 SSE 后台订阅，此工具只返回当前已缓存的日志内容。",
-        inputSchema: {
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(5000)
-                .optional()
-                .default(200)
-                .describe("返回最近日志条数，默认 200，最大 5000"),
-            runtimeStatusLimit: z
-                .number()
-                .int()
-                .min(0)
-                .max(200)
-                .optional()
-                .default(20)
-                .describe("返回最近 runtime_status 条数，默认 20"),
-        },
-    }, async ({ limit, runtimeStatusLimit }) => {
-        if (!deviceLogSubscriptionState.target) {
-            const device = await (0, device_config_1.readDeviceConfig)();
-            if (device) {
-                ensureDeviceLogSubscription(device.ip, device.port);
-            }
-        }
-        return createTextToolResult(buildDeviceLogSnapshotText(limit, runtimeStatusLimit));
-    });
-    server.registerTool("package_project", {
-        title: "Package Project",
-        description: "执行生产构建并加密，返回 enc.msbundle 路径。",
-        inputSchema: {
-            workspacePath: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
-        },
-    }, async ({ workspacePath }) => {
-        const workspace = await ensureWorkspacePath(workspacePath);
-        const encryptedPath = await (0, packager_1.packageProject)(workspace);
-        return createTextToolResult(`打包完成: ${encryptedPath}`);
-    });
-    server.registerTool("run_project", {
-        title: "Run Project",
-        description: "构建并同步到当前默认设备后运行项目，仅使用 HTTP 设备连接。",
-        inputSchema: {
-            workspacePath: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
-        },
-    }, async ({ workspacePath }) => {
-        const workspace = await ensureWorkspacePath(workspacePath);
-        const target = await resolveRuntimeHttpTarget();
-        await (0, project_1.runOnDevice)({
-            ...createRuntimeHttpRequestOptions(target),
-            workspacePath: workspace,
-        });
-        return createTextToolResult(`运行请求已发送到 ${target.label}`);
-    });
-    server.registerTool("run_ui_project", {
-        title: "Run UI Project",
-        description: "构建并同步到当前默认设备后预览 UI，仅使用 HTTP 设备连接。",
-        inputSchema: {
-            workspacePath: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
-        },
-    }, async ({ workspacePath }) => {
-        const workspace = await ensureWorkspacePath(workspacePath);
-        const target = await resolveRuntimeHttpTarget();
-        await (0, project_1.runUIOnDevice)({
-            ...createRuntimeHttpRequestOptions(target),
-            workspacePath: workspace,
-        });
-        return createTextToolResult(`UI 预览请求已发送到 ${target.label}`);
-    });
-    server.registerTool("stop_project", {
-        title: "Stop Project",
-        description: "停止当前默认设备上的项目，仅使用 HTTP 设备连接。",
-        inputSchema: {},
-    }, async () => {
-        const target = await resolveRuntimeHttpTarget();
-        await (0, project_1.stopOnDevice)(createRuntimeHttpRequestOptions(target));
-        return createTextToolResult(`停止请求已发送到 ${target.label}`);
-    });
-}
+const doc_tools_1 = require("./doc-tools");
+const runtime_tools_1 = require("./runtime-tools");
 /**
  * 创建并注册 MCP 工具
  * @returns 返回已注册工具的 MCP Server 实例
@@ -941,8 +19,8 @@ function createMcpServer() {
         name: "ms-vite-plugin-mcp",
         version: version_1.PACKAGE_VERSION,
     });
-    registerDocResources(server);
-    registerDocTools(server);
-    registerRuntimeTools(server);
+    (0, doc_tools_1.registerDocResources)(server);
+    (0, doc_tools_1.registerDocTools)(server);
+    (0, runtime_tools_1.registerRuntimeTools)(server);
     return server;
 }