refactor(core): 拆分 model/mqtt/update 为单一职责子模块

- model/ 按领域拆为 connection/subscription/message/publish/variable/log/settings
- mqtt/ 拆为门面(引擎与事件)、tls、v5、v4 四块
- update/ 拆为门面(版本工具与命名约定)、check(检查)、install(下载/安装/清理)
- sysmon 只保留进程资源采样，窗口置顶迁至新 platform.rs
- 对外路径经 mod.rs 再导出保持不变，测试随门面保留（33 通过）

gpui-app/src/model/connection.rs

@@ -0,0 +1,277 @@
+//! 连接配置：协议版本、传输方式、遗嘱、TLS 与连接参数。
+
+
+use serde::{Deserialize, Serialize};
+
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+#[derive(Default)]
+pub enum ProtocolVersion {
+    /// MQTT 3.1.1
+    V311,
+    /// MQTT 5.0
+    #[default]
+    V5,
+}
+
+impl ProtocolVersion {
+    pub const ALL: [Self; 2] = [Self::V5, Self::V311];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::V311 => "MQTT 3.1.1",
+            Self::V5 => "MQTT 5.0",
+        }
+    }
+
+    pub fn is_v5(self) -> bool {
+        matches!(self, Self::V5)
+    }
+}
+
+
+/// 传输方式。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[derive(Default)]
+pub enum TransportKind {
+    /// 明文 TCP，默认 1883
+    #[default]
+    Tcp,
+    /// TLS over TCP，默认 8883
+    Tls,
+    /// WebSocket (ws://)，默认 8083
+    Ws,
+    /// WebSocket over TLS (wss://)，默认 8084
+    Wss,
+}
+
+impl TransportKind {
+    pub const ALL: [Self; 4] = [Self::Tcp, Self::Tls, Self::Ws, Self::Wss];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Tcp => "TCP",
+            Self::Tls => "TLS",
+            Self::Ws => "WebSocket",
+            Self::Wss => "WSS",
+        }
+    }
+
+    pub fn default_port(self) -> u16 {
+        match self {
+            Self::Tcp => 1883,
+            Self::Tls => 8883,
+            Self::Ws => 8083,
+            Self::Wss => 8084,
+        }
+    }
+
+    pub fn is_tls(self) -> bool {
+        matches!(self, Self::Tls | Self::Wss)
+    }
+
+    pub fn is_websocket(self) -> bool {
+        matches!(self, Self::Ws | Self::Wss)
+    }
+}
+
+
+/// MQTT 5 遗嘱消息（3.1.1 下忽略 v5 专属属性）。
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+pub struct LastWill {
+    pub topic: String,
+    pub payload: String,
+    pub qos: u8,
+    pub retain: bool,
+    #[serde(default)]
+    pub content_type: Option<String>,
+    #[serde(default)]
+    pub response_topic: Option<String>,
+}
+
+/// SSL/TLS 自定义配置（CA、双向认证、跳过校验）。
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+pub struct SslConfig {
+    /// 自定义 CA 文件路径（PEM），作为系统根证书的补充
+    #[serde(default)]
+    pub ca_file: String,
+    /// 客户端证书（PEM），双向认证用
+    #[serde(default)]
+    pub client_cert_file: String,
+    /// 客户端私钥（PEM），与客户端证书配套
+    #[serde(default)]
+    pub client_key_file: String,
+    /// 跳过服务器证书校验（insecure），仅调试环境使用
+    #[serde(default)]
+    pub ignore_ca: bool,
+}
+
+impl SslConfig {
+    /// 是否完全未配置（走 rumqttc 默认 TLS 即可）。
+    pub fn is_default(&self) -> bool {
+        !self.ignore_ca
+            && self.ca_file.is_empty()
+            && self.client_cert_file.is_empty()
+            && self.client_key_file.is_empty()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConnectionConfig {
+    pub id: String,
+    pub name: String,
+    /// 主机（不含端口、协议前缀）
+    pub host: String,
+    pub port: u16,
+    /// WebSocket 路径，如 /mqtt
+    #[serde(default)]
+    pub path: String,
+
+    #[serde(default)]
+    pub protocol: ProtocolVersion,
+    #[serde(default)]
+    pub transport: TransportKind,
+
+    pub client_id: String,
+    #[serde(default)]
+    pub username: String,
+    #[serde(default)]
+    pub password: String,
+
+    #[serde(default = "default_true")]
+    pub clean_start: bool,
+    #[serde(default = "default_keep_alive")]
+    pub keep_alive: u16,
+
+    // ── MQTT 5 专属 ──
+    #[serde(default)]
+    pub session_expiry_interval: u32,
+    #[serde(default)]
+    pub receive_maximum: Option<u16>,
+    #[serde(default)]
+    pub maximum_packet_size: Option<u32>,
+    #[serde(default)]
+    pub topic_alias_maximum: Option<u16>,
+
+    /// 连接成功后自动恢复已保存的订阅
+    #[serde(default = "default_true")]
+    pub auto_resubscribe: bool,
+    /// 断线自动重连
+    #[serde(default = "default_true")]
+    pub auto_reconnect: bool,
+    /// 应用启动时自动连接该连接
+    #[serde(default)]
+    pub auto_connect: bool,
+
+    #[serde(default)]
+    pub last_will: Option<LastWill>,
+
+    /// 创建时间（unix 秒），用于排序
+    #[serde(default)]
+    pub created_at: i64,
+
+    /// 连接分组（对标 MQTTX folder）
+    #[serde(default)]
+    pub group: Option<String>,
+    /// 连接超时（秒），覆盖建连与 CONNACK 等待
+    #[serde(default = "default_connection_timeout")]
+    pub connection_timeout_secs: u16,
+    /// 最大重连次数，0 = 无限重连
+    #[serde(default)]
+    pub max_reconnect_times: u32,
+    /// SSL/TLS 自定义配置
+    #[serde(default)]
+    pub ssl: SslConfig,
+}
+
+pub(super) fn default_true() -> bool {
+    true
+}
+pub(super) fn default_keep_alive() -> u16 {
+    60
+}
+pub(super) fn default_connection_timeout() -> u16 {
+    10
+}
+
+/// 生成随机 Client ID（新建连接与表单「重新生成」共用同一逻辑）。
+pub fn generate_client_id() -> String {
+    format!("mqttx_{}", &uuid::Uuid::new_v4().simple().to_string()[..8])
+}
+
+impl ConnectionConfig {
+    pub fn new() -> Self {
+        let transport = TransportKind::default();
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            name: "新建连接".into(),
+            host: "broker.emqx.io".into(),
+            port: transport.default_port(),
+            path: "/mqtt".into(),
+            protocol: ProtocolVersion::V5,
+            transport,
+            client_id: generate_client_id(),
+            username: String::new(),
+            password: String::new(),
+            clean_start: true,
+            keep_alive: 60,
+            session_expiry_interval: 0,
+            receive_maximum: None,
+            maximum_packet_size: None,
+            topic_alias_maximum: None,
+            auto_resubscribe: true,
+            auto_reconnect: true,
+            auto_connect: false,
+            last_will: None,
+            created_at: chrono::Local::now().timestamp(),
+            group: None,
+            connection_timeout_secs: default_connection_timeout(),
+            max_reconnect_times: 0,
+            ssl: SslConfig::default(),
+        }
+    }
+
+    /// broker.emqx.io 等公共服务器的快速预设。
+    pub fn with_public(name: &str, host: &str, port: u16, transport: TransportKind) -> Self {
+        let mut c = Self::new();
+        c.name = name.into();
+        c.host = host.into();
+        c.port = port;
+        c.transport = transport;
+        c
+    }
+
+    pub fn display_address(&self) -> String {
+        format!("{}:{}", self.host, self.port)
+    }
+
+    /// 与另一份配置相比，影响 broker 会话建立的关键参数是否变化。
+    /// 这些字段改动只有在重新建立连接后才会生效，用于提示用户重连。
+    /// WS 路径、遗嘱、TLS 配置、keep_alive 同样随 CONNECT 报文一次性生效，
+    /// 必须纳入比较。
+    pub fn session_params_changed(&self, other: &ConnectionConfig) -> bool {
+        self.host != other.host
+            || self.port != other.port
+            || self.path != other.path
+            || self.transport != other.transport
+            || self.protocol != other.protocol
+            || self.client_id != other.client_id
+            || self.username != other.username
+            || self.password != other.password
+            || self.clean_start != other.clean_start
+            || self.keep_alive != other.keep_alive
+            || self.last_will != other.last_will
+            || self.ssl != other.ssl
+    }
+}
+
+impl Default for ConnectionConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+// ─── 订阅 ────────────────────────────────────────────────────────────────────

gpui-app/src/model/log.rs

@@ -0,0 +1,45 @@
+//! 运行日志：日志级别与日志条目。
+
+
+
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogLevel {
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+impl LogLevel {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Debug => "DEBUG",
+            Self::Info => "INFO",
+            Self::Warn => "WARN",
+            Self::Error => "ERROR",
+        }
+    }
+
+    pub fn parse(s: &str) -> Self {
+        match s {
+            "debug" => Self::Debug,
+            "warn" => Self::Warn,
+            "error" => Self::Error,
+            _ => Self::Info,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct LogEntry {
+    pub timestamp: i64,
+    pub connection_id: String,
+    pub level: LogLevel,
+    pub event: String,
+    pub message: String,
+    pub details: Option<String>,
+}
+
+// ─── 连接状态 ────────────────────────────────────────────────────────────────

gpui-app/src/model/message.rs

@@ -0,0 +1,199 @@
+//! 消息：方向、载荷格式、消息记录与条数/字节双预算的环形缓冲。
+
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+
+use std::collections::VecDeque;
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Direction {
+    Received,
+    Published,
+}
+
+impl Direction {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Received => "接收",
+            Self::Published => "发布",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[derive(Default)]
+pub enum PayloadFormat {
+    #[default]
+    Plaintext,
+    Json,
+    Base64,
+    Hex,
+}
+
+impl PayloadFormat {
+    pub const ALL: [Self; 4] = [Self::Plaintext, Self::Json, Self::Base64, Self::Hex];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Plaintext => "Plaintext",
+            Self::Json => "JSON",
+            Self::Base64 => "Base64",
+            Self::Hex => "Hex",
+        }
+    }
+
+    pub fn encode(self, text: &str) -> Result<Vec<u8>, String> {
+        match self {
+            Self::Plaintext | Self::Json => Ok(text.as_bytes().to_vec()),
+            Self::Base64 => {
+                use base64::Engine as _;
+                base64::engine::general_purpose::STANDARD
+                    .decode(text.trim())
+                    .map_err(|e| format!("Base64 解码失败: {e}"))
+            }
+            Self::Hex => {
+                let cleaned: String = text.chars().filter(|c| !c.is_whitespace()).collect();
+                if !cleaned.len().is_multiple_of(2) {
+                    return Err("Hex 长度必须为偶数（每两个字符一个字节）".into());
+                }
+                // 必须先做全字节校验：长度检查按字节计数，多字节字符（如中文）
+                // 可凑成偶数字节，直接按字节索引切片会落在字符边界内而 panic。
+                if !cleaned.bytes().all(|b| b.is_ascii_hexdigit()) {
+                    return Err("Hex 解码失败: 含非十六进制字符".into());
+                }
+                (0..cleaned.len())
+                    .step_by(2)
+                    .map(|i| {
+                        u8::from_str_radix(&cleaned[i..i + 2], 16)
+                            .map_err(|e| format!("Hex 解码失败: {e}"))
+                    })
+                    .collect()
+            }
+        }
+    }
+}
+
+
+/// 一条收到/发出的消息记录。payload 以 UTF-8 文本保存（非文本按 lossy 显示）。
+///
+/// 内存优化：`connection_id`/`topic` 用 `Arc<str>`——同一连接内主题高度重复，
+/// 驻留后数千条记录只保留一份字符串。
+#[derive(Debug, Clone)]
+pub struct MqttRecord {
+    pub seq: u64,
+    pub connection_id: Arc<str>,
+    pub direction: Direction,
+    pub topic: Arc<str>,
+    /// Arc 共享：消息列表渲染每帧克隆最多数百条记录，零拷贝
+    pub payload: Arc<str>,
+    pub qos: u8,
+    pub retain: bool,
+    /// unix 毫秒
+    pub timestamp: i64,
+    pub user_properties: Vec<(String, String)>,
+    pub content_type: Option<String>,
+    pub response_topic: Option<String>,
+    pub correlation_data: Option<String>,
+    pub message_expiry_interval: Option<u32>,
+    pub subscription_identifier: Option<u32>,
+    /// payload 超过 [`MAX_PAYLOAD_RETAIN`] 被截断
+    pub payload_truncated: bool,
+    /// 非文本负载的原始字节（合法 UTF-8 时为 None）。文本化会失真
+    /// （非法字节被替换为 U+FFFD），详情面板的 Hex/Base64 需要真实报文。
+    pub raw_bytes: Option<Arc<[u8]>>,
+}
+
+impl MqttRecord {
+    /// 该记录保留的主要字节数（文本 + 原始字节），用于内存预算驱逐。
+    /// 其余字段（主题/属性等）相对小一个数量级，不计入。
+    pub fn retained_bytes(&self) -> usize {
+        self.payload.len() + self.raw_bytes.as_ref().map_or(0, |b| b.len())
+    }
+}
+
+/// 单连接的消息环形缓冲：条数上限 + [`MAX_CONNECTION_MESSAGE_BYTES`]
+/// 字节上限双重驱逐（从最旧开始，均摊 O(1)）。
+pub struct MessageRing {
+    queue: VecDeque<MqttRecord>,
+    bytes: usize,
+}
+
+impl MessageRing {
+    pub fn new(max_count: usize) -> Self {
+        Self {
+            // 预分配按较小值钳制：设置上限十万条时不一次性分配过大
+            queue: VecDeque::with_capacity(max_count.clamp(16, 512)),
+            bytes: 0,
+        }
+    }
+
+    /// `max_count` 每次传入以便运行时调整设置后即时生效。
+    /// 设置层已校验 ≥100，这里只防 0 值导致缓冲被清空。
+    pub fn push(&mut self, record: MqttRecord, max_count: usize) {
+        let max_count = max_count.max(1);
+        self.bytes += record.retained_bytes();
+        while self.queue.len() >= max_count
+            || (self.bytes > MAX_CONNECTION_MESSAGE_BYTES && self.queue.len() > 1)
+        {
+            let Some(old) = self.queue.pop_front() else { break };
+            self.bytes -= old.retained_bytes();
+        }
+        self.queue.push_back(record);
+    }
+
+    pub fn len(&self) -> usize {
+        self.queue.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.queue.is_empty()
+    }
+
+    /// 当前保留的字节数（payload + 原始字节）。
+    pub fn retained_bytes(&self) -> usize {
+        self.bytes
+    }
+
+    pub fn iter(&self) -> std::collections::vec_deque::Iter<'_, MqttRecord> {
+        self.queue.iter()
+    }
+}
+
+/// 消息历史中单条 payload 的保留上限。超限截断，避免个别大报文
+/// 长期占据历史缓冲（MQTTX 亦有类似限制）。
+pub const MAX_PAYLOAD_RETAIN: usize = 128 * 1024;
+
+/// 每连接消息历史的字节预算（payload + 原始字节）。条数上限
+/// （max_messages）在大报文流下形同虚设（2000 条 × 128KB ≈ 256MB），
+/// 超出预算后从最旧开始驱逐，保证单连接消息内存有上界。
+pub const MAX_CONNECTION_MESSAGE_BYTES: usize = 32 * 1024 * 1024;
+
+/// 把原始 payload 字节转成用于历史记录的共享文本，超限截断。
+/// 返回 (文本, 非文本时的原始字节, 是否截断)。截断时回退到 UTF-8 字符边界。
+///
+/// 仅当文本化会失真（非合法 UTF-8，字节被替换为 U+FFFD）时才保留原始
+/// 字节（同样受 [`MAX_PAYLOAD_RETAIN`] 限制）；纯文本负载零额外开销。
+pub fn retained_payload(raw: &[u8]) -> (Arc<str>, Option<Arc<[u8]>>, bool) {
+    let truncated = raw.len() > MAX_PAYLOAD_RETAIN;
+    let text_part = if truncated {
+        let mut end = MAX_PAYLOAD_RETAIN;
+        while end > 0 && (raw[end] & 0xC0) == 0x80 {
+            end -= 1;
+        }
+        &raw[..end]
+    } else {
+        raw
+    };
+    let raw_bytes = match std::str::from_utf8(text_part) {
+        Ok(_) => None,
+        Err(_) => Some(Arc::from(text_part.to_vec())),
+    };
+    let text: Arc<str> = Arc::from(String::from_utf8_lossy(text_part).as_ref());
+    (text, raw_bytes, truncated)
+}
+
+// ─── 发布参数 / 发布预设 ──────────────────────────────────────────────────────

gpui-app/src/model/mod.rs

@@ -0,0 +1,379 @@
+//! 应用数据模型：按领域拆分的纯数据层（不依赖 GPUI）。
+//!
+//! - [`connection`] 连接配置与协议/传输枚举
+//! - [`subscription`] 订阅与订阅选项
+//! - [`message`] 消息记录与环形缓冲
+//! - [`publish`] 发布参数与发布预设
+//! - [`variable`] 全局变量与模板渲染
+//! - [`log`] 运行日志
+//! - [`settings`] 应用设置与主题偏好
+
+mod connection;
+mod log;
+mod message;
+mod publish;
+mod settings;
+mod subscription;
+mod variable;
+
+pub use connection::*;
+pub use log::*;
+pub use message::*;
+pub use publish::*;
+pub use settings::*;
+pub use subscription::*;
+pub use variable::*;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    use std::sync::Arc;
+
+    // 修复回归：Hex 奇数长度必须报错，不能静默截断
+    #[test]
+    fn hex_odd_length_is_rejected() {
+        let err = PayloadFormat::Hex.encode("abc").unwrap_err();
+        assert!(err.contains("偶数"), "应提示偶数长度，实际: {err}");
+        assert!(PayloadFormat::Hex.encode("").is_ok());
+        assert_eq!(
+            PayloadFormat::Hex.encode("68 69").unwrap(),
+            vec![0x68, 0x69],
+            "空白应被忽略"
+        );
+        assert!(PayloadFormat::Hex.encode("zz").is_err());
+    }
+
+    #[test]
+    fn base64_encode_roundtrip() {
+        use base64::Engine as _;
+        let text = "hello 世界";
+        let encoded = base64::engine::general_purpose::STANDARD.encode(text);
+        assert_eq!(PayloadFormat::Base64.encode(&encoded).unwrap(), text.as_bytes());
+        assert!(PayloadFormat::Base64.encode("not base64!!!").is_err());
+    }
+
+    #[test]
+    fn plaintext_and_json_encode_as_utf8() {
+        assert_eq!(
+            PayloadFormat::Plaintext.encode("中文").unwrap(),
+            "中文".as_bytes()
+        );
+        assert_eq!(
+            PayloadFormat::Json.encode(r#"{"a":1}"#).unwrap(),
+            r#"{"a":1}"#.as_bytes()
+        );
+    }
+
+    // 修复回归：raw_bytes 是运行时字段，不得写入持久化 JSON
+    #[test]
+    fn raw_bytes_not_serialized() {
+        let p = PublishParams {
+            topic: "t".into(),
+            payload: "hi".into(),
+            raw_bytes: Some(vec![0x00, 0xff]),
+            ..Default::default()
+        };
+        let json = serde_json::to_string(&p).unwrap();
+        assert!(!json.contains("raw_bytes"), "raw_bytes 不应被序列化: {json}");
+        let back: PublishParams = serde_json::from_str(&json).unwrap();
+        assert!(back.raw_bytes.is_none());
+        // 反序列化时输入中的 raw_bytes 字段应被忽略（skip 双向生效）
+        let mut with_junk = serde_json::to_string(&PublishParams::default()).unwrap();
+        with_junk.pop(); // 去掉结尾 '}'
+        with_junk.push_str(r#", "raw_bytes":[1,2]}"#);
+        let back: PublishParams = serde_json::from_str(&with_junk).unwrap();
+        assert!(back.raw_bytes.is_none(), "#[serde(skip)] 应忽略输入字段");
+    }
+
+    // 修复回归：同一条消息内 $ts 与 $ts_ms 基于同一时刻
+    #[test]
+    fn template_timestamps_share_one_timebase() {
+        let out = render_template("s={{$ts}} ms={{$ts_ms}}", &[]);
+        let (s_part, ms_part) = out.split_once(" ms=").expect("格式 s=.. ms=..");
+        let s: i64 = s_part
+            .strip_prefix("s=")
+            .expect("秒字段")
+            .parse()
+            .unwrap();
+        let ms: i64 = ms_part.parse().expect("毫秒字段");
+        assert_eq!(s, ms / 1000, "秒与毫秒应来自同一时间基准: {out}");
+    }
+
+    #[test]
+    fn template_unknown_placeholder_kept_and_custom_var_resolved() {
+        assert_eq!(render_template("{{$unknown}}", &[]), "{{$unknown}}");
+        let vars = vec![GlobalVariable {
+            key: "device".into(),
+            value: "sensor-1".into(),
+        }];
+        assert!(render_template("d={{device}}/{{$uuid}}", &vars).starts_with("d=sensor-1/"));
+        // 多字节字符不被拆坏
+        assert_eq!(render_template("中文{{$no}}", &[]), "中文{{$no}}");
+    }
+
+    // 连接前遗嘱模板注入：只改副本、空遗嘱不 panic、v5 属性一并渲染
+    #[test]
+    fn render_will_templates_injects_and_keeps_no_will_safe() {
+        let vars = vec![GlobalVariable {
+            key: "device".into(),
+            value: "sensor-9".into(),
+        }];
+        // 无遗嘱：直接返回
+        let mut plain = ConnectionConfig::new();
+        render_will_templates(&mut plain, &vars);
+        assert!(plain.last_will.is_none());
+
+        let mut cfg = ConnectionConfig::new();
+        cfg.last_will = Some(LastWill {
+            topic: "alarm/{{device}}".into(),
+            payload: "d={{device}}".into(),
+            qos: 1,
+            retain: false,
+            content_type: Some("text/{{device}}".into()),
+            response_topic: Some("ack/{{device}}".into()),
+        });
+        render_will_templates(&mut cfg, &vars);
+        let w = cfg.last_will.as_ref().unwrap();
+        assert_eq!(w.topic, "alarm/sensor-9");
+        assert_eq!(w.payload, "d=sensor-9");
+        assert_eq!(w.content_type.as_deref(), Some("text/sensor-9"));
+        assert_eq!(w.response_topic.as_deref(), Some("ack/sensor-9"));
+        // 原始模板串不因注入而需要回写：连接配置持久化的是模板原文，
+        // 这里只验证副本注入结果；未知占位符保留
+        let mut raw = ConnectionConfig::new();
+        raw.last_will = Some(LastWill {
+            topic: "t/{{unknown}}".into(),
+            ..Default::default()
+        });
+        render_will_templates(&mut raw, &vars);
+        assert_eq!(raw.last_will.as_ref().unwrap().topic, "t/{{unknown}}");
+    }
+
+    // 预设持久化往返：raw_bytes 不落盘，参数完整保留
+    #[test]
+    fn publish_preset_roundtrip_skips_raw_bytes() {
+        let preset = PublishPreset {
+            id: "p1".into(),
+            name: "报警".into(),
+            connection_id: Some("c1".into()),
+            params: PublishParams {
+                topic: "alarm/{{device}}".into(),
+                payload: "6869".into(),
+                payload_format: PayloadFormat::Hex,
+                qos: 1,
+                retain: true,
+                content_type: Some("application/json".into()),
+                user_properties: vec![("k".into(), "v".into())],
+                raw_bytes: Some(vec![0x68, 0x69]),
+                ..Default::default()
+            },
+        };
+        let json = serde_json::to_string(&preset).unwrap();
+        let back: PublishPreset = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.name, "报警");
+        assert_eq!(back.params.topic, "alarm/{{device}}");
+        assert_eq!(back.params.payload_format, PayloadFormat::Hex);
+        assert_eq!(back.params.qos, 1);
+        assert!(back.params.retain);
+        assert_eq!(back.params.content_type.as_deref(), Some("application/json"));
+        assert_eq!(back.params.user_properties.len(), 1);
+        assert!(back.params.raw_bytes.is_none());
+    }
+
+    #[test]
+    fn payload_format_equality_and_default() {
+        assert_eq!(PayloadFormat::default(), PayloadFormat::Plaintext);
+        assert_ne!(PayloadFormat::Hex, PayloadFormat::Base64);
+        let json = serde_json::to_string(&PayloadFormat::Hex).unwrap();
+        assert_eq!(
+            serde_json::from_str::<PayloadFormat>(&json).unwrap(),
+            PayloadFormat::Hex
+        );
+    }
+
+    // 向后兼容：旧版 connections.json 不含 Phase 1 新字段，必须能反序列化且取默认值
+    #[test]
+    fn legacy_connection_json_fills_new_defaults() {
+        let legacy = r#"{
+            "id": "c1",
+            "name": "旧连接",
+            "host": "broker.emqx.io",
+            "port": 1883,
+            "client_id": "legacy_cid",
+            "keep_alive": 30
+        }"#;
+        let c: ConnectionConfig = serde_json::from_str(legacy).expect("旧版 JSON 应能反序列化");
+        assert_eq!(c.name, "旧连接");
+        assert_eq!(c.keep_alive, 30);
+        assert!(c.group.is_none(), "group 默认应为 None");
+        assert_eq!(c.connection_timeout_secs, 10, "连接超时默认 10 秒");
+        assert_eq!(c.max_reconnect_times, 0, "最大重连次数默认 0（无限）");
+        assert!(c.ssl.ca_file.is_empty());
+        assert!(c.ssl.client_cert_file.is_empty());
+        assert!(c.ssl.client_key_file.is_empty());
+        assert!(!c.ssl.ignore_ca, "ignore_ca 默认关闭");
+    }
+
+    // 向后兼容：旧版订阅 JSON 必须默认 enabled=true，其余 v5 选项为关闭/None
+    #[test]
+    fn legacy_subscription_json_defaults_enabled() {
+        let legacy = r#"{"id":"s1","connection_id":"c1","topic":"a/b","qos":1}"#;
+        let s: Subscription = serde_json::from_str(legacy).expect("旧版订阅应能反序列化");
+        assert!(s.enabled, "旧订阅默认启用");
+        assert!(s.alias.is_none());
+        assert!(s.sub_identifier.is_none());
+        assert!(!s.no_local);
+        assert!(!s.retain_as_published);
+        assert_eq!(s.retain_handling, 0);
+        // Subscription::new 同样产出默认启用的订阅
+        assert!(Subscription::new("c1", "t", 0).enabled);
+    }
+
+    // payload 截断：上限内不截断；超出时截断且不切坏 UTF-8 字符
+    #[test]
+    fn retained_payload_caps_and_preserves_utf8() {
+        let small = b"hello";
+        let (p, raw, trunc) = retained_payload(small);
+        assert_eq!(&*p, "hello");
+        assert!(raw.is_none(), "合法 UTF-8 不保留原始字节");
+        assert!(!trunc);
+
+        // 中文每字符 3 字节，让上限落在字符中间（256K 不是 3 的倍数）
+        let big: Vec<u8> = "中".repeat(MAX_PAYLOAD_RETAIN).into_bytes();
+        let (p, _, trunc) = retained_payload(&big);
+        assert!(trunc, "超过上限必须截断");
+        assert!(p.len() <= MAX_PAYLOAD_RETAIN);
+        assert_eq!(p.chars().last(), Some('中'), "不能切坏 UTF-8 字符");
+        assert!(
+            big.starts_with(p.as_bytes()),
+            "截断内容必须是原数据前缀"
+        );
+
+        // 恰好上限不截断
+        let exact = vec![b'a'; MAX_PAYLOAD_RETAIN];
+        let (_, raw, trunc) = retained_payload(&exact);
+        assert!(!trunc);
+        assert!(raw.is_none());
+    }
+
+    // 非文本负载：保留原始字节供 Hex/Base64 详情，文本侧 lossy 展示
+    #[test]
+    fn retained_payload_keeps_raw_bytes_for_binary() {
+        let binary = vec![0x00, 0xff, 0xfe, 0x01];
+        let (p, raw, trunc) = retained_payload(&binary);
+        assert!(!trunc);
+        assert_eq!(&*p, String::from_utf8_lossy(&binary));
+        let raw = raw.expect("非法 UTF-8 必须保留原始字节");
+        assert_eq!(&*raw, &binary);
+    }
+
+    // Hex 编码：多字节字符不得 panic（曾按字节切片落入字符边界内而崩溃）
+    #[test]
+    fn hex_encode_rejects_non_hex_without_panic() {
+        assert!(PayloadFormat::Hex.encode("deadBEEF").is_ok());
+        assert!(PayloadFormat::Hex.encode("de ad be ef").is_ok());
+        assert!(PayloadFormat::Hex.encode("abc").is_err(), "奇数长度报错");
+        assert!(PayloadFormat::Hex.encode("zz").is_err(), "非法字符报错");
+        // 偶数字节长度的多字节字符：修复前此处在字符边界内切片 panic
+        assert!(PayloadFormat::Hex.encode("中文").is_err());
+        assert!(PayloadFormat::Hex.encode("😀").is_err());
+    }
+
+    // 会话参数比较必须覆盖所有随 CONNECT 报文一次性生效的字段
+    #[test]
+    fn session_params_changed_covers_connect_time_fields() {
+        let a = ConnectionConfig::default();
+        let mut b = a.clone();
+        assert!(!a.session_params_changed(&b));
+
+        b.keep_alive = a.keep_alive + 1;
+        assert!(a.session_params_changed(&b), "keep_alive 改动应触发重连提示");
+        b = a.clone();
+
+        b.last_will = Some(LastWill {
+            topic: "w/t".into(),
+            ..Default::default()
+        });
+        assert!(a.session_params_changed(&b), "遗嘱改动应触发重连提示");
+        b = a.clone();
+
+        b.ssl.ca_file = "/tmp/ca.pem".into();
+        assert!(a.session_params_changed(&b), "TLS 配置改动应触发重连提示");
+    }
+
+    fn ring_record(seq: u64, payload_len: usize, raw_len: usize) -> MqttRecord {
+        MqttRecord {
+            seq,
+            connection_id: "c".into(),
+            direction: Direction::Received,
+            topic: "t".into(),
+            payload: Arc::from("a".repeat(payload_len)),
+            qos: 0,
+            retain: false,
+            timestamp: 0,
+            user_properties: Vec::new(),
+            content_type: None,
+            response_topic: None,
+            correlation_data: None,
+            message_expiry_interval: None,
+            subscription_identifier: None,
+            payload_truncated: false,
+            raw_bytes: if raw_len > 0 {
+                Some(Arc::from(vec![0u8; raw_len]))
+            } else {
+                None
+            },
+        }
+    }
+
+    // 消息环形缓冲：条数上限正常驱逐
+    #[test]
+    fn message_ring_enforces_count_limit() {
+        let mut ring = MessageRing::new(4);
+        for i in 0..10 {
+            ring.push(ring_record(i, 64, 0), 4);
+        }
+        assert_eq!(ring.len(), 4);
+        assert_eq!(
+            ring.iter().next().map(|r| r.seq),
+            Some(6),
+            "应从最旧开始驱逐"
+        );
+        assert_eq!(ring.retained_bytes(), 4 * 64);
+    }
+
+    // 消息环形缓冲：大报文流下字节预算优先于条数上限，内存有上界
+    #[test]
+    fn message_ring_enforces_byte_budget() {
+        let mut ring = MessageRing::new(2000);
+        // 每条 256KB（payload 128KB + raw 128KB）：2000 条本会到 512MB
+        let per = MAX_PAYLOAD_RETAIN;
+        for i in 0..2000 {
+            ring.push(ring_record(i, per, per), 2000);
+        }
+        assert!(
+            ring.retained_bytes() <= MAX_CONNECTION_MESSAGE_BYTES + 2 * per,
+            "字节数 {} 超出预算 {}",
+            ring.retained_bytes(),
+            MAX_CONNECTION_MESSAGE_BYTES
+        );
+        assert!(
+            ring.len() < 2000,
+            "大报文流不应保留满额条数（实际 {} 条）",
+            ring.len()
+        );
+        assert_eq!(ring.iter().next().map(|r| r.seq), Some((2000 - ring.len()) as u64));
+    }
+
+    // 单条超预算的记录也至少保留最新一条（列表不能被清空）
+    #[test]
+    fn message_ring_never_empties_on_oversized_record() {
+        let mut ring = MessageRing::new(10);
+        ring.push(ring_record(0, MAX_PAYLOAD_RETAIN, MAX_PAYLOAD_RETAIN), 10);
+        assert_eq!(ring.len(), 1);
+        ring.push(ring_record(1, 64, 0), 10);
+        assert_eq!(ring.len(), 2);
+        assert_eq!(ring.iter().next().map(|r| r.seq), Some(0));
+    }
+}

