diff --git a/example_devices.py b/example_devices.py
new file mode 100644
index 00000000..d5b26b2c
--- /dev/null
+++ b/example_devices.py
@@ -0,0 +1,588 @@
+"""
+示例设备类文件，用于测试注册表编辑器
+"""
+
+import asyncio
+from typing import Dict, Any, Optional, List
+
+
+class SmartPumpController:
+    """
+    智能泵控制器
+
+    支持多种泵送模式，具有高精度流量控制和自动校准功能。
+    适用于实验室自动化系统中的液体处理任务。
+    """
+
+    def __init__(self, device_id: str = "smart_pump_01", port: str = "/dev/ttyUSB0"):
+        """
+        初始化智能泵控制器
+
+        Args:
+            device_id: 设备唯一标识符
+            port: 通信端口
+        """
+        self.device_id = device_id
+        self.port = port
+        self.is_connected = False
+        self.current_flow_rate = 0.0
+        self.total_volume_pumped = 0.0
+        self.calibration_factor = 1.0
+        self.pump_mode = "continuous"  # continuous, volume, rate
+
+    def connect_device(self, timeout: int = 10) -> bool:
+        """
+        连接到泵设备
+
+        Args:
+            timeout: 连接超时时间（秒）
+
+        Returns:
+            bool: 连接是否成功
+        """
+        # 模拟连接过程
+        self.is_connected = True
+        return True
+
+    def disconnect_device(self) -> bool:
+        """
+        断开设备连接
+
+        Returns:
+            bool: 断开连接是否成功
+        """
+        self.is_connected = False
+        self.current_flow_rate = 0.0
+        return True
+
+    def set_flow_rate(self, flow_rate: float, units: str = "ml/min") -> bool:
+        """
+        设置泵流速
+
+        Args:
+            flow_rate: 流速值
+            units: 流速单位
+
+        Returns:
+            bool: 设置是否成功
+        """
+        if not self.is_connected:
+            return False
+
+        self.current_flow_rate = flow_rate
+        return True
+
+    async def pump_volume_async(self, volume: float, flow_rate: float) -> Dict[str, Any]:
+        """
+        异步泵送指定体积的液体
+
+        Args:
+            volume: 目标体积 (mL)
+            flow_rate: 泵送流速 (mL/min)
+
+        Returns:
+            Dict: 包含操作结果的字典
+        """
+        if not self.is_connected:
+            return {"success": False, "error": "设备未连接"}
+
+        # 计算泵送时间
+        pump_time = (volume / flow_rate) * 60  # 转换为秒
+
+        self.current_flow_rate = flow_rate
+        await asyncio.sleep(min(pump_time, 3.0))  # 模拟泵送过程
+
+        self.total_volume_pumped += volume
+        self.current_flow_rate = 0.0
+
+        return {
+            "success": True,
+            "pumped_volume": volume,
+            "actual_time": min(pump_time, 3.0),
+            "total_volume": self.total_volume_pumped,
+        }
+
+    def emergency_stop(self) -> bool:
+        """
+        紧急停止泵
+
+        Returns:
+            bool: 停止是否成功
+        """
+        self.current_flow_rate = 0.0
+        return True
+
+    def perform_calibration(self, reference_volume: float, measured_volume: float) -> bool:
+        """
+        执行泵校准
+
+        Args:
+            reference_volume: 参考体积
+            measured_volume: 实际测量体积
+
+        Returns:
+            bool: 校准是否成功
+        """
+        if measured_volume > 0:
+            self.calibration_factor = reference_volume / measured_volume
+            return True
+        return False
+
+    # 状态查询方法
+    def get_connection_status(self) -> str:
+        """获取连接状态"""
+        return "connected" if self.is_connected else "disconnected"
+
+    def get_current_flow_rate(self) -> float:
+        """获取当前流速 (mL/min)"""
+        return self.current_flow_rate
+
+    def get_total_volume(self) -> float:
+        """获取累计泵送体积 (mL)"""
+        return self.total_volume_pumped
+
+    def get_calibration_factor(self) -> float:
+        """获取校准因子"""
+        return self.calibration_factor
+
+    def get_pump_mode(self) -> str:
+        """获取泵送模式"""
+        return self.pump_mode
+
+    def get_device_status(self) -> Dict[str, Any]:
+        """获取设备完整状态信息"""
+        return {
+            "device_id": self.device_id,
+            "connected": self.is_connected,
+            "flow_rate": self.current_flow_rate,
+            "total_volume": self.total_volume_pumped,
+            "calibration_factor": self.calibration_factor,
+            "mode": self.pump_mode,
+            "running": self.current_flow_rate > 0,
+        }
+
+
+class AdvancedTemperatureController:
+    """
+    高级温度控制器
+
+    支持PID控制、多点温度监控和程序化温度曲线。
+    适用于需要精确温度控制的化学反应和材料处理过程。
+    """
+
+    def __init__(self, controller_id: str = "temp_controller_01"):
+        """
+        初始化温度控制器
+
+        Args:
+            controller_id: 控制器ID
+        """
+        self.controller_id = controller_id
+        self.current_temperature = 25.0
+        self.target_temperature = 25.0
+        self.is_heating = False
+        self.is_cooling = False
+        self.pid_enabled = True
+        self.temperature_history: List[Dict] = []
+
+    def set_target_temperature(self, temperature: float, rate: float = 10.0) -> bool:
+        """
+        设置目标温度
+
+        Args:
+            temperature: 目标温度 (°C)
+            rate: 升温/降温速率 (°C/min)
+
+        Returns:
+            bool: 设置是否成功
+        """
+        self.target_temperature = temperature
+        return True
+
+    async def heat_to_temperature_async(
+        self, temperature: float, tolerance: float = 0.5, timeout: int = 600
+    ) -> Dict[str, Any]:
+        """
+        异步加热到指定温度
+
+        Args:
+            temperature: 目标温度 (°C)
+            tolerance: 温度容差 (°C)
+            timeout: 最大等待时间 (秒)
+
+        Returns:
+            Dict: 操作结果
+        """
+        self.target_temperature = temperature
+        start_temp = self.current_temperature
+
+        if temperature > start_temp:
+            self.is_heating = True
+        elif temperature < start_temp:
+            self.is_cooling = True
+
+        # 模拟温度变化过程
+        steps = min(abs(temperature - start_temp) * 2, 20)  # 计算步数
+        step_time = min(timeout / steps if steps > 0 else 1, 2.0)  # 每步最多2秒
+
+        for step in range(int(steps)):
+            progress = (step + 1) / steps
+            self.current_temperature = start_temp + (temperature - start_temp) * progress
+
+            # 记录温度历史
+            self.temperature_history.append(
+                {
+                    "timestamp": asyncio.get_event_loop().time(),
+                    "temperature": self.current_temperature,
+                    "target": self.target_temperature,
+                }
+            )
+
+            await asyncio.sleep(step_time)
+
+            # 保持历史记录不超过100条
+            if len(self.temperature_history) > 100:
+                self.temperature_history.pop(0)
+
+        # 最终设置为目标温度
+        self.current_temperature = temperature
+        self.is_heating = False
+        self.is_cooling = False
+
+        return {
+            "success": True,
+            "final_temperature": self.current_temperature,
+            "start_temperature": start_temp,
+            "time_taken": steps * step_time,
+        }
+
+    def enable_pid_control(self, kp: float = 1.0, ki: float = 0.1, kd: float = 0.05) -> bool:
+        """
+        启用PID控制
+
+        Args:
+            kp: 比例增益
+            ki: 积分增益
+            kd: 微分增益
+
+        Returns:
+            bool: 启用是否成功
+        """
+        self.pid_enabled = True
+        return True
+
+    def run_temperature_program(self, program: List[Dict]) -> bool:
+        """
+        运行温度程序
+
+        Args:
+            program: 温度程序列表，每个元素包含温度和持续时间
+
+        Returns:
+            bool: 程序启动是否成功
+        """
+        # 模拟程序启动
+        return True
+
+    # 状态查询方法
+    def get_current_temperature(self) -> float:
+        """获取当前温度 (°C)"""
+        return round(self.current_temperature, 2)
+
+    def get_target_temperature(self) -> float:
+        """获取目标温度 (°C)"""
+        return self.target_temperature
+
+    def get_heating_status(self) -> bool:
+        """获取加热状态"""
+        return self.is_heating
+
+    def get_cooling_status(self) -> bool:
+        """获取制冷状态"""
+        return self.is_cooling
+
+    def get_pid_status(self) -> bool:
+        """获取PID控制状态"""
+        return self.pid_enabled
+
+    def get_temperature_history(self) -> List[Dict]:
+        """获取温度历史记录"""
+        return self.temperature_history[-10:]  # 返回最近10条记录
+
+    def get_controller_status(self) -> Dict[str, Any]:
+        """获取控制器完整状态"""
+        return {
+            "controller_id": self.controller_id,
+            "current_temp": self.current_temperature,
+            "target_temp": self.target_temperature,
+            "is_heating": self.is_heating,
+            "is_cooling": self.is_cooling,
+            "pid_enabled": self.pid_enabled,
+            "history_count": len(self.temperature_history),
+        }
+
+
+class MultiChannelAnalyzer:
+    """
+    多通道分析仪
+
+    支持同时监测多个通道的信号，提供实时数据采集和分析功能。
+    常用于光谱分析、电化学测量等应用场景。
+    """
+
+    def __init__(self, analyzer_id: str = "analyzer_01", channels: int = 8):
+        """
+        初始化多通道分析仪
+
+        Args:
+            analyzer_id: 分析仪ID
+            channels: 通道数量
+        """
+        self.analyzer_id = analyzer_id
+        self.channel_count = channels
+        self.channel_data = {i: {"value": 0.0, "unit": "V", "enabled": True} for i in range(channels)}
+        self.is_measuring = False
+        self.sample_rate = 1000  # Hz
+
+    def configure_channel(self, channel: int, enabled: bool = True, unit: str = "V") -> bool:
+        """
+        配置通道
+
+        Args:
+            channel: 通道编号
+            enabled: 是否启用
+            unit: 测量单位
+
+        Returns:
+            bool: 配置是否成功
+        """
+        if 0 <= channel < self.channel_count:
+            self.channel_data[channel]["enabled"] = enabled
+            self.channel_data[channel]["unit"] = unit
+            return True
+        return False
+
+    async def start_measurement_async(self, duration: int = 10) -> Dict[str, Any]:
+        """
+        开始异步测量
+
+        Args:
+            duration: 测量持续时间（秒）
+
+        Returns:
+            Dict: 测量结果
+        """
+        self.is_measuring = True
+
+        # 模拟数据采集
+        measurements = []
+        for second in range(duration):
+            timestamp = asyncio.get_event_loop().time()
+            frame_data = {}
+
+            for channel in range(self.channel_count):
+                if self.channel_data[channel]["enabled"]:
+                    # 模拟传感器数据
+                    import random
+
+                    value = random.uniform(-5.0, 5.0)
+                    frame_data[f"channel_{channel}"] = value
+                    self.channel_data[channel]["value"] = value
+
+            measurements.append({"timestamp": timestamp, "data": frame_data})
+
+            await asyncio.sleep(1.0)  # 每秒采集一次
+
+        self.is_measuring = False
+
+        return {
+            "success": True,
+            "duration": duration,
+            "samples_count": len(measurements),
+            "measurements": measurements[-5:],  # 只返回最后5个样本
+            "channels_active": len([ch for ch in self.channel_data.values() if ch["enabled"]]),
+        }
+
+    def stop_measurement(self) -> bool:
+        """
+        停止测量
+
+        Returns:
+            bool: 停止是否成功
+        """
+        self.is_measuring = False
+        return True
+
+    def reset_channels(self) -> bool:
+        """
+        重置所有通道
+
+        Returns:
+            bool: 重置是否成功
+        """
+        for channel in self.channel_data:
+            self.channel_data[channel]["value"] = 0.0
+        return True
+
+    # 状态查询方法
+    def get_measurement_status(self) -> bool:
+        """获取测量状态"""
+        return self.is_measuring
+
+    def get_channel_count(self) -> int:
+        """获取通道数量"""
+        return self.channel_count
+
+    def get_sample_rate(self) -> float:
+        """获取采样率 (Hz)"""
+        return self.sample_rate
+
+    def get_channel_values(self) -> Dict[int, float]:
+        """获取所有通道的当前值"""
+        return {ch: data["value"] for ch, data in self.channel_data.items() if data["enabled"]}
+
+    def get_enabled_channels(self) -> List[int]:
+        """获取已启用的通道列表"""
+        return [ch for ch, data in self.channel_data.items() if data["enabled"]]
+
+    def get_analyzer_status(self) -> Dict[str, Any]:
+        """获取分析仪完整状态"""
+        return {
+            "analyzer_id": self.analyzer_id,
+            "channel_count": self.channel_count,
+            "is_measuring": self.is_measuring,
+            "sample_rate": self.sample_rate,
+            "active_channels": len(self.get_enabled_channels()),
+            "channel_data": self.channel_data,
+        }
+
+
+class AutomatedDispenser:
+    """
+    自动分配器
+
+    精确控制固体和液体材料的分配，支持多种分配模式和容器管理。
+    集成称重功能，确保分配精度和重现性。
+    """
+
+    def __init__(self, dispenser_id: str = "dispenser_01"):
+        """
+        初始化自动分配器
+
+        Args:
+            dispenser_id: 分配器ID
+        """
+        self.dispenser_id = dispenser_id
+        self.is_ready = True
+        self.current_position = {"x": 0.0, "y": 0.0, "z": 0.0}
+        self.dispensed_total = 0.0
+        self.container_capacity = 1000.0  # mL
+        self.precision_mode = True
+
+    def move_to_position(self, x: float, y: float, z: float) -> bool:
+        """
+        移动到指定位置
+
+        Args:
+            x: X坐标 (mm)
+            y: Y坐标 (mm)
+            z: Z坐标 (mm)
+
+        Returns:
+            bool: 移动是否成功
+        """
+        self.current_position = {"x": x, "y": y, "z": z}
+        return True
+
+    async def dispense_liquid_async(self, volume: float, container_id: str, viscosity: str = "low") -> Dict[str, Any]:
+        """
+        异步分配液体
+
+        Args:
+            volume: 分配体积 (mL)
+            container_id: 容器ID
+            viscosity: 液体粘度等级
+
+        Returns:
+            Dict: 分配结果
+        """
+        if not self.is_ready:
+            return {"success": False, "error": "设备未就绪"}
+
+        if volume <= 0:
+            return {"success": False, "error": "体积必须大于0"}
+
+        # 模拟分配过程
+        dispense_time = volume * 0.1  # 每mL需要0.1秒
+        if viscosity == "high":
+            dispense_time *= 2  # 高粘度液体需要更长时间
+
+        await asyncio.sleep(min(dispense_time, 5.0))  # 最多等待5秒
+
+        self.dispensed_total += volume
+
+        return {
+            "success": True,
+            "dispensed_volume": volume,
+            "container_id": container_id,
+            "actual_time": min(dispense_time, 5.0),
+            "total_dispensed": self.dispensed_total,
+        }
+
+    def clean_dispenser(self, wash_volume: float = 5.0) -> bool:
+        """
+        清洗分配器
+
+        Args:
+            wash_volume: 清洗液体积 (mL)
+
+        Returns:
+            bool: 清洗是否成功
+        """
+        # 模拟清洗过程
+        return True
+
+    def calibrate_volume(self, target_volume: float) -> bool:
+        """
+        校准分配体积
+
+        Args:
+            target_volume: 校准目标体积 (mL)
+
+        Returns:
+            bool: 校准是否成功
+        """
+        # 模拟校准过程
+        return True
+
+    # 状态查询方法
+    def get_ready_status(self) -> bool:
+        """获取就绪状态"""
+        return self.is_ready
+
+    def get_current_position(self) -> Dict[str, float]:
+        """获取当前位置坐标"""
+        return self.current_position.copy()
+
+    def get_dispensed_total(self) -> float:
+        """获取累计分配体积 (mL)"""
+        return self.dispensed_total
+
+    def get_container_capacity(self) -> float:
+        """获取容器容量 (mL)"""
+        return self.container_capacity
+
+    def get_precision_mode(self) -> bool:
+        """获取精密模式状态"""
+        return self.precision_mode
+
+    def get_dispenser_status(self) -> Dict[str, Any]:
+        """获取分配器完整状态"""
+        return {
+            "dispenser_id": self.dispenser_id,
+            "ready": self.is_ready,
+            "position": self.current_position,
+            "dispensed_total": self.dispensed_total,
+            "capacity": self.container_capacity,
+            "precision_mode": self.precision_mode,
+        }
diff --git a/unilabos/app/web/api.py b/unilabos/app/web/api.py
index eb18b4dc..bf51f4af 100644
--- a/unilabos/app/web/api.py
+++ b/unilabos/app/web/api.py
@@ -26,6 +26,49 @@ admin = APIRouter()
 
 # 存储所有活动的WebSocket连接
 active_connections: set[WebSocket] = set()
+# 存储注册表编辑器的WebSocket连接
+registry_editor_connections: set[WebSocket] = set()
+# 存储状态页面的WebSocket连接
+status_page_connections: set[WebSocket] = set()
+
+# 状态跟踪变量，用于差异检测
+_static_data_sent_connections: set[WebSocket] = set()
+_previous_host_node_info: dict = {}
+_previous_local_devices: dict = {}
+
+
+def compute_host_node_diff(current: dict, previous: dict) -> dict:
+    """计算主机节点信息的差异，只返回有变化的部分"""
+    diff = {}
+
+    # 检查可用性变化
+    if current.get("available") != previous.get("available"):
+        diff["available"] = current.get("available")
+
+    # 检查设备列表变化
+    current_devices = current.get("devices", {})
+    previous_devices = previous.get("devices", {})
+    if current_devices != previous_devices:
+        diff["devices"] = current_devices
+
+    # 检查动作客户端变化
+    current_action_clients = current.get("action_clients", {})
+    previous_action_clients = previous.get("action_clients", {})
+    if current_action_clients != previous_action_clients:
+        diff["action_clients"] = current_action_clients
+
+    # 检查订阅主题变化
+    current_topics = current.get("subscribed_topics", [])
+    previous_topics = previous.get("subscribed_topics", [])
+    if current_topics != previous_topics:
+        diff["subscribed_topics"] = current_topics
+
+    # 设备状态始终包含（因为需要实时更新）
+    if "device_status" in current:
+        diff["device_status"] = current["device_status"]
+        diff["device_status_timestamps"] = current.get("device_status_timestamps", {})
+
+    return diff
 
 
 async def broadcast_device_status():
@@ -56,6 +99,137 @@ async def broadcast_device_status():
             await asyncio.sleep(1)
 
 
+async def broadcast_status_page_data():
+    """广播状态页面数据到所有连接的客户端（优化版：增量更新）"""
+    global _previous_local_devices, _static_data_sent_connections, _previous_host_node_info
+
+    while True:
+        try:
+            if status_page_connections:
+                from unilabos.app.web.utils.host_utils import get_host_node_info
+                from unilabos.app.web.utils.ros_utils import get_ros_node_info
+                from unilabos.app.web.utils.device_utils import get_registry_info
+                from unilabos.config.config import BasicConfig
+                from unilabos.registry.registry import lab_registry
+                from unilabos.ros.msgs.message_converter import msg_converter_manager
+                from unilabos.utils.type_check import TypeEncoder
+                import json
+
+                # 获取当前数据
+                host_node_info = get_host_node_info()
+                ros_node_info = get_ros_node_info()
+
+                # 检查需要发送静态数据的新连接
+                new_connections = status_page_connections - _static_data_sent_connections
+
+                # 向新连接发送静态数据（Device Types、Resource Types、Converter Modules）
+                if new_connections:
+                    devices = []
+                    resources = []
+                    modules = {"names": [], "classes": [], "displayed_count": 0, "total_count": 0}
+
+                    if lab_registry:
+                        devices = json.loads(
+                            json.dumps(lab_registry.obtain_registry_device_info(), ensure_ascii=False, cls=TypeEncoder)
+                        )
+                        # 资源类型
+                        for resource_id, resource_info in lab_registry.resource_type_registry.items():
+                            resources.append(
+                                {
+                                    "id": resource_id,
+                                    "name": resource_info.get("name", "未命名"),
+                                    "file_path": resource_info.get("file_path", ""),
+                                }
+                            )
+
+                    # 获取导入的模块
+                    if msg_converter_manager:
+                        modules["names"] = msg_converter_manager.list_modules()
+                        all_classes = [i for i in msg_converter_manager.list_classes() if "." in i]
+                        modules["total_count"] = len(all_classes)
+                        modules["classes"] = all_classes
+
+                    # 静态数据
+                    registry_info = get_registry_info()
+                    static_data = {
+                        "type": "static_data_init",
+                        "data": {
+                            "devices": devices,
+                            "resources": resources,
+                            "modules": modules,
+                            "registry_info": registry_info,
+                            "is_host_mode": BasicConfig.is_host_mode,
+                            "host_node_info": host_node_info,  # 添加主机节点初始信息
+                            "ros_node_info": ros_node_info,  # 添加本地设备初始信息
+                        },
+                    }
+
+                    # 发送到新连接
+                    disconnected_new_connections = set()
+                    for connection in new_connections:
+                        try:
+                            await connection.send_json(static_data)
+                            _static_data_sent_connections.add(connection)
+                        except Exception as e:
+                            print(f"Error sending static data to new client: {e}")
+                            disconnected_new_connections.add(connection)
+
+                    # 清理断开的新连接
+                    for conn in disconnected_new_connections:
+                        status_page_connections.discard(conn)
+                        _static_data_sent_connections.discard(conn)
+
+                # 检查主机节点信息是否有变更
+                host_node_diff = compute_host_node_diff(host_node_info, _previous_host_node_info)
+                host_changed = bool(host_node_diff)
+
+                # 检查Local Devices是否有变更
+                current_devices = ros_node_info.get("registered_devices", {})
+                devices_changed = current_devices != _previous_local_devices
+
+                # 只有当有真正的变化时才发送更新
+                if host_changed or devices_changed:
+                    # 发送增量更新数据
+                    update_data = {
+                        "type": "incremental_update",
+                        "data": {
+                            "timestamp": asyncio.get_event_loop().time(),
+                        },
+                    }
+
+                    # 只包含有变化的主机节点信息
+                    if host_changed:
+                        update_data["data"]["host_node_info"] = host_node_diff
+
+                    # 如果Local Devices发生变更，添加到更新数据中
+                    if devices_changed:
+                        update_data["data"]["ros_node_info"] = ros_node_info
+                        _previous_local_devices = current_devices.copy()
+
+                    # 更新主机节点状态
+                    if host_changed:
+                        _previous_host_node_info = host_node_info.copy()
+
+                    # 发送增量更新到所有连接
+                    disconnected_connections = set()
+                    for connection in status_page_connections:
+                        try:
+                            await connection.send_json(update_data)
+                        except Exception as e:
+                            print(f"Error sending incremental update to client: {e}")
+                            disconnected_connections.add(connection)
+
+                    # 清理断开的连接
+                    for conn in disconnected_connections:
+                        status_page_connections.discard(conn)
+                        _static_data_sent_connections.discard(conn)
+
+            await asyncio.sleep(1)  # 每秒检查一次更新
+        except Exception as e:
+            print(f"Error in status page broadcast: {e}")
+            await asyncio.sleep(1)
+
+
 @api.websocket("/ws/device_status")
 async def websocket_device_status(websocket: WebSocket):
     """WebSocket端点，用于实时获取设备状态"""
@@ -72,6 +246,838 @@ async def websocket_device_status(websocket: WebSocket):
         active_connections.remove(websocket)
 
 
