feat(logging): compact coloured timestamp + fix UI compile error

Adds src/logging.rs with CompactUtcTime (FormatTime impl, time crate).
Replaces the default ISO 8601 timestamp with [2026-05-22]-[12:56:28.9].
ANSI-gated colouring on terminals: orange date digits, light blue time
digits, darker shades on internal punctuation, gray brackets/separator,
green separator dash. Plain text fallback for the UI log panel and
Android Logcat. Wired into all three subscriber setups (main, UI, JNI).

Also fixes a compile error in the UI binary: stream_timeout_secs was
added to Config in b3c51e0 but never plumbed through FormState. Added
to the struct, both init paths (load-from-config and fresh-default),
to_config() output, and ConfigWire so Save doesn't drop a non-default
value.

Author: CaptainMirage

src/android_jni.rs

@@ -132,6 +132,7 @@ fn install_logging_once() {
             .with_target(false)
             .with_ansi(false)
             .with_writer(LogcatWriter)
+            .with_timer(crate::logging::CompactUtcTime)
             .try_init();
 
         let _ = rustls::crypto::ring::default_provider().install_default();

src/bin/ui.rs

@@ -294,6 +294,7 @@ struct FormState {
     auto_blacklist_window_secs: u64,
     auto_blacklist_cooldown_secs: u64,
     request_timeout_secs: u64,
+    stream_timeout_secs: u64,
     /// Optional second-hop exit node for CF-anti-bot bypass (chatgpt.com /
     /// claude.ai / grok.com / x.com). Config-only — no UI editor yet.
     /// See `assets/exit_node/` for the generic exit-node handler.
@@ -391,6 +392,7 @@ fn load_form() -> (FormState, Option<String>) {
             auto_blacklist_window_secs: c.auto_blacklist_window_secs,
             auto_blacklist_cooldown_secs: c.auto_blacklist_cooldown_secs,
             request_timeout_secs: c.request_timeout_secs,
+            stream_timeout_secs: c.stream_timeout_secs,
             exit_node: c.exit_node.clone(),
         }
     } else {
@@ -433,6 +435,7 @@ fn load_form() -> (FormState, Option<String>) {
             auto_blacklist_window_secs: 30,
             auto_blacklist_cooldown_secs: 120,
             request_timeout_secs: 30,
+            stream_timeout_secs: 300,
             exit_node: mhrv_rs::config::ExitNodeConfig::default(),
         }
     };
@@ -618,6 +621,7 @@ impl FormState {
             auto_blacklist_window_secs: self.auto_blacklist_window_secs,
             auto_blacklist_cooldown_secs: self.auto_blacklist_cooldown_secs,
             request_timeout_secs: self.request_timeout_secs,
+            stream_timeout_secs: self.stream_timeout_secs,
             // Exit-node config (CF-anti-bot bypass for chatgpt.com / claude.ai
             // / grok.com / x.com). Round-trip through FormState — config-only
             // editing for now, UI editor planned for v1.9.x desktop UI batch.
@@ -637,6 +641,166 @@ fn save_config(cfg: &Config) -> Result<PathBuf, String> {
     Ok(path)
 }
 
+#[derive(serde::Serialize)]
+struct ConfigWire<'a> {
+    mode: &'a str,
+    google_ip: &'a str,
+    front_domain: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    script_id: Option<ScriptIdWire<'a>>,
+    auth_key: &'a str,
+    listen_host: &'a str,
+    listen_port: u16,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    socks5_port: Option<u16>,
+    log_level: &'a str,
+    verify_ssl: bool,
+    #[serde(skip_serializing_if = "std::collections::HashMap::is_empty")]
+    hosts: &'a std::collections::HashMap<String, String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    upstream_socks5: Option<&'a str>,
+    #[serde(skip_serializing_if = "is_zero_u8")]
+    parallel_relay: u8,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    sni_hosts: Option<Vec<&'a str>>,
+    #[serde(skip_serializing_if = "is_false")]
+    normalize_x_graphql: bool,
+    #[serde(skip_serializing_if = "is_false")]
+    youtube_via_relay: bool,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    passthrough_hosts: &'a Vec<String>,
+    // IP-scan knobs. These used to be missing from the wire struct, so
+    // every Save-config silently dropped them — the user would toggle
+    // "fetch from API" on, save, reopen, and find it off again. Add
+    // them here and keep them in sync if Config ever grows more.
+    #[serde(skip_serializing_if = "is_false")]
+    fetch_ips_from_api: bool,
+    max_ips_to_scan: usize,
+    scan_batch_size: usize,
+    google_ip_validation: bool,
+    /// Default false (= bypass DoH). Only emitted when explicitly true
+    /// so unchanged configs stay clean.
+    #[serde(skip_serializing_if = "is_false")]
+    tunnel_doh: bool,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    bypass_doh_hosts: &'a Vec<String>,
+    /// PR #763: default true (= browser DoH rejected, system DNS used).
+    /// Skip when matching default to keep unchanged configs clean —
+    /// emit only when the user has explicitly disabled the block.
+    #[serde(skip_serializing_if = "is_true")]
+    block_doh: bool,
+    /// Default false. Emit only when the user enables STUN/TURN blocking.
+    #[serde(skip_serializing_if = "is_false")]
+    block_stun: bool,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    fronting_groups: &'a Vec<FrontingGroup>,
+    /// Auto-blacklist tuning + batch timeout (#391, #444, #430). Skip
+    /// serialization when matching the historical defaults so unchanged
+    /// configs stay clean — only emitted when the user has explicitly
+    /// tuned them.
+    #[serde(skip_serializing_if = "is_default_strikes")]
+    auto_blacklist_strikes: u32,
+    #[serde(skip_serializing_if = "is_default_window_secs")]
+    auto_blacklist_window_secs: u64,
+    #[serde(skip_serializing_if = "is_default_cooldown_secs")]
+    auto_blacklist_cooldown_secs: u64,
+    #[serde(skip_serializing_if = "is_default_timeout_secs")]
+    request_timeout_secs: u64,
+    #[serde(skip_serializing_if = "is_default_stream_timeout_secs")]
+    stream_timeout_secs: u64,
+    /// HTTP/2 multiplexing kill switch. Default false (h2 active); only
+    /// emitted on save when the user has explicitly disabled h2, so
+    /// unchanged configs stay clean.
+    #[serde(skip_serializing_if = "is_false")]
+    force_http1: bool,
+    /// Exit-node config (CF-anti-bot bypass for chatgpt.com / claude.ai /
+    /// grok.com / x.com via exit-node second-hop relay). Skip when fully
+    /// default (disabled with no URL/PSK/hosts) so configs without
+    /// exit-node setup stay clean. Round-tripped through FormState so
+    /// Save preserves user-edited values.
+    #[serde(skip_serializing_if = "is_default_exit_node")]
+    exit_node: &'a mhrv_rs::config::ExitNodeConfig,
+}
+
+fn is_default_strikes(v: &u32) -> bool { *v == 3 }
+fn is_default_window_secs(v: &u64) -> bool { *v == 30 }
+fn is_default_cooldown_secs(v: &u64) -> bool { *v == 120 }
+fn is_default_timeout_secs(v: &u64) -> bool { *v == 30 }
+fn is_default_stream_timeout_secs(v: &u64) -> bool { *v == 300 }
+fn is_default_exit_node(en: &&mhrv_rs::config::ExitNodeConfig) -> bool {
+    !en.enabled
+        && en.relay_url.is_empty()
+        && en.psk.is_empty()
+        && en.hosts.is_empty()
+        && (en.mode.is_empty() || en.mode == "selective")
+}
+
+fn is_false(b: &bool) -> bool {
+    !*b
+}
+
+fn is_true(b: &bool) -> bool {
+    *b
+}
+
+fn is_zero_u8(v: &u8) -> bool {
+    *v == 0
+}
+
+#[derive(serde::Serialize)]
+#[serde(untagged)]
+enum ScriptIdWire<'a> {
+    One(&'a str),
+    Many(Vec<&'a str>),
+}
+
+impl<'a> From<&'a Config> for ConfigWire<'a> {
+    fn from(c: &'a Config) -> Self {
+        let script_id = c.script_id.as_ref().map(|s| match s {
+            ScriptId::One(v) => ScriptIdWire::One(v.as_str()),
+            ScriptId::Many(v) => ScriptIdWire::Many(v.iter().map(String::as_str).collect()),
+        });
+        ConfigWire {
+            mode: c.mode.as_str(),
+            google_ip: c.google_ip.as_str(),
+            front_domain: c.front_domain.as_str(),
+            script_id,
+            auth_key: c.auth_key.as_str(),
+            listen_host: c.listen_host.as_str(),
+            listen_port: c.listen_port,
+            socks5_port: c.socks5_port,
+            log_level: c.log_level.as_str(),
+            verify_ssl: c.verify_ssl,
+            hosts: &c.hosts,
+            upstream_socks5: c.upstream_socks5.as_deref(),
+            parallel_relay: c.parallel_relay,
+            sni_hosts: c
+                .sni_hosts
+                .as_ref()
+                .map(|v| v.iter().map(String::as_str).collect()),
+            normalize_x_graphql: c.normalize_x_graphql,
+            youtube_via_relay: c.youtube_via_relay,
+            passthrough_hosts: &c.passthrough_hosts,
+            fetch_ips_from_api: c.fetch_ips_from_api,
+            max_ips_to_scan: c.max_ips_to_scan,
+            scan_batch_size: c.scan_batch_size,
+            google_ip_validation: c.google_ip_validation,
+            tunnel_doh: c.tunnel_doh,
+            bypass_doh_hosts: &c.bypass_doh_hosts,
+            block_doh: c.block_doh,
+            block_stun: c.block_stun,
+            fronting_groups: &c.fronting_groups,
+            auto_blacklist_strikes: c.auto_blacklist_strikes,
+            auto_blacklist_window_secs: c.auto_blacklist_window_secs,
+            auto_blacklist_cooldown_secs: c.auto_blacklist_cooldown_secs,
+            request_timeout_secs: c.request_timeout_secs,
+            stream_timeout_secs: c.stream_timeout_secs,
+            force_http1: c.force_http1,
+            exit_node: &c.exit_node,
+        }
+    }
+}
+
 /// Accent color — same blue used throughout the UI for primary actions.
 const ACCENT: egui::Color32 = egui::Color32::from_rgb(70, 120, 180);
 const ACCENT_HOVER: egui::Color32 = egui::Color32::from_rgb(90, 145, 205);
@@ -2480,7 +2644,8 @@ fn install_ui_tracing(shared: Arc<Shared>, config_level: &str) {
     let fmt_layer = tracing_subscriber::fmt::layer()
         .with_target(false)
         .with_ansi(false)
-        .with_writer(writer);
+        .with_writer(writer)
+        .with_timer(mhrv_rs::logging::CompactUtcTime);
 
     let _ = tracing_subscriber::registry()
         .with(filter_layer)

src/lib.rs

@@ -13,6 +13,7 @@ pub mod tunnel_client;
 pub mod scan_ips;
 pub mod scan_sni;
 pub mod test_cmd;
+pub mod logging;
 pub mod update_check;
 
 #[cfg(target_os = "android")]

src/logging.rs

@@ -0,0 +1,38 @@
+use time::OffsetDateTime;
+use tracing_subscriber::fmt::{format::Writer, time::FormatTime};
+
+pub struct CompactUtcTime;
+
+impl FormatTime for CompactUtcTime {
+    fn format_time(&self, w: &mut Writer<'_>) -> std::fmt::Result {
+        let now = OffsetDateTime::now_utc();
+        if w.has_ansi_escapes() {
+            write!(
+                w,
+                "{g}[{bo}{year:04}{odo}-{bo}{mo:02}{odo}-{bo}{day:02}{g}]{sg}-{g}[{sb}{h:02}{db}:{sb}{min:02}{db}:{sb}{s:02}{db}.{sb}{t}{g}]{r}",
+                g   = "\x1b[38;5;250m",  // light gray    — brackets
+                bo  = "\x1b[38;5;215m",  // light orange  — date digits
+                odo = "\x1b[38;5;166m",  // dark orange   — dashes inside date
+                sg  = "\x1b[38;5;120m",  // light green   — separator dash
+                sb  = "\x1b[38;5;159m",  // light blue    — time digits
+                db  = "\x1b[38;5;74m",   // dark blue     — colons + dot inside time
+                r   = "\x1b[0m",
+                year = now.year(),
+                mo   = now.month() as u8,
+                day  = now.day(),
+                h    = now.hour(),
+                min  = now.minute(),
+                s    = now.second(),
+                t    = now.millisecond() / 100,
+            )
+        } else {
+            write!(
+                w,
+                "[{:04}-{:02}-{:02}]-[{:02}:{:02}:{:02}.{}]",
+                now.year(), now.month() as u8, now.day(),
+                now.hour(), now.minute(), now.second(),
+                now.millisecond() / 100,
+            )
+        }
+    }
+}

src/main.rs

@@ -5,6 +5,7 @@ use std::process::ExitCode;
 use std::sync::Arc;
 
 use tokio::sync::Mutex;
+use mhrv_rs::logging::CompactUtcTime;
 use tracing_subscriber::EnvFilter;
 
 use mhrv_rs::cert_installer::{install_ca, is_ca_trusted, reconcile_sudo_environment, remove_ca};
@@ -131,6 +132,7 @@ fn init_logging(level: &str) {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(filter)
         .with_target(false)
+        .with_timer(CompactUtcTime)
         .try_init();
 }