gpui-app/src/model/publish.rs

@@ -0,0 +1,57 @@
+//! 发布：发布参数与可保存的发布预设。
+
+
+use serde::{Deserialize, Serialize};
+
+
+use super::*;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct PublishParams {
+    pub topic: String,
+    /// 用于界面展示与记录的文本负载。
+    pub payload: String,
+    #[serde(default)]
+    pub payload_format: PayloadFormat,
+    pub qos: u8,
+    pub retain: bool,
+    /// MQTT 5 用户属性
+    #[serde(default)]
+    pub user_properties: Vec<(String, String)>,
+    #[serde(default)]
+    pub content_type: Option<String>,
+    #[serde(default)]
+    pub message_expiry_interval: Option<u32>,
+    #[serde(default)]
+    pub response_topic: Option<String>,
+    #[serde(default)]
+    pub correlation_data: Option<String>,
+    /// 实际发送的字节。Base64/Hex 时为解码结果；不持久化、不参与预设。
+    /// None 时引擎回退为 `payload.as_bytes()`。
+    #[serde(skip)]
+    pub raw_bytes: Option<Vec<u8>>,
+}
+
+/// 发布预设：保存常用的发布参数，一键复用（对标 MQTTX Publish Scripts/Preset）。
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PublishPreset {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub connection_id: Option<String>,
+    #[serde(flatten)]
+    pub params: PublishParams,
+}
+
+impl PublishPreset {
+    pub fn new(name: impl Into<String>, params: PublishParams) -> Self {
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            name: name.into(),
+            connection_id: None,
+            params,
+        }
+    }
+}
+
+// ─── 全局变量 ────────────────────────────────────────────────────────────────

