ms-vite-plugin 1.1.11 → 1.1.13

package/dist/mcp/tools.js

@@ -40,16 +40,375 @@ const z = __importStar(require("zod/v4"));
 const fsExtra = __importStar(require("fs-extra"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const build_1 = require("../build");
 const packager_1 = require("../packager");
 const project_1 = require("../project");
-const ws_manager_1 = require("../ws-manager");
 const project_2 = require("./project");
 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 targetText = deviceLogSubscriptionState.target
+        ? `${deviceLogSubscriptionState.target.ip}:${deviceLogSubscriptionState.target.port}`
+        : "未订阅";
+    const recentLogs = deviceLogSubscriptionState.logs
+        .slice(-limit)
+        .map((log) => `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.message}`);
+    const recentRuntimeStatus = deviceLogSubscriptionState.runtimeStatus
+        .slice(-runtimeStatusLimit)
+        .map((entry) => `[${entry.timestamp}] ${JSON.stringify(entry.raw, null, 2).replace(/\n/g, " ")}`);
+    return [
+        `订阅目标: ${targetText}`,
+        `连接状态: ${deviceLogSubscriptionState.status}`,
+        `缓存日志: ${deviceLogSubscriptionState.logs.length}/${DEVICE_LOG_MEMORY_LIMIT}`,
+        `缓存 runtime_status: ${deviceLogSubscriptionState.runtimeStatus.length}/${DEVICE_LOG_MEMORY_LIMIT}`,
+        `startedAt: ${deviceLogSubscriptionState.startedAt ?? "unknown"}`,
+        `lastEventAt: ${deviceLogSubscriptionState.lastEventAt ?? "unknown"}`,
+        `lastError: ${deviceLogSubscriptionState.lastError ?? "none"}`,
+        "",
+        `最新日志（最多 ${limit} 条）:`,
+        recentLogs.length > 0 ? recentLogs.join("\n") : "无日志",
+        "",
+        `最新 runtime_status（最多 ${runtimeStatusLimit} 条）:`,
+        recentRuntimeStatus.length > 0
+            ? recentRuntimeStatus.join("\n")
+            : "无 runtime_status",
+    ].join("\n");
+}
+/**
+ * 格式化单条 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 服务实例
@@ -125,14 +484,7 @@ function registerDocTools(server) {
         inputSchema: {},
     }, async () => {
         const language = (0, docs_service_1.getCurrentDocsLanguage)();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `当前文档语言: ${language} (${types_1.DOC_LANGUAGE_LABELS[language]})`,
-                },
-            ],
-        };
+        return createTextToolResult(`当前文档语言: ${language} (${types_1.DOC_LANGUAGE_LABELS[language]})`);
     });
     server.registerTool("set_docs_language", {
         title: "Set Docs Language",
@@ -145,14 +497,7 @@ function registerDocTools(server) {
     }, async ({ language }) => {
         const active = (0, docs_service_1.setCurrentDocsLanguage)(language);
         const docsDir = (0, docs_service_1.getDocsDirByLanguage)(active);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `文档语言已切换为 ${active} (${types_1.DOC_LANGUAGE_LABELS[active]})\n目录: ${docsDir}`,
-                },
-            ],
-        };
+        return createTextToolResult(`文档语言已切换为 ${active} (${types_1.DOC_LANGUAGE_LABELS[active]})\n目录: ${docsDir}`);
     });
     server.registerTool("list_api_docs", {
         title: "List API Docs",
@@ -166,21 +511,14 @@ function registerDocTools(server) {
     }, 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) => `${index + 1}. ${doc.title}\nslug: ${doc.slug}\nuri: ${(0, docs_service_1.getDocUri)(activeLanguage, doc.slug)}`);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: lines.length === 0
-                        ? `当前语言 ${activeLanguage} 下没有可用文档。`
-                        : [
-                            `当前语言: ${activeLanguage} (${types_1.DOC_LANGUAGE_LABELS[activeLanguage]})`,
-                            "",
-                            ...lines,
-                        ].join("\n"),
-                },
-            ],
-        };
+        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",
@@ -215,16 +553,9 @@ function registerDocTools(server) {
             : [
                 `当前语言: ${activeLanguage} (${types_1.DOC_LANGUAGE_LABELS[activeLanguage]})`,
                 "",
-                ...matches.map((doc, index) => `${index + 1}. ${doc.title}\nslug: ${doc.slug}\nuri: ${(0, docs_service_1.getDocUri)(activeLanguage, doc.slug)}`),
+                ...matches.map((doc, index) => formatApiDocSummary(activeLanguage, doc.title, doc.slug, index)),
             ].join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text,
-                },
-            ],
-        };
+        return createTextToolResult(text);
     });
     server.registerTool("read_api_doc", {
         title: "Read API Doc",
@@ -241,24 +572,9 @@ function registerDocTools(server) {
         const docs = await (0, docs_service_1.getApiDocsByLanguage)(activeLanguage);
         const target = docs.find((doc) => doc.slug === slug);
         if (!target) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `未找到文档 ${slug}.md（语言: ${activeLanguage}）。`,
-                    },
-                ],
-                isError: true,
-            };
+            return createTextToolResult(`未找到文档 ${slug}.md（语言: ${activeLanguage}）。`, true);
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `标题: ${target.title}\n语言: ${activeLanguage}\nURI: ${(0, docs_service_1.getDocUri)(activeLanguage, target.slug)}\n\n${target.content}`,
-                },
-            ],
-        };
+        return createTextToolResult(`标题: ${target.title}\n语言: ${activeLanguage}\nURI: ${(0, docs_service_1.getDocUri)(activeLanguage, target.slug)}\n\n${target.content}`);
     });
 }
 /**
@@ -315,14 +631,7 @@ function registerRuntimeTools(server) {
         },
     }, async ({ workspacePath }) => {
         const workspace = await ensureWorkspacePath(workspacePath);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `默认工作目录已设置为: ${workspace}`,
-                },
-            ],
-        };
+        return createTextToolResult(`默认工作目录已设置为: ${workspace}`);
     });
     server.registerTool("get_workspace", {
         title: "Get Workspace",
@@ -330,98 +639,27 @@ function registerRuntimeTools(server) {
         inputSchema: {},
     }, async () => {
         if (!currentWorkspacePath) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "当前未设置工作目录，请先调用 set_workspace。",
-                    },
-                ],
-            };
+            return createTextToolResult("当前未设置工作目录，请先调用 set_workspace。");
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `当前工作目录: ${currentWorkspacePath}`,
-                },
-            ],
-        };
+        return createTextToolResult(`当前工作目录: ${currentWorkspacePath}`);
     });
     /**
-     * 格式化运行期日志结果（供 run/run_ui 直接回传）
-     * @param ip 设备 IP
-     * @param port 设备端口
-     * @param durationSeconds 监听秒数
-     * @param result 日志监听结果
-     * @returns 可拼接到 tool 响应的文本
-     * @example
-     * const text = formatRunLogSection("192.168.1.10", 9800, 10, result)
-     */
-    function formatRunLogSection(ip, port, result) {
-        const logsPreview = result.logs
-            .slice(-20)
-            .map((log) => `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.message}`)
-            .join("\n");
-        return [
-            `运行日志来源: ${ip}:${port}`,
-            `结束原因: ${result.stopReason}，日志: ${result.logs.length} 条，runtime_status: ${result.runtimeStatus.length} 条`,
-            "最新日志（最多展示最后20条）:",
-            logsPreview || "无日志",
-        ].join("\n");
-    }
-    /**
-     * 启动持续日志监听（后台，不阻塞当前 tool 返回）
-     * @param ip 设备 IP
-     * @param port 设备端口
-     * @param maxLogs 日志环形缓冲上限
-     * @returns 返回提示文本
-     * @example
-     * const tip = startBackgroundContinuousLogWatch("192.168.1.10", 9800, 300)
-     */
-    function startBackgroundContinuousLogWatch(ip, port, maxLogs) {
-        void (0, project_1.watchDeviceLogsBySse)(ip, port, 0, maxLogs)
-            .then((result) => {
-            console.log(`[mcp] continuous logs ${ip}:${port} ended, reason=${result.stopReason}, logs=${result.logs.length}, runtime_status=${result.runtimeStatus.length}`);
-        })
-            .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn(`[mcp] continuous logs ${ip}:${port} failed: ${message}`);
-        });
-        return `已切换为持续日志监听: ${ip}:${port}（直到连接断开，max ${maxLogs}）`;
-    }
-    /**
-     * 解析运行目标：
-     * - 显式 transport=ws: 强制走 ws
-     * - 显式 transport=http: 强制走 http
-     * - 未显式 transport:
-     *   1) 若传入 ip/port，则走 http
-     *   2) 若当前已有 ws 设备连接，则优先走 ws
-     *   3) 否则回退到 http 默认设备配置
-     * @param options 工具调用参数
-     * @returns 返回标准化后的请求目标
+     * 解析当前默认 HTTP 设备
+     * - 当前 MCP 仅支持单设备模型
+     * - 所有设备工具默认复用 set_device 保存的连接信息
+     * @returns 返回标准化后的 HTTP 请求目标
      * @example
-     * const target = await resolvePreferredRuntimeTarget({ ip: "192.168.1.10" })
+     * const target = await resolveRuntimeHttpTarget()
      */