+@api.websocket("/ws/registry_editor")
+async def websocket_registry_editor(websocket: WebSocket):
+    """WebSocket端点，用于注册表编辑器"""
+    await websocket.accept()
+    registry_editor_connections.add(websocket)
+
+    try:
+        while True:
+            # 接收来自客户端的消息
+            message = await websocket.receive_text()
+            import json
+
+            data = json.loads(message)
+
+            if data.get("type") == "import_file":
+                await handle_file_import(websocket, data["data"])
+            elif data.get("type") == "analyze_file":
+                await handle_file_analysis(websocket, data["data"])
+            elif data.get("type") == "analyze_file_content":
+                await handle_file_content_analysis(websocket, data["data"])
+            elif data.get("type") == "import_file_content":
+                await handle_file_content_import(websocket, data["data"])
+
+    except WebSocketDisconnect:
+        registry_editor_connections.remove(websocket)
+    except Exception as e:
+        print(f"Registry Editor WebSocket error: {e}")
+        if websocket in registry_editor_connections:
+            registry_editor_connections.remove(websocket)
+
+
+@api.websocket("/ws/status_page")
+async def websocket_status_page(websocket: WebSocket):
+    """WebSocket端点，用于状态页面实时数据更新"""
+    await websocket.accept()
+    status_page_connections.add(websocket)
+
+    try:
+        while True:
+            # 接收来自客户端的消息（用于保持连接活跃）
+            message = await websocket.receive_text()
+            # 状态页面通常只需要接收数据，不需要发送复杂指令
+
+    except WebSocketDisconnect:
+        status_page_connections.remove(websocket)
+    except Exception as e:
+        print(f"Status Page WebSocket error: {e}")
+        if websocket in status_page_connections:
+            status_page_connections.remove(websocket)
+
+
+async def handle_file_analysis(websocket: WebSocket, request_data: dict):
+    """处理文件分析请求，获取文件中的类列表"""
+    import json
+    import os
+    import sys
+    import inspect
+    import traceback
+    from pathlib import Path
+    from unilabos.config.config import BasicConfig
+
+    file_path = request_data.get("file_path")
+
+    async def send_log(message: str, level: str = "info"):
+        """发送日志消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "log", "message": message, "level": level}))
+        except Exception as e:
+            print(f"Failed to send log: {e}")
+
+    async def send_analysis_result(result_data: dict):
+        """发送分析结果到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "file_analysis_result", "data": result_data}))
+        except Exception as e:
+            print(f"Failed to send analysis result: {e}")
+
+    try:
+        # 验证文件路径参数
+        if not file_path:
+            await send_analysis_result({"success": False, "error": "文件路径为空", "file_path": ""})
+            return
+
+        # 获取工作目录并构建完整路径
+        working_dir_str = getattr(BasicConfig, "working_dir", None) or os.getcwd()
+        working_dir = Path(working_dir_str)
+        full_file_path = working_dir / file_path
+
+        # 验证文件路径
+        if not full_file_path.exists():
+            await send_analysis_result(
+                {"success": False, "error": f"文件路径不存在: {file_path}", "file_path": file_path}
+            )
+            return
+
+        await send_log(f"开始分析文件: {file_path}")
+
+        # 验证文件是Python文件
+        if not file_path.endswith(".py"):
+            await send_analysis_result({"success": False, "error": "请选择Python文件 (.py)", "file_path": file_path})
+            return
+
+        full_file_path = full_file_path.absolute()
+        await send_log(f"文件绝对路径: {full_file_path}")
+
+        # 添加文件目录到sys.path
+        file_dir = str(full_file_path.parent)
+        if file_dir not in sys.path:
+            sys.path.insert(0, file_dir)
+            await send_log(f"已添加路径到sys.path: {file_dir}")
+
+        # 确定模块名
+        module_name = full_file_path.stem
+        await send_log(f"使用模块名: {module_name}")
+
+        # 导入模块进行分析
+        try:
+            # 如果模块已经导入，先删除以便重新导入
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+                await send_log(f"已删除旧模块: {module_name}")
+
+            import importlib.util
+
+            spec = importlib.util.spec_from_file_location(module_name, full_file_path)
+            if spec is None or spec.loader is None:
+                await send_analysis_result(
+                    {"success": False, "error": "无法创建模块规范", "file_path": str(full_file_path)}
+                )
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            await send_log(f"成功导入模块用于分析: {module_name}")
+
+        except Exception as e:
+            await send_analysis_result(
+                {"success": False, "error": f"导入模块失败: {str(e)}", "file_path": str(full_file_path)}
+            )
+            return
+
+        # 分析模块中的类
+        classes = []
+        for name in dir(module):
+            try:
+                obj = getattr(module, name)
+                if isinstance(obj, type) and obj.__module__ == module_name:
+                    # 获取类的文档字符串
+                    docstring = inspect.getdoc(obj) or ""
+                    # 只取第一行作为简短描述
+                    short_desc = docstring.split("\n")[0] if docstring else ""
+
+                    classes.append({"name": name, "docstring": short_desc, "full_docstring": docstring})
+            except Exception as e:
+                await send_log(f"分析类 {name} 时出错: {str(e)}", "warning")
+                continue
+
+        if not classes:
+            await send_analysis_result(
+                {
+                    "success": False,
+                    "error": "模块中未找到任何类定义",
+                    "file_path": str(full_file_path),
+                    "module_name": module_name,
+                }
+            )
+            return
+
+        await send_log(f"找到 {len(classes)} 个类: {[cls['name'] for cls in classes]}")
+
+        # 发送分析结果
+        await send_analysis_result(
+            {"success": True, "file_path": str(full_file_path), "module_name": module_name, "classes": classes}
+        )
+
+    except Exception as e:
+        await send_analysis_result(
+            {
+                "success": False,
+                "error": f"分析过程中发生错误: {str(e)}",
+                "file_path": file_path,
+                "traceback": traceback.format_exc(),
+            }
+        )
+
+
+async def handle_file_content_analysis(websocket: WebSocket, request_data: dict):
+    """处理文件内容分析请求，直接分析上传的文件内容"""
+    import json
+    import os
+    import sys
+    import inspect
+    import traceback
+    import tempfile
+    from pathlib import Path
+
+    file_name = request_data.get("file_name")
+    file_content = request_data.get("file_content")
+    file_size = request_data.get("file_size", 0)
+
+    async def send_log(message: str, level: str = "info"):
+        """发送日志消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "log", "message": message, "level": level}))
+        except Exception as e:
+            print(f"Failed to send log: {e}")
+
+    async def send_analysis_result(result_data: dict):
+        """发送分析结果到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "file_analysis_result", "data": result_data}))
+        except Exception as e:
+            print(f"Failed to send analysis result: {e}")
+
+    try:
+        # 验证文件内容
+        if not file_name or not file_content:
+            await send_analysis_result({"success": False, "error": "文件名或文件内容为空", "file_name": file_name})
+            return
+
+        await send_log(f"开始分析文件: {file_name} ({file_size} 字节)")
+
+        # 验证文件是Python文件
+        if not file_name.endswith(".py"):
+            await send_analysis_result({"success": False, "error": "请选择Python文件 (.py)", "file_name": file_name})
+            return
+
+        # 创建临时文件
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as temp_file:
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+
+        await send_log(f"创建临时文件: {temp_file_path}")
+
+        try:
+            # 添加临时文件目录到sys.path
+            temp_dir = str(Path(temp_file_path).parent)
+            if temp_dir not in sys.path:
+                sys.path.insert(0, temp_dir)
+                await send_log(f"已添加临时目录到sys.path: {temp_dir}")
+
+            # 确定模块名（去掉.py扩展名）
+            module_name = file_name.replace(".py", "").replace("-", "_").replace(" ", "_")
+            await send_log(f"使用模块名: {module_name}")
+
+            # 导入模块进行分析
+            try:
+                # 如果模块已经导入，先删除以便重新导入
+                if module_name in sys.modules:
+                    del sys.modules[module_name]
+                    await send_log(f"已删除旧模块: {module_name}")
+
+                import importlib.util
+
+                spec = importlib.util.spec_from_file_location(module_name, temp_file_path)
+                if spec is None or spec.loader is None:
+                    raise Exception("无法创建模块规范")
+
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[module_name] = module
+                spec.loader.exec_module(module)
+
+                await send_log(f"成功导入模块用于分析: {module_name}")
+
+            except Exception as e:
+                await send_analysis_result(
+                    {"success": False, "error": f"导入模块失败: {str(e)}", "file_name": file_name}
+                )
+                return
+
+            # 分析模块中的类
+            classes = []
+            for name in dir(module):
+                try:
+                    obj = getattr(module, name)
+                    if isinstance(obj, type) and obj.__module__ == module_name:
+                        # 获取类的文档字符串
+                        docstring = inspect.getdoc(obj) or ""
+                        # 只取第一行作为简短描述
+                        short_desc = docstring.split("\n")[0] if docstring else "无描述"
+
+                        classes.append({"name": name, "docstring": short_desc, "full_docstring": docstring})
+                except Exception as e:
+                    await send_log(f"分析类 {name} 时出错: {str(e)}", "warning")
+                    continue
+
+            if not classes:
+                await send_analysis_result(
+                    {
+                        "success": False,
+                        "error": "模块中未找到任何类定义",
+                        "file_name": file_name,
+                        "module_name": module_name,
+                    }
+                )
+                return
+
+            await send_log(f"找到 {len(classes)} 个类: {[cls['name'] for cls in classes]}")
+
+            # 发送分析结果
+            await send_analysis_result(
+                {
+                    "success": True,
+                    "file_name": file_name,
+                    "module_name": module_name,
+                    "classes": classes,
+                    "temp_file_path": temp_file_path,  # 保存临时文件路径供后续使用
+                }
+            )
+
+        finally:
+            # 清理临时文件（在导入完成后再删除）
+            try:
+                if os.path.exists(temp_file_path):
+                    # 延迟删除，给导入操作留出时间
+                    import threading
+
+                    def delayed_cleanup():
+                        import time
+
+                        time.sleep(60)  # 等待60秒后删除
+                        try:
+                            os.unlink(temp_file_path)
+                        except OSError:
+                            pass
+
+                    threading.Thread(target=delayed_cleanup, daemon=True).start()
+            except Exception as e:
+                await send_log(f"清理临时文件时出错: {str(e)}", "warning")
+
+    except Exception as e:
+        await send_analysis_result(
+            {
+                "success": False,
+                "error": f"分析过程中发生错误: {str(e)}",
+                "file_name": file_name,
+                "traceback": traceback.format_exc(),
+            }
+        )
+
+
+async def handle_file_content_import(websocket: WebSocket, request_data: dict):
+    """处理基于文件内容的导入请求"""
+    import json
+    import os
+    import sys
+    import traceback
+    import tempfile
+    from pathlib import Path
+
+    file_name = request_data.get("file_name")
+    file_content = request_data.get("file_content")
+    file_size = request_data.get("file_size", 0)
+    registry_type = request_data.get("registry_type", "device")
+    class_name = request_data.get("class_name")
+
+    async def send_log(message: str, level: str = "info"):
+        """发送日志消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "log", "message": message, "level": level}))
+        except Exception as e:
+            print(f"Failed to send log: {e}")
+
+    async def send_progress(message: str):
+        """发送进度消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "progress", "message": message}))
+        except Exception as e:
+            print(f"Failed to send progress: {e}")
+
+    async def send_error(message: str):
+        """发送错误消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "error", "message": message}))
+        except Exception as e:
+            print(f"Failed to send error: {e}")
+
+    async def send_result(result_data: dict):
+        """发送结果数据到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "result", "data": result_data}))
+        except Exception as e:
+            print(f"Failed to send result: {e}")
+
+    try:
+        # 验证输入参数
+        if not file_name or not file_content or not class_name:
+            await send_error("文件名、文件内容或类名为空")
+            return
+
+        await send_log(f"开始处理文件: {file_name} ({file_size} 字节)")
+        await send_progress("正在创建临时文件...")
+
+        # 创建临时文件
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as temp_file:
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+
+        await send_log(f"创建临时文件: {temp_file_path}")
+
+        # 添加临时文件目录到sys.path
+        temp_dir = str(Path(temp_file_path).parent)
+        if temp_dir not in sys.path:
+            sys.path.insert(0, temp_dir)
+            await send_log(f"已添加临时目录到sys.path: {temp_dir}")
+
+        # 确定模块名
+        module_name = file_name.replace(".py", "").replace("-", "_").replace(" ", "_")
+        await send_log(f"使用模块名: {module_name}")
+
+        # 导入模块
+        try:
+            # 如果模块已经导入，先删除以便重新导入
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+                await send_log(f"已删除旧模块: {module_name}")
+
+            import importlib.util
+
+            spec = importlib.util.spec_from_file_location(module_name, temp_file_path)
+            if spec is None or spec.loader is None:
+                await send_error("无法创建模块规范")
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            await send_log(f"成功导入模块: {module_name}")
+
+        except Exception as e:
+            await send_error(f"导入模块失败: {str(e)}")
+            return
+
+        # 验证类存在
+        if not hasattr(module, class_name):
+            await send_error(f"模块中未找到类: {class_name}")
+            return
+
+        target_class = getattr(module, class_name)
+        await send_log(f"找到目标类: {class_name}")
+
+        # 使用registry.py的增强类信息功能进行分析
+        await send_progress("正在生成注册表信息...")
+
+        try:
+            from unilabos.utils.import_manager import get_enhanced_class_info
+
+            # 分析类信息
+            enhanced_info = get_enhanced_class_info(f"{module_name}:{class_name}", use_dynamic=True)
+
+            if not enhanced_info.get("dynamic_import_success", False):
+                await send_error("动态导入类信息失败")
+                return
+
+            await send_log("成功分析类信息")
+
+            # 生成注册表schema
+            registry_schema = {
+                "class_name": class_name,
+                "module": f"{module_name}:{class_name}",
+                "type": "python",
+                "description": enhanced_info.get("class_docstring", ""),
+                "version": "1.0.0",
+                "category": [registry_type],
+                "status_types": {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()},
+                "action_value_mappings": {},
+                "init_param_schema": {},
+                "registry_type": registry_type,
+                "file_path": f"uploaded_file://{file_name}",
+            }
+
+            # 处理动作方法
+            for method_name, method_info in enhanced_info["action_methods"].items():
+                registry_schema["action_value_mappings"][f"auto-{method_name}"] = {
+                    "type": "UniLabJsonCommandAsync" if method_info["is_async"] else "UniLabJsonCommand",
+                    "goal": {},
+                    "feedback": {},
+                    "result": {},
+                    "args": method_info["args"],
+                    "description": method_info.get("docstring", ""),
+                }
+
+            await send_log("成功生成注册表schema")
+
+            # 准备结果数据
+            result = {
+                "class_info": {
+                    "class_name": class_name,
+                    "module_name": module_name,
+                    "file_name": file_name,
+                    "file_size": file_size,
+                    "docstring": enhanced_info.get("class_docstring", ""),
+                    "dynamic_import_success": enhanced_info.get("dynamic_import_success", False),
+                },
+                "registry_schema": registry_schema,
+                "action_methods": enhanced_info["action_methods"],
+                "status_methods": enhanced_info["status_methods"],
+            }
+
+            # 发送结果
+            await send_result(result)
+            await send_log("分析完成")
+
+        except Exception as e:
+            await send_error(f"分析类信息时发生错误: {str(e)}")
+            await send_log(f"详细错误信息: {traceback.format_exc()}")
+            return
+
+        finally:
+            # 清理临时文件
+            try:
+                if os.path.exists(temp_file_path):
+                    import threading
+
+                    def delayed_cleanup():
+                        import time
+
+                        time.sleep(30)  # 等待30秒后删除
+                        try:
+                            os.unlink(temp_file_path)
+                        except OSError:
+                            pass
+
+                    threading.Thread(target=delayed_cleanup, daemon=True).start()
+            except Exception as e:
+                await send_log(f"清理临时文件时出错: {str(e)}", "warning")
+
+    except Exception as e:
+        await send_error(f"处理过程中发生错误: {str(e)}")
+        await send_log(f"详细错误信息: {traceback.format_exc()}")
+
+
+async def handle_file_import(websocket: WebSocket, request_data: dict):
+    """处理文件导入请求"""
+    import json
+    import os
+    import sys
+    import traceback
+    from pathlib import Path
+    from unilabos.config.config import BasicConfig
+
+    file_path = request_data.get("file_path")
+    registry_type = request_data.get("registry_type", "device")
+    class_name = request_data.get("class_name")
+    module_name = request_data.get("module_name")
+
+    async def send_log(message: str, level: str = "info"):
+        """发送日志消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "log", "message": message, "level": level}))
+        except Exception as e:
+            print(f"Failed to send log: {e}")
+
+    async def send_progress(message: str):
+        """发送进度消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "progress", "message": message}))
+        except Exception as e:
+            print(f"Failed to send progress: {e}")
+
+    async def send_error(message: str):
+        """发送错误消息到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "error", "message": message}))
+        except Exception as e:
+            print(f"Failed to send error: {e}")
+
+    async def send_result(result_data: dict):
+        """发送结果数据到客户端"""
+        try:
+            await websocket.send_text(json.dumps({"type": "result", "data": result_data}))
+        except Exception as e:
+            print(f"Failed to send result: {e}")
+
+    try:
+        # 验证文件路径参数
+        if not file_path:
+            await send_error("文件路径为空")
+            return
+
+        # 获取工作目录并构建完整路径
+        working_dir_str = getattr(BasicConfig, "working_dir", None) or os.getcwd()
+        working_dir = Path(working_dir_str)
+        full_file_path = working_dir / file_path
+
+        # 验证文件路径
+        if not full_file_path.exists():
+            await send_error(f"文件路径不存在: {file_path}")
+            return
+
+        await send_log(f"开始处理文件: {file_path}")
+        await send_progress("正在验证文件...")
+
+        # 验证文件是Python文件
+        if not file_path.endswith(".py"):
+            await send_error("请选择Python文件 (.py)")
+            return
+
+        full_file_path = full_file_path.absolute()
+        await send_log(f"文件绝对路径: {full_file_path}")
+
+        # 动态导入模块
+        await send_progress("正在导入模块...")
+
+        # 添加文件目录到sys.path
+        file_dir = str(full_file_path.parent)
+        if file_dir not in sys.path:
+            sys.path.insert(0, file_dir)
+            await send_log(f"已添加路径到sys.path: {file_dir}")
+
+        # 确定模块名
+        if not module_name:
+            module_name = full_file_path.stem
+        await send_log(f"使用模块名: {module_name}")
+
+        # 导入模块
+        try:
+            # 如果模块已经导入，先删除以便重新导入
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+                await send_log(f"已删除旧模块: {module_name}")
+
+            import importlib.util
+
+            spec = importlib.util.spec_from_file_location(module_name, full_file_path)
+            if spec is None or spec.loader is None:
+                await send_error("无法创建模块规范")
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            await send_log(f"成功导入模块: {module_name}")
+
+        except Exception as e:
+            await send_error(f"导入模块失败: {str(e)}")
+            return
+
+        # 分析模块
+        await send_progress("正在分析模块...")
+
+        # 获取模块中的所有类
+        classes = []
+        for name in dir(module):
+            obj = getattr(module, name)
+            if isinstance(obj, type) and obj.__module__ == module_name:
+                classes.append((name, obj))
+
+        if not classes:
+            await send_error("模块中未找到任何类定义")
+            return
+
+        await send_log(f"找到 {len(classes)} 个类: {[name for name, _ in classes]}")
+
+        # 确定要分析的类
+        target_class = None
+        target_class_name = None
+
+        if class_name:
+            # 用户指定了类名
+            for name, cls in classes:
+                if name == class_name:
+                    target_class = cls
+                    target_class_name = name
+                    break
+            if not target_class:
+                await send_error(f"未找到指定的类: {class_name}")
+                return
+        else:
+            # 自动选择第一个类
+            target_class_name, target_class = classes[0]
+            await send_log(f"自动选择类: {target_class_name}")
+
+        # 使用registry.py的增强类信息功能进行分析
+        await send_progress("正在生成注册表信息...")
+
+        try:
+            from unilabos.utils.import_manager import get_enhanced_class_info
+
+            # 分析类信息
+            enhanced_info = get_enhanced_class_info(f"{module_name}:{target_class_name}", use_dynamic=True)
+
+            if not enhanced_info.get("dynamic_import_success", False):
+                await send_error("动态导入类信息失败")
+                return
+
+            await send_log("成功分析类信息")
+
+            # 生成注册表schema
+            registry_schema = {
+                "class_name": target_class_name,
+                "module": f"{module_name}:{target_class_name}",
+                "type": "python",
+                "description": enhanced_info.get("class_docstring", ""),
+                "version": "1.0.0",
+                "category": [registry_type],
+                "status_types": {k: v["return_type"] for k, v in enhanced_info["status_methods"].items()},
+                "action_value_mappings": {},
+                "init_param_schema": {},
+                "registry_type": registry_type,
+                "file_path": str(full_file_path),
+            }
+
+            # 处理动作方法
+            for method_name, method_info in enhanced_info["action_methods"].items():
+                registry_schema["action_value_mappings"][f"auto-{method_name}"] = {
+                    "type": "UniLabJsonCommandAsync" if method_info["is_async"] else "UniLabJsonCommand",
+                    "goal": {},
+                    "feedback": {},
+                    "result": {},
+                    "args": method_info["args"],
+                    "description": method_info.get("docstring", ""),
+                }
+
+            await send_log("成功生成注册表schema")
+
+            # 转换为YAML格式
+            import yaml
+            from unilabos.utils.type_check import NoAliasDumper
+
+            # 创建最终的YAML配置（使用设备ID作为根键）
+            class_name_safe = class_name or "unknown"
+            suffix = "_device" if registry_type == "device" else "_resource"
+            device_id = f"{class_name_safe.lower()}{suffix}"
+            final_config = {device_id: registry_schema}
+
+            yaml_content = yaml.dump(
+                final_config, allow_unicode=True, default_flow_style=False, Dumper=NoAliasDumper, sort_keys=True
+            )
+
+            # 准备结果数据（只保留YAML结果）
+            result = {
+                "registry_schema": yaml_content,
+                "device_id": device_id,
+                "class_name": class_name,
+                "module_name": module_name,
+                "file_path": file_path,
+            }
+
+            # 发送结果
+            await send_result(result)
+            await send_log("注册表生成完成")
+
+        except Exception as e:
+            await send_error(f"分析类信息时发生错误: {str(e)}")
+            await send_log(f"详细错误信息: {traceback.format_exc()}")
+            return
+
+    except Exception as e:
+        await send_error(f"处理过程中发生错误: {str(e)}")
+        await send_log(f"详细错误信息: {traceback.format_exc()}")
+
+
+@api.get("/file-browser", summary="Browse files and directories", response_model=Resp)
+def get_file_browser_data(path: str = ""):
+    """获取文件浏览器数据"""
+    import os
+    from pathlib import Path
+    from unilabos.config.config import BasicConfig
+
+    try:
+        # 获取工作目录
+        working_dir_str = getattr(BasicConfig, "working_dir", None) or os.getcwd()
+        working_dir = Path(working_dir_str)
+
+        # 如果提供了相对路径，则在工作目录下查找
+        if path:
+            target_path = working_dir / path
+        else:
+            target_path = working_dir
+
+        # 确保路径在工作目录内（安全检查）
+        target_path = target_path.resolve()
+
+        if not target_path.exists():
+            return Resp(code=RespCode.ErrorInvalidReq, message=f"路径不存在: {path}")
+
+        if not target_path.is_dir():
+            return Resp(code=RespCode.ErrorInvalidReq, message=f"不是目录: {path}")
+
+        # 获取目录内容
+        items = []
+
+        parent_path = target_path.parent
+        relative_parent = parent_path.relative_to(working_dir)
+        items.append(
+            {
+                "name": "..",
+                "type": "directory",
+                "path": str(relative_parent) if relative_parent != Path(".") else "",
+                "size": 0,
+                "is_parent": True,
+            }
+        )
+
+        # 获取子目录和文件
+        try:
+            for item in sorted(target_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
+                if item.name.startswith("."):  # 跳过隐藏文件
+                    continue
+
+                item_type = "directory" if item.is_dir() else "file"
+                relative_path = item.relative_to(working_dir)
+
+                item_info = {
+                    "name": item.name,
+                    "type": item_type,
+                    "path": str(relative_path),
+                    "size": item.stat().st_size if item.is_file() else 0,
+                    "is_python": item.suffix == ".py" if item.is_file() else False,
+                    "is_parent": False,
+                }
+                items.append(item_info)
+        except PermissionError:
+            return Resp(code=RespCode.ErrorInvalidReq, message="无权限访问此目录")
+
+        return Resp(
+            data={
+                "current_path": str(target_path.relative_to(working_dir)) if target_path != working_dir else "",
+                "working_dir": str(working_dir),
+                "items": items,
+            }
+        )
+
+    except Exception as e:
+        return Resp(code=RespCode.ErrorInvalidReq, message=f"获取目录信息失败: {str(e)}")
+
+
 @api.get("/resources", summary="Resource list", response_model=Resp)
 def get_resources():
     """获取资源列表"""
@@ -82,18 +1088,6 @@ def get_resources():
     return Resp(data=dict(data))
 
 
-@api.get("/repository", summary="Raw Material list", response_model=Resp)
-def get_raw_material():
-    """获取原材料列表"""
-    return Resp(data={})
-
-
-@api.post("/repository", summary="Raw Material set", response_model=Resp)
-def post_raw_material():
-    """设置原材料"""
-    return Resp(data={})
-
-
 @api.get("/devices", summary="Device list", response_model=Resp)
 def get_devices():
     """获取设备列表"""
@@ -104,12 +1098,6 @@ def get_devices():
     return Resp(data=dict(data))
 
 
-@api.get("/devices/{id}/info", summary="Device info", response_model=Resp)
-def device_info(id: str):
-    """获取设备信息"""
-    return Resp(data={})
-
-
 @api.get("/job/{id}/status", summary="Job status", response_model=JobStatusResp)
 def job_status(id: str):
     """获取任务状态"""
@@ -129,63 +1117,6 @@ def post_job_add(req: JobAddReq):
     return JobAddResp(data=data)
 
 
-@api.post("/job/step_finish", summary="步骤完成推送", response_model=Resp)
-def callback_step_finish(req: JobStepFinishReq):
-    """任务步骤完成回调"""
-    print(req)
-    return Resp(data={})
-
-
-@api.post("/job/preintake_finish", summary="通量完成推送", response_model=Resp)
-def callback_preintake_finish(req: JobPreintakeFinishReq):
-    """通量完成回调"""
-    print(req)
-    return Resp(data={})
-
-
-@api.post("/job/finish", summary="完成推送", response_model=Resp)
-def callback_order_finish(req: JobFinishReq):
-    """任务完成回调"""
-    print(req)
-    return Resp(data={})
-
-
-@admin.get("/device_models", summary="Device model list", response_model=Resp)
-def admin_device_models():
-    """获取设备模型列表"""
-    return Resp(data={})
-
-
-@admin.post("/device_model/add", summary="Add Device model", response_model=Resp)
-def admin_device_model_add():
-    """添加设备模型"""
-    return Resp(data={})
-
-
-@admin.delete("/device_model/{id}", summary="Delete device model", response_model=Resp)
-def admin_device_model_del(id: str):
-    """删除设备模型"""
-    return Resp(data={})
-
-
-@admin.get("/devices", summary="Device list", response_model=Resp)
-def admin_devices():
-    """获取设备列表(管理员)"""
-    return Resp(data={})
-
-
-@admin.post("/devices/add", summary="Add Device", response_model=Resp)
-def admin_device_add():
-    """添加设备"""
-    return Resp(data={})
-
-
-@admin.delete("/devices/{id}", summary="Delete device", response_model=Resp)
-def admin_device_del(id: str):
-    """删除设备"""
-    return Resp(data={})
-
-
 def setup_api_routes(app):
     """设置API路由"""
     app.include_router(admin, prefix="/admin/v1", tags=["admin"])
@@ -195,3 +1126,4 @@ def setup_api_routes(app):
     @app.on_event("startup")
     async def startup_event():
         asyncio.create_task(broadcast_device_status())
+        asyncio.create_task(broadcast_status_page_data())
diff --git a/unilabos/app/web/pages.py b/unilabos/app/web/pages.py
index 9f9a6c0a..2887c2a0 100644
--- a/unilabos/app/web/pages.py
+++ b/unilabos/app/web/pages.py
@@ -78,21 +78,23 @@ def setup_web_pages(router: APIRouter) -> None:
             HTMLResponse: 渲染后的HTML页面
         """
         try:
-            # 准备设备数据
+            # 准备初始数据结构（这些数据将通过WebSocket实时更新）
             devices = []
             resources = []
             modules = {"names": [], "classes": [], "displayed_count": 0, "total_count": 0}
 
-            # 获取在线设备信息
+            # 获取在线设备信息（用于初始渲染）
             ros_node_info = get_ros_node_info()
-            # 获取主机节点信息
+            # 获取主机节点信息（用于初始渲染）
             host_node_info = get_host_node_info()
-            # 获取Registry路径信息
+            # 获取Registry路径信息（静态信息，不需要实时更新）
             registry_info = get_registry_info()
 
-            # 获取已加载的设备
+            # 获取初始数据用于页面渲染（后续将被WebSocket数据覆盖）
             if lab_registry:
-                devices = json.loads(json.dumps(lab_registry.obtain_registry_device_info(), ensure_ascii=False, cls=TypeEncoder))
+                devices = json.loads(
+                    json.dumps(lab_registry.obtain_registry_device_info(), ensure_ascii=False, cls=TypeEncoder)
+                )
                 # 资源类型
                 for resource_id, resource_info in lab_registry.resource_type_registry.items():
                     resources.append(
@@ -103,7 +105,7 @@ def setup_web_pages(router: APIRouter) -> None:
                         }
                     )
 
-            # 获取导入的模块
+            # 获取导入的模块（初始数据）
             if msg_converter_manager:
                 modules["names"] = msg_converter_manager.list_modules()
                 all_classes = [i for i in msg_converter_manager.list_classes() if "." in i]
@@ -171,3 +173,20 @@ def setup_web_pages(router: APIRouter) -> None:
         except Exception as e:
             error(f"打开文件夹时出错: {str(e)}")
             return {"status": "error", "message": f"Failed to open folder: {str(e)}"}
+
+    @router.get("/registry-editor", response_class=HTMLResponse, summary="Registry Editor")
+    async def registry_editor_page() -> str:
+        """
+        注册表编辑页面，用于导入Python文件并生成注册表
+
+        Returns:
+            HTMLResponse: 渲染后的HTML页面
+        """
+        try:
+            # 使用模板渲染页面
+            template = env.get_template("registry_editor.html")
+            html = template.render()
+            return html
+        except Exception as e:
+            error(f"生成注册表编辑页面时出错: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error generating registry editor page: {str(e)}")
diff --git a/unilabos/app/web/templates/base.html b/unilabos/app/web/templates/base.html
index 8e3a31d7..cb3e1a4e 100644
--- a/unilabos/app/web/templates/base.html
+++ b/unilabos/app/web/templates/base.html
@@ -162,7 +162,6 @@
 <body>
     <h1>{% block header %}UniLab{% endblock %}</h1>
     {% block nav %}
-    <a href="/unilabos/webtic" class="home-link">Home</a>
     {% endblock %}
 
     {% block top_info %}{% endblock %}
diff --git a/unilabos/app/web/templates/home.html b/unilabos/app/web/templates/home.html
index a95f9d6a..2517f1ce 100644
--- a/unilabos/app/web/templates/home.html
+++ b/unilabos/app/web/templates/home.html
@@ -1,22 +1,25 @@
-{% extends "base.html" %}
-
-{% block title %}UniLab API{% endblock %}
-
-{% block header %}UniLab API{% endblock %}
-
-{% block nav %}
-<a href="/status" class="status-link">System Status</a>
-{% endblock %}
-
-{% block content %}
-<div class="card">
-    <h2>Available Endpoints</h2>
-    {% for route in routes %}
-    <div class="endpoint">
-        <span class="method">{{ route.method }}</span>
-        <a href="{{ route.path }}">{{ route.path }}</a>
-        <p>{{ route.summary }}</p>
-    </div>
-    {% endfor %}
+{% extends "base.html" %} {% block title %}UniLab API{% endblock %} {% block
+header %}UniLab API{% endblock %} {% block nav %}
+<div class="nav-tabs">
+  <a
+    href="/"
+    class="nav-tab"
+    style="background-color: #2196f3; color: white"
+    target="_blank"
+    >主页</a
+  >
+  class="nav-tab">状态</a>
+  <a href="/registry-editor" class="nav-tab" target="_blank">注册表编辑</a>
 </div>
-{% endblock %} 
\ No newline at end of file
+{% endblock %} {% block content %}
+<div class="card">
+  <h2>Available Endpoints</h2>
+  {% for route in routes %}
+  <div class="endpoint">
+    <span class="method">{{ route.method }}</span>
+    <a href="{{ route.path }}">{{ route.path }}</a>
+    <p>{{ route.summary }}</p>
+  </div>
+  {% endfor %}
+</div>
+{% endblock %}
diff --git a/unilabos/app/web/templates/registry_editor.html b/unilabos/app/web/templates/registry_editor.html
new file mode 100644
index 00000000..8e23b398
--- /dev/null
+++ b/unilabos/app/web/templates/registry_editor.html
@@ -0,0 +1,1085 @@
+{% extends "base.html" %} {% block title %}注册表编辑器 - UniLab{% endblock %}
+{% block header %}注册表编辑器{% endblock %} {% block nav %}
+{% endblock %} {% block scripts %}
+<style>
+  .editor-container {
+    max-width: 100%;
+    margin: 0;
+    padding: 10px;
+    position: relative;
+  }
+  .form-section {
+    background: white;
+    border-radius: 8px;
+    padding: 20px;
+    margin-bottom: 20px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  }
+  .form-group {
+    margin-bottom: 15px;
+  }
+  .form-group label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: bold;
+    color: #333;
+  }
+  .form-control {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    font-size: 14px;
+    box-sizing: border-box;
+  }
+  .btn {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 4px;
+    font-size: 14px;
+    cursor: pointer;
+    margin-right: 10px;
+    transition: background-color 0.2s;
+  }
+  .btn-primary {
+    background-color: #2196f3;
+    color: white;
+  }
+  .btn-primary:hover {
+    background-color: #0b7dda;
+  }
+  .btn-secondary {
+    background-color: #6c757d;
+    color: white;
+  }
+  .btn-secondary:hover {
+    background-color: #545b62;
+  }
+  .radio-group {
+    display: flex;
+    gap: 15px;
+    margin-top: 8px;
+  }
+  .radio-option {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+  }
+  .log-container {
+    background: #1e1e1e;
+    color: #ffffff;
+    border-radius: 4px;
+    padding: 15px;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 13px;
+    max-height: 400px;
+    overflow-y: auto;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    border: 1px solid #444;
+  }
+  .status-indicator {
+    display: inline-block;
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    margin-right: 8px;
+  }
+  .status-disconnected {
+    background-color: #f44336;
+  }
+  .status-connected {
+    background-color: #4caf50;
+  }
+  .status-processing {
+    background-color: #ff9800;
+  }
+  .results-section {
+    background: white;
+    border-radius: 8px;
+    padding: 20px;
+    margin-bottom: 20px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  }
+  .results-tabs {
+    display: flex;
+    margin-bottom: 15px;
+    border-bottom: 1px solid #ddd;
+  }
+  .result-tab {
+    padding: 10px 20px;
+    cursor: pointer;
+    border-bottom: 2px solid transparent;
+    transition: all 0.2s;
+  }
+  .result-tab.active {
+    border-bottom-color: #2196f3;
+    color: #2196f3;
+    font-weight: bold;
+  }
+  .result-tab:hover {
+    background-color: #f5f5f5;
+  }
+  .result-content {
+    display: none;
+  }
+  .result-content.active {
+    display: block;
+  }
+  .schema-viewer {
+    background: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 4px;
+    padding: 15px;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 13px;
+    max-height: 500px;
+    overflow: auto;
+    white-space: pre-wrap;
+  }
+  .error-message {
+    background-color: #f8d7da;
+    border: 1px solid #f5c6cb;
+    color: #721c24;
+    padding: 10px;
+    border-radius: 4px;
+    margin-bottom: 15px;
+  }
+  .success-message {
+    background-color: #d4edda;
+    border: 1px solid #c3e6cb;
+    color: #155724;
+    padding: 10px;
+    border-radius: 4px;
+    margin-bottom: 15px;
+  }
+  .file-info {
+    background: #e9f7fe;
+    padding: 10px;
+    border-radius: 4px;
+    margin-top: 10px;
+    font-size: 13px;
+    color: #555;
+  }
+  .file-input-group {
+    display: flex;
+    gap: 10px;
+    align-items: center;
+  }
+  .file-browse-btn {
+    white-space: nowrap;
+    min-width: 100px;
+  }
+  .form-text {
+    display: block;
+    margin-top: 5px;
+    font-size: 12px;
+    color: #6c757d;
+  }
+  .file-analysis-status {
+    background: #fff3cd;
+    border: 1px solid #ffeaa7;
+    color: #856404;
+    padding: 10px;
+    border-radius: 4px;
+    margin-top: 10px;
+    font-size: 13px;
+  }
+  .class-info {
+    background: #d1ecf1;
+    border: 1px solid #bee5eb;
+    color: #0c5460;
+    padding: 10px;
+    border-radius: 4px;
+    margin-top: 10px;
+    font-size: 13px;
+  }
+  .file-browser-container {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    background: white;
+  }
+  .current-path {
+    padding: 8px 12px;
+    background: #f8f9fa;
+    border-bottom: 1px solid #ddd;
+    font-size: 13px;
+    color: #555;
+  }
+  .file-browser {
+    max-height: 300px;
+    overflow-y: auto;
+    padding: 0;
+  }
+  .file-item {
+    padding: 8px 12px;
+    border-bottom: 1px solid #eee;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    transition: background-color 0.2s;
+  }
+  .file-item:hover {
+    background-color: #f8f9fa;
+  }
+  .file-item.selected {
+    background-color: #e3f2fd;
+    border-left: 3px solid #2196f3;
+  }
+  .file-icon {
+    margin-right: 8px;
+    font-size: 16px;
+    width: 20px;
+    text-align: center;
+  }
+  .file-name {
+    flex: 1;
+    font-size: 14px;
+  }
+  .file-size {
+    font-size: 12px;
+    color: #666;
+    margin-left: 8px;
+  }
+  .directory-icon {
+    color: #ff9800;
+  }
+  .python-file-icon {
+    color: #4caf50;
+  }
+  .other-file-icon {
+    color: #666;
+  }
+  .selected-file {
+    padding: 8px 12px;
+    background: #e8f5e8;
+    border-top: 1px solid #ddd;
+    font-size: 13px;
+  }
+  .loading-indicator {
+    padding: 20px;
+    text-align: center;
+    color: #666;
+    font-style: italic;
+  }
+  .yaml-container {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    background: white;
+  }
+  .yaml-header {
+    padding: 10px 12px;
+    background: #f8f9fa;
+    border-bottom: 1px solid #ddd;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+  }
+  .copy-yaml-btn {
+    font-size: 12px;
+    padding: 4px 12px;
+  }
+
+  /* 连接状态右上角定位 */
+  .connection-status-fixed {
+    position: fixed;
+    top: 80px;
+    right: 20px;
+    background: white;
+    padding: 10px;
+    border-radius: 8px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    z-index: 1000;
+    border: 1px solid #ddd;
+  }
+
+  /* 主要内容区域两栏布局 */
+  .main-content {
+    display: flex;
+    gap: 20px;
+    margin-bottom: 20px;
+  }
+
+  .left-column {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .right-column {
+    flex: 1;
+    min-width: 0;
+  }
+
+  /* 日志区域在底部 */
+  .log-section-bottom {
+    background: white;
+    border-top: 2px solid #e0e0e0;
+    padding: 15px;
+    margin-top: 20px;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  }
+
+  /* 响应式设计 */
+  @media (max-width: 1024px) {
+    .main-content {
+      flex-direction: column;
+    }
+
+    .connection-status-fixed {
+      position: relative;
+      top: auto;
+      right: auto;
+      margin-bottom: 20px;
+    }
+  }
+</style>
+{% endblock %} {% block content %}
+<div class="editor-container">
+  <!-- 连接状态 - 右上角固定 -->
+  <div class="connection-status-fixed">
+    <div id="connection-status">
+      <span class="status-indicator status-disconnected" id="status-dot"></span>
+      <span id="status-text">未连接</span>
+    </div>
+  </div>
+
+  <!-- 主要内容区域 -->
+  <div class="main-content">
+    <!-- 左栏：文件导入配置 -->
+    <div class="left-column">
+      <div class="form-section">
+        <h3>文件导入配置</h3>
+
+        <div class="form-group">
+          <label for="registry-type">注册表类型</label>
+          <div class="radio-group">
+            <div class="radio-option">
+              <input
+                type="radio"
+                id="type-device"
+                name="registry-type"
+                value="device"
+                checked
+              />
+              <label for="type-device">设备 (Device)</label>
+            </div>
+            <div class="radio-option">
+              <input
+                type="radio"
+                id="type-resource"
+                name="registry-type"
+                value="resource"
+              />
+              <label for="type-resource">资源 (Resource)</label>
+            </div>
+          </div>
+        </div>
+
+        <div class="form-group">
+          <label for="file-browser">选择Python文件</label>
+          <div class="file-browser-container">
+            <!-- 当前路径显示 -->
+            <div class="current-path">
+              <strong>当前路径：</strong>
+              <span id="current-path-display">加载中...</span>
+            </div>
+
+            <!-- 文件浏览器 -->
+            <div class="file-browser" id="file-browser">
+              <div class="loading-indicator">正在加载文件列表...</div>
+            </div>
+
+            <!-- 选择的文件显示 -->
+            <div class="selected-file" id="selected-file" style="display: none">
+              <strong>已选择：</strong>
+              <span id="selected-file-name"></span>
+              <span id="selected-file-size" class="file-size"></span>
+            </div>
+          </div>
+          <small class="form-text">只显示 .py 文件和文件夹</small>
+        </div>
+
+        <div class="form-group">
+          <button
+            class="btn btn-secondary"
+            onclick="analyzeFile()"
+            id="analyze-btn"
+            disabled
+          >
+            分析文件
+          </button>
+          <small class="form-text">首先分析文件以获取可用的类列表</small>
+        </div>
+
+        <div
+          class="form-group"
+          id="class-selection-group"
+          style="display: none"
+        >
+          <label for="class-name" id="class-selection-label">选择类名</label>
+          <select id="class-name" class="form-control">
+            <option value="" id="class-selection-option">请选择类...</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <button
+            class="btn btn-primary"
+            onclick="importFile()"
+            id="import-btn"
+            disabled
+          >
+            生成注册表
+          </button>
+          <button class="btn btn-secondary" onclick="clearResults()">
+            重置
+          </button>
+        </div>
+
+        <div id="workflow-tips" class="class-info">
+          <strong>使用流程:</strong><br />
+          1. 选择注册表类型（设备/资源）<br />
+          2. 在文件浏览器中导航并选择Python文件<br />
+          3. 点击"分析文件"获取可用类列表<br />
+          4. 从下拉列表中选择要注册的类<br />
+          5. 点击"生成注册表"获得YAML配置文件
+        </div>
+
+        <div id="file-info" class="file-info" style="display: none">
+          <strong>文件信息：</strong>
+          <div id="file-details"></div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 右栏：注册表配置结果 -->
+    <div class="right-column">
+      <div id="results-section" class="form-section" style="display: none">
+        <h3>注册表配置结果</h3>
+        <div class="yaml-container">
+          <div class="yaml-header">
+            <strong>YAML格式注册表配置</strong>
+            <button
+              class="btn btn-secondary copy-yaml-btn"
+              onclick="copyYamlToClipboard()"
+            >
+              复制YAML
+            </button>
+          </div>
+          <div class="schema-viewer" id="yaml-registry-viewer">等待数据...</div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 处理日志 - 底部 -->
+  <div class="log-section-bottom">
+    <h3>处理日志</h3>
+    <div id="log-output" class="log-container">等待操作...</div>
+  </div>
+</div>
+
+<script>
+  let ws = null;
+  let isConnected = false;
+  let currentPath = '';
+  let selectedFilePath = null;
+
+  // 页面加载完成后初始化
+  document.addEventListener('DOMContentLoaded', function () {
+    initWebSocket();
+    loadFileBrowser(''); // 加载根目录
+    initRegistryTypeListener();
+  });
+
+  // 初始化注册表类型监听器
+  function initRegistryTypeListener() {
+    const radioButtons = document.querySelectorAll(
+      'input[name="registry-type"]'
+    );
+    radioButtons.forEach((radio) => {
+      radio.addEventListener('change', function () {
+        updateClassSelectionLabel(this.value);
+      });
+    });
+
+    // 初始化标签文字
+    const checkedRadio = document.querySelector(
+      'input[name="registry-type"]:checked'
+    );
+    if (checkedRadio) {
+      updateClassSelectionLabel(checkedRadio.value);
+    }
+  }
+
+  // 更新类选择标签文字
+  function updateClassSelectionLabel(registryType) {
+    const label = document.getElementById('class-selection-label');
+    const option = document.getElementById('class-selection-option');
+
+    if (registryType === 'resource') {
+      label.textContent = '选择类名/可执行函数';
+      option.textContent = '请选择类或函数...';
+    } else {
+      label.textContent = '选择类名';
+      option.textContent = '请选择类...';
+    }
+  }
+
+  // 初始化WebSocket连接
+  function initWebSocket() {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${protocol}//${window.location.host}/api/v1/ws/registry_editor`;
+
+    ws = new WebSocket(wsUrl);
+
+    ws.onopen = function (event) {
+      isConnected = true;
+      updateConnectionStatus('connected', '已连接');
+      addLog('WebSocket连接已建立', 'info');
+    };
+
+    ws.onmessage = function (event) {
+      try {
+        const data = JSON.parse(event.data);
+        handleWebSocketMessage(data);
+      } catch (e) {
+        addLog(`解析消息失败: ${e.message}`, 'error');
+      }
+    };
+
+    ws.onclose = function (event) {
+      isConnected = false;
+      updateConnectionStatus('disconnected', '连接已断开');
+      addLog('WebSocket连接已断开', 'warning');
+
+      // 5秒后尝试重连
+      setTimeout(initWebSocket, 5000);
+    };
+
+    ws.onerror = function (error) {
+      addLog('WebSocket连接错误', 'error');
+      updateConnectionStatus('disconnected', '连接错误');
+    };
+  }
+
+  // 更新连接状态
+  function updateConnectionStatus(status, text) {
+    const statusDot = document.getElementById('status-dot');
+    const statusText = document.getElementById('status-text');
+
+    statusDot.className = `status-indicator status-${status}`;
+    statusText.textContent = text;
+  }
+
+  // 处理WebSocket消息
+  function handleWebSocketMessage(data) {
+    switch (data.type) {
+      case 'log':
+        addLog(data.message, data.level || 'info');
+        break;
+      case 'progress':
+        updateConnectionStatus('processing', data.message);
+        break;
+      case 'result':
+        handleAnalysisResult(data.data);
+        break;
+      case 'file_analysis_result':
+        handleFileAnalysisResult(data.data);
+        break;
+      case 'error':
+        addLog(data.message, 'error');
+        updateConnectionStatus('connected', '已连接');
+        break;
+      default:
+        addLog(`收到未知消息类型: ${data.type}`, 'warning');
+    }
+  }
+
+  // 处理分析结果
+  function handleAnalysisResult(result) {
+    updateConnectionStatus('connected', '已连接');
+
+    // 显示结果区域
+    document.getElementById('results-section').style.display = 'block';
+
+    // 显示YAML格式的注册表配置
+    if (result.registry_schema) {
+      // 直接显示后端返回的YAML字符串
+      const yamlViewer = document.getElementById('yaml-registry-viewer');
+      yamlViewer.textContent = result.registry_schema;
+
+      // 保存YAML内容供复制使用
+      window.registryYaml = result.registry_schema;
+
+      addLog(`生成的设备ID: ${result.device_id}`, 'info');
+    }
+
+    addLog('注册表生成完成！', 'success');
+  }
+
+  // 复制YAML到剪贴板
+  function copyYamlToClipboard() {
+    if (!window.registryYaml) {
+      addLog('没有可复制的YAML内容', 'error');
+      return;
+    }
+
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard
+        .writeText(window.registryYaml)
+        .then(() => {
+          addLog('YAML配置已复制到剪贴板', 'success');
+
+          // 视觉反馈
+          const copyBtn = document.querySelector('.copy-yaml-btn');
+          const originalText = copyBtn.textContent;
+          copyBtn.textContent = '已复制!';
+          copyBtn.style.backgroundColor = '#4caf50';
+
+          setTimeout(() => {
+            copyBtn.textContent = originalText;
+            copyBtn.style.backgroundColor = '';
+          }, 2000);
+        })
+        .catch((err) => {
+          addLog('复制失败，请手动复制', 'error');
+        });
+    } else {
+      // 后备方案：选择文本
+      const yamlViewer = document.getElementById('yaml-registry-viewer');
+      const range = document.createRange();
+      range.selectNodeContents(yamlViewer);
+      const selection = window.getSelection();
+      selection.removeAllRanges();
+      selection.addRange(range);
+
+      addLog('已选择YAML文本，请按Ctrl+C复制', 'info');
+    }
+  }
+
+  // 添加日志
+  function addLog(message, level = 'info') {
+    const logOutput = document.getElementById('log-output');
+    const timestamp = new Date().toLocaleTimeString();
+
+    let prefix = '';
+    switch (level) {
+      case 'error':
+        prefix = '[ERROR]';
+        break;
+      case 'warning':
+        prefix = '[WARN]';
+        break;
+      case 'success':
+        prefix = '[SUCCESS]';
+        break;
+      case 'info':
+      default:
+        prefix = '[INFO]';
+        break;
+    }
+
+    const logLine = `${timestamp} ${prefix} ${message}\n`;
+    logOutput.textContent += logLine;
+    logOutput.scrollTop = logOutput.scrollHeight;
+  }
+
+  // 加载文件浏览器
+  async function loadFileBrowser(path) {
+    try {
+      const response = await fetch(
+        `/api/v1/file-browser?path=${encodeURIComponent(path)}`
+      );
+      const result = await response.json();
+
+      if (result.code === 0) {
+        const data = result.data;
+        currentPath = data.current_path;
+        renderFileBrowser(data);
+      } else {
+        addLog(`加载目录失败: ${result.message}`, 'error');
+      }
+    } catch (error) {
+      addLog(`加载目录时出错: ${error}`, 'error');
+    }
+  }
+
+  // 渲染文件浏览器
+  function renderFileBrowser(data) {
+    const fileBrowser = document.getElementById('file-browser');
+    const currentPathDisplay = document.getElementById('current-path-display');
+
+    // 更新当前路径显示
+    currentPathDisplay.textContent = data.current_path || data.working_dir;
+
+    // 清空文件浏览器
+    fileBrowser.innerHTML = '';
+
+    // 添加返回上级目录选项（除了根路径）
+    const currentPath = data.current_path || data.working_dir;
+    if (currentPath && currentPath !== '' && !isRootPath(currentPath)) {
+      const parentItem = document.createElement('div');
+      parentItem.className = 'file-item';
+      parentItem.innerHTML = `
+        <span class="file-icon directory-icon">⬆️</span>
+        <span class="file-name">..</span>
+        <span class="file-size">(返回上级目录)</span>
+      `;
+
+      // 计算上级目录路径
+      const parentPath = currentPath.split(/[/\\]/).slice(0, -1).join('/');
+      parentItem.onclick = () => loadFileBrowser(parentPath);
+
+      fileBrowser.appendChild(parentItem);
+    }
+
+    if (data.items.length === 0) {
+      if (fileBrowser.children.length === 0) {
+        fileBrowser.innerHTML =
+          '<div class="loading-indicator">此目录为空</div>';
+      }
+      return;
+    }
+
+    // 渲染文件和目录
+    data.items.forEach((item) => {
+      const fileItem = document.createElement('div');
+      fileItem.className = 'file-item';
+      fileItem.dataset.path = item.path;
+      fileItem.dataset.type = item.type;
+
+      let icon = '';
+      let iconClass = '';
+
+      if (item.type === 'directory') {
+        icon = '📁';
+        iconClass = 'directory-icon';
+      } else if (item.is_python) {
+        icon = '🐍';
+        iconClass = 'python-file-icon';
+      } else {
+        return; // 只显示Python文件和目录
+      }
+
+      let sizeText = '';
+      if (item.type === 'file') {
+        sizeText = `<span class="file-size">(${formatFileSize(
+          item.size
+        )})</span>`;
+      }
+
+      fileItem.innerHTML = `
+        <span class="file-icon ${iconClass}">${icon}</span>
+        <span class="file-name">${item.name}</span>
+        ${sizeText}
+      `;
+
+      // 添加点击事件
+      if (item.type === 'directory') {
+        fileItem.onclick = () => loadFileBrowser(item.path);
+      } else if (item.is_python) {
+        fileItem.onclick = () => selectFile(item);
+      }
+
+      fileBrowser.appendChild(fileItem);
+    });
+  }
+
+  // 选择文件
+  function selectFile(fileInfo) {
+    // 清除之前的选择
+    document.querySelectorAll('.file-item').forEach((item) => {
+      item.classList.remove('selected');
+    });
+
+    // 标记当前选择
+    event.target.closest('.file-item').classList.add('selected');
+
+    // 保存选择的文件信息
+    selectedFilePath = fileInfo.path;
+    window.selectedFileInfo = fileInfo;
+
+    // 显示选择的文件信息
+    const selectedFileDiv = document.getElementById('selected-file');
+    const selectedFileName = document.getElementById('selected-file-name');
+    const selectedFileSize = document.getElementById('selected-file-size');
+
+    selectedFileName.textContent = fileInfo.name;
+    selectedFileSize.textContent = `(${formatFileSize(fileInfo.size)})`;
+    selectedFileDiv.style.display = 'block';
+
+    // 启用分析按钮
+    const analyzeBtn = document.getElementById('analyze-btn');
+    analyzeBtn.disabled = false;
+
+    addLog(`已选择文件: ${fileInfo.name}`, 'info');
+    addLog('点击"分析文件"按钮开始分析', 'success');
+  }
+
+  // 判断是否为根路径
+  function isRootPath(path) {
+    if (!path || path === '') return true;
+
+    // Windows根路径（如 C:, D:, C:\, D:\）
+    if (/^[A-Za-z]:?\\?$/.test(path)) return true;
+
+    // Unix根路径
+    if (path === '/') return true;
+
+    // 网络路径根（\\server 或 //server）
+    if (/^[\\\/]{2}[^\\\/]+$/.test(path)) return true;
+
+    return false;
+  }
+
+  // 格式化文件大小
+  function formatFileSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+  }
+
+  // 分析文件
+  function analyzeFile() {
+    if (!isConnected) {
+      addLog('WebSocket未连接，请等待连接建立', 'error');
+      return;
+    }
+
+    if (!selectedFilePath) {
+      addLog('请先选择文件', 'error');
+      return;
+    }
+
+    const analyzeBtn = document.getElementById('analyze-btn');
+    analyzeBtn.disabled = true;
+    analyzeBtn.textContent = '分析中...';
+
+    const request = {
+      type: 'analyze_file',
+      data: {
+        file_path: selectedFilePath,
+      },
+    };
+
+    ws.send(JSON.stringify(request));
+    addLog(`开始分析文件: ${selectedFilePath}`, 'info');
+  }
+
+  // 处理文件分析结果
+  function handleFileAnalysisResult(analysisResult) {
+    const analyzeBtn = document.getElementById('analyze-btn');
+    const classSelectionGroup = document.getElementById(
+      'class-selection-group'
+    );
+    const classSelect = document.getElementById('class-name');
+
+    analyzeBtn.disabled = false;
+    analyzeBtn.textContent = '重新分析';
+
+    if (analysisResult.success) {
+      const classes = analysisResult.classes || [];
+      const registryType = document.querySelector(
+        'input[name="registry-type"]:checked'
+      ).value;
+
+      // 清空现有选项并设置默认选项
+      const defaultText =
+        registryType === 'resource' ? '请选择类或函数...' : '请选择类...';
+      classSelect.innerHTML = `<option value="">${defaultText}</option>`;
+
+      // 添加找到的类
+      classes.forEach((cls) => {
+        const option = document.createElement('option');
+        option.value = cls.name;
+        option.textContent = `${cls.name} - ${cls.docstring || '无描述'}`;
+        classSelect.appendChild(option);
+      });
+
+      if (classes.length > 0) {
+        classSelectionGroup.style.display = 'block';
+        addLog(
+          `找到 ${classes.length} 个类: ${classes
+            .map((c) => c.name)
+            .join(', ')}`,
+          'success'
+        );
+
+        // 显示分析状态
+        showFileAnalysisStatus(analysisResult);
+
+        // 监听类选择变化，启用导入按钮
+        classSelect.onchange = function () {
+          const importBtn = document.getElementById('import-btn');
+          if (this.value) {
+            importBtn.disabled = false;
+            addLog(`选择了类: ${this.value}`, 'info');
+          } else {
+            importBtn.disabled = true;
+          }
+        };
+      } else {
+        addLog('文件中未找到任何类定义', 'warning');
+        classSelectionGroup.style.display = 'none';
+      }
+    } else {
+      addLog(`文件分析失败: ${analysisResult.error}`, 'error');
+      classSelectionGroup.style.display = 'none';
+    }
+  }
+
+  // 显示文件分析状态
+  function showFileAnalysisStatus(analysisResult) {
+    // 移除现有的分析状态显示
+    const existingStatus = document.getElementById('file-analysis-status');
+    if (existingStatus) {
+      existingStatus.remove();
+    }
+
+    // 创建新的状态显示
+    const statusDiv = document.createElement('div');
+    statusDiv.id = 'file-analysis-status';
+    statusDiv.className = 'file-analysis-status';
+
+    let statusContent = `
+      <strong>文件分析结果:</strong><br>
+      文件路径: ${analysisResult.file_path}<br>
+      模块名: ${analysisResult.module_name}<br>
+      找到类数量: ${analysisResult.classes.length}
+    `;
+
+    if (analysisResult.classes.length > 0) {
+      statusContent += '<br><strong>可用类:</strong>';
+      analysisResult.classes.forEach((cls) => {
+        statusContent += `<br>• ${cls.name}: ${cls.docstring || '无描述'}`;
+      });
+    }
+
+    statusDiv.innerHTML = statusContent;
+
+    // 插入到类选择组前面
+    const classSelectionGroup = document.getElementById(
+      'class-selection-group'
+    );
+    classSelectionGroup.parentNode.insertBefore(statusDiv, classSelectionGroup);
+  }
+
+  // 导入文件
+  function importFile() {
+    if (!isConnected) {
+      addLog('WebSocket未连接，请等待连接建立', 'error');
+      return;
+    }
+
+    if (!selectedFilePath) {
+      addLog('请先选择文件', 'error');
+      return;
+    }
+
+    const classSelect = document.getElementById('class-name');
+    const className = classSelect.value.trim();
+
+    if (!className) {
+      addLog('请先分析文件并选择要导入的类', 'error');
+      return;
+    }
+
+    const registryType = document.querySelector(
+      'input[name="registry-type"]:checked'
+    ).value;
+
+    updateConnectionStatus('processing', '正在生成注册表...');
+
+    const request = {
+      type: 'import_file',
+      data: {
+        file_path: selectedFilePath,
+        registry_type: registryType,
+        class_name: className,
+        module_name: null, // 模块名自动生成
+      },
+    };
+
+    ws.send(JSON.stringify(request));
+    addLog(`开始导入文件: ${selectedFilePath}`, 'info');
+    addLog(`注册表类型: ${registryType}`, 'info');
+    addLog(`选择的类: ${className}`, 'info');
+
+    // 显示文件信息
+    showFileInfo(selectedFilePath, registryType, className);
+  }
+
+  // 显示文件信息
+  function showFileInfo(filePath, registryType, className) {
+    const fileInfo = document.getElementById('file-info');
+    const fileDetails = document.getElementById('file-details');
+
+    let details = `
+            <div><strong>文件路径:</strong> ${filePath}</div>
+            <div><strong>注册表类型:</strong> ${registryType}</div>
+            <div><strong>选择的类:</strong> ${className}</div>
+        `;
+
+    fileDetails.innerHTML = details;
+    fileInfo.style.display = 'block';
+  }
+
+  // 清空结果
+  function clearResults() {
+    // 重置文件选择
+    selectedFilePath = null;
+    window.selectedFileInfo = null;
+
+    // 清除文件选择状态
+    document.querySelectorAll('.file-item').forEach((item) => {
+      item.classList.remove('selected');
+    });
+
+    // 隐藏选择的文件显示
+    document.getElementById('selected-file').style.display = 'none';
+
+    // 重置分析按钮
+    const analyzeBtn = document.getElementById('analyze-btn');
+    analyzeBtn.disabled = true;
+    analyzeBtn.textContent = '分析文件';
+
+    // 重置导入按钮
+    const importBtn = document.getElementById('import-btn');
+    importBtn.disabled = true;
+
+    // 隐藏类选择
+    document.getElementById('class-selection-group').style.display = 'none';
+
+    // 根据当前注册表类型设置默认选项文字
+    const registryType = document.querySelector(
+      'input[name="registry-type"]:checked'
+    ).value;
+    const defaultText =
+      registryType === 'resource' ? '请选择类或函数...' : '请选择类...';
+    document.getElementById(
+      'class-name'
+    ).innerHTML = `<option value="">${defaultText}</option>`;
+
+    // 移除分析状态显示
+    const analysisStatus = document.getElementById('file-analysis-status');
+    if (analysisStatus) {
+      analysisStatus.remove();
+    }
+
+    // 清空其他显示区域
+    document.getElementById('results-section').style.display = 'none';
+    document.getElementById('file-info').style.display = 'none';
+    document.getElementById('log-output').textContent = '等待操作...';
+
+    // 清空YAML查看器
+    document.getElementById('yaml-registry-viewer').textContent = '等待数据...';
+    window.registryYaml = null;
+
+    addLog('已重置所有设置', 'info');
+  }
+</script>
+{% endblock %}
diff --git a/unilabos/app/web/templates/status.html b/unilabos/app/web/templates/status.html
index e1105b7b..44412a2c 100644
--- a/unilabos/app/web/templates/status.html
+++ b/unilabos/app/web/templates/status.html
@@ -1,1255 +1,2375 @@
-{% extends "base.html" %}
+{% extends "base.html" %} {% block title %}UniLab System Status{% endblock %} {%
+block header %}UniLab System Status{% endblock %} {% block top_info %}
+<!-- 页面导航 -->
+<div class="nav-tabs" style="margin-bottom: 15px">
+  <a href="/" class="nav-tab" target="_blank">主页</a>
+  <a
+    href="/status"
+    class="nav-tab"
+    style="background-color: #4caf50; color: white"
+    >状态</a
+  >
+  <a href="/registry-editor" class="nav-tab" target="_blank">注册表编辑</a>
+</div>
 
