autosave (vm / Linux)

Author: pshirshov

modules/nixos/zwave.nix

@@ -30,6 +30,7 @@ let
     sendEvents = true;
     publishNodeDetails = true;
     entityTemplate = "%nid";
+    ignoreLoc = true;
   };
 
   mqttSettingsJson = builtins.toJSON mqttSettings;

pkg/mqtt-controller/crates/mqtt-controller-frontend/src/app.rs

@@ -15,12 +15,43 @@ pub enum Tab {
     Heating,
 }
 
+impl Tab {
+    fn from_hash(hash: &str) -> Self {
+        match hash.trim_start_matches('#') {
+            "plugs" => Tab::Plugs,
+            "heating" => Tab::Heating,
+            _ => Tab::Rooms,
+        }
+    }
+
+    fn to_hash(self) -> &'static str {
+        match self {
+            Tab::Rooms => "#rooms",
+            Tab::Plugs => "#plugs",
+            Tab::Heating => "#heating",
+        }
+    }
+}
+
 #[component]
 pub fn App() -> impl IntoView {
     let ws = WsState::new();
     provide_context(ws.clone());
 
-    let (active_tab, set_active_tab) = signal(Tab::Rooms);
+    let initial_tab = web_sys::window()
+        .and_then(|w| w.location().hash().ok())
+        .map(|h| Tab::from_hash(&h))
+        .unwrap_or(Tab::Rooms);
+
+    let (active_tab, set_active_tab) = signal(initial_tab);
+
+    // Sync tab changes to URL hash.
+    Effect::new(move |_| {
+        let tab = active_tab.get();
+        if let Some(window) = web_sys::window() {
+            let _ = window.location().set_hash(tab.to_hash());
+        }
+    });
     provide_context(active_tab);
 
     // Auto-set entity filter based on active tab + topology.

pkg/mqtt-controller/crates/mqtt-controller-frontend/src/components/plug_card.rs

@@ -35,16 +35,22 @@ fn PlugCard(plug: PlugSnapshot) -> impl IntoView {
     let detail_name = plug.device.clone();
 
     let status_text = if plug.on { "ON" } else { "OFF" };
-    let idle_text = plug.idle_since_ago_ms.map(|ms| {
-        let secs = ms / 1000;
-        if secs < 60 {
-            format!(" (idle {secs}s)")
-        } else {
-            format!(" (idle {}m)", secs / 60)
-        }
-    }).unwrap_or_default();
     let power_text = plug.power_watts.map(|w| format!(" {w:.1}W")).unwrap_or_default();
-    let meta_text = format!("{status_text}{idle_text}{power_text}");
+    let meta_text = format!("{status_text}{power_text}");
+
+    // Kill-switch countdown badge: shows remaining time before auto-off.
+    let kill_switch_badge = plug.idle_since_ago_ms.and_then(|elapsed_ms| {
+        let holdoff_secs = plug.kill_switch_holdoff_secs?;
+        let elapsed_secs = elapsed_ms / 1000;
+        let remaining = holdoff_secs.saturating_sub(elapsed_secs);
+        let total_min = holdoff_secs / 60;
+        let text = if remaining < 60 {
+            format!("kill: {remaining}s / {total_min}m")
+        } else {
+            format!("kill: {}m / {total_min}m", remaining / 60)
+        };
+        Some(text)
+    });
 
     let json_text = serde_json::to_string_pretty(&plug).unwrap_or_default();
 
@@ -89,6 +95,9 @@ fn PlugCard(plug: PlugSnapshot) -> impl IntoView {
             </div>
             <div class="card-meta">
                 {meta_text}
+                {kill_switch_badge.map(|text| view! {
+                    <span class="badge kill-switch">{text}</span>
+                })}
             </div>
             <div class="card-controls">
                 <button

pkg/mqtt-controller/crates/mqtt-controller-frontend/style.css

@@ -140,6 +140,7 @@ header h1 {
 .badge.idle { background: var(--idle); color: #000; }
 .badge.unknown { background: var(--off); color: var(--text); }
 .badge.inhibited { background: #6a5acd; color: #fff; }
+.badge.kill-switch { background: var(--accent); color: #fff; }
 .badge.schedule-badge { background: var(--border); cursor: pointer; }
 
 .card-controls {

pkg/mqtt-controller/crates/mqtt-controller-wire/src/lib.rs

@@ -40,6 +40,11 @@ pub struct PlugSnapshot {
     pub on: bool,
     /// Milliseconds since the plug entered idle (power below threshold).
     pub idle_since_ago_ms: Option<u64>,
+    /// Kill-switch holdoff duration in seconds. When `idle_since_ago_ms`
+    /// is `Some`, this is the total holdoff the plug must survive before
+    /// being turned off.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kill_switch_holdoff_secs: Option<u64>,
     /// Most recent power reading in watts, if available.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub power_watts: Option<f64>,
@@ -274,6 +279,7 @@ mod tests {
                 device: "z2m-p-printer".into(),
                 on: true,
                 idle_since_ago_ms: Some(30000),
+                kill_switch_holdoff_secs: Some(600),
                 power_watts: Some(120.5),
             }],
             heating_zones: vec![HeatingZoneSnapshot {

pkg/mqtt-controller/crates/mqtt-controller/src/controller/kill_switch.rs

@@ -70,6 +70,26 @@ impl KillSwitchEvaluator {
             .min()
     }
 
+    /// Maximum holdoff duration across all `PowerBelow` rules targeting
+    /// `device` that are currently tracking idle. Returns `None` if no
+    /// rule is idle.
+    pub fn holdoff_secs(&self, device: &str) -> Option<u64> {
+        self.topology
+            .actions_for_power_below(device)
+            .iter()
+            .filter_map(|&idx| {
+                let resolved = &self.topology.actions()[idx];
+                if !self.idle_since.contains_key(&resolved.name) {
+                    return None;
+                }
+                match &resolved.trigger {
+                    Trigger::PowerBelow { for_seconds, .. } => Some(*for_seconds),
+                    _ => None,
+                }
+            })
+            .max()
+    }
+
     /// Clear all kill-switch tracking for a device. Called on any
     /// off-transition (explicit off, toggle off, kill-switch fire from
     /// the controller side, etc.).

pkg/mqtt-controller/crates/mqtt-controller/src/controller/mod.rs

@@ -331,6 +331,12 @@ impl Controller {
         self.kill_switch.earliest_idle(device)
     }
 
+    /// Maximum kill-switch holdoff duration (seconds) for idle rules
+    /// targeting `device`.
+    pub fn kill_switch_holdoff_secs(&self, device: &str) -> Option<u64> {
+        self.kill_switch.holdoff_secs(device)
+    }
+
     /// Reference to the immutable topology.
     pub fn topology(&self) -> &Arc<Topology> {
         &self.topology

pkg/mqtt-controller/crates/mqtt-controller/src/web/snapshot.rs

@@ -36,10 +36,12 @@ pub fn build_full_snapshot(controller: &Controller, now: Instant) -> FullStateSn
             let idle_since_ago_ms = controller
                 .earliest_kill_switch_idle(name)
                 .map(|t| ago_ms(now, t));
+            let kill_switch_holdoff_secs = controller.kill_switch_holdoff_secs(name);
             PlugSnapshot {
                 device: name.clone(),
                 on: state.map_or(false, |s| s.on),
                 idle_since_ago_ms,
+                kill_switch_holdoff_secs,
                 power_watts: state.and_then(|s| s.last_power),
             }
         })
@@ -127,10 +129,12 @@ pub fn build_plug_snapshot(
     let idle_since_ago_ms = controller
         .earliest_kill_switch_idle(device)
         .map(|t| ago_ms(now, t));
+    let kill_switch_holdoff_secs = controller.kill_switch_holdoff_secs(device);
     Some(PlugSnapshot {
         device: device.to_string(),
         on: state.on,
         idle_since_ago_ms,
+        kill_switch_holdoff_secs,
         power_watts: state.last_power,
     })
 }