-    async function resolvePreferredRuntimeTarget(options) {
-        const hasHttpHint = options.ip !== undefined || options.port !== undefined;
-        const shouldUseWs = options.transport === "ws" ||
-            (options.transport === undefined &&
-                !hasHttpHint &&
-                ws_manager_1.WSManager.isConnected());
-        if (shouldUseWs) {
-            const wsPort = String(options.wsPort ?? 31111);
-            const wsWaitMs = String(options.wsWaitMs ?? 30000);
-            return {
-                transport: "ws",
-                wsPort,
-                wsWaitMs,
-                label: `transport=ws (wsPort=${wsPort})`,
-            };
+    async function resolveRuntimeHttpTarget() {
+        let device;
+        try {
+            device = await (0, device_config_1.resolveDeviceConfig)();
+        }
+        catch {
+            throw new Error("未设置设备：请先调用 set_device。");
         }
-        const device = await (0, device_config_1.resolveDeviceConfig)(options.ip, options.port);
         return {
-            transport: "http",
             ip: device.ip,
             port: (0, device_config_1.normalizePort)(device.port),
             label: `${device.ip}:${device.port}`,
@@ -429,7 +667,7 @@ function registerRuntimeTools(server) {
     }
     server.registerTool("set_device", {
         title: "Set Device",
-        description: "设置默认设备连接信息。首次配置后，后续 run/stop 可不再传 ip。",
+        description: "设置当前唯一设备连接信息。设置后其余设备工具均复用该设备。",
         inputSchema: {
             ip: z.string().min(1).describe("设备 IP 地址，例如 192.168.1.100"),
             port: z
@@ -442,14 +680,13 @@ function registerRuntimeTools(server) {
         },
     }, async ({ ip, port }) => {
         const config = await (0, device_config_1.setDeviceConfig)(ip, port);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `默认设备已设置为 ${config.ip}:${config.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",
@@ -458,52 +695,14 @@ function registerRuntimeTools(server) {
     }, async () => {
         const config = await (0, device_config_1.readDeviceConfig)();
         if (!config) {
-            return {
-                content: [
-                    { type: "text", text: "当前未设置默认设备，请先调用 set_device。" },
-                ],
-            };
+            return createTextToolResult("当前未设置默认设备，请先调用 set_device。");
         }
-        return {
-            content: [
-                { type: "text", text: `当前默认设备: ${config.ip}:${config.port}` },
-            ],
-        };
+        return createTextToolResult(`当前默认设备: ${config.ip}:${config.port}`);
     });
     server.registerTool("take_screenshot", {
         title: "Take Screenshot",
-        description: "获取设备截图。可返回 base64，或落地到文件后返回文件路径（默认写入系统临时目录）。",
+        description: "获取当前默认设备截图。可返回 base64，或落地到文件后返回文件路径（默认写入系统临时目录）。",
         inputSchema: {
-            transport: z
-                .enum(["http", "ws"])
-                .optional()
-                .describe("传输方式：http|ws；不传时自动优先 ws（若已连接）"),
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址（transport=http 时可传；未传则使用 set_device 默认值）"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-            wsPort: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("WS 服务端口（transport=ws 时可选，默认 31111）"),
-            wsWaitMs: z
-                .number()
-                .int()
-                .min(1)
-                .max(600000)
-                .optional()
-                .describe("WS 等待连接超时毫秒（transport=ws 时可选，默认 30000）"),
             format: z
                 .enum(["file", "base64"])
                 .optional()
@@ -515,35 +714,12 @@ function registerRuntimeTools(server) {
                 .optional()
                 .describe("当 format=file 时可指定输出路径，不传则写入系统临时目录"),
         },
-    }, async ({ transport, ip, port, wsPort, wsWaitMs, format, outputPath }) => {
-        const target = await resolvePreferredRuntimeTarget({
-            transport,
-            ip,
-            port,
-            wsPort,
-            wsWaitMs,
-        });
-        const requestOptions = target.transport === "ws"
-            ? {
-                transport: "ws",
-                wsPort: target.wsPort,
-                wsWaitMs: target.wsWaitMs,
-            }
-            : {
-                ip: target.ip,
-                port: target.port,
-                transport: "http",
-            };
+    }, async ({ format, outputPath }) => {
+        const target = await resolveRuntimeHttpTarget();
+        const requestOptions = createRuntimeHttpRequestOptions(target);
         if (format === "base64") {
             const base64 = await (0, project_1.getScreenshotBase64OnDevice)(requestOptions);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `截图成功: ${target.label}\nformat: base64\n${base64}`,
-                    },
-                ],
-            };
+            return createTextToolResult(`截图成功: ${target.label}\nformat: base64\n${base64}`);
         }
         const image = await (0, project_1.getScreenshotOnDevice)(requestOptions);
         const targetPath = outputPath && outputPath.trim()
@@ -553,49 +729,12 @@ function registerRuntimeTools(server) {
                 .slice(2, 8)}.jpg`);
         await fsExtra.ensureDir(path.dirname(targetPath));
         await fsExtra.writeFile(targetPath, image);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `截图成功: ${target.label}\nformat: file\npath: ${targetPath}\nsize: ${image.length} bytes`,
-                },
-            ],
-        };
+        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）。",
+        description: "获取当前默认设备页面节点 XML（/api/source）。",
         inputSchema: {
-            transport: z
-                .enum(["http", "ws"])
-                .optional()
-                .describe("传输方式：http|ws；不传时自动优先 ws（若已连接）"),
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址（transport=http 时可传；未传则使用 set_device 默认值）"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-            wsPort: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("WS 服务端口（transport=ws 时可选，默认 31111）"),
-            wsWaitMs: z
-                .number()
-                .int()
-                .min(1)
-                .max(600000)
-                .optional()
-                .describe("WS 等待连接超时毫秒（transport=ws 时可选，默认 30000）"),
             maxDepth: z
                 .number()
                 .int()
@@ -613,113 +752,41 @@ function registerRuntimeTools(server) {
                 .default(120)
                 .describe("设备端节点抓取超时秒数，默认 120"),
         },
-    }, async ({ transport, ip, port, wsPort, wsWaitMs, maxDepth, timeout }) => {
-        const target = await resolvePreferredRuntimeTarget({
-            transport,
-            ip,
-            port,
-            wsPort,
-            wsWaitMs,
-        });
-        const requestOptions = target.transport === "ws"
-            ? {
-                transport: "ws",
-                wsPort: target.wsPort,
-                wsWaitMs: target.wsWaitMs,
-            }
-            : {
-                ip: target.ip,
-                port: target.port,
-                transport: "http",
-            };
+    }, async ({ maxDepth, timeout }) => {
+        const target = await resolveRuntimeHttpTarget();
+        const requestOptions = createRuntimeHttpRequestOptions(target);
         const source = await (0, project_1.getSourceOnDevice)(requestOptions, maxDepth, timeout);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `节点获取成功: ${target.label}\nmaxDepth: ${maxDepth}\ntimeout: ${timeout}\n\n${source}`,
-                },
-            ],
-        };
+        return createTextToolResult(`节点获取成功: ${target.label}\nmaxDepth: ${maxDepth}\ntimeout: ${timeout}\n\n${source}`);
     });