-{% block title %}UniLab System Status{% endblock %}
-
-{% block header %}UniLab System Status{% endblock %}
-
-{% block top_info %}
 <!-- 系统模式显示 -->
 <div class="system-mode-banner">
-    <div class="mode-indicator {% if is_host_mode %}host-mode{% else %}slave-mode{% endif %}">
-        系统模式: <strong>{{ "主机模式 (HOST)" if is_host_mode else "从机模式 (SLAVE)" }}</strong>
-    </div>
+  <div
+    class="mode-indicator {% if is_host_mode %}host-mode{% else %}slave-mode{% endif %}"
+  >
+    系统模式:
+    <strong
+      >{{ "主机模式 (HOST)" if is_host_mode else "从机模式 (SLAVE)" }}</strong
+    >
+  </div>
 </div>
 
 {% if registry_info %}
 <div class="registry-info">
-    {% if registry_info.paths %}
-    <div class="registry-path">
-        <strong>注册表路径:</strong>
-        <ul class="path-list">
-        {% for path in registry_info.paths %}
-            <li>
-                <span class="path">{{ path }}</span>
-                <span class="folder-link" onclick="openFolder('{{ path }}')" title="打开文件夹">📁</span>
-            </li>
-        {% endfor %}
-        </ul>
-    </div>
-    {% endif %}
-    
-    {% if registry_info.devices_paths %}
-    <div class="registry-path">
-        <strong>设备目录:</strong>
-        <ul class="path-list">
-        {% for path in registry_info.devices_paths %}
-            <li>
-                <span class="path">{{ path }}</span>
-                <span class="folder-link" onclick="openFolder('{{ path }}')" title="打开文件夹">📁</span>
-            </li>
-        {% endfor %}
-        </ul>
-    </div>
-    {% endif %}
-    
-    {% if registry_info.device_comms_paths %}
-    <div class="registry-path">
-        <strong>设备通信目录:</strong>
-        <ul class="path-list">
-        {% for path in registry_info.device_comms_paths %}
-            <li>
-                <span class="path">{{ path }}</span>
-                <span class="folder-link" onclick="openFolder('{{ path }}')" title="打开文件夹">📁</span>
-            </li>
-        {% endfor %}
-        </ul>
-    </div>
-    {% endif %}
-    
-    {% if registry_info.resources_paths %}
-    <div class="registry-path">
-        <strong>资源目录:</strong>
-        <ul class="path-list">
-        {% for path in registry_info.resources_paths %}
-            <li>
-                <span class="path">{{ path }}</span>
-                <span class="folder-link" onclick="openFolder('{{ path }}')" title="打开文件夹">📁</span>
-            </li>
-        {% endfor %}
-        </ul>
-    </div>
-    {% endif %}
+  {% if registry_info.paths %}
+  <div class="registry-path">
+    <strong>注册表路径:</strong>
+    <ul class="path-list">
+      {% for path in registry_info.paths %}
+      <li>
+        <span class="path">{{ path }}</span>
+        <span
+          class="folder-link"
+          onclick="openFolder('{{ path }}')"
+          title="打开文件夹"
+          >📁</span
+        >
+      </li>
+      {% endfor %}
+    </ul>
+  </div>
+  {% endif %} {% if registry_info.devices_paths %}
+  <div class="registry-path">
+    <strong>设备目录:</strong>
+    <ul class="path-list">
+      {% for path in registry_info.devices_paths %}
+      <li>
+        <span class="path">{{ path }}</span>
+        <span
+          class="folder-link"
+          onclick="openFolder('{{ path }}')"
+          title="打开文件夹"
+          >📁</span
+        >
+      </li>
+      {% endfor %}
+    </ul>
+  </div>
+  {% endif %} {% if registry_info.device_comms_paths %}
+  <div class="registry-path">
+    <strong>设备通信目录:</strong>
+    <ul class="path-list">
+      {% for path in registry_info.device_comms_paths %}
+      <li>
+        <span class="path">{{ path }}</span>
+        <span
+          class="folder-link"
+          onclick="openFolder('{{ path }}')"
+          title="打开文件夹"
+          >📁</span
+        >
+      </li>
+      {% endfor %}
+    </ul>
+  </div>
+  {% endif %} {% if registry_info.resources_paths %}
+  <div class="registry-path">
+    <strong>资源目录:</strong>
+    <ul class="path-list">
+      {% for path in registry_info.resources_paths %}
+      <li>
+        <span class="path">{{ path }}</span>
+        <span
+          class="folder-link"
+          onclick="openFolder('{{ path }}')"
+          title="打开文件夹"
+          >📁</span
+        >
+      </li>
+      {% endfor %}
+    </ul>
+  </div>
+  {% endif %}
 </div>
 {% endif %}
 
 <div class="nav-tabs">
-    {% if is_host_mode and host_node_info.available %}
-    <a href="#host-node-section" class="nav-tab">主机节点</a>
-    {% endif %}
-    <a href="#online-devices-section" class="nav-tab">本地设备</a>
-    <a href="#devices-section" class="nav-tab">设备类型</a>
-    <a href="#resources-section" class="nav-tab">资源类型</a>
-    <a href="#modules-section" class="nav-tab">转换器模块</a>
+  {% if is_host_mode and host_node_info.available %}
+  <a href="#host-node-section" class="nav-tab">主机节点</a>
+  {% endif %}
+  <a href="#online-devices-section" class="nav-tab">本地设备</a>
+  <a href="#devices-section" class="nav-tab">设备类型</a>
+  <a href="#resources-section" class="nav-tab">资源类型</a>
+  <a href="#modules-section" class="nav-tab">转换器模块</a>
 </div>
-{% endblock %}
-
-{% block content %}
+{% endblock %} {% block content %}
 <!-- 主机节点信息部分 -->
 {% if is_host_mode and host_node_info.available %}
 <div class="card" id="host-node-section">
-    <h2>主机节点信息</h2>
-    
-    <!-- 主机控制的设备 -->
-    <div class="host-section">
-        <h3>已管理设备 <span class="count-badge">{{ host_node_info.devices|length }}</span></h3>
-        <table class="responsive-table">
-            <tr>
-                <th>设备ID</th>
-                <th>命名空间</th>
-                <th>机器名称</th>
-                <th>状态</th>
-            </tr>
-            {% for device_id, device_info in host_node_info.devices.items() %}
-            <tr>
-                <td>{{ device_id }}</td>
-                <td>{{ device_info.namespace }}</td>
-                <td>{{ device_info.machine_name }}</td>
-                <td><span class="status-badge online">{{ "在线" if device_info.is_online else "离线" }}</span></td>
-            </tr>
-            {% else %}
-            <tr>
-                <td colspan="4" class="empty-state">没有发现已管理的设备</td>
-            </tr>
-            {% endfor %}
-        </table>
-    </div>
-    
-    <!-- 主机的动作客户端 -->
-    <div class="host-section">
-        <h3>动作客户端 <span class="count-badge">{{ host_node_info.action_clients|length }}</span></h3>
-        <table class="responsive-table collapsible-table">
-            <h4>已接纳动作:</h4>
-            <table class="inner-table">
-                <tr>
-                    <th>话题</th>
-                    <th>类型</th>
-                    <th></th>
-                </tr>
-                {% for action_name, action_info in host_node_info.action_clients.items() %}
-                <tr class="action-row collapsible-sub-row" data-target="action-cmd-{{ loop.index }}-{{ device_loop_index }}">
-                    <td>{{ action_name }}</td>
-                    <td>{{ action_info.type_name }}</td>
-                    <td><span class="toggle-sub-indicator">▼</span></td>
-                </tr>
-                <tr id="action-cmd-{{ loop.index }}-{{ device_loop_index }}" class="cmd-row" style="display: none;">
-                    <td colspan="5">
-                        <div class="cmd-block">
-                            <strong>发送命令:</strong>
-                            <div class="cmd-line">
-                                <pre>ros2 action send_goal {{ action_info.action_path }} {{ action_info.type_name_convert }} "{{ action_info.goal_info }}"</pre>
-                                <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
-                            </div>
-                            
-                            <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
-                        </div>
-                    </td>
-                </tr>
-                {% endfor %}
-            </table>
-        </table>
-    </div>
-    
-    <!-- 主机已订阅的主题 -->
-    <div class="host-section">
-        <h3>已订阅主题 <span class="count-badge">{{ host_node_info.subscribed_topics|length }}</span></h3>
-        <div class="topics-container">
-            {% if host_node_info.subscribed_topics %}
-            <div class="topics-list">
-                {% for topic in host_node_info.subscribed_topics %}
-                <div class="topic-item">
-                    <span class="topic-name">{{ topic }}</span>
-                    <button class="copy-btn small" onclick="copyToClipboard('{{ topic }}', event)" title="复制主题名">复制</button>
-                </div>
-                {% endfor %}
+  <h2>主机节点信息</h2>
+
+  <!-- 主机控制的设备 -->
+  <div class="host-section">
+    <h3>
+      已管理设备
+      <span class="count-badge">{{ host_node_info.devices|length }}</span>
+    </h3>
+    <table class="responsive-table">
+      <tr>
+        <th>设备ID</th>
+        <th>命名空间</th>
+        <th>机器名称</th>
+        <th>状态</th>
+      </tr>
+      {% for device_id, device_info in host_node_info.devices.items() %}
+      <tr>
+        <td>{{ device_id }}</td>
+        <td>{{ device_info.namespace }}</td>
+        <td>{{ device_info.machine_name }}</td>
+        <td>
+          <span class="status-badge online"
+            >{{ "在线" if device_info.is_online else "离线" }}</span
+          >
+        </td>
+      </tr>
+      {% else %}
+      <tr>
+        <td colspan="4" class="empty-state">没有发现已管理的设备</td>
+      </tr>
+      {% endfor %}
+    </table>
+  </div>
+
+  <!-- 主机的动作客户端 -->
+  <div class="host-section">
+    <h3>
+      动作客户端
+      <span class="count-badge"
+        >{{ host_node_info.action_clients|length }}</span
+      >
+    </h3>
+    <table class="responsive-table collapsible-table">
+      <h4>已接纳动作:</h4>
+      <table class="inner-table">
+        <tr>
+          <th>话题</th>
+          <th>类型</th>
+          <th></th>
+        </tr>
+        {% for action_name, action_info in host_node_info.action_clients.items()
+        %}
+        <tr
+          class="action-row collapsible-sub-row"
+          data-target="action-cmd-{{ loop.index }}-{{ device_loop_index }}"
+        >
+          <td>{{ action_name }}</td>
+          <td>{{ action_info.type_name }}</td>
+          <td><span class="toggle-sub-indicator">▼</span></td>
+        </tr>
+        <tr
+          id="action-cmd-{{ loop.index }}-{{ device_loop_index }}"
+          class="cmd-row"
+          style="display: none"
+        >
+          <td colspan="5">
+            <div class="cmd-block">
+              <strong>发送命令:</strong>
+              <div class="cmd-line">
+                <pre>
+ros2 action send_goal {{ action_info.action_path }} {{ action_info.type_name_convert }} "{{ action_info.goal_info }}"</pre
+                >
+                <button
+                  class="copy-btn"
+                  onclick="copyToClipboard(this.previousElementSibling.textContent, event)"
+                >
+                  复制
+                </button>
+              </div>
+
+              <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
             </div>
-            {% else %}
-            <div class="empty-state">没有发现已订阅的主题</div>
-            {% endif %}
+          </td>
+        </tr>
+        {% endfor %}
+      </table>
+    </table>
+  </div>
+
+  <!-- 主机已订阅的主题 -->
+  <div class="host-section">
+    <h3>
+      已订阅主题
+      <span class="count-badge"
+        >{{ host_node_info.subscribed_topics|length }}</span
+      >
+    </h3>
+    <div class="topics-container">
+      {% if host_node_info.subscribed_topics %}
+      <div class="topics-list">
+        {% for topic in host_node_info.subscribed_topics %}
+        <div class="topic-item">
+          <span class="topic-name">{{ topic }}</span>
+          <button
+            class="copy-btn small"
+            onclick="copyToClipboard('{{ topic }}', event)"
+            title="复制主题名"
+          >
+            复制
+          </button>
         </div>
+        {% endfor %}
+      </div>
+      {% else %}
+      <div class="empty-state">没有发现已订阅的主题</div>
+      {% endif %}
     </div>
-    
-    <!-- 设备状态 -->
-    {% if host_node_info.device_status %}
-    <div class="host-section">
-        <h3>设备状态</h3>
-        <table class="responsive-table">
-            <tr>
-                <th>设备ID</th>
-                <th>属性</th>
-                <th>值</th>
-                <th>最后更新</th>
-            </tr>
-            {% for device_id, properties in host_node_info.device_status.items() %}
-                {% for prop_name, prop_value in properties.items() %}
-                <tr>
-                    {% if loop.first %}
-                    <td rowspan="{{ properties|length }}">{{ device_id }}</td>
-                    {% endif %}
-                    <td>{{ prop_name }}</td>
-                    <td>{{ prop_value }}</td>
-                    <td>
-                        {% if device_id in host_node_info.device_status_timestamps and prop_name in host_node_info.device_status_timestamps[device_id] %}
-                            {% set ts_info = host_node_info.device_status_timestamps[device_id][prop_name] %}
-                            {% if ts_info.elapsed >= 0 %}
-                                <span class="timestamp" title="{{ ts_info.timestamp }}">{{ ts_info.elapsed }} 秒前</span>
-                            {% else %}
-                                <span class="timestamp not-updated">未更新</span>
-                            {% endif %}
-                        {% else %}
-                            <span class="timestamp not-updated">无数据</span>
-                        {% endif %}
-                    </td>
-                </tr>
-                {% endfor %}
-            {% else %}
-            <tr>
-                <td colspan="4" class="empty-state">没有设备状态数据</td>
-            </tr>
-            {% endfor %}
-        </table>
-    </div>
-    {% endif %}
+  </div>
+
+  <!-- 设备状态 -->
+  {% if host_node_info.device_status %}
+  <div class="host-section">
+    <h3>设备状态</h3>
+    <table class="responsive-table">
+      <tr>
+        <th>设备ID</th>
+        <th>属性</th>
+        <th>值</th>
+        <th>最后更新</th>
+      </tr>
+      {% for device_id, properties in host_node_info.device_status.items() %} {%
+      for prop_name, prop_value in properties.items() %}
+      <tr>
+        {% if loop.first %}
+        <td rowspan="{{ properties|length }}">{{ device_id }}</td>
+        {% endif %}
+        <td>{{ prop_name }}</td>
+        <td>{{ prop_value }}</td>
+        <td>
+          {% if device_id in host_node_info.device_status_timestamps and
+          prop_name in host_node_info.device_status_timestamps[device_id] %} {%
+          set ts_info =
+          host_node_info.device_status_timestamps[device_id][prop_name] %} {% if
+          ts_info.elapsed >= 0 %}
+          <span class="timestamp" title="{{ ts_info.timestamp }}"
+            >{{ ts_info.elapsed }} 秒前</span
+          >
+          {% else %}
+          <span class="timestamp not-updated">未更新</span>
+          {% endif %} {% else %}
+          <span class="timestamp not-updated">无数据</span>
+          {% endif %}
+        </td>
+      </tr>
+      {% endfor %} {% else %}
+      <tr>
+        <td colspan="4" class="empty-state">没有设备状态数据</td>
+      </tr>
+      {% endfor %}
+    </table>
+  </div>
+  {% endif %}
 </div>
 {% endif %}
 
 <!-- 当前中断设备部分 -->
 <div class="card" id="online-devices-section">
-    <h2>Local Devices</h2>
-    <table class="responsive-table">
-        <tr>
-            <th>Device ID</th>
-            <th>节点名称</th>
-            <th>命名空间</th>
-            <th>机器名称</th>
-            <th>状态项</th>
-            <th>动作数</th>
-        </tr>
-        {% for device_id, device_info in ros_node_info.registered_devices.items() %}
-        {% set device_loop_index = loop.index %}
-        <tr class="collapsible-row device-row" data-target="device-detail-{{ loop.index }}">
-            <td>{{ device_id }}</td>
-            <td>{{ device_info.node_name }}</td>
-            <td>{{ device_info.namespace }}</td>
-            <td>{{ device_info.machine_name|default("本地") }}</td>
-            <td>{{ ros_node_info.device_topics.get(device_id, {})|length }}</td>
-            <td>{{ ros_node_info.device_actions.get(device_id, {})|length }} <span class="toggle-indicator">▼</span></td>
-        </tr>
-        <tr id="device-detail-{{ loop.index }}" class="detail-row" style="display: none;">
-            <td colspan="5">
-                <div class="content-full">
-                    UUID: {{ device_info.uuid }}
-                    {% if device_id in ros_node_info.device_topics %}
-                    <h4>已发布状态:</h4>
-                    <table class="inner-table">
-                        <tr>
-                            <th>名称</th>
-                            <th>类型</th>
-                            <th>话题</th>
-                            <th>间隔</th>
-                            <th></th>
-                        </tr>
-                        {% for status_name, status_info in ros_node_info.device_topics[device_id].items() %}
-                        <tr class="topic-row collapsible-sub-row" data-target="topic-cmd-{{ loop.index }}-{{ device_loop_index }}">
-                            <td>{{ status_name }}</td>
-                            <td>{{ status_info.type_name }}</td>
-                            <td>{{ status_info.topic_path }}</td>
-                            <td>{{ status_info.timer_period }}</td>
-                            <td><span class="toggle-sub-indicator">▼</span></td>
-                        </tr>
-                        <tr id="topic-cmd-{{ loop.index }}-{{ device_loop_index }}" class="cmd-row" style="display: none;">
-                            <td colspan="5">
-                                <div class="cmd-block">
-                                    <strong>订阅命令:</strong>
-                                    <div class="cmd-line">
-                                        <pre>ros2 topic echo {{ status_info.topic_path }}</pre>
-                                        <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
-                                    </div>
-                                </div>
-                            </td>
-                        </tr>
-                        {% endfor %}
-                    </table>
-                    {% endif %}
-                    
-                    {% if device_id in ros_node_info.device_actions %}
-                    <h4>已发布动作:</h4>
-                    <table class="inner-table">
-                        <tr>
-                            <th>名称</th>
-                            <th>类型</th>
-                            <th>话题</th>
-                            <th></th>
-                        </tr>
-                        {% for action_name, action_info in ros_node_info.device_actions[device_id].items() %}
-                        <tr class="action-row collapsible-sub-row" data-target="action-cmd-{{ loop.index }}-{{ device_loop_index }}">
-                            <td>{{ action_name }}</td>
-                            <td>{{ action_info.type_name }}</td>
-                            <td>{{ action_info.action_path }}</td>
-                            <td><span class="toggle-sub-indicator">▼</span></td>
-                        </tr>
-                        <tr id="action-cmd-{{ loop.index }}-{{ device_loop_index }}" class="cmd-row" style="display: none;">
-                            <td colspan="5">
-                                <div class="cmd-block">
-                                    <strong>发送命令:</strong>
-                                    <div class="cmd-line">
-                                        <pre>ros2 action send_goal {{ action_info.action_path }} {{ action_info.type_name_convert }} "{{ action_info.goal_info }}"</pre>
-                                        <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
-                                    </div>
-                                    
-                                    <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
-                                </div>
-                            </td>
-                        </tr>
-                        {% endfor %}
-                    </table>
-                    {% endif %}
+  <h2>Local Devices</h2>
+  <table class="responsive-table">
+    <tr>
+      <th>Device ID</th>
+      <th>节点名称</th>
+      <th>命名空间</th>
+      <th>机器名称</th>
+      <th>状态项</th>
+      <th>动作数</th>
+    </tr>
+    {% for device_id, device_info in ros_node_info.registered_devices.items() %}
+    {% set device_loop_index = loop.index %}
+    <tr
+      class="collapsible-row device-row"
+      data-target="device-detail-{{ loop.index }}"
+    >
+      <td>{{ device_id }}</td>
+      <td>{{ device_info.node_name }}</td>
+      <td>{{ device_info.namespace }}</td>
+      <td>{{ device_info.machine_name|default("本地") }}</td>
+      <td>{{ ros_node_info.device_topics.get(device_id, {})|length }}</td>
+      <td>
+        {{ ros_node_info.device_actions.get(device_id, {})|length }}
+        <span class="toggle-indicator">▼</span>
+      </td>
+    </tr>
+    <tr
+      id="device-detail-{{ loop.index }}"
+      class="detail-row"
+      style="display: none"
+    >
+      <td colspan="5">
+        <div class="content-full">
+          UUID: {{ device_info.uuid }} {% if device_id in
+          ros_node_info.device_topics %}
+          <h4>已发布状态:</h4>
+          <table class="inner-table">
+            <tr>
+              <th>名称</th>
+              <th>类型</th>
+              <th>话题</th>
+              <th>间隔</th>
+              <th></th>
+            </tr>
+            {% for status_name, status_info in
+            ros_node_info.device_topics[device_id].items() %}
+            <tr
+              class="topic-row collapsible-sub-row"
+              data-target="topic-cmd-{{ loop.index }}-{{ device_loop_index }}"
+            >
+              <td>{{ status_name }}</td>
+              <td>{{ status_info.type_name }}</td>
+              <td>{{ status_info.topic_path }}</td>
+              <td>{{ status_info.timer_period }}</td>
+              <td><span class="toggle-sub-indicator">▼</span></td>
+            </tr>
+            <tr
+              id="topic-cmd-{{ loop.index }}-{{ device_loop_index }}"
+              class="cmd-row"
+              style="display: none"
+            >
+              <td colspan="5">
+                <div class="cmd-block">
+                  <strong>订阅命令:</strong>
+                  <div class="cmd-line">
+                    <pre>ros2 topic echo {{ status_info.topic_path }}</pre>
+                    <button
+                      class="copy-btn"
+                      onclick="copyToClipboard(this.previousElementSibling.textContent, event)"
+                    >
+                      复制
+                    </button>
+                  </div>
                 </div>
-            </td>
-        </tr>
-        {% endfor %}
-    </table>
+              </td>
+            </tr>
+            {% endfor %}
+          </table>
+          {% endif %} {% if device_id in ros_node_info.device_actions %}
+          <h4>已发布动作:</h4>
+          <table class="inner-table">
+            <tr>
+              <th>名称</th>
+              <th>类型</th>
+              <th>话题</th>
+              <th></th>
+            </tr>
+            {% for action_name, action_info in
+            ros_node_info.device_actions[device_id].items() %}
+            <tr
+              class="action-row collapsible-sub-row"
+              data-target="action-cmd-{{ loop.index }}-{{ device_loop_index }}"
+            >
+              <td>{{ action_name }}</td>
+              <td>{{ action_info.type_name }}</td>
+              <td>{{ action_info.action_path }}</td>
+              <td><span class="toggle-sub-indicator">▼</span></td>
+            </tr>
+            <tr
+              id="action-cmd-{{ loop.index }}-{{ device_loop_index }}"
+              class="cmd-row"
+              style="display: none"
+            >
+              <td colspan="5">
+                <div class="cmd-block">
+                  <strong>发送命令:</strong>
+                  <div class="cmd-line">
+                    <pre>
+ros2 action send_goal {{ action_info.action_path }} {{ action_info.type_name_convert }} "{{ action_info.goal_info }}"</pre
+                    >
+                    <button
+                      class="copy-btn"
+                      onclick="copyToClipboard(this.previousElementSibling.textContent, event)"
+                    >
+                      复制
+                    </button>
+                  </div>
+
+                  <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
+                </div>
+              </td>
+            </tr>
+            {% endfor %}
+          </table>
+          {% endif %}
+        </div>
+      </td>
+    </tr>
+    {% endfor %}
+  </table>
 </div>
 
 <!-- 设备部分 -->
 <div class="card" id="devices-section">
-    <h2>Device Types</h2>
+  <h2 class="collapsible-header" data-target="devices-table">
+    Device Types
+    <span class="toggle-indicator">▼</span>
+  </h2>
+  <div id="devices-table" class="collapsible-content" style="display: none">
     <table class="responsive-table">
-        <tr>
-            <th>ID</th>
-            <th>Name</th>
-            <th>File Path</th>
-            <th></th>
-        </tr>
-        {% for device in devices %}
-        <tr class="collapsible-row" data-target="device-info-{{ loop.index }}">
-            <td>{{ device.id }}</td>
-            <td>{{ device.name }}</td>
-            <td class="file-path">
-                {{ device.file_path }}
-                <span class="folder-link" onclick="openFolder('{{ device.file_path }}'); event.stopPropagation();" title="打开文件夹">📁</span>
-            </td>
-            <td><span class="toggle-indicator">▼</span></td>
-        </tr>
-        <tr id="device-info-{{ loop.index }}" class="detail-row" style="display: none;">
-            <td colspan="5">
-                <div class="content-full">
-                    {% if device.class %}
-                        <pre>{{ device.class | tojson(indent=4) }}</pre>
-                    {% else %}
-                        <!-- 这里可以放占位内容，比如 -->
-                        <pre>// No data</pre>
-                    {% endif %}
+      <tr>
+        <th>ID</th>
+        <th>Name</th>
+        <th>File Path</th>
+        <th></th>
+      </tr>
+      {% for device in devices %}
+      <tr class="collapsible-row" data-target="device-info-{{ loop.index }}">
+        <td>{{ device.id }}</td>
+        <td>{{ device.name }}</td>
+        <td class="file-path">
+          {{ device.file_path }}
+          <span
+            class="folder-link"
+            onclick="openFolder('{{ device.file_path }}'); event.stopPropagation();"
+            title="打开文件夹"
+            >📁</span
+          >
+        </td>
+        <td><span class="toggle-indicator">▼</span></td>
+      </tr>
+      <tr
+        id="device-info-{{ loop.index }}"
+        class="detail-row"
+        style="display: none"
+      >
+        <td colspan="5">
+          <div class="content-full">
+            {% if device.class %}
+            <pre>{{ device.class | tojson(indent=4) }}</pre>
+            {% else %}
+            <!-- 这里可以放占位内容，比如 -->
+            <pre>// No data</pre>
+            {% endif %} {% if device.is_online %}
+            <div class="status-badge">
+              <span class="online-status">在线</span>
+            </div>
+            {% endif %} {% if device.is_online and device.status_publishers %}
+            <h4>状态发布者:</h4>
+            <ul class="detail-list">
+              {% for status_name, status_info in
+              device.status_publishers.items() %}
+              <li>
+                <strong>{{ status_name }}</strong> - 类型: {{ status_info.type
+                }} <br />话题: {{ status_info.topic }}
+              </li>
+              {% endfor %}
+            </ul>
+            {% endif %} {% if device.is_online and device.actions %}
+            <h4>可用动作:</h4>
+            <ul class="detail-list">
+              {% for action_name, action_info in device.actions.items() %}
+              <li>
+                <strong>{{ action_name }}</strong> - 类型: {{ action_info.type
+                }} <br />话题: {{ action_info.topic }}
+                <br />
+                <div class="cmd-block">
+                  <strong>发送命令:</strong>
+                  <div class="cmd-line">
+                    <pre>{{ action_info.command }}</pre>
+                    <button
+                      class="copy-btn"
+                      onclick="copyToClipboard(this.previousElementSibling.textContent, event)"
+                    >
+                      复制
+                    </button>
+                    <button
+                      class="debug-btn"
+                      onclick="toggleDebugInfo(this, event)"
+                    >
+                      调试
+                    </button>
+                    <div class="debug-info" style="display: none">
+                      {% if action_info %}
+                      <pre>{{ action_info | tojson(indent=4) }}</pre>
+                      {% else %}
+                      <!-- 这里可以放占位内容，比如 -->
+                      <pre>// No data</pre>
+                      {% endif %}
+                    </div>
+                  </div>
 
-                    {% if device.is_online %}
-                    <div class="status-badge"><span class="online-status">在线</span></div>
-                    {% endif %}
-                    
-                    {% if device.is_online and device.status_publishers %}
-                    <h4>状态发布者:</h4>
-                    <ul class="detail-list">
-                        {% for status_name, status_info in device.status_publishers.items() %}
-                        <li>
-                            <strong>{{ status_name }}</strong> - 类型: {{ status_info.type }}
-                            <br>话题: {{ status_info.topic }}
-                        </li>
-                        {% endfor %}
-                    </ul>
-                    {% endif %}
-                    
-                    {% if device.is_online and device.actions %}
-                    <h4>可用动作:</h4>
-                    <ul class="detail-list">
-                        {% for action_name, action_info in device.actions.items() %}
-                        <li>
-                            <strong>{{ action_name }}</strong> - 类型: {{ action_info.type }}
-                            <br>话题: {{ action_info.topic }}
-                            <br>
-                            <div class="cmd-block">
-                                <strong>发送命令:</strong>
-                                <div class="cmd-line">
-                                    <pre>{{ action_info.command }}</pre>
-                                    <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
-                                    <button class="debug-btn" onclick="toggleDebugInfo(this, event)">调试</button>
-                                    <div class="debug-info" style="display:none;">
-                                        {% if action_info %}
-                                            <pre>{{ action_info | tojson(indent=4) }}</pre>
-                                        {% else %}
-                                            <!-- 这里可以放占位内容，比如 -->
-                                            <pre>// No data</pre>
-                                        {% endif %}
-                                    </div>
-                                </div>
-                                
-                                <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
-                            </div>
-                        </li>
-                        {% endfor %}
-                    </ul>
-                    {% endif %}
+                  <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
                 </div>
-            </td>
-        </tr>
-        {% endfor %}
+              </li>
+              {% endfor %}
+            </ul>
+            {% endif %}
+          </div>
+        </td>
+      </tr>
+      {% endfor %}
     </table>
+  </div>
 </div>
 
 <!-- 资源部分 -->
 <div class="card" id="resources-section">
-    <h2>Resource Types</h2>
+  <h2 class="collapsible-header" data-target="resources-table">
+    Resource Types
+    <span class="toggle-indicator">▼</span>
+  </h2>
+  <div id="resources-table" class="collapsible-content" style="display: none">
     <table class="responsive-table">
-        <tr>
-            <th>ID</th>
-            <th>Name</th>
-            <th>File Path</th>
-        </tr>
-        {% for resource in resources %}
-        <tr>
-            <td>{{ resource.id }}</td>
-            <td>{{ resource.name }}</td>
-            <td class="file-path">
-                {{ resource.file_path }}
-                <span class="folder-link" onclick="openFolder('{{ resource.file_path }}')" title="打开文件夹">📁</span>
-            </td>
-        </tr>
-        {% endfor %}
+      <tr>
+        <th>ID</th>
+        <th>Name</th>
+        <th>File Path</th>
+      </tr>
+      {% for resource in resources %}
+      <tr>
+        <td>{{ resource.id }}</td>
+        <td>{{ resource.name }}</td>
+        <td class="file-path">
+          {{ resource.file_path }}
+          <span
+            class="folder-link"
+            onclick="openFolder('{{ resource.file_path }}')"
+            title="打开文件夹"
+            >📁</span
+          >
+        </td>
+      </tr>
+      {% endfor %}
     </table>
+  </div>
 </div>
 
 <!-- 模块部分 -->
 <div class="card" id="modules-section">
-    <h2>Converter Modules</h2>
+  <h2 class="collapsible-header" data-target="modules-content">
+    Converter Modules
+    <span class="toggle-indicator">▼</span>
+  </h2>
+  <div id="modules-content" class="collapsible-content" style="display: none">
     <h3>Loaded Modules</h3>
     <table class="responsive-table">
-        <tr>
-            <th>Module Path</th>
-        </tr>
-        {% for module in modules.names %}
-        <tr>
-            <td>{{ module }}</td>
-        </tr>
-        {% endfor %}
+      <tr>
+        <th>Module Path</th>
+      </tr>
+      {% for module in modules.names %}
+      <tr>
+        <td>{{ module }}</td>
+      </tr>
+      {% endfor %}
     </table>
 
-    <h3>Available Classes 
-        <span class="classes-count">({{ modules.total_count }})</span>
+    <h3>
+      Available Classes
+      <span class="classes-count">({{ modules.total_count }})</span>
     </h3>
     <table class="responsive-table">
-        <tr>
-            <th>Class Name</th>
-        </tr>
-        {% for class_name in modules.classes %}
-        <tr>
-            <td>{{ class_name }}</td>
-        </tr>
-        {% endfor %}
+      <tr>
+        <th>Class Name</th>
+      </tr>
+      {% for class_name in modules.classes %}
+      <tr>
+        <td>{{ class_name }}</td>
+      </tr>
+      {% endfor %}
     </table>
+  </div>
 </div>
 
 <!-- 返回顶部按钮 -->
 <button id="back-to-top" title="返回顶部">↑</button>
-{% endblock %}
-
-{% block scripts %}
-{{ super() }}
+{% endblock %} {% block scripts %} {{ super() }}
 <script>
-    // 在页面加载完成后执行初始化
-    document.addEventListener('DOMContentLoaded', function() {
-        initFolderOpener();
-        initCollapsibleRows();
-        initScrollToSections();
-        initBackToTop();
-        initWebSocket();
+  // 在页面加载完成后执行初始化
+  document.addEventListener('DOMContentLoaded', function () {
+    initFolderOpener();
+    initCollapsibleRows();
+    initCollapsibleHeaders();
+    initScrollToSections();
+    initBackToTop();
+    initWebSocket();
+    restoreCollapsibleStates(); // 恢复折叠状态
+  });
+
+  // 折叠状态管理
+  function saveCollapsibleState(elementId, isExpanded) {
+    try {
+      const states = JSON.parse(
+        localStorage.getItem('collapsibleStates') || '{}'
+      );
+      states[elementId] = isExpanded;
+      localStorage.setItem('collapsibleStates', JSON.stringify(states));
+    } catch (e) {
+      console.warn('无法保存折叠状态:', e);
+    }
+  }
+
+  function getCollapsibleState(elementId) {
+    try {
+      const states = JSON.parse(
+        localStorage.getItem('collapsibleStates') || '{}'
+      );
+      return states[elementId];
+    } catch (e) {
+      console.warn('无法读取折叠状态:', e);
+      return null;
+    }
+  }
+
+  function restoreCollapsibleStates() {
+    try {
+      // 恢复折叠行状态
+      const collapsibleRows = document.querySelectorAll(
+        '.collapsible-row[data-target]'
+      );
+      collapsibleRows.forEach((row) => {
+        const targetId = row.getAttribute('data-target');
+        const savedState = getCollapsibleState(targetId);
+        if (savedState !== null) {
+          const content = document.getElementById(targetId);
+          if (content) {
+            if (savedState) {
+              // 展开
+              row.classList.add('active');
+              content.style.display = 'table-row';
+              const indicator = row.querySelector('.toggle-indicator');
+              if (indicator) indicator.textContent = '▲';
+            } else {
+              // 折叠
+              row.classList.remove('active');
+              content.style.display = 'none';
+              const indicator = row.querySelector('.toggle-indicator');
+              if (indicator) indicator.textContent = '▼';
+            }
+          }
+        }
+      });
+
+      // 恢复折叠标题状态
+      const collapsibleHeaders = document.querySelectorAll(
+        '.collapsible-header[data-target]'
+      );
+      collapsibleHeaders.forEach((header) => {
+        const targetId = header.getAttribute('data-target');
+        const savedState = getCollapsibleState(targetId);
+        if (savedState !== null) {
+          const content = document.getElementById(targetId);
+          if (content) {
+            const indicator = header.querySelector('.toggle-indicator');
+            if (savedState) {
+              // 展开
+              content.style.display = 'block';
+              if (indicator) indicator.textContent = '▲';
+            } else {
+              // 折叠
+              content.style.display = 'none';
+              if (indicator) indicator.textContent = '▼';
+            }
+          }
+        }
+      });
+    } catch (e) {
+      console.warn('恢复折叠状态时出错:', e);
+    }
+  }
+
+  // WebSocket连接
+  let ws = null;
+  let reconnectAttempts = 0;
+  const maxReconnectAttempts = 5;
+  const reconnectDelay = 3000; // 3秒
+  let connectionStatusElement = null;
+
+  function showConnectionStatus(status, message) {
+    // 如果状态元素不存在，创建一个
+    if (!connectionStatusElement) {
+      connectionStatusElement = document.createElement('div');
+      connectionStatusElement.className = 'connection-status';
+      document.body.appendChild(connectionStatusElement);
+    }
+
+    connectionStatusElement.className = 'connection-status ' + status;
+    connectionStatusElement.innerHTML = `<span class="status-dot"></span><span class="status-text">${message}</span>`;
+
+    // 3秒后自动隐藏
+    if (status === 'connected') {
+      setTimeout(() => {
+        connectionStatusElement.style.opacity = '0';
+      }, 3000);
+    } else {
+      connectionStatusElement.style.opacity = '1';
+    }
+  }
+
+  function initWebSocket() {
+    // 获取WebSocket URL - 连接到状态页面专用端点
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${protocol}//${window.location.host}/api/v1/ws/status_page`;
+
+    showConnectionStatus('connecting', '正在连接服务器...');
+
+    ws = new WebSocket(wsUrl);
+
+    ws.onopen = function () {
+      console.log('状态页面WebSocket连接已建立');
+      showConnectionStatus('connected', '已连接到服务器');
+      reconnectAttempts = 0;
+
+      // 显示实时更新指示器
+      showLiveUpdateIndicator();
+
+      // 发送心跳保持连接
+      setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send('heartbeat');
+        }
+      }, 30000); // 每30秒发送一次心跳
+    };
+
+    ws.onmessage = function (event) {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === 'device_status') {
+          updateDeviceStatus(data.data);
+        } else if (data.type === 'static_data_init') {
+          // 初始化静态数据（只接收一次）
+          initStaticData(data.data);
+          updateLastRefreshTime();
+        } else if (data.type === 'incremental_update') {
+          // 处理增量更新
+          handleIncrementalUpdate(data.data);
+          updateLastRefreshTime();
+        }
+      } catch (error) {
+        console.error('处理WebSocket消息时出错:', error);
+      }
+    };
+
+    ws.onclose = function (event) {
+      console.log(
+        `WebSocket连接已关闭，代码: ${event.code}, 原因: ${event.reason}`
+      );
+
+      if (event.wasClean) {
+        showConnectionStatus('disconnected', '连接已正常关闭');
+      } else {
+        showConnectionStatus('error', '连接意外断开');
+      }
+
+      if (reconnectAttempts < maxReconnectAttempts) {
+        showConnectionStatus(
+          'reconnecting',
+          `正在尝试重新连接 (${
+            reconnectAttempts + 1
+          }/${maxReconnectAttempts})...`
+        );
+        setTimeout(initWebSocket, reconnectDelay);
+        reconnectAttempts++;
+      } else {
+        showConnectionStatus('error', '重连失败，请刷新页面重试');
+      }
+    };
+
+    ws.onerror = function (error) {
+      console.error('WebSocket错误:', error);
+      showConnectionStatus('error', 'WebSocket连接错误');
+    };
+  }
+
+  function updateDeviceStatus(data) {
+    const { device_status, device_status_timestamps } = data;
+
+    // 查找设备状态表格 - 在host-node-section下，寻找具有"设备状态"标题的host-section
+    const deviceStatusSections = Array.from(
+      document.querySelectorAll('#host-node-section .host-section h3')
+    )
+      .filter((h3) => h3.textContent.trim() === '设备状态')
+      .map((h3) => h3.parentElement);
+
+    if (deviceStatusSections.length === 0) {
+      console.log('未找到设备状态部分');
+      return;
+    }
+
+    const statusSection = deviceStatusSections[0];
+    const table = statusSection.querySelector('table.responsive-table');
+
+    if (!table) {
+      console.log('未找到设备状态表格');
+      return;
+    }
+
+    // 保存表头
+    const header = table.rows[0].cloneNode(true);
+
+    // 清空表格（保留表头）
+    while (table.rows.length > 1) {
+      table.deleteRow(1);
+    }
+
+    // 没有数据时显示空状态行
+    if (Object.keys(device_status).length === 0) {
+      const emptyRow = table.insertRow();
+      const emptyCell = emptyRow.insertCell();
+      emptyCell.colSpan = 4;
+      emptyCell.className = 'empty-state';
+      emptyCell.textContent = '没有设备状态数据';
+      return;
+    }
+
+    // 添加数据行
+    for (const [device_id, properties] of Object.entries(device_status)) {
+      const propNames = Object.keys(properties);
+
+      for (let i = 0; i < propNames.length; i++) {
+        const prop_name = propNames[i];
+        const prop_value = properties[prop_name];
+
+        const row = table.insertRow();
+
+        // 如果是设备的第一个属性，添加设备ID单元格
+        if (i === 0) {
+          const deviceCell = row.insertCell();
+          deviceCell.rowSpan = propNames.length;
+          deviceCell.textContent = device_id;
+        }
+
+        // 添加属性名称单元格
+        const propCell = row.insertCell();
+        propCell.textContent = prop_name;
+
+        // 添加属性值单元格
+        const valueCell = row.insertCell();
+        valueCell.textContent = prop_value;
+
+        // 添加时间戳单元格
+        const timestampCell = row.insertCell();
+        const tsInfo = device_status_timestamps[device_id]?.[prop_name];
+
+        if (tsInfo && tsInfo.elapsed >= 0) {
+          const timestampSpan = document.createElement('span');
+          timestampSpan.className = 'timestamp';
+          timestampSpan.setAttribute('title', tsInfo.timestamp);
+          timestampSpan.textContent = `${Math.round(tsInfo.elapsed)} 秒前`;
+          timestampCell.appendChild(timestampSpan);
+        } else {
+          const notUpdatedSpan = document.createElement('span');
+          notUpdatedSpan.className = 'timestamp not-updated';
+          notUpdatedSpan.textContent = '未更新';
+          timestampCell.appendChild(notUpdatedSpan);
+        }
+      }
+    }
+  }
+
+  // 处理主机节点可用性状态变化
+  function handleHostNodeAvailabilityChange(isHostMode, hostNodeInfo) {
+    const hostSection = document.getElementById('host-node-section');
+    const hostNavLink = document.querySelector('a[href="#host-node-section"]');
+
+    // 检查是否需要显示主机节点部分
+    const shouldShowHostNode =
+      isHostMode && hostNodeInfo && hostNodeInfo.available;
+
+    if (shouldShowHostNode && !hostSection) {
+      // 主机节点从不可用变为可用，需要创建HTML
+      console.log('创建主机节点部分HTML');
+      createHostNodeSection(hostNodeInfo);
+
+      // 添加导航链接
+      if (!hostNavLink) {
+        addHostNodeNavLink();
+      }
+    } else if (!shouldShowHostNode && hostSection) {
+      // 主机节点从可用变为不可用，隐藏或移除
+      console.log('隐藏主机节点部分');
+      hostSection.style.display = 'none';
+
+      // 移除导航链接
+      if (hostNavLink) {
+        hostNavLink.remove();
+      }
+    } else if (shouldShowHostNode && hostSection) {
+      // 主机节点仍然可用，确保显示
+      hostSection.style.display = 'block';
+
+      // 确保导航链接存在
+      if (!hostNavLink) {
+        addHostNodeNavLink();
+      }
+    }
+  }
+
+  // 创建主机节点部分HTML
+  function createHostNodeSection(hostNodeInfo) {
+    const onlineDevicesSection = document.getElementById(
+      'online-devices-section'
+    );
+    if (!onlineDevicesSection) {
+      console.warn('找不到插入位置');
+      return;
+    }
+
+    const hostSectionHtml = `
+      <div class="card" id="host-node-section">
+        <h2>主机节点信息</h2>
+        
+        <!-- 主机控制的设备 -->
+        <div class="host-section">
+          <h3>
+            已管理设备
+            <span class="count-badge">0</span>
+          </h3>
+          <table class="responsive-table">
+            <tr>
+              <th>设备ID</th>
+              <th>命名空间</th>
+              <th>机器名称</th>
+              <th>状态</th>
+            </tr>
+            <tr>
+              <td colspan="4" class="empty-state">没有发现已管理的设备</td>
+            </tr>
+          </table>
+        </div>
+
+        <!-- 主机的动作客户端 -->
+        <div class="host-section">
+          <h3>
+            动作客户端
+            <span class="count-badge">0</span>
+          </h3>
+          <div class="collapsible-table">
+            <h4>已接纳动作:</h4>
+            <table class="inner-table">
+              <tr>
+                <th>话题</th>
+                <th>类型</th>
+                <th></th>
+              </tr>
+            </table>
+          </div>
+        </div>
+
+        <!-- 主机已订阅的主题 -->
+        <div class="host-section">
+          <h3>
+            已订阅主题
+            <span class="count-badge">0</span>
+          </h3>
+          <div class="topics-container">
+            <div class="empty-state">没有发现已订阅的主题</div>
+          </div>
+        </div>
+
+        <!-- 设备状态 -->
+        <div class="host-section">
+          <h3>设备状态</h3>
+          <table class="responsive-table">
+            <tr>
+              <th>设备ID</th>
+              <th>属性</th>
+              <th>值</th>
+              <th>最后更新</th>
+            </tr>
+            <tr>
+              <td colspan="4" class="empty-state">没有设备状态数据</td>
+            </tr>
+          </table>
+        </div>
+      </div>
+    `;
+
+    // 在本地设备部分之前插入主机节点部分
+    onlineDevicesSection.insertAdjacentHTML('beforebegin', hostSectionHtml);
+
+    console.log('主机节点部分HTML已创建');
+  }
+
+  // 添加主机节点导航链接
+  function addHostNodeNavLink() {
+    const navTabs = document.querySelector('.nav-tabs');
+    const onlineDevicesNavLink = document.querySelector(
+      'a[href="#online-devices-section"]'
+    );
+
+    if (navTabs && onlineDevicesNavLink) {
+      const hostNavLink = document.createElement('a');
+      hostNavLink.href = '#host-node-section';
+      hostNavLink.className = 'nav-tab';
+      hostNavLink.textContent = '主机节点';
+
+      // 在"本地设备"链接之前插入
+      navTabs.insertBefore(hostNavLink, onlineDevicesNavLink);
+
+      // 添加点击事件
+      hostNavLink.addEventListener('click', function (e) {
+        e.preventDefault();
+        const targetElement = document.querySelector('#host-node-section');
+        if (targetElement) {
+          targetElement.scrollIntoView({ behavior: 'smooth' });
+        }
+      });
+
+      console.log('主机节点导航链接已添加');
+    }
+  }
+
+  // 初始化静态数据（只接收一次）
+  function initStaticData(data) {
+    console.log('初始化静态数据', data);
+
+    // 更新设备类型表格
+    if (data.devices) {
+      updateDevicesTable(data.devices);
+    }
+
+    // 更新资源类型表格
+    if (data.resources) {
+      updateResourcesTable(data.resources);
+    }
+
+    // 更新模块信息表格
+    if (data.modules) {
+      updateModulesTable(data.modules);
+    }
+
+    // 初始化主机节点信息（如果是主机模式）
+    if (data.host_node_info && data.is_host_mode) {
+      const isHostMode = data.is_host_mode;
+      handleHostNodeAvailabilityChange(isHostMode, data.host_node_info);
+
+      // 初始化主机节点各个部分
+      if (data.host_node_info.available) {
+        if (data.host_node_info.devices) {
+          updateHostDevicesTable(data.host_node_info.devices);
+        }
+        if (data.host_node_info.action_clients) {
+          updateHostActionClients(data.host_node_info.action_clients);
+        }
+        if (data.host_node_info.subscribed_topics) {
+          updateHostSubscribedTopics(data.host_node_info.subscribed_topics);
+        }
+        if (data.host_node_info.device_status) {
+          updateDeviceStatus({
+            device_status: data.host_node_info.device_status,
+            device_status_timestamps:
+              data.host_node_info.device_status_timestamps,
+          });
+        }
+      }
+    }
+
+    // 初始化本地设备信息
+    if (data.ros_node_info) {
+      updateLocalDevicesTable(data.ros_node_info);
+    }
+
+    // 这些是真正的静态数据，页面生命周期内不会变化
+    console.log('静态数据初始化完成');
+  }
+
+  // 处理增量更新
+  function handleIncrementalUpdate(data) {
+    console.log('处理增量更新', data);
+
+    // 检查并处理主机节点信息变化（只处理包含的字段）
+    if (data.host_node_info) {
+      // 获取当前是否为主机模式（从页面初始数据获取）
+      const isHostMode =
+        document.querySelector('.mode-indicator.host-mode') !== null;
+
+      // 检查可用性变化
+      if ('available' in data.host_node_info) {
+        handleHostNodeAvailabilityChange(isHostMode, data.host_node_info);
+      }
+
+      // 只更新包含的字段，避免不必要的DOM操作
+      if ('device_status' in data.host_node_info) {
+        updateDeviceStatus({
+          device_status: data.host_node_info.device_status,
+          device_status_timestamps:
+            data.host_node_info.device_status_timestamps,
+        });
+      }
+
+      if ('devices' in data.host_node_info) {
+        updateHostDevicesTable(data.host_node_info.devices);
+      }
+
+      if ('action_clients' in data.host_node_info) {
+        updateHostActionClients(data.host_node_info.action_clients);
+      }
+
+      if ('subscribed_topics' in data.host_node_info) {
+        updateHostSubscribedTopics(data.host_node_info.subscribed_topics);
+      }
+    }
+
+    // 只有当ros_node_info存在时才更新本地设备（表示发生了变更）
+    if (data.ros_node_info && data.ros_node_info.registered_devices) {
+      console.log('更新本地设备表格');
+      updateLocalDevicesTable(data.ros_node_info);
+    }
+  }
+
+  // 更新设备类型表格
+  function updateDevicesTable(devices) {
+    const table = document.querySelector('#devices-table .responsive-table');
+    if (!table) return;
+
+    // 保存表头
+    const header = table.rows[0].cloneNode(true);
+
+    // 清空表格（保留表头）
+    while (table.rows.length > 1) {
+      table.deleteRow(1);
+    }
+
+    // 添加设备数据行
+    devices.forEach((device, index) => {
+      const row = table.insertRow();
+      row.className = 'collapsible-row';
+      row.setAttribute('data-target', `device-info-${index + 1}`);
+
+      row.innerHTML = `
+          <td>${device.id}</td>
+          <td>${device.name || '未命名'}</td>
+          <td class="file-path">
+            ${device.file_path || ''}
+            <span class="folder-link" onclick="openFolder('${
+              device.file_path
+            }'); event.stopPropagation();" title="打开文件夹">📁</span>
+          </td>
+          <td><span class="toggle-indicator">▼</span></td>
+        `;
+
+      // 添加详情行
+      const detailRow = table.insertRow();
+      detailRow.id = `device-info-${index + 1}`;
+      detailRow.className = 'detail-row';
+      detailRow.style.display = 'none';
+
+      const detailCell = detailRow.insertCell();
+      detailCell.colSpan = 5;
+
+      let deviceClassInfo = '';
+      if (device.class) {
+        try {
+          deviceClassInfo = JSON.stringify(device.class, null, 4);
+        } catch (e) {
+          deviceClassInfo = '// 数据格式错误';
+        }
+      } else {
+        deviceClassInfo = '// No data';
+      }
+
+      detailCell.innerHTML = `
+          <div class="content-full">
+            <pre>${deviceClassInfo}</pre>
+          </div>
+        `;
     });
 
-    // WebSocket连接
-    let ws = null;
-    let reconnectAttempts = 0;
-    const maxReconnectAttempts = 5;
-    const reconnectDelay = 3000; // 3秒
-    let connectionStatusElement = null;
-    
-    function showConnectionStatus(status, message) {
-        // 如果状态元素不存在，创建一个
-        if (!connectionStatusElement) {
-            connectionStatusElement = document.createElement('div');
-            connectionStatusElement.className = 'connection-status';
-            document.body.appendChild(connectionStatusElement);
-        }
-        
-        connectionStatusElement.className = 'connection-status ' + status;
-        connectionStatusElement.innerHTML = `<span class="status-dot"></span><span class="status-text">${message}</span>`;
-        
-        // 3秒后自动隐藏
-        if (status === 'connected') {
-            setTimeout(() => {
-                connectionStatusElement.style.opacity = '0';
-            }, 3000);
-        } else {
-            connectionStatusElement.style.opacity = '1';
-        }
+    // 延迟恢复状态，确保DOM更新完成
+    setTimeout(restoreCollapsibleStates, 100);
+  }
+
+  // 更新资源类型表格
+  function updateResourcesTable(resources) {
+    const table = document.querySelector('#resources-table .responsive-table');
+    if (!table) return;
+
+    // 清空表格（保留表头）
+    while (table.rows.length > 1) {
+      table.deleteRow(1);
     }
 
-    function initWebSocket() {
-        // 获取WebSocket URL
-        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsUrl = `${protocol}//${window.location.host}/api/v1/ws/device_status`;
-        
-        showConnectionStatus('connecting', '正在连接服务器...');
-        
-        ws = new WebSocket(wsUrl);
-        
-        ws.onopen = function() {
-            console.log('WebSocket连接已建立');
-            showConnectionStatus('connected', '已连接到服务器');
-            reconnectAttempts = 0;
-        };
-        
-        ws.onmessage = function(event) {
-            try {
-                const data = JSON.parse(event.data);
-                if (data.type === 'device_status') {
-                    updateDeviceStatus(data.data);
-                }
-            } catch (error) {
-                console.error('处理WebSocket消息时出错:', error);
-            }
-        };
-        
-        ws.onclose = function(event) {
-            console.log(`WebSocket连接已关闭，代码: ${event.code}, 原因: ${event.reason}`);
-            
-            if (event.wasClean) {
-                showConnectionStatus('disconnected', '连接已正常关闭');
-            } else {
-                showConnectionStatus('error', '连接意外断开');
-            }
-            
-            if (reconnectAttempts < maxReconnectAttempts) {
-                showConnectionStatus('reconnecting', `正在尝试重新连接 (${reconnectAttempts + 1}/${maxReconnectAttempts})...`);
-                setTimeout(initWebSocket, reconnectDelay);
-                reconnectAttempts++;
-            } else {
-                showConnectionStatus('error', '重连失败，请刷新页面重试');
-            }
-        };
-        
-        ws.onerror = function(error) {
-            console.error('WebSocket错误:', error);
-            showConnectionStatus('error', 'WebSocket连接错误');
-        };
+    // 添加资源数据行
+    resources.forEach((resource) => {
+      const row = table.insertRow();
+      row.innerHTML = `
+          <td>${resource.id}</td>
+          <td>${resource.name}</td>
+          <td class="file-path">
+            ${resource.file_path}
+            <span class="folder-link" onclick="openFolder('${resource.file_path}')" title="打开文件夹">📁</span>
+          </td>
+        `;
+    });
+  }
+
+  // 更新模块信息表格
+  function updateModulesTable(modules) {
+    // 更新模块列表
+    const moduleTable = document.querySelector(
+      '#modules-content table:first-of-type'
+    );
+    if (moduleTable) {
+      while (moduleTable.rows.length > 1) {
+        moduleTable.deleteRow(1);
+      }
+
+      modules.names.forEach((moduleName) => {
+        const row = moduleTable.insertRow();
+        row.innerHTML = `<td>${moduleName}</td>`;
+      });
     }
 
-    function updateDeviceStatus(data) {
-        const { device_status, device_status_timestamps } = data;
-        
-        // 查找设备状态表格 - 在host-node-section下，寻找具有"设备状态"标题的host-section
-        const deviceStatusSections = Array.from(document.querySelectorAll('#host-node-section .host-section h3'))
-            .filter(h3 => h3.textContent.trim() === '设备状态')
-            .map(h3 => h3.parentElement);
-            
-        if (deviceStatusSections.length === 0) {
-            console.log('未找到设备状态部分');
-            return;
-        }
-        
-        const statusSection = deviceStatusSections[0];
-        const table = statusSection.querySelector('table.responsive-table');
-        
-        if (!table) {
-            console.log('未找到设备状态表格');
-            return;
-        }
-        
-        // 保存表头
-        const header = table.rows[0].cloneNode(true);
-        
-        // 清空表格（保留表头）
-        while (table.rows.length > 1) {
-            table.deleteRow(1);
-        }
-        
-        // 没有数据时显示空状态行
-        if (Object.keys(device_status).length === 0) {
-            const emptyRow = table.insertRow();
-            const emptyCell = emptyRow.insertCell();
-            emptyCell.colSpan = 4;
-            emptyCell.className = 'empty-state';
-            emptyCell.textContent = '没有设备状态数据';
-            return;
-        }
-        
-        // 添加数据行
-        for (const [device_id, properties] of Object.entries(device_status)) {
-            const propNames = Object.keys(properties);
-            
-            for (let i = 0; i < propNames.length; i++) {
-                const prop_name = propNames[i];
-                const prop_value = properties[prop_name];
-                
-                const row = table.insertRow();
-                
-                // 如果是设备的第一个属性，添加设备ID单元格
-                if (i === 0) {
-                    const deviceCell = row.insertCell();
-                    deviceCell.rowSpan = propNames.length;
-                    deviceCell.textContent = device_id;
-                }
-                
-                // 添加属性名称单元格
-                const propCell = row.insertCell();
-                propCell.textContent = prop_name;
-                
-                // 添加属性值单元格
-                const valueCell = row.insertCell();
-                valueCell.textContent = prop_value;
-                
-                // 添加时间戳单元格
-                const timestampCell = row.insertCell();
-                const tsInfo = device_status_timestamps[device_id]?.[prop_name];
-                
-                if (tsInfo && tsInfo.elapsed >= 0) {
-                    const timestampSpan = document.createElement('span');
-                    timestampSpan.className = 'timestamp';
-                    timestampSpan.setAttribute('title', tsInfo.timestamp);
-                    timestampSpan.textContent = `${Math.round(tsInfo.elapsed)} 秒前`;
-                    timestampCell.appendChild(timestampSpan);
-                } else {
-                    const notUpdatedSpan = document.createElement('span');
-                    notUpdatedSpan.className = 'timestamp not-updated';
-                    notUpdatedSpan.textContent = '未更新';
-                    timestampCell.appendChild(notUpdatedSpan);
-                }
-            }
-        }
+    // 更新类列表和计数
+    const classesHeader = document.querySelector(
+      '#modules-content h3 .classes-count'
+    );
+    if (classesHeader) {
+      classesHeader.textContent = `(${modules.total_count})`;
     }
 
-    // 文件夹打开功能
-    function initFolderOpener() {
-        function openFolder(path) {
-            if (!path) {
-                alert("路径为空");
-                return;
-            }
-            
-            // 对于Windows路径，确保格式正确
-            const formattedPath = path.includes(':\\') ? path : path.replace(':', ':\\');
-            
-            fetch(`/open-folder?path=${encodeURIComponent(formattedPath)}`)
-                .then(response => response.json())
-                .then(data => {
-                    if (data.status === 'error') {
-                        alert('错误: ' + data.message);
-                    }
-                })
-                .catch(error => {
-                    console.error('Error:', error);
-                    alert('请求失败: ' + error);
-                });
-        }
-        
-        // 确保openFolder函数在全局范围内可用
-        window.openFolder = openFolder;
+    const classTable = document.querySelector(
+      '#modules-content table:last-of-type'
+    );
+    if (classTable) {
+      while (classTable.rows.length > 1) {
+        classTable.deleteRow(1);
+      }
+
+      modules.classes.forEach((className) => {
+        const row = classTable.insertRow();
+        row.innerHTML = `<td>${className}</td>`;
+      });
     }
-    
-    // 折叠行功能
-    function initCollapsibleRows() {
-        // 设备行点击事件
-        const deviceRows = document.querySelectorAll('.collapsible-row');
-        deviceRows.forEach(row => {
-            row.addEventListener("click", function() {
-                const targetId = this.getAttribute('data-target');
-                if (!targetId) return;
-                
-                const content = document.getElementById(targetId);
-                if (!content) return;
-                
-                this.classList.toggle("active");
-                
-                if (content.style.display === "table-row") {
-                    content.style.display = "none";
-                    const indicator = this.querySelector('.toggle-indicator');
-                    if (indicator) indicator.textContent = "▼";
-                } else {
-                    content.style.display = "table-row";
-                    const indicator = this.querySelector('.toggle-indicator');
-                    if (indicator) indicator.textContent = "▲";
-                }
-            });
-        });
-        
-        // 子行点击事件（状态和动作行）
-        const subRows = document.querySelectorAll('.collapsible-sub-row');
-        subRows.forEach(row => {
-            row.addEventListener("click", function(e) {
-                const targetId = this.getAttribute('data-target');
-                if (!targetId) return;
-                
-                const content = document.getElementById(targetId);
-                if (!content) return;
-                
-                if (content.style.display === "table-row" || content.style.display === "") {
-                    content.style.display = "none";
-                    const indicator = this.querySelector('.toggle-sub-indicator');
-                    if (indicator) indicator.textContent = "▼";
-                } else {
-                    content.style.display = "table-row";
-                    const indicator = this.querySelector('.toggle-sub-indicator');
-                    if (indicator) indicator.textContent = "▲";
-                }
-                
-                // 阻止事件冒泡
-                e.stopPropagation();
-            });
+  }
+
+  // 更新主机设备管理表格
+  function updateHostDevicesTable(devices) {
+    // 查找已管理设备部分的表格
+    const hostSection = document.getElementById('host-node-section');
+    if (!hostSection) {
+      console.log('主机节点部分不存在');
+      return;
+    }
+
+    const deviceManagementSection = Array.from(
+      hostSection.querySelectorAll('.host-section')
+    ).find((section) => {
+      const h3 = section.querySelector('h3');
+      return h3 && h3.textContent.includes('已管理设备');
+    });
+
+    if (!deviceManagementSection) {
+      console.log('已管理设备部分不存在');
+      return;
+    }
+
+    const table = deviceManagementSection.querySelector('.responsive-table');
+    if (!table) {
+      console.log('已管理设备表格不存在');
+      return;
+    }
+
+    // 清空表格（保留表头）
+    while (table.rows.length > 1) {
+      table.deleteRow(1);
+    }
+
+    // 更新设备数量显示
+    const countBadge = deviceManagementSection.querySelector('.count-badge');
+    const deviceCount = Object.keys(devices).length;
+    if (countBadge) {
+      countBadge.textContent = deviceCount;
+    }
+
+    if (deviceCount === 0) {
+      const emptyRow = table.insertRow();
+      const emptyCell = emptyRow.insertCell();
+      emptyCell.colSpan = 4;
+      emptyCell.className = 'empty-state';
+      emptyCell.textContent = '没有发现已管理的设备';
+      return;
+    }
+
+    // 添加设备数据行
+    for (const [deviceId, deviceInfo] of Object.entries(devices)) {
+      const row = table.insertRow();
+      row.innerHTML = `
+          <td>${deviceId}</td>
+          <td>${deviceInfo.namespace || ''}</td>
+          <td>${deviceInfo.machine_name || ''}</td>
+          <td><span class="status-badge online">${
+            deviceInfo.is_online ? '在线' : '离线'
+          }</span></td>
+        `;
+    }
+  }
+
+  // 更新主机动作客户端
+  function updateHostActionClients(actionClients) {
+    const hostSection = document.getElementById('host-node-section');
+    if (!hostSection) return;
+
+    // 查找动作客户端部分
+    const actionClientsSection = Array.from(
+      hostSection.querySelectorAll('.host-section')
+    ).find((section) => {
+      const h3 = section.querySelector('h3');
+      return h3 && h3.textContent.includes('动作客户端');
+    });
+
+    if (!actionClientsSection) return;
+
+    // 更新计数显示
+    const countBadge = actionClientsSection.querySelector('.count-badge');
+    const actionCount = Object.keys(actionClients).length;
+    if (countBadge) {
+      countBadge.textContent = actionCount;
+    }
+
+    // 查找内部表格
+    const innerTable = actionClientsSection.querySelector('.inner-table');
+    if (!innerTable) return;
+
+    // 清空表格（保留表头）
+    while (innerTable.rows.length > 1) {
+      innerTable.deleteRow(1);
+    }
+
+    // 添加动作客户端数据
+    if (actionCount === 0) {
+      const emptyRow = innerTable.insertRow();
+      const emptyCell = emptyRow.insertCell();
+      emptyCell.colSpan = 3;
+      emptyCell.className = 'empty-state';
+      emptyCell.textContent = '没有动作客户端';
+      return;
+    }
+
+    let index = 1;
+    for (const [actionName, actionInfo] of Object.entries(actionClients)) {
+      // 主行
+      const row = innerTable.insertRow();
+      row.className = 'action-row collapsible-sub-row';
+      row.setAttribute('data-target', `host-action-cmd-${index}`);
+      row.innerHTML = `
+        <td>${actionName}</td>
+        <td>${actionInfo.type_name || ''}</td>
+        <td><span class="toggle-sub-indicator">▼</span></td>
+      `;
+
+      // 命令行
+      const cmdRow = innerTable.insertRow();
+      cmdRow.id = `host-action-cmd-${index}`;
+      cmdRow.className = 'cmd-row';
+      cmdRow.style.display = 'none';
+      cmdRow.innerHTML = `
+        <td colspan="5">
+          <div class="cmd-block">
+            <strong>发送命令:</strong>
+            <div class="cmd-line">
+              <pre>ros2 action send_goal ${actionInfo.action_path} ${actionInfo.type_name_convert} "${actionInfo.goal_info}"</pre>
+              <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
+            </div>
+            <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
+          </div>
+        </td>
+      `;
+
+      index++;
+    }
+
+    // 事件委托已经处理了动态添加的元素，不需要重新初始化
+  }
+
+  // 更新主机订阅主题
+  function updateHostSubscribedTopics(subscribedTopics) {
+    const hostSection = document.getElementById('host-node-section');
+    if (!hostSection) return;
+
+    // 查找已订阅主题部分
+    const topicsSection = Array.from(
+      hostSection.querySelectorAll('.host-section')
+    ).find((section) => {
+      const h3 = section.querySelector('h3');
+      return h3 && h3.textContent.includes('已订阅主题');
+    });
+
+    if (!topicsSection) return;
+
+    // 更新计数显示
+    const countBadge = topicsSection.querySelector('.count-badge');
+    const topicsCount = subscribedTopics.length;
+    if (countBadge) {
+      countBadge.textContent = topicsCount;
+    }
+
+    // 查找主题容器
+    const topicsContainer = topicsSection.querySelector('.topics-container');
+    if (!topicsContainer) return;
+
+    // 清空容器
+    topicsContainer.innerHTML = '';
+
+    if (topicsCount === 0) {
+      topicsContainer.innerHTML =
+        '<div class="empty-state">没有发现已订阅的主题</div>';
+      return;
+    }
+
+    // 添加主题列表
+    const topicsList = document.createElement('div');
+    topicsList.className = 'topics-list';
+
+    subscribedTopics.forEach((topic) => {
+      const topicItem = document.createElement('div');
+      topicItem.className = 'topic-item';
+      topicItem.innerHTML = `
+        <span class="topic-name">${topic}</span>
+        <button class="copy-btn small" onclick="copyToClipboard('${topic}', event)" title="复制主题名">复制</button>
+      `;
+      topicsList.appendChild(topicItem);
+    });
+
+    topicsContainer.appendChild(topicsList);
+  }
+
+  // 更新本地设备表格
+  function updateLocalDevicesTable(rosNodeInfo) {
+    const table = document.querySelector(
+      '#online-devices-section .responsive-table'
+    );
+    if (!table) return;
+
+    // 清空表格（保留表头）
+    while (table.rows.length > 1) {
+      table.deleteRow(1);
+    }
+
+    const devices = rosNodeInfo.registered_devices || {};
+    const deviceTopics = rosNodeInfo.device_topics || {};
+    const deviceActions = rosNodeInfo.device_actions || {};
+
+    if (Object.keys(devices).length === 0) {
+      const emptyRow = table.insertRow();
+      const emptyCell = emptyRow.insertCell();
+      emptyCell.colSpan = 6;
+      emptyCell.className = 'empty-state';
+      emptyCell.textContent = '没有发现本地设备';
+      return;
+    }
+
+    // 添加设备数据行
+    let deviceIndex = 0;
+    for (const [deviceId, deviceInfo] of Object.entries(devices)) {
+      deviceIndex++;
+
+      // 主行
+      const row = table.insertRow();
+      row.className = 'collapsible-row device-row';
+      row.setAttribute('data-target', `device-detail-${deviceIndex}`);
+
+      const topicsCount = Object.keys(deviceTopics[deviceId] || {}).length;
+      const actionsCount = Object.keys(deviceActions[deviceId] || {}).length;
+
+      row.innerHTML = `
+          <td>${deviceId}</td>
+          <td>${deviceInfo.node_name || ''}</td>
+          <td>${deviceInfo.namespace || ''}</td>
+          <td>${deviceInfo.machine_name || '本地'}</td>
+          <td>${topicsCount}</td>
+          <td>${actionsCount} <span class="toggle-indicator">▼</span></td>
+        `;
+
+      // 详情行
+      const detailRow = table.insertRow();
+      detailRow.id = `device-detail-${deviceIndex}`;
+      detailRow.className = 'detail-row';
+      detailRow.style.display = 'none';
+
+      const detailCell = detailRow.insertCell();
+      detailCell.colSpan = 5;
+
+      let detailContent = `<div class="content-full">UUID: ${
+        deviceInfo.uuid || ''
+      }`;
+
+      // 添加状态发布者信息
+      if (
+        deviceTopics[deviceId] &&
+        Object.keys(deviceTopics[deviceId]).length > 0
+      ) {
+        detailContent += '<h4>已发布状态:</h4><table class="inner-table">';
+        detailContent +=
+          '<tr><th>名称</th><th>类型</th><th>话题</th><th>间隔</th><th></th></tr>';
+
+        Object.entries(deviceTopics[deviceId]).forEach(
+          ([statusName, statusInfo], statusIndex) => {
+            detailContent += `
+              <tr class="topic-row collapsible-sub-row" data-target="topic-cmd-${
+                statusIndex + 1
+              }-${deviceIndex}">
+                <td>${statusName}</td>
+                <td>${statusInfo.type_name || ''}</td>
+                <td>${statusInfo.topic_path || ''}</td>
+                <td>${statusInfo.timer_period || ''}</td>
+                <td><span class="toggle-sub-indicator">▼</span></td>
+              </tr>
+              <tr id="topic-cmd-${
+                statusIndex + 1
+              }-${deviceIndex}" class="cmd-row" style="display: none;">
+                <td colspan="5">
+                  <div class="cmd-block">
+                    <strong>订阅命令:</strong>
+                    <div class="cmd-line">
+                      <pre>ros2 topic echo ${statusInfo.topic_path}</pre>
+                      <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
+                    </div>
+                  </div>
+                </td>
+              </tr>
+            `;
+          }
+        );
+
+        detailContent += '</table>';
+      }
+
+      // 添加已发布动作信息
+      if (
+        deviceActions[deviceId] &&
+        Object.keys(deviceActions[deviceId]).length > 0
+      ) {
+        detailContent += '<h4>已发布动作:</h4><table class="inner-table">';
+        detailContent +=
+          '<tr><th>名称</th><th>类型</th><th>话题</th><th></th></tr>';
+
+        Object.entries(deviceActions[deviceId]).forEach(
+          ([actionName, actionInfo], actionIndex) => {
+            detailContent += `
+              <tr class="action-row collapsible-sub-row" data-target="action-cmd-${
+                actionIndex + 1
+              }-${deviceIndex}">
+                <td>${actionName}</td>
+                <td>${actionInfo.type_name || ''}</td>
+                <td>${actionInfo.action_path || ''}</td>
+                <td><span class="toggle-sub-indicator">▼</span></td>
+              </tr>
+              <tr id="action-cmd-${
+                actionIndex + 1
+              }-${deviceIndex}" class="cmd-row" style="display: none;">
+                <td colspan="5">
+                  <div class="cmd-block">
+                    <strong>发送命令:</strong>
+                    <div class="cmd-line">
+                      <pre>ros2 action send_goal ${actionInfo.action_path} ${
+              actionInfo.type_name_convert
+            } "${actionInfo.goal_info}"</pre>
+                      <button class="copy-btn" onclick="copyToClipboard(this.previousElementSibling.textContent, event)">复制</button>
+                    </div>
+                    <p class="goal-tip">提示: 根据目标结构修改命令参数</p>
+                  </div>
+                </td>
+              </tr>
+            `;
+          }
+        );
+
+        detailContent += '</table>';
+      }
+
+      detailContent += '</div>';
+      detailCell.innerHTML = detailContent;
+    }
+
+    // 延迟恢复状态，确保DOM更新完成
+    setTimeout(restoreCollapsibleStates, 100);
+  }
+
+  // 文件夹打开功能
+  function initFolderOpener() {
+    function openFolder(path) {
+      if (!path) {
+        alert('路径为空');
+        return;
+      }
+
+      // 对于Windows路径，确保格式正确
+      const formattedPath = path.includes(':\\')
+        ? path
+        : path.replace(':', ':\\');
+
+      fetch(`/open-folder?path=${encodeURIComponent(formattedPath)}`)
+        .then((response) => response.json())
+        .then((data) => {
+          if (data.status === 'error') {
+            alert('错误: ' + data.message);
+          }
+        })
+        .catch((error) => {
+          console.error('Error:', error);
+          alert('请求失败: ' + error);
         });
     }
-    
-    // 初始化导航标签跳转
-    function initScrollToSections() {
-        const navTabs = document.querySelectorAll('.nav-tab');
-        navTabs.forEach(tab => {
-            tab.addEventListener('click', function(e) {
-                e.preventDefault();
-                const targetId = this.getAttribute('href');
-                if (targetId && targetId.startsWith('#')) {
-                    const targetElement = document.querySelector(targetId);
-                    if (targetElement) {
-                        targetElement.scrollIntoView({
-                            behavior: 'smooth'
-                        });
-                    }
-                }
-            });
-        });
+
+    // 确保openFolder函数在全局范围内可用
+    window.openFolder = openFolder;
+  }
+
+  // 折叠行功能 - 使用事件委托避免重复绑定问题
+  function initCollapsibleRows() {
+    // 移除旧的事件监听器（如果存在）
+    document.removeEventListener('click', handleCollapsibleRowClick);
+    document.removeEventListener('click', handleCollapsibleSubRowClick);
+
+    // 使用事件委托处理主折叠行点击
+    document.addEventListener('click', handleCollapsibleRowClick);
+
+    // 使用事件委托处理子行点击
+    document.addEventListener('click', handleCollapsibleSubRowClick);
+  }
+
+  // 处理主折叠行点击
+  function handleCollapsibleRowClick(e) {
+    const row = e.target.closest('.collapsible-row:not(.collapsible-sub-row)');
+    if (!row) return;
+
+    const targetId = row.getAttribute('data-target');
+    if (!targetId) return;
+
+    const content = document.getElementById(targetId);
+    if (!content) return;
+
+    // 阻止事件冒泡到其他处理器
+    e.stopPropagation();
+
+    row.classList.toggle('active');
+
+    const isExpanding = content.style.display !== 'table-row';
+
+    if (content.style.display === 'table-row') {
+      content.style.display = 'none';
+      const indicator = row.querySelector('.toggle-indicator');
+      if (indicator) indicator.textContent = '▼';
+      saveCollapsibleState(targetId, false); // 保存折叠状态
+    } else {
+      content.style.display = 'table-row';
+      const indicator = row.querySelector('.toggle-indicator');
+      if (indicator) indicator.textContent = '▲';
+      saveCollapsibleState(targetId, true); // 保存展开状态
     }
-    
-    // 初始化返回顶部按钮
-    function initBackToTop() {
-        const backToTopBtn = document.getElementById("back-to-top");
-        if (!backToTopBtn) return;
-        
-        // 显示/隐藏按钮
-        window.addEventListener('scroll', function() {
-            if (document.body.scrollTop > 20 || document.documentElement.scrollTop > 20) {
-                backToTopBtn.style.display = "block";
-            } else {
-                backToTopBtn.style.display = "none";
-            }
-        });
-        
-        // 点击返回顶部
-        backToTopBtn.addEventListener('click', function() {
-            window.scrollTo({
-                top: 0,
-                behavior: 'smooth'
-            });
-        });
+  }
+
+  // 处理子行点击（状态和动作行）
+  function handleCollapsibleSubRowClick(e) {
+    const subRow = e.target.closest('.collapsible-sub-row');
+    if (!subRow) return;
+
+    const targetId = subRow.getAttribute('data-target');
+    if (!targetId) return;
+
+    const content = document.getElementById(targetId);
+    if (!content) return;
+
+    // 阻止事件冒泡
+    e.stopPropagation();
+
+    if (content.style.display === 'table-row' || content.style.display === '') {
+      content.style.display = 'none';
+      const indicator = subRow.querySelector('.toggle-sub-indicator');
+      if (indicator) indicator.textContent = '▼';
+      saveCollapsibleState(targetId, false); // 保存折叠状态
+    } else {
+      content.style.display = 'table-row';
+      const indicator = subRow.querySelector('.toggle-sub-indicator');
+      if (indicator) indicator.textContent = '▲';
+      saveCollapsibleState(targetId, true); // 保存展开状态
     }
-    
-    // 复制功能
-    function copyToClipboard(text, event) {
-        if (event) event.stopPropagation();
-        const textToCopy = text.trim();
-        
-        // 使用现代API复制
-        if (navigator.clipboard && navigator.clipboard.writeText) {
-            navigator.clipboard.writeText(textToCopy)
-                .then(() => {
-                    showCopySuccess(event.target);
-                })
-                .catch(err => {
-                    console.error('复制失败: ', err);
-                    fallbackCopy(textToCopy, event.target);
-                });
+  }
+
+  // 折叠标题功能
+  function initCollapsibleHeaders() {
+    const headers = document.querySelectorAll('.collapsible-header');
+    headers.forEach((header) => {
+      header.addEventListener('click', function () {
+        const targetId = this.getAttribute('data-target');
+        if (!targetId) return;
+
+        const content = document.getElementById(targetId);
+        if (!content) return;
+
+        const indicator = this.querySelector('.toggle-indicator');
+
+        if (content.style.display === 'none') {
+          content.style.display = 'block';
+          if (indicator) indicator.textContent = '▲';
+          saveCollapsibleState(targetId, true); // 保存展开状态
         } else {
-            fallbackCopy(textToCopy, event.target);
+          content.style.display = 'none';
+          if (indicator) indicator.textContent = '▼';
+          saveCollapsibleState(targetId, false); // 保存折叠状态
         }
-    }
-    
-    // 复制功能的后备方案
-    function fallbackCopy(text, button) {
-        const textarea = document.createElement('textarea');
-        textarea.value = text;
-        textarea.style.position = 'fixed';
-        textarea.style.left = '-9999px';
-        document.body.appendChild(textarea);
-        textarea.select();
-        
-        try {
-            const successful = document.execCommand('copy');
-            if (successful) {
-                showCopySuccess(button);
-            } else {
-                alert("复制失败，请手动复制");
-            }
-        } catch (err) {
-            console.error('复制失败: ', err);
-            alert("复制失败，请手动复制");
+      });
+    });
+  }
+
+  // 初始化导航标签跳转
+  function initScrollToSections() {
+    const navTabs = document.querySelectorAll('.nav-tab');
+    navTabs.forEach((tab) => {
+      tab.addEventListener('click', function (e) {
+        e.preventDefault();
+        const targetId = this.getAttribute('href');
+        if (targetId && targetId.startsWith('#')) {
+          const targetElement = document.querySelector(targetId);
+          if (targetElement) {
+            targetElement.scrollIntoView({
+              behavior: 'smooth',
+            });
+          }
         }
-        
-        document.body.removeChild(textarea);
+      });
+    });
+  }
+
+  // 初始化返回顶部按钮
+  function initBackToTop() {
+    const backToTopBtn = document.getElementById('back-to-top');
+    if (!backToTopBtn) return;
+
+    // 显示/隐藏按钮
+    window.addEventListener('scroll', function () {
+      if (
+        document.body.scrollTop > 20 ||
+        document.documentElement.scrollTop > 20
+      ) {
+        backToTopBtn.style.display = 'block';
+      } else {
+        backToTopBtn.style.display = 'none';
+      }
+    });
+
+    // 点击返回顶部
+    backToTopBtn.addEventListener('click', function () {
+      window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+      });
+    });
+  }
+
+  // 复制功能
+  function copyToClipboard(text, event) {
+    if (event) event.stopPropagation();
+    const textToCopy = text.trim();
+
+    // 使用现代API复制
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard
+        .writeText(textToCopy)
+        .then(() => {
+          showCopySuccess(event.target);
+        })
+        .catch((err) => {
+          console.error('复制失败: ', err);
+          fallbackCopy(textToCopy, event.target);
+        });
+    } else {
+      fallbackCopy(textToCopy, event.target);
     }
-    
-    // 显示复制成功
-    function showCopySuccess(button) {
-        const originalText = button.textContent;
-        button.textContent = "已复制!";
-        button.classList.add("copy-success");
-        
-        setTimeout(() => {
-            button.textContent = originalText;
-            button.classList.remove("copy-success");
-        }, 1500);
+  }
+
+  // 复制功能的后备方案
+  function fallbackCopy(text, button) {
+    const textarea = document.createElement('textarea');
+    textarea.value = text;
+    textarea.style.position = 'fixed';
+    textarea.style.left = '-9999px';
+    document.body.appendChild(textarea);
+    textarea.select();
+
+    try {
+      const successful = document.execCommand('copy');
+      if (successful) {
+        showCopySuccess(button);
+      } else {
+        alert('复制失败，请手动复制');
+      }
+    } catch (err) {
+      console.error('复制失败: ', err);
+      alert('复制失败，请手动复制');
     }
-    
-    // 调试信息切换
-    function toggleDebugInfo(btn, event) {
-        event.stopPropagation();
-        const debugInfo = btn.nextElementSibling;
-        if (debugInfo.style.display === "none" || debugInfo.style.display === "") {
-            debugInfo.style.display = "block";
-            btn.textContent = "隐藏调试";
-        } else {
-            debugInfo.style.display = "none";
-            btn.textContent = "调试";
-        }
+
+    document.body.removeChild(textarea);
+  }
+
+  // 显示复制成功
+  function showCopySuccess(button) {
+    const originalText = button.textContent;
+    button.textContent = '已复制!';
+    button.classList.add('copy-success');
+
+    setTimeout(() => {
+      button.textContent = originalText;
+      button.classList.remove('copy-success');
+    }, 1500);
+  }
+
+  // 调试信息切换
+  function toggleDebugInfo(btn, event) {
+    event.stopPropagation();
+    const debugInfo = btn.nextElementSibling;
+    if (debugInfo.style.display === 'none' || debugInfo.style.display === '') {
+      debugInfo.style.display = 'block';
+      btn.textContent = '隐藏调试';
+    } else {
+      debugInfo.style.display = 'none';
+      btn.textContent = '调试';
     }
+  }
+
+  // 显示实时更新指示器
+  function showLiveUpdateIndicator() {
+    // 创建实时更新指示器
+    const indicator = document.createElement('div');
+    indicator.id = 'live-update-indicator';
+    indicator.innerHTML = `
+        <div class="live-indicator">
+          <span class="live-dot"></span>
+          <span class="live-text">实时更新</span>
+          <span class="last-update" id="last-update-time">刚刚</span>
+        </div>
+      `;
+
+    // 插入到页面头部
+    const header = document.querySelector('h1');
+    if (header) {
+      header.parentNode.insertBefore(indicator, header.nextSibling);
+    }
+  }
+
+  // 更新最后刷新时间
+  function updateLastRefreshTime() {
+    const lastUpdateElement = document.getElementById('last-update-time');
+    if (lastUpdateElement) {
+      const now = new Date();
+      lastUpdateElement.textContent = `最后更新: ${now.toLocaleTimeString()}`;
+    }
+  }
 </script>
 <style>
-    /* 基础样式改进 */
-    body {
-        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-    }
-    
-    .card {
-        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
-        border-radius: 8px;
-        margin-bottom: 30px;
-        padding: 20px;
-        background-color: #fff;
-        transition: all 0.3s ease;
-        scroll-margin-top: 20px; /* 为锚点添加滚动边距 */
-    }
-    
-    .card h2 {
-        margin-top: 0;
-        color: #333;
-        border-bottom: 2px solid #eee;
-        padding-bottom: 10px;
-    }
-    
-    /* 导航标签美化 */
-    .nav-tabs {
-        display: flex;
-        margin-bottom: 20px;
-        border-bottom: 1px solid #ddd;
-        padding-bottom: 5px;
-        flex-wrap: wrap;
-    }
-    
-    .nav-tab {
-        padding: 8px 16px;
-        margin-right: 5px;
-        background-color: #f5f5f5;
-        border-radius: 5px 5px 0 0;
-        text-decoration: none;
-        color: #555;
-        transition: all 0.2s ease;
-        font-weight: 500;
-    }
-    
-    .nav-tab:hover {
-        background-color: #e0e0e0;
-        color: #333;
-    }
-    
-    /* 表格样式美化 */
+  /* 基础样式改进 */
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen,
+      Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+  }
+
+  .card {
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    border-radius: 8px;
+    margin-bottom: 30px;
+    padding: 20px;
+    background-color: #fff;
+    transition: all 0.3s ease;
+    scroll-margin-top: 20px; /* 为锚点添加滚动边距 */
+  }
+
+  .card h2 {
+    margin-top: 0;
+    color: #333;
+    border-bottom: 2px solid #eee;
+    padding-bottom: 10px;
+  }
+
+  /* 导航标签美化 */
+  .nav-tabs {
+    display: flex;
+    margin-bottom: 20px;
+    border-bottom: 1px solid #ddd;
+    padding-bottom: 5px;
+    flex-wrap: wrap;
+  }
+
+  .nav-tab {
+    padding: 8px 16px;
+    margin-right: 5px;
+    background-color: #f5f5f5;
+    border-radius: 5px 5px 0 0;
+    text-decoration: none;
+    color: #555;
+    transition: all 0.2s ease;
+    font-weight: 500;
+  }
+
+  .nav-tab:hover {
+    background-color: #e0e0e0;
+    color: #333;
+  }
+
+  /* 表格样式美化 */
+  .responsive-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 20px;
+    font-size: 14px;
+  }
+
+  .responsive-table th {
+    background-color: #f5f5f5;
+    color: #333;
+    font-weight: 600;
+    text-align: left;
+    padding: 12px 15px;
+    border-bottom: 2px solid #ddd;
+  }
+
+  .responsive-table td {
+    padding: 10px 15px;
+    border-bottom: 1px solid #eee;
+    vertical-align: middle;
+  }
+
+  /* 可折叠标题样式 */
+  .collapsible-header {
+    cursor: pointer;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 10px;
+    padding: 10px 0;
+    border-bottom: 2px solid #eee;
+    transition: color 0.2s ease;
+  }
+
+  .collapsible-header:hover {
+    color: #4285f4;
+  }
+
+  .collapsible-content {
+    transition: all 0.3s ease;
+  }
+
+  /* 可折叠行美化 */
+  .collapsible-row {
+    transition: background-color 0.2s ease;
+    cursor: pointer;
+  }
+
+  .collapsible-row:hover {
+    background-color: #f9f9f9;
+  }
+
+  .collapsible-row.active {
+    background-color: #f0f7ff;
+    border-left: 3px solid #4285f4;
+  }
+
+  .toggle-indicator,
+  .toggle-sub-indicator {
+    font-size: 12px;
+    color: #888;
+    float: right;
+    transition: transform 0.2s ease;
+  }
+
+  .collapsible-row.active .toggle-indicator {
+    transform: rotate(180deg);
+    color: #4285f4;
+  }
+
+  /* 详情行样式 */
+  .detail-row td {
+    padding: 0;
+  }
+
+  .content-full {
+    padding: 15px;
+    background-color: #fafafa;
+    border-top: 1px solid #eee;
+  }
+
+  /* 子表格（内部表格）样式 */
+  .inner-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 10px 0;
+    font-size: 13px;
+  }
+
+  .inner-table th {
+    background-color: #eef2f7;
+    padding: 8px 10px;
+    font-weight: 500;
+  }
+
+  .inner-table td {
+    padding: 8px 10px;
+    border-bottom: 1px solid #eee;
+  }
+
+  /* 状态和动作行样式 */
+  .topic-row,
+  .action-row {
+    background-color: #f9f9f9;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+  }
+
+  .topic-row:hover,
+  .action-row:hover {
+    background-color: #f0f0f0;
+  }
+
+  /* 复制按钮美化 */
+  .toggle-cmd-btn {
+    background: #f0f0f0;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 4px 8px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+  }
+
+  .toggle-cmd-btn:hover {
+    background: #e0e0e0;
+  }
+
+  .copy-btn {
+    background: #eef;
+    border: 1px solid #ccf;
+    border-radius: 4px;
+    padding: 4px 10px;
+    cursor: pointer;
+    margin-left: 10px;
+    transition: all 0.2s ease;
+  }
+
+  .copy-btn:hover {
+    background: #ddf;
+  }
+
+  .copy-success {
+    background: #dffddf !important;
+    color: #2c7c2c !important;
+  }
+
+  .debug-btn {
+    background: #fee;
+    border: 1px solid #fcc;
+    border-radius: 4px;
+    padding: 4px 10px;
+    cursor: pointer;
+    margin-left: 5px;
+    font-size: 12px;
+    transition: all 0.2s ease;
+  }
+
+  .debug-btn:hover {
+    background: #fdd;
+  }
+
+  /* 命令块样式优化 */
+  .cmd-block {
+    background: #f8f8f8;
+    border: 1px solid #eee;
+    border-radius: 4px;
+    padding: 12px;
+    margin: 8px 0;
+  }
+
+  .cmd-line {
+    display: flex;
+    align-items: center;
+    margin: 8px 0;
+    background: #fff;
+    padding: 8px 12px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    overflow-x: auto;
+    font-family: 'Consolas', 'Monaco', monospace;
+  }
+
+  .cmd-line pre {
+    margin: 0;
+    white-space: pre-wrap;
+    word-break: break-all;
+    flex: 1;
+  }
+
+  /* 路径和文件夹链接样式 */
+  .folder-link {
+    cursor: pointer;
+    margin-left: 5px;
+    color: #4285f4;
+    transition: transform 0.2s ease;
+  }
+
+  .folder-link:hover {
+    transform: scale(1.1);
+  }
+
+  .path-list {
+    list-style-type: none;
+    padding-left: 10px;
+  }
+
+  .path-list li {
+    margin-bottom: 5px;
+  }
+
+  /* 返回顶部按钮 */
+  #back-to-top {
+    display: none;
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    z-index: 99;
+    font-size: 18px;
+    border: none;
+    outline: none;
+    background-color: #4285f4;
+    color: white;
+    cursor: pointer;
+    padding: 10px 15px;
+    border-radius: 50%;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+    transition: all 0.3s ease;
+  }
+
+  #back-to-top:hover {
+    background-color: #3367d6;
+    transform: translateY(-2px);
+  }
+
+  /* 在线状态标签 */
+  .online-status {
+    display: inline-block;
+    background-color: #4caf50;
+    color: white;
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 12px;
+    font-weight: 500;
+  }
+
+  /* 详情列表样式 */
+  .detail-list {
+    padding-left: 15px;
+  }
+
+  .detail-list li {
+    margin-bottom: 15px;
+    padding-bottom: 12px;
+    border-bottom: 1px dashed #eee;
+  }
+
+  /* 提示文本样式 */
+  .goal-tip {
+    font-size: 12px;
+    color: #666;
+    margin-top: 8px;
+    font-style: italic;
+    background: #fffde7;
+    padding: 5px 8px;
+    border-radius: 3px;
+    border-left: 3px solid #ffd54f;
+  }
+
+  /* 调试信息样式 */
+  .debug-info {
+    margin-top: 8px;
+    background: #fffde7;
+    border: 1px solid #fff9c4;
+    border-radius: 4px;
+    padding: 10px;
+    font-size: 12px;
+    max-height: 300px;
+    overflow-y: auto;
+  }
+
+  /* 时间戳样式 */
+  .timestamp {
+    font-size: 13px;
+    background-color: #f5f5f5;
+    padding: 3px 6px;
+    border-radius: 3px;
+    color: #555;
+    transition: background-color 0.3s ease;
+  }
+
+  .timestamp.not-updated {
+    background-color: #fff3e0;
+    color: #e65100;
+  }
+
+  .timestamp[title]:hover::after {
+    content: '时间戳: ' attr(title);
+    position: absolute;
+    background: #333;
+    color: #fff;
+    padding: 5px 10px;
+    border-radius: 4px;
+    z-index: 10;
+    font-size: 12px;
+    margin-top: 5px;
+    margin-left: -10px;
+  }
+
+  /* 响应式样式优化 */
+  @media screen and (max-width: 768px) {
     .responsive-table {
-        width: 100%;
-        border-collapse: collapse;
-        margin-bottom: 20px;
-        font-size: 14px;
+      width: 100%;
+      overflow-x: auto;
+      display: block;
     }
-    
-    .responsive-table th {
-        background-color: #f5f5f5;
-        color: #333;
-        font-weight: 600;
-        text-align: left;
-        padding: 12px 15px;
-        border-bottom: 2px solid #ddd;
+
+    .nav-tabs {
+      overflow-x: auto;
+      white-space: nowrap;
+      display: block;
+      padding-bottom: 10px;
     }
-    
-    .responsive-table td {
-        padding: 10px 15px;
-        border-bottom: 1px solid #eee;
-        vertical-align: middle;
+
+    .nav-tab {
+      display: inline-block;
+      margin-bottom: 5px;
     }
-    
-    /* 可折叠行美化 */
-    .collapsible-row {
-        transition: background-color 0.2s ease;
-        cursor: pointer;
+
+    .file-path {
+      max-width: 150px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
     }
-    
-    .collapsible-row:hover {
-        background-color: #f9f9f9;
-    }
-    
-    .collapsible-row.active {
-        background-color: #f0f7ff;
-        border-left: 3px solid #4285f4;
-    }
-    
-    .toggle-indicator, .toggle-sub-indicator {
-        font-size: 12px;
-        color: #888;
-        float: right;
-        transition: transform 0.2s ease;
-    }
-    
-    .collapsible-row.active .toggle-indicator {
-        transform: rotate(180deg);
-        color: #4285f4;
-    }
-    
-    /* 详情行样式 */
-    .detail-row td {
-        padding: 0;
-    }
-    
-    .content-full {
-        padding: 15px;
-        background-color: #fafafa;
-        border-top: 1px solid #eee;
-    }
-    
-    /* 子表格（内部表格）样式 */
-    .inner-table {
-        width: 100%;
-        border-collapse: collapse;
-        margin: 10px 0;
-        font-size: 13px;
-    }
-    
-    .inner-table th {
-        background-color: #eef2f7;
-        padding: 8px 10px;
-        font-weight: 500;
-    }
-    
-    .inner-table td {
-        padding: 8px 10px;
-        border-bottom: 1px solid #eee;
-    }
-    
-    /* 状态和动作行样式 */
-    .topic-row, .action-row {
-        background-color: #f9f9f9;
-        cursor: pointer;
-        transition: background-color 0.2s ease;
-    }
-    
-    .topic-row:hover, .action-row:hover {
-        background-color: #f0f0f0;
-    }
-    
-    /* 复制按钮美化 */
-    .toggle-cmd-btn {
-        background: #f0f0f0;
-        border: 1px solid #ddd;
-        border-radius: 4px;
-        padding: 4px 8px;
-        cursor: pointer;
-        transition: all 0.2s ease;
-    }
-    
-    .toggle-cmd-btn:hover {
-        background: #e0e0e0;
-    }
-    
-    .copy-btn {
-        background: #eef;
-        border: 1px solid #ccf;
-        border-radius: 4px;
-        padding: 4px 10px;
-        cursor: pointer;
-        margin-left: 10px;
-        transition: all 0.2s ease;
-    }
-    
-    .copy-btn:hover {
-        background: #ddf;
-    }
-    
-    .copy-success {
-        background: #dffddf !important;
-        color: #2c7c2c !important;
-    }
-    
-    .debug-btn {
-        background: #fee;
-        border: 1px solid #fcc;
-        border-radius: 4px;
-        padding: 4px 10px;
-        cursor: pointer;
-        margin-left: 5px;
-        font-size: 12px;
-        transition: all 0.2s ease;
-    }
-    
-    .debug-btn:hover {
-        background: #fdd;
-    }
-    
-    /* 命令块样式优化 */
+
     .cmd-block {
-        background: #f8f8f8;
-        border: 1px solid #eee;
-        border-radius: 4px;
-        padding: 12px;
-        margin: 8px 0;
+      padding: 10px;
+      overflow-x: auto;
     }
-    
-    .cmd-line {
-        display: flex;
-        align-items: center;
-        margin: 8px 0;
-        background: #fff;
-        padding: 8px 12px;
-        border: 1px solid #ddd;
-        border-radius: 4px;
-        overflow-x: auto;
-        font-family: 'Consolas', 'Monaco', monospace;
+
+    .cmd-block pre {
+      white-space: pre-wrap;
+      word-break: break-word;
+      font-size: 12px;
     }
-    
-    .cmd-line pre {
-        margin: 0;
-        white-space: pre-wrap;
-        word-break: break-all;
-        flex: 1;
+
+    .device-row td:nth-child(3) {
+      display: none;
     }
-    
-    /* 路径和文件夹链接样式 */
-    .folder-link {
-        cursor: pointer;
-        margin-left: 5px;
-        color: #4285f4;
-        transition: transform 0.2s ease;
+  }
+
+  /* 动画效果 */
+  @keyframes fadeIn {
+    from {
+      opacity: 0;
     }
-    
-    .folder-link:hover {
-        transform: scale(1.1);
+    to {
+      opacity: 1;
     }
-    
-    .path-list {
-        list-style-type: none;
-        padding-left: 10px;
+  }
+
+  .detail-row {
+    animation: fadeIn 0.3s ease;
+  }
+
+  /* 连接状态样式 */
+  .connection-status {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    padding: 10px 15px;
+    border-radius: 4px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+    background-color: #f5f5f5;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    font-size: 14px;
+    transition: opacity 0.3s ease;
+  }
+
+  .connection-status .status-dot {
+    width: 10px;
+    height: 10px;
+    border-radius: 50%;
+    margin-right: 8px;
+  }
+
+  .connection-status.connecting .status-dot {
+    background-color: #ffc107;
+    animation: pulse 1.5s infinite;
+  }
+
+  .connection-status.connected .status-dot {
+    background-color: #4caf50;
+  }
+
+  .connection-status.disconnected .status-dot {
+    background-color: #9e9e9e;
+  }
+
+  .connection-status.reconnecting .status-dot {
+    background-color: #ff9800;
+    animation: pulse 1.5s infinite;
+  }
+
+  .connection-status.error .status-dot {
+    background-color: #f44336;
+  }
+
+  @keyframes pulse {
+    0% {
+      opacity: 0.5;
     }
-    
-    .path-list li {
-        margin-bottom: 5px;
+    50% {
+      opacity: 1;
     }
-    
-    /* 返回顶部按钮 */
-    #back-to-top {
-        display: none;
-        position: fixed;
-        bottom: 20px;
-        right: 20px;
-        z-index: 99;
-        font-size: 18px;
-        border: none;
-        outline: none;
-        background-color: #4285f4;
-        color: white;
-        cursor: pointer;
-        padding: 10px 15px;
-        border-radius: 50%;
-        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
-        transition: all 0.3s ease;
-    }
-    
-    #back-to-top:hover {
-        background-color: #3367d6;
-        transform: translateY(-2px);
-    }
-    
-    /* 在线状态标签 */
-    .online-status {
-        display: inline-block;
-        background-color: #4caf50;
-        color: white;
-        padding: 4px 8px;
-        border-radius: 4px;
-        font-size: 12px;
-        font-weight: 500;
-    }
-    
-    /* 详情列表样式 */
-    .detail-list {
-        padding-left: 15px;
-    }
-    
-    .detail-list li {
-        margin-bottom: 15px;
-        padding-bottom: 12px;
-        border-bottom: 1px dashed #eee;
-    }
-    
-    /* 提示文本样式 */
-    .goal-tip {
-        font-size: 12px;
-        color: #666;
-        margin-top: 8px;
-        font-style: italic;
-        background: #fffde7;
-        padding: 5px 8px;
-        border-radius: 3px;
-        border-left: 3px solid #ffd54f;
-    }
-    
-    /* 调试信息样式 */
-    .debug-info {
-        margin-top: 8px;
-        background: #fffde7;
-        border: 1px solid #fff9c4;
-        border-radius: 4px;
-        padding: 10px;
-        font-size: 12px;
-        max-height: 300px;
-        overflow-y: auto;
-    }
-    
-    /* 时间戳样式 */
-    .timestamp {
-        font-size: 13px;
-        background-color: #f5f5f5;
-        padding: 3px 6px;
-        border-radius: 3px;
-        color: #555;
-        transition: background-color 0.3s ease;
-    }
-    
-    .timestamp.not-updated {
-        background-color: #fff3e0;
-        color: #e65100;
-    }
-    
-    .timestamp[title]:hover::after {
-        content: '时间戳: ' attr(title);
-        position: absolute;
-        background: #333;
-        color: #fff;
-        padding: 5px 10px;
-        border-radius: 4px;
-        z-index: 10;
-        font-size: 12px;
-        margin-top: 5px;
-        margin-left: -10px;
-    }
-    
-    /* 响应式样式优化 */
-    @media screen and (max-width: 768px) {
-        .responsive-table {
-            width: 100%;
-            overflow-x: auto;
-            display: block;
-        }
-        
-        .nav-tabs {
-            overflow-x: auto;
-            white-space: nowrap;
-            display: block;
-            padding-bottom: 10px;
-        }
-        
-        .nav-tab {
-            display: inline-block;
-            margin-bottom: 5px;
-        }
-        
-        .file-path {
-            max-width: 150px;
-            white-space: nowrap;
-            overflow: hidden;
-            text-overflow: ellipsis;
-        }
-        
-        .cmd-block {
-            padding: 10px;
-            overflow-x: auto;
-        }
-        
-        .cmd-block pre {
-            white-space: pre-wrap;
-            word-break: break-word;
-            font-size: 12px;
-        }
-        
-        .device-row td:nth-child(3) {
-            display: none;
-        }
-    }
-    
-    /* 动画效果 */
-    @keyframes fadeIn {
-        from { opacity: 0; }
-        to { opacity: 1; }
-    }
-    
-    .detail-row {
-        animation: fadeIn 0.3s ease;
-    }
-    
-    /* 连接状态样式 */
-    .connection-status {
-        position: fixed;
-        top: 20px;
-        right: 20px;
-        padding: 10px 15px;
-        border-radius: 4px;
-        box-shadow: 0 2px 8px rgba(0,0,0,0.2);
-        background-color: #f5f5f5;
-        z-index: 1000;
-        display: flex;
-        align-items: center;
-        font-size: 14px;
-        transition: opacity 0.3s ease;
-    }
-    
-    .connection-status .status-dot {
-        width: 10px;
-        height: 10px;
-        border-radius: 50%;
-        margin-right: 8px;
-    }
-    
-    .connection-status.connecting .status-dot {
-        background-color: #ffc107;
-        animation: pulse 1.5s infinite;
-    }
-    
-    .connection-status.connected .status-dot {
-        background-color: #4caf50;
-    }
-    
-    .connection-status.disconnected .status-dot {
-        background-color: #9e9e9e;
-    }
-    
-    .connection-status.reconnecting .status-dot {
-        background-color: #ff9800;
-        animation: pulse 1.5s infinite;
-    }
-    
-    .connection-status.error .status-dot {
-        background-color: #f44336;
-    }
-    
-    @keyframes pulse {
-        0% { opacity: 0.5; }
-        50% { opacity: 1; }
-        100% { opacity: 0.5; }
+    100% {
+      opacity: 0.5;
     }
+  }
+
+  /* 实时更新指示器样式 */
+  #live-update-indicator {
+    position: fixed;
+    top: 70px;
+    right: 20px;
+    z-index: 1000;
+    background-color: #f8f9fa;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    padding: 8px 12px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+    font-size: 13px;
+  }
+
+  .live-indicator {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .live-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background-color: #4caf50;
+    animation: pulse 2s infinite;
+  }
+
+  .live-text {
+    color: #555;
+    font-weight: 500;
+  }
+
+  .last-update {
+    color: #777;
+    font-size: 12px;
+    padding: 2px 6px;
+    border-radius: 3px;
+    transition: all 0.3s ease;
+  }
 </style>
-{% endblock %} 
\ No newline at end of file
+{% endblock %}