Merge pull request locainin#13 from locainin/dev

see here: locainin#13 (comment)

Author: locainin

crates/noticenterctl/src/dbus/dbus_ops.rs

@@ -1,42 +1,47 @@
 //! D-Bus command execution for noticenterctl.
 
-use anyhow::Result;
+use std::future::Future;
+use std::time::Duration;
+
+use anyhow::{anyhow, Result};
 use unixnotis_core::{util, ControlProxy};
 
 use crate::cli_args::{Command, DndState};
 use crate::main_log_follow::follow_debug_logs;
 use crate::main_output::{print_inhibitors, print_notifications};
 
+const CONTROL_CALL_TIMEOUT: Duration = Duration::from_secs(5);
+
 pub(crate) async fn handle_command(proxy: &ControlProxy<'_>, command: Command) -> Result<()> {
     // CLI forwards work to the daemon
     match command {
         Command::TogglePanel => {
             // Simple toggle keeps the daemon in control of its own visibility rules.
-            proxy.toggle_panel().await?;
+            run_control_call(proxy.toggle_panel()).await?;
         }
         Command::OpenPanel { debug } => {
             // Debug mode opens the panel and streams daemon logs for real-time triage.
             if let Some(level) = debug {
-                proxy.open_panel_debug(level.into()).await?;
+                run_control_call(proxy.open_panel_debug(level.into())).await?;
                 // Panel open should still succeed when journal follow is unavailable.
                 if let Err(err) = follow_debug_logs() {
                     eprintln!("debug log follow unavailable: {err}");
                 }
             } else {
-                proxy.open_panel().await?;
+                run_control_call(proxy.open_panel()).await?;
             }
         }
         Command::ClosePanel => {
             // Explicit close avoids accidental toggles when the panel is hidden.
-            proxy.close_panel().await?;
+            run_control_call(proxy.close_panel()).await?;
         }
         Command::Clear => {
             // Clear removes both active notifications and history entries.
-            proxy.clear_all().await?;
+            run_control_call(proxy.clear_all()).await?;
         }
         Command::Dismiss { id } => {
             // Dismiss targets a single notification by id.
-            proxy.dismiss(id).await?;
+            run_control_call(proxy.dismiss(id)).await?;
         }
         Command::ListActive { full } => {
             // Full output needs the debug gate
@@ -45,7 +50,7 @@ pub(crate) async fn handle_command(proxy: &ControlProxy<'_>, command: Command) -
                 // Fall back to the safe view
                 eprintln!("--full requires UNIXNOTIS_DIAGNOSTIC=1; using redacted output");
             }
-            let notifications = proxy.list_active().await?;
+            let notifications = run_control_call(proxy.list_active()).await?;
             // Shared output helper
             print_notifications("active", &notifications, allow_full);
         }
@@ -55,34 +60,34 @@ pub(crate) async fn handle_command(proxy: &ControlProxy<'_>, command: Command) -
             if full && !util::diagnostic_mode() {
                 eprintln!("--full requires UNIXNOTIS_DIAGNOSTIC=1; using redacted output");
             }
-            let notifications = proxy.list_history().await?;
+            let notifications = run_control_call(proxy.list_history()).await?;
             print_notifications("history", &notifications, allow_full);
         }
         Command::Dnd { state } => match state {
             DndState::On => {
                 // Explicit enable avoids ambiguous scripts.
-                proxy.set_dnd(true).await?;
+                run_control_call(proxy.set_dnd(true)).await?;
             }
             DndState::Off => {
                 // Explicit disable avoids ambiguous scripts.
-                proxy.set_dnd(false).await?;
+                run_control_call(proxy.set_dnd(false)).await?;
             }
             DndState::Toggle => {
                 // Toggle must happen atomically in the daemon to avoid read-modify-write races.
-                proxy.toggle_dnd().await?;
+                run_control_call(proxy.toggle_dnd()).await?;
             }
         },
         Command::Inhibit { reason, scope } => {
             // Print the token only
-            let token = proxy.inhibit(&reason, scope.as_scope()).await?;
+            let token = run_control_call(proxy.inhibit(&reason, scope.as_scope())).await?;
             println!("{token}");
         }
         Command::Uninhibit { id } => {
             // Token removal is safe to repeat if a previous call already released it.
-            proxy.uninhibit(id).await?;
+            run_control_call(proxy.uninhibit(id)).await?;
         }
         Command::ListInhibitors => {
-            let inhibitors = proxy.list_inhibitors().await?;
+            let inhibitors = run_control_call(proxy.list_inhibitors()).await?;
             // Shared output helper
             print_inhibitors(&inhibitors);
         }
@@ -96,3 +101,14 @@ pub(crate) async fn handle_command(proxy: &ControlProxy<'_>, command: Command) -
 
     Ok(())
 }
+
+async fn run_control_call<T>(call: impl Future<Output = zbus::Result<T>>) -> Result<T> {
+    match tokio::time::timeout(CONTROL_CALL_TIMEOUT, call).await {
+        Ok(Ok(value)) => Ok(value),
+        Ok(Err(err)) => Err(err.into()),
+        Err(_) => Err(anyhow!(
+            "timed out waiting for unixnotis daemon response after {}s",
+            CONTROL_CALL_TIMEOUT.as_secs()
+        )),
+    }
+}

crates/unixnotis-daemon/src/daemon.rs

@@ -54,10 +54,17 @@ pub struct DaemonState {
     // Burst tracking lets one noisy sender fall back to snapshot invalidation
     // instead of forcing a storm of full add/update fanout
     notification_signal_bursts: StdMutex<std::collections::HashMap<String, NotificationBurstState>>,
+    // Trial mode allows local rebuild loops without forcing daemon restarts for control auth
+    trial_mode: bool,
 }
 
 impl DaemonState {
-    pub fn new(connection: Connection, config: Config, sound: SoundSettings) -> Arc<Self> {
+    pub fn new(
+        connection: Connection,
+        config: Config,
+        sound: SoundSettings,
+        trial_mode: bool,
+    ) -> Arc<Self> {
         let store = NotificationStore::new(config);
         Arc::new(Self {
             store: Mutex::new(store),
@@ -70,6 +77,7 @@ impl DaemonState {
             last_emitted_state: StdMutex::new(None),
             last_emitted_popup_gate: StdMutex::new(None),
             notification_signal_bursts: StdMutex::new(std::collections::HashMap::new()),
+            trial_mode,
         })
     }
 
@@ -246,6 +254,10 @@ impl DaemonState {
             sender_name.unwrap_or("<unknown>"),
         )
     }
+
+    pub(crate) fn trial_mode(&self) -> bool {
+        self.trial_mode
+    }
 }
 
 pub(crate) fn to_fdo_error(err: zbus::Error) -> zbus::fdo::Error {