gpui-app/src/model/settings.rs

@@ -0,0 +1,82 @@
+//! 应用设置：连接状态枚举、主题偏好与全局设置项。
+
+
+use serde::{Deserialize, Serialize};
+
+
+use super::*;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum ConnectionStatus {
+    #[default]
+    Disconnected,
+    Connecting,
+    Connected,
+    Error,
+}
+
+impl ConnectionStatus {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Disconnected => "未连接",
+            Self::Connecting => "连接中",
+            Self::Connected => "已连接",
+            Self::Error => "错误",
+        }
+    }
+}
+
+// ─── 应用设置 ────────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum ThemeModePref {
+    Light,
+    Dark,
+    #[default]
+    System,
+}
+
+impl ThemeModePref {
+    pub const ALL: [Self; 3] = [Self::System, Self::Light, Self::Dark];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::System => "跟随系统",
+            Self::Light => "浅色",
+            Self::Dark => "深色",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppSettings {
+    #[serde(default)]
+    pub theme: ThemeModePref,
+    /// 每条连接在内存中保留的最大消息条数
+    #[serde(default = "default_max_messages")]
+    pub max_messages: usize,
+    /// 时间戳是否显示毫秒
+    #[serde(default = "default_true")]
+    pub show_millis: bool,
+    /// 是否自动检查更新（占位，暂不实现更新）
+    #[serde(default = "default_true")]
+    pub auto_check_update: bool,
+}
+
+fn default_max_messages() -> usize {
+    2000
+}
+
+impl Default for AppSettings {
+    fn default() -> Self {
+        Self {
+            theme: ThemeModePref::default(),
+            max_messages: default_max_messages(),
+            show_millis: true,
+            auto_check_update: true,
+        }
+    }
+}
+
+// ─── 单元测试 ────────────────────────────────────────────────────────────────

gpui-app/src/model/subscription.rs

@@ -0,0 +1,80 @@
+//! 订阅：订阅条目与下发引擎的订阅选项。
+
+
+use serde::{Deserialize, Serialize};
+
+
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Subscription {
+    pub id: String,
+    pub connection_id: String,
+    pub topic: String,
+    pub qos: u8,
+    /// 本地备注颜色（与 MQTTX 一致，按订阅给消息着色），0..=359 色相
+    #[serde(default)]
+    pub color: Option<f32>,
+    /// 订阅别名（对标 MQTTX topic alias），仅用于界面展示
+    #[serde(default)]
+    pub alias: Option<String>,
+    /// 是否启用该订阅；禁用后界面置灰、恢复订阅时跳过
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    /// MQTT 5 订阅标识符
+    #[serde(default)]
+    pub sub_identifier: Option<u32>,
+    /// MQTT 5 No Local (NL)
+    #[serde(default)]
+    pub no_local: bool,
+    /// MQTT 5 Retain As Published (RAP)
+    #[serde(default)]
+    pub retain_as_published: bool,
+    /// MQTT 5 Retain Handling (0/1/2)
+    #[serde(default)]
+    pub retain_handling: u8,
+}
+
+impl Subscription {
+    pub fn new(connection_id: impl Into<String>, topic: impl Into<String>, qos: u8) -> Self {
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            connection_id: connection_id.into(),
+            topic: topic.into(),
+            qos,
+            color: None,
+            alias: None,
+            enabled: true,
+            sub_identifier: None,
+            no_local: false,
+            retain_as_published: false,
+            retain_handling: 0,
+        }
+    }
+}
+
+/// MQTT 5 订阅选项（NL/RAP/Retain Handling/订阅标识符）；v4 连接会忽略这些选项。
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SubscribeOptions {
+    /// 订阅标识符，0 视为未设置
+    #[serde(default)]
+    pub sub_identifier: Option<u32>,
+    #[serde(default)]
+    pub no_local: bool,
+    #[serde(default)]
+    pub retain_as_published: bool,
+    /// 0=每次订阅都发送保留消息，1=仅新订阅发送，2=不发送
+    #[serde(default)]
+    pub retain_handling: u8,
+}
+
+impl From<&Subscription> for SubscribeOptions {
+    fn from(sub: &Subscription) -> Self {
+        Self {
+            sub_identifier: sub.sub_identifier,
+            no_local: sub.no_local,
+            retain_as_published: sub.retain_as_published,
+            retain_handling: sub.retain_handling,
+        }
+    }
+}

