ms-vite-plugin 1.4.14 → 1.4.15

package/dist/mcp/device-log.d.ts

@@ -1,25 +1,10 @@
+import type { RuntimeHttpTarget } from "./tool-utils";
 /**
- * 设备日志内存缓存上限
- * - 采用环形窗口思路，仅保留最新 5000 条，避免 MCP 进程长期运行时内存无限增长
- */
-export declare const DEVICE_LOG_MEMORY_LIMIT = 5000;
-/**
- * 确保后台日志订阅处于目标设备上
- * - 若目标未变化且订阅仍在运行，则直接复用已有连接
- * - 若目标发生变化，则重置缓存并重新建立订阅
- * @param ip 设备 IP
- * @param port 设备端口
- * @returns 返回是否复用了现有订阅
- * @example
- * const reused = ensureDeviceLogSubscription("192.168.1.10", 9800)
- */
-export declare function ensureDeviceLogSubscription(ip: string, port: number): boolean;
-/**
- * 生成日志缓存快照文本
- * @param limit 需要返回的日志条数
- * @param runtimeStatusLimit 需要返回的 runtime_status 条数
- * @returns 返回用于 MCP 文本响应的快照内容
+ * 构建当前设备日志文本快照
+ * @param target 当前默认 HTTP 设备
+ * @param limit 需要返回的最新日志行数
+ * @returns 返回可直接作为 MCP 文本响应的日志内容
  * @example
- * const text = buildDeviceLogSnapshotText(100, 20)
+ * const text = await buildDeviceLogSnapshotText({ ip: "192.168.1.10", port: "9800", label: "192.168.1.10:9800" }, 200)
  */
-export declare function buildDeviceLogSnapshotText(limit: number, runtimeStatusLimit: number): string;
+export declare function buildDeviceLogSnapshotText(target: RuntimeHttpTarget, limit: number): Promise<string>;

package/dist/mcp/device-log.js

@@ -1,390 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEVICE_LOG_MEMORY_LIMIT = void 0;
-exports.ensureDeviceLogSubscription = ensureDeviceLogSubscription;
 exports.buildDeviceLogSnapshotText = buildDeviceLogSnapshotText;
-/**
- * 设备日志内存缓存上限
- * - 采用环形窗口思路，仅保留最新 5000 条，避免 MCP 进程长期运行时内存无限增长
- */
-exports.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);
-}
-/**
- * 重置当前日志缓存快照
- * @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), exports.DEVICE_LOG_MEMORY_LIMIT);
-                        }
-                        else if (event.event === "runtime_status") {
-                            pushRingBuffer(deviceLogSubscriptionState.runtimeStatus, {
-                                raw: parsed,
-                                timestamp: new Date().toISOString(),
-                            }, exports.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 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 数值存在时返回格式化结果，否则返回未知
- * @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.systemUsed, " MB")}/${formatRuntimeMetricText(memory.total, " MB")}`,
-        `系统占用: ${formatRuntimeMetricText(memory.usagePercentage, "%")}`,
-        `应用: ${formatRuntimeMetricText(memory.used, " MB")}`,
-    ].join(" | ");
-}
-/**
- * 生成日志缓存快照文本
- * @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));
+const project_1 = require("../project");
+/**
+ * 构建当前设备日志文本快照
+ * @param target 当前默认 HTTP 设备
+ * @param limit 需要返回的最新日志行数
+ * @returns 返回可直接作为 MCP 文本响应的日志内容
+ * @example
+ * const text = await buildDeviceLogSnapshotText({ ip: "192.168.1.10", port: "9800", label: "192.168.1.10:9800" }, 200)
+ */
+async function buildDeviceLogSnapshotText(target, limit) {
+    const result = await (0, project_1.getCurrentLogLinesOnDevice)({
+        ip: target.ip,
+        port: target.port,
+        transport: "http",
+    }, limit);
+    const lines = result.lines.length > 0 ? result.lines.join("\n") : "无日志";
     return [
-        `设备: ${deviceLogSubscriptionState.target
-            ? `${deviceLogSubscriptionState.target.ip}:${deviceLogSubscriptionState.target.port}`
-            : "未订阅"}`,
-        `状态: ${formatDeviceLogSubscriptionStatus(deviceLogSubscriptionState.status)}`,
-        ...(deviceLogSubscriptionState.lastError
-            ? [`最近错误: ${deviceLogSubscriptionState.lastError}`]
-            : []),
-        "",
-        `最新日志（最多 ${limit} 条）:`,
-        recentLogs.length > 0 ? recentLogs.join("\n") : "无日志",
+        `设备: ${target.label}`,
+        `还有更早日志: ${result.hasMore ? "是" : "否"}`,
         "",
-        `最新运行状态（最多 ${runtimeStatusLimit} 条）:`,
-        recentRuntimeStatus.length > 0
-            ? recentRuntimeStatus.join("\n")
-            : "无运行状态",
+        `最新日志（最多 ${limit} 行）:`,
+        lines,
     ].join("\n");
 }

package/dist/mcp/runtime-tools.js

@@ -142,13 +142,7 @@ function registerRuntimeTools(server) {
         },
     }, async ({ ip, port }) => {
         const config = await (0, device_config_1.setDeviceConfig)(ip, port);
-        const reusedSubscription = (0, device_log_1.ensureDeviceLogSubscription)(config.ip, config.port);
-        return (0, tool_utils_1.createTextToolResult)([
-            `默认设备已设置为 ${config.ip}:${config.port}`,
-            reusedSubscription
-                ? "SSE 日志后台订阅已复用现有连接"
-                : `SSE 日志后台订阅已启动，内存缓存上限 ${device_log_1.DEVICE_LOG_MEMORY_LIMIT} 条`,
-        ].join("\n"));
+        return (0, tool_utils_1.createTextToolResult)(`默认设备已设置为 ${config.ip}:${config.port}`);
     });
     server.registerTool("get_device", {
         title: "Get Device",
@@ -226,7 +220,7 @@ function registerRuntimeTools(server) {
     });
     server.registerTool("get_logs", {
         title: "Get Device Logs",
-        description: "获取当前默认设备的日志缓存快照。调用 set_device 后会自动建立 SSE 后台订阅，此工具只返回当前已缓存的日志内容。",
+        description: "获取当前默认设备的最新日志行。",
         inputSchema: {
             limit: z
                 .number()
@@ -236,19 +230,10 @@ function registerRuntimeTools(server) {
                 .optional()
                 .default(200)
                 .describe("返回最近日志条数，默认 200，最大 5000"),
-            runtimeStatusLimit: z
-                .number()
-                .int()
-                .min(0)
-                .max(200)
-                .optional()
-                .default(20)
-                .describe("返回最近 runtime_status 条数，默认 20"),
         },
-    }, async ({ limit, runtimeStatusLimit }) => {
+    }, async ({ limit }) => {
         const target = await (0, tool_utils_1.resolveRuntimeHttpTarget)();
-        (0, device_log_1.ensureDeviceLogSubscription)(target.ip, Number.parseInt(target.port, 10));
-        return (0, tool_utils_1.createTextToolResult)((0, device_log_1.buildDeviceLogSnapshotText)(limit, runtimeStatusLimit));
+        return (0, tool_utils_1.createTextToolResult)(await (0, device_log_1.buildDeviceLogSnapshotText)(target, limit));
     });
     server.registerTool("package_project", {
         title: "Package Project",

package/dist/project.d.ts

@@ -10,35 +10,13 @@ export interface DeviceCliOptions {
     workspacePath?: string;
 }
 /**
- * 设备日志条目
+ * 当前日志最新行接口响应
  */
-export interface DeviceLogEntry {
-    /** 日志级别，例如 debug/info/warn/error */
-    level: string;
-    /** 日志文本 */
-    message: string;
-    /** 日志时间戳（ISO 字符串） */
-    timestamp: string;
-}
-/**
- * 运行时状态条目（来自 SSE runtime_status 事件）
- */
-export interface DeviceRuntimeStatusEntry {
-    /** 原始 runtime_status 数据 */
-    raw: Record<string, unknown>;
-    /** 事件时间戳（本地接收时间） */
-    timestamp: string;
-}
-/**
- * SSE 日志监听结果
- */
-export interface DeviceLogWatchResult {
-    /** 收集到的日志条目 */
-    logs: DeviceLogEntry[];
-    /** 收集到的 runtime_status 条目 */
-    runtimeStatus: DeviceRuntimeStatusEntry[];
-    /** 监听结束原因 */
-    stopReason: "timeout" | "runtime_continuous" | "runtime_stopped" | "stream_closed" | "manual_abort" | "unknown";
+export interface CurrentLogLinesResponse {
+    /** 当前日志文件最新行，按日志原始输出顺序排列 */
+    lines: string[];
+    /** 本次返回范围前是否还有更早日志 */
+    hasMore: boolean;
 }
 /**
  * 在设备上获取截图 JPG 二进制数据（HTTP）
@@ -67,18 +45,14 @@ export declare function getScreenshotBase64OnDevice(options: DeviceCliOptions):
  */
 export declare function getSourceOnDevice(options: DeviceCliOptions, maxDepth?: number, timeout?: number): Promise<string>;
 /**
- * 监听设备 SSE 日志并返回原始结果
- * @param ip 设备 IP 地址
- * @param port 设备端口
- * @param durationMs 监听时长（毫秒），默认 15000；传 0 表示不设超时，持续监听
- * @param maxLogs 最多收集日志条数，默认 200
- * @param stopOnRuntimeStopped 若为 true，则在运行状态从 true 回落到 false 后结束监听
- * @param stopOnRuntimeContinuous 若为 true，则在确认持续运行态后结束监听（用于 single 模式快速返回）
- * @returns 返回日志与运行状态
+ * 在设备上获取当前日志文件最新行
+ * @param options 命令选项（仅支持 http 传输）
+ * @param count 需要读取的最新日志行数，默认 200，最大 5000
+ * @returns 返回最新日志行和是否还有更早日志
  * @example
- * const result = await watchDeviceLogsBySse("192.168.1.10", 9800, 30000, 300, true, true)
+ * const result = await getCurrentLogLinesOnDevice({ ip: "192.168.1.10", port: "9800" }, 200)
  */
-export declare function watchDeviceLogsBySse(ip: string, port: number, durationMs?: number, maxLogs?: number, stopOnRuntimeStopped?: boolean, stopOnRuntimeContinuous?: boolean): Promise<DeviceLogWatchResult>;
+export declare function getCurrentLogLinesOnDevice(options: DeviceCliOptions, count?: number): Promise<CurrentLogLinesResponse>;
 /**
  * 在设备上运行项目（先同步后运行）
  * @param options 命令选项

package/dist/project.js

@@ -39,7 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getScreenshotOnDevice = getScreenshotOnDevice;
 exports.getScreenshotBase64OnDevice = getScreenshotBase64OnDevice;
 exports.getSourceOnDevice = getSourceOnDevice;
-exports.watchDeviceLogsBySse = watchDeviceLogsBySse;
+exports.getCurrentLogLinesOnDevice = getCurrentLogLinesOnDevice;
 exports.runOnDevice = runOnDevice;
 exports.runUIOnDevice = runUIOnDevice;
 exports.stopOnDevice = stopOnDevice;
@@ -463,196 +463,40 @@ async function getSourceOnDevice(options, maxDepth = 50, timeout = 120) {
     return response.text();
 }
 /**
- * 将 SSE 文本块解析为事件字段结构
- * @param rawBlock 单个 SSE 事件文本块（以空行分隔）
- * @returns 返回事件名与数据字符串
+ * 在设备上获取当前日志文件最新行
+ * @param options 命令选项（仅支持 http 传输）
+ * @param count 需要读取的最新日志行数，默认 200，最大 5000
+ * @returns 返回最新日志行和是否还有更早日志
  * @example
- * parseSseEventBlock("event: log\ndata: {\"level\":\"info\"}")
+ * const result = await getCurrentLogLinesOnDevice({ ip: "192.168.1.10", port: "9800" }, 200)
  */
-function parseSseEventBlock(rawBlock) {
-    const lines = rawBlock.split(/\r?\n/);
-    let eventName = "message";
-    const dataLines = [];
-    for (const line of lines) {
-        if (!line || line.startsWith(":")) {
-            continue;
-        }
-        if (line.startsWith("event:")) {
-            eventName = line.slice("event:".length).trim() || "message";
-            continue;
-        }
-        if (line.startsWith("data:")) {
-            dataLines.push(line.slice("data:".length).trimStart());
-        }
-    }
-    return {
-        event: eventName,
-        data: dataLines.join("\n"),
-    };
-}
-/**
- * 将原始日志对象标准化为 DeviceLogEntry
- * @param payload 日志原始对象
- * @returns 返回标准化日志对象
- * @example
- * normalizeLogEntry({ level: "info", message: "ok", timestamp: "2026-01-01T00:00:00Z" })
- */
-function normalizeLogEntry(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,
-    };
-}
-/**
- * 监听设备 SSE 日志并返回原始结果
- * @param ip 设备 IP 地址
- * @param port 设备端口
- * @param durationMs 监听时长（毫秒），默认 15000；传 0 表示不设超时，持续监听
- * @param maxLogs 最多收集日志条数，默认 200
- * @param stopOnRuntimeStopped 若为 true，则在运行状态从 true 回落到 false 后结束监听
- * @param stopOnRuntimeContinuous 若为 true，则在确认持续运行态后结束监听（用于 single 模式快速返回）
- * @returns 返回日志与运行状态
- * @example
- * const result = await watchDeviceLogsBySse("192.168.1.10", 9800, 30000, 300, true, true)
- */
-async function watchDeviceLogsBySse(ip, port, durationMs = 15000, maxLogs = 200, stopOnRuntimeStopped = false, stopOnRuntimeContinuous = false) {
-    if (!ip.trim()) {
-        throw new Error("监听日志失败: 设备 IP 不能为空");
+async function getCurrentLogLinesOnDevice(options, count = 200) {
+    const transport = parseTransport(options);
+    if (transport !== "http") {
+        throw new Error("获取日志失败: 当前日志行接口仅支持 http 传输");
     }
-    if (!Number.isInteger(port) || port < 1 || port > 65535) {
-        throw new Error(`监听日志失败: 无效端口 ${port}`);
-    }
-    if (!Number.isInteger(durationMs) || durationMs < 0) {
-        throw new Error(`监听日志失败: 无效 durationMs ${durationMs}`);
-    }
-    if (!Number.isInteger(maxLogs) || maxLogs < 1) {
-        throw new Error(`监听日志失败: 无效 maxLogs ${maxLogs}`);
-    }
-    const url = `http://${ip}:${port}/logger/sse`;
-    const logs = [];
-    const runtimeStatus = [];
-    const controller = new AbortController();
-    let stopReason = "unknown";
-    let seenRunningStatus = false;
-    let runningStatusCount = 0;
-    let shouldStopReading = false;
-    const timeoutHandle = durationMs > 0
-        ? setTimeout(() => {
-            stopReason = "timeout";
-            controller.abort();
-        }, durationMs)
-        : undefined;
-    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"}`);
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder("utf-8");
-        let buffer = "";
-        while (true) {
-            if (shouldStopReading) {
-                break;
-            }
-            const { value, done } = await reader.read();
-            if (done) {
-                if (stopReason === "unknown") {
-                    stopReason = "stream_closed";
-                }
-                break;
-            }
-            buffer += decoder.decode(value, { stream: true });
-            // SSE 事件以双换行分隔，这里逐块解析，避免半包解析错误
-            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);
-                        if (event.event === "log") {
-                            // 日志缓冲使用环形窗口，持续监听时不会无限增长
-                            if (logs.length >= maxLogs) {
-                                logs.shift();
-                            }
-                            logs.push(normalizeLogEntry(parsed));
-                        }
-                        else if (event.event === "runtime_status") {
-                            if (runtimeStatus.length >= maxLogs) {
-                                runtimeStatus.shift();
-                            }
-                            runtimeStatus.push({
-                                raw: parsed,
-                                timestamp: new Date().toISOString(),
-                            });
-                            if (parsed.isRunning === true) {
-                                seenRunningStatus = true;
-                                runningStatusCount += 1;
-                                // 连续收到运行态，视为长期任务，single 模式可立即返回并转持续监听
-                                if (stopOnRuntimeContinuous && runningStatusCount >= 2) {
-                                    stopReason = "runtime_continuous";
-                                    controller.abort();
-                                    shouldStopReading = true;
-                                    break;
-                                }
-                            }
-                            else if (parsed.isRunning === false) {
-                                runningStatusCount = 0;
-                            }
-                            if (stopOnRuntimeStopped &&
-                                seenRunningStatus &&
-                                parsed.isRunning === false) {
-                                stopReason = "runtime_stopped";
-                                controller.abort();
-                                shouldStopReading = true;
-                                break;
-                            }
-                        }
-                    }
-                    catch {
-                        // 兼容非 JSON 数据：不抛错，继续监听后续事件
-                    }
-                }
-                splitIndex = buffer.search(/\r?\n\r?\n/);
-            }
-            if (shouldStopReading) {
-                break;
-            }
-        }
+    if (!Number.isInteger(count) || count < 1 || count > 5000) {
+        throw new Error(`获取日志失败: 无效 count ${count}`);
     }
-    catch (error) {
-        // 监听超时是预期行为，忽略 AbortError 并正常输出已采集日志
-        if (!(error instanceof Error &&
-            (error.name === "AbortError" ||
-                error.message === "The operation was aborted."))) {
-            throw error;
-        }
-        if (stopReason === "unknown") {
-            stopReason = "manual_abort";
-        }
+    const { ip, port } = parseHttpOptions(options);
+    const url = new URL(`http://${ip}:${port}/logger/current/lines`);
+    url.searchParams.set("count", String(count));
+    const response = await fetch(url.toString(), { method: "GET" });
+    if (response.status === 404) {
+        return {
+            lines: [],
+            hasMore: false,
+        };
     }
-    finally {
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
+    if (!response.ok) {
+        throw new Error(`获取日志失败，状态码: ${response.status}`);
     }
+    const payload = (await response.json());
     return {
-        logs,
-        runtimeStatus,
-        stopReason,
+        lines: Array.isArray(payload.lines)
+            ? payload.lines.map((line) => String(line))
+            : [],
+        hasMore: payload.hasMore === true,
     };
 }
 /**

package/docs/SKILL.md

@@ -112,8 +112,7 @@ MCP 可用时：
 
 1. 使用 `get_device` 查看当前默认设备。
 2. 如果未设置设备，使用 `set_device` 设置设备 IP 和端口。
-3. 设置设备后，日志 SSE 后台订阅会自动启动。
-4. 使用 `get_logs` 获取日志缓存快照。
+3. 使用 `get_logs` 获取当前日志最新行。
 
 命令 fallback 时：
 

package/docs/mcp-agent-description.md

@@ -137,8 +137,7 @@ MCP 可用时：
 
 - 使用 `get_device` 查看当前默认设备。
 - 使用 `set_device` 设置设备 IP 和端口。
-- 设备设置后会自动启动日志 SSE 后台订阅。
-- 使用 `get_logs` 查看日志缓存快照。
+- 使用 `get_logs` 查看当前日志最新行。
 
 UI 预览发起后不需要长时间等待结果，可以通过 `take_screenshot` 查看当前界面效果。
 

package/package.json

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