-    server.registerTool("watch_logs", {
-        title: "Watch Logs",
-        description: "通过 SSE 监听设备实时日志。首次可传 ip，也可复用 set_device 保存的默认设备。",
+    server.registerTool("get_logs", {
+        title: "Get Device Logs",
+        description: "获取当前默认设备的日志缓存快照。调用 set_device 后会自动建立 SSE 后台订阅，此工具只返回当前已缓存的日志内容。",
         inputSchema: {
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址，未传则使用 set_device 保存的默认值"),
-            port: z
+            limit: z
                 .number()
                 .int()
                 .min(1)
-                .max(65535)
+                .max(5000)
                 .optional()
-                .describe("设备端口，默认 9800"),
-            durationSeconds: z
+                .default(200)
+                .describe("返回最近日志条数，默认 200，最大 5000"),
+            runtimeStatusLimit: z
                 .number()
                 .int()
                 .min(0)
-                .max(300)
-                .optional()
-                .default(15)
-                .describe("监听时长（秒），默认 15 秒；传 0 表示持续监听直到连接断开"),
-            maxLogs: z
-                .number()
-                .int()
-                .min(10)
-                .max(5000)
-                .optional()
-                .default(200)
-                .describe("最多收集日志条数，默认 200"),
-        },
-    }, async ({ ip, port, durationSeconds, maxLogs }) => {
-        const device = await (0, device_config_1.resolveDeviceConfig)(ip, port);
-        const result = await (0, project_1.watchDeviceLogsBySse)(device.ip, device.port, durationSeconds * 1000, maxLogs);
-        const logsPreview = result.logs
-            .slice(-20)
-            .map((log) => `[${log.timestamp}] [${log.level.toUpperCase()}] ${log.message}`)
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `监听目标: ${device.ip}:${device.port}`,
-                        `监听模式: ${durationSeconds === 0 ? "持续直到连接断开" : `${durationSeconds}s`}`,
-                        `结束原因: ${result.stopReason}，收集日志: ${result.logs.length} 条，runtime_status: ${result.runtimeStatus.length} 条`,
-                        "",
-                        "最新日志（最多展示最后20条）:",
-                        logsPreview || "无日志",
-                    ].join("\n"),
-                },
-            ],
-        };
-    });
-    server.registerTool("build_project", {
-        title: "Build Project",
-        description: "构建 KuaiJS 项目，支持开发模式与生产模式。",
-        inputSchema: {
-            workspacePath: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
-            dev: z
-                .boolean()
+                .max(200)
                 .optional()
-                .describe("是否开发模式构建，true=开发模式，false=生产模式"),
+                .default(20)
+                .describe("返回最近 runtime_status 条数，默认 20"),
         },
-    }, async ({ workspacePath, dev }) => {
-        const workspace = await ensureWorkspacePath(workspacePath);
-        await (0, build_1.buildAll)(Boolean(dev), workspace);
-        return {
-            content: [
-                { type: "text", text: `构建完成，模式: ${dev ? "dev" : "prod"}` },
-            ],
-        };
+    }, 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",
@@ -734,271 +801,54 @@ function registerRuntimeTools(server) {
     }, async ({ workspacePath }) => {
         const workspace = await ensureWorkspacePath(workspacePath);
         const encryptedPath = await (0, packager_1.packageProject)(workspace);
-        return {
-            content: [{ type: "text", text: `打包完成: ${encryptedPath}` }],
-        };
+        return createTextToolResult(`打包完成: ${encryptedPath}`);
     });
     server.registerTool("run_project", {
         title: "Run Project",
-        description: "构建并同步到设备后运行项目。不传 transport 时会自动优先使用已连接的 WS 设备。",
+        description: "构建并同步到当前默认设备后运行项目，仅使用 HTTP 设备连接。",
         inputSchema: {
-            transport: z
-                .enum(["http", "ws"])
-                .optional()
-                .describe("传输方式：http|ws；不传时自动优先 ws（若已连接）"),
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址（transport=http 时可传；未传则使用 set_device 默认值）"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-            wsPort: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("WS 服务端口（transport=ws 时可选，默认 31111）"),
-            wsWaitMs: z
-                .number()
-                .int()
-                .min(1)
-                .max(600000)
-                .optional()
-                .describe("WS 等待连接超时毫秒（transport=ws 时可选，默认 30000）"),
             workspacePath: z
                 .string()
                 .min(1)
                 .optional()
                 .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
-            watchLogs: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe("是否在运行前启动日志监听，默认 false"),
-            logMode: z
-                .enum(["single", "continuous"])
-                .optional()
-                .default("single")
-                .describe("日志模式：single=按 runtime_status 收敛，continuous=持续监听"),
-            logMaxLogs: z
-                .number()
-                .int()
-                .min(10)
-                .max(5000)
-                .optional()
-                .default(300)
-                .describe("日志最大收集条数，默认 300"),
         },
-    }, async ({ transport, ip, port, wsPort, wsWaitMs, workspacePath, watchLogs, logMode, logMaxLogs, }) => {
+    }, async ({ workspacePath }) => {
         const workspace = await ensureWorkspacePath(workspacePath);
-        let logPromise;
-        let logDeviceIp = "";
-        let logDevicePort = 0;
-        let logSetupWarning = "";
-        let logModeNotice = "";
-        if (watchLogs) {
-            try {
-                const logDevice = await (0, device_config_1.resolveDeviceConfig)(ip, port);
-                // 先挂监听，再执行 run，确保拿到启动期实时日志
-                logDeviceIp = logDevice.ip;
-                logDevicePort = logDevice.port;
-                if (logMode === "continuous") {
-                    logModeNotice = startBackgroundContinuousLogWatch(logDevice.ip, logDevice.port, logMaxLogs);
-                }
-                else {
-                    logPromise = (0, project_1.watchDeviceLogsBySse)(logDevice.ip, logDevice.port, 0, logMaxLogs, true, true);
-                }
-            }
-            catch (error) {
-                logSetupWarning = `日志监听未启动: ${error instanceof Error ? error.message : String(error)}`;
-            }
-        }
-        const target = await resolvePreferredRuntimeTarget({
-            transport,
-            ip,
-            port,
-            wsPort,
-            wsWaitMs,
+        const target = await resolveRuntimeHttpTarget();
+        await (0, project_1.runOnDevice)({
+            ...createRuntimeHttpRequestOptions(target),
+            workspacePath: workspace,
         });
-        await (0, project_1.runOnDevice)(target.transport === "ws"
-            ? {
-                transport: "ws",
-                wsPort: target.wsPort,
-                wsWaitMs: target.wsWaitMs,
-                workspacePath: workspace,
-            }
-            : {
-                ip: target.ip,
-                port: target.port,
-                transport: "http",
-                workspacePath: workspace,
-            });
-        let logSection = "";
-        if (logPromise) {
-            const result = await logPromise;
-            const sections = [
-                formatRunLogSection(logDeviceIp, logDevicePort, result),
-            ];
-            if (result.stopReason === "runtime_continuous") {
-                sections.push(startBackgroundContinuousLogWatch(logDeviceIp, logDevicePort, logMaxLogs));
-            }
-            logSection = `\n\n${sections.join("\n")}`;
-        }
-        else if (logModeNotice) {
-            logSection = `\n\n${logModeNotice}`;
-        }
-        else if (logSetupWarning) {
-            logSection = `\n\n${logSetupWarning}`;
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `运行请求已发送到 ${target.label}${logSection}`,
-                },
-            ],
-        };
+        return createTextToolResult(`运行请求已发送到 ${target.label}`);
     });
     server.registerTool("run_ui_project", {
         title: "Run UI Project",
-        description: "构建并同步到设备后预览 UI。不传 transport 时会自动优先使用已连接的 WS 设备。",
+        description: "构建并同步到当前默认设备后预览 UI，仅使用 HTTP 设备连接。",
         inputSchema: {
-            transport: z
-                .enum(["http", "ws"])
-                .optional()
-                .describe("传输方式：http|ws；不传时自动优先 ws（若已连接）"),
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址（transport=http 时可传；未传则使用 set_device 默认值）"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-            wsPort: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("WS 服务端口（transport=ws 时可选，默认 31111）"),
-            wsWaitMs: z
-                .number()
-                .int()
-                .min(1)
-                .max(600000)
-                .optional()
-                .describe("WS 等待连接超时毫秒（transport=ws 时可选，默认 30000）"),
             workspacePath: z
                 .string()
                 .min(1)
                 .optional()
                 .describe("可选工作目录；不传时使用 set_workspace 记忆值"),
         },
-    }, async ({ transport, ip, port, wsPort, wsWaitMs, workspacePath }) => {
+    }, async ({ workspacePath }) => {
         const workspace = await ensureWorkspacePath(workspacePath);
-        const target = await resolvePreferredRuntimeTarget({
-            transport,
-            ip,
-            port,
-            wsPort,
-            wsWaitMs,
+        const target = await resolveRuntimeHttpTarget();
+        await (0, project_1.runUIOnDevice)({
+            ...createRuntimeHttpRequestOptions(target),
+            workspacePath: workspace,
         });
-        await (0, project_1.runUIOnDevice)(target.transport === "ws"
-            ? {
-                transport: "ws",
-                wsPort: target.wsPort,
-                wsWaitMs: target.wsWaitMs,
-                workspacePath: workspace,
-            }
-            : {
-                ip: target.ip,
-                port: target.port,
-                transport: "http",
-                workspacePath: workspace,
-            });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `UI 预览请求已发送到 ${target.label}`,
-                },
-            ],
-        };
+        return createTextToolResult(`UI 预览请求已发送到 ${target.label}`);
     });
     server.registerTool("stop_project", {
         title: "Stop Project",
-        description: "停止设备上的项目。不传 transport 时会自动优先使用已连接的 WS 设备。",
-        inputSchema: {
-            transport: z
-                .enum(["http", "ws"])
-                .optional()
-                .describe("传输方式：http|ws；不传时自动优先 ws（若已连接）"),
-            ip: z
-                .string()
-                .min(1)
-                .optional()
-                .describe("设备 IP 地址（transport=http 时可传；未传则使用 set_device 默认值）"),
-            port: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("设备端口，默认 9800"),
-            wsPort: z
-                .number()
-                .int()
-                .min(1)
-                .max(65535)
-                .optional()
-                .describe("WS 服务端口（transport=ws 时可选，默认 31111）"),
-            wsWaitMs: z
-                .number()
-                .int()
-                .min(1)
-                .max(600000)
-                .optional()
-                .describe("WS 等待连接超时毫秒（transport=ws 时可选，默认 30000）"),
-        },
-    }, async ({ transport, ip, port, wsPort, wsWaitMs }) => {
-        const target = await resolvePreferredRuntimeTarget({
-            transport,
-            ip,
-            port,
-            wsPort,
-            wsWaitMs,
-        });
-        await (0, project_1.stopOnDevice)(target.transport === "ws"
-            ? {
-                transport: "ws",
-                wsPort: target.wsPort,
-                wsWaitMs: target.wsWaitMs,
-            }
-            : {
-                ip: target.ip,
-                port: target.port,
-                transport: "http",
-            });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `停止请求已发送到 ${target.label}`,
-                },
-            ],
-        };
+        description: "停止当前默认设备上的项目，仅使用 HTTP 设备连接。",
+        inputSchema: {},
+    }, async () => {
+        const target = await resolveRuntimeHttpTarget();
+        await (0, project_1.stopOnDevice)(createRuntimeHttpRequestOptions(target));
+        return createTextToolResult(`停止请求已发送到 ${target.label}`);
     });
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms-vite-plugin",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "type": "commonjs",
   "license": "MIT",
   "publishConfig": {