gpui-app/src/model/variable.rs

@@ -0,0 +1,71 @@
+//! 全局变量：模板占位符渲染（含 {{timestamp}} 时间基一致性）。
+
+
+use serde::{Deserialize, Serialize};
+
+
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GlobalVariable {
+    pub key: String,
+    pub value: String,
+}
+
+/// 解析 `{{key}}` 模板：
+/// - 用户定义的全局变量优先；
+/// - 内置变量：`{{$ts}}`（unix 秒）、`{{$ts_ms}}`（毫秒）、`{{$uuid}}`；
+/// - 找不到的占位符保持原样。
+pub fn render_template(input: &str, vars: &[GlobalVariable]) -> String {
+    let mut out = String::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    // 同一次渲染内时间基准保持一致，避免一条消息里多个时间变量取值不同。
+    let now_ms = chrono::Local::now().timestamp_millis();
+    let now_s = now_ms / 1000;
+    let mut i = 0;
+    while i < bytes.len() {
+        if i + 1 < bytes.len() && bytes[i] == b'{' && bytes[i + 1] == b'{'
+            && let Some(rel_end) = input[i + 2..].find("}}") {
+                let key = &input[i + 2..i + 2 + rel_end];
+                let resolved = match key.trim() {
+                    "$ts" => Some(now_s.to_string()),
+                    "$ts_ms" => Some(now_ms.to_string()),
+                    "$uuid" => Some(uuid::Uuid::new_v4().to_string()),
+                    k => vars
+                        .iter()
+                        .find(|v| v.key == k)
+                        .map(|v| v.value.clone()),
+                };
+                match resolved {
+                    Some(v) => out.push_str(&v),
+                    None => out.push_str(&input[i..i + 2 + rel_end + 2]),
+                }
+                i = i + 2 + rel_end + 2;
+                continue;
+            }
+        // 按字符推进，避免把多字节 UTF-8 拆开
+        let ch = input[i..].chars().next().unwrap();
+        out.push(ch);
+        i += ch.len_utf8();
+    }
+    out
+}
+
+/// 连接前渲染遗嘱消息中的 `{{变量}}`。
+/// 只作用于本次连接的配置副本，落盘的连接配置保持模板原文，
+/// 这样改全局变量后下次重连即生效，`$ts` 等也按连接时刻求值。
+pub fn render_will_templates(cfg: &mut ConnectionConfig, vars: &[GlobalVariable]) {
+    let Some(will) = cfg.last_will.as_mut() else {
+        return;
+    };
+    will.topic = render_template(&will.topic, vars);
+    will.payload = render_template(&will.payload, vars);
+    if let Some(v) = will.content_type.take() {
+        will.content_type = Some(render_template(&v, vars));
+    }
+    if let Some(v) = will.response_topic.take() {
+        will.response_topic = Some(render_template(&v, vars));
+    }
+}
+
+// ─── 日志 ────────────────────────────────────────────────────────────────────