feat: linux back-end abstraction

.gitignore

@@ -33,3 +33,10 @@ Thumbs.db
 tmp/
 .temp/
 dist/
+
+# Local agent/tooling installs
+/.agents/
+/.claude/
+/node_modules/
+/package.json
+/bun.lock

Cargo.toml

@@ -10,6 +10,7 @@ serde_json = "1"
 image = { version = "0.25", default-features = false, features = ["png"] }
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 clap = { version = "4.5", features = ["derive"] }
+base64 = "0.22"
 
 # GTK stack
 gtk4 = { version = "0.8", package = "gtk4" }

src/app/tray.rs

@@ -404,7 +404,13 @@ pub fn run_launcher(settings: Settings) -> AppResult<()> {
                 doctor_view
                     .buffer()
                     .set_text(&diagnostics_service::doctor_report());
-                status_label.set_text(&result.message);
+                let status_prefix = match (result.attempted, result.repaired) {
+                    (true, true) => "Repair complete",
+                    (true, false) => "Repair attempted",
+                    (false, true) => "No repair needed",
+                    (false, false) => "Repair unavailable",
+                };
+                status_label.set_text(&format!("{status_prefix}: {}", result.message));
             });
         }
         connect_clear_shortcut(

src/app/window.rs

@@ -234,6 +234,10 @@ pub fn run(capture: CaptureResult, settings: Settings, current_mode: CaptureMode
         close_after_copy_toggle.set_active(settings.borrow().close_after_copy);
         close_after_copy_toggle
             .set_tooltip_text(Some("Close the editor immediately after Ctrl+C or Copy."));
+        let close_after_save_toggle = gtk::CheckButton::with_label("Close After Save");
+        close_after_save_toggle.set_active(settings.borrow().close_after_save);
+        close_after_save_toggle
+            .set_tooltip_text(Some("Close the editor immediately after Save or Save As."));
         let open_after_save_toggle = gtk::CheckButton::with_label("Open After Save");
         open_after_save_toggle.set_active(settings.borrow().open_after_save);
         open_after_save_toggle
@@ -278,15 +282,20 @@ pub fn run(capture: CaptureResult, settings: Settings, current_mode: CaptureMode
             let c = canvas.clone();
             let s = Rc::clone(&settings);
             let status_label = status_label.clone();
+            let app = app.clone();
             save_btn.connect_clicked(move |_| {
                 if let Ok(png) = c.render_png() {
                     let cfg = s.borrow();
                     if let Ok(path) = export::save_capture(&png, &cfg, current_mode) {
+                        let close_after_save = cfg.close_after_save;
                         c.mark_saved();
                         let _ = export::maybe_open_saved_path(&path, &cfg);
                         status_label
                             .set_text(&format!("Saved annotated image to {}.", path.display()));
                         eprintln!("Saved annotated image: {}", path.display());
+                        if close_after_save {
+                            app.quit();
+                        }
                     } else {
                         status_label.set_text("Saving failed. Check the terminal for details.");
                     }
@@ -312,6 +321,14 @@ pub fn run(capture: CaptureResult, settings: Settings, current_mode: CaptureMode
                 let _ = settings_service::save(&guard);
             });
         }
+        {
+            let s = Rc::clone(&settings);
+            close_after_save_toggle.connect_toggled(move |toggle| {
+                let mut guard = s.borrow_mut();
+                guard.close_after_save = toggle.is_active();
+                let _ = settings_service::save(&guard);
+            });
+        }
         {
             let s = Rc::clone(&settings);
             open_after_save_toggle.connect_toggled(move |toggle| {
@@ -491,6 +508,7 @@ pub fn run(capture: CaptureResult, settings: Settings, current_mode: CaptureMode
         inspector.append(&export_settings_title);
         inspector.append(&folder_btn);
         inspector.append(&close_after_copy_toggle);
+        inspector.append(&close_after_save_toggle);
         inspector.append(&open_after_save_toggle);
 
         shell.append(&tools_panel);
@@ -513,8 +531,9 @@ pub fn run(capture: CaptureResult, settings: Settings, current_mode: CaptureMode
             let s = Rc::clone(&settings);
             let status_label = status_label.clone();
             let window = window.clone();
+            let app = app.clone();
             save_as_btn.connect_clicked(move |_| {
-                prompt_save_as(&window, &c, &s, &status_label, current_mode);
+                prompt_save_as(&window, &c, &s, &status_label, &app, current_mode);
             });
         }
         {
@@ -786,6 +805,7 @@ fn prompt_save_as(
     canvas: &EditorCanvas,
     settings: &Rc<RefCell<Settings>>,
     status_label: &gtk::Label,
+    app: &adw::Application,
     current_mode: CaptureMode,
 ) {
     let cfg = settings.borrow().clone();
@@ -804,6 +824,7 @@ fn prompt_save_as(
     let canvas = canvas.clone();
     let settings = Rc::clone(settings);
     let status_label = status_label.clone();
+    let app = app.clone();
     dialog.run_async(move |dialog, response| {
         if response == gtk::ResponseType::Accept {
             if let Some(file) = dialog.file() {
@@ -813,11 +834,15 @@ fn prompt_save_as(
                             Ok(()) => {
                                 canvas.mark_saved();
                                 let cfg = settings.borrow();
+                                let close_after_save = cfg.close_after_save;
                                 let _ = export::maybe_open_saved_path(&path, &cfg);
                                 status_label.set_text(&format!(
                                     "Saved annotated image to {}.",
                                     path.display()
                                 ));
+                                if close_after_save {
+                                    app.quit();
+                                }
                             }
                             Err(err) => {
                                 status_label.set_text(&format!("Save As failed: {err}"));

src/capture/mod.rs

@@ -6,7 +6,7 @@ use crate::platform::linux::{grim, hyprctl};
 use crate::settings::config::CaptureMode;
 use anyhow::Result;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct CaptureResult {
     pub png_data: Vec<u8>,
 }

src/capture/window.rs

@@ -10,3 +10,74 @@ pub fn capture(backend: &dyn CaptureBackend) -> Result<CaptureResult> {
         .context("grim failed to capture active window region")?;
     Ok(CaptureResult { png_data })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::capture;
+    use crate::capture::CaptureBackend;
+    use anyhow::{anyhow, Result};
+    use std::cell::RefCell;
+
+    #[derive(Default)]
+    struct FakeBackend {
+        calls: RefCell<Vec<&'static str>>,
+        geometry_result: Option<String>,
+        region_result: Option<Vec<u8>>,
+    }
+
+    impl CaptureBackend for FakeBackend {
+        fn capture_fullscreen(&self) -> Result<Vec<u8>> {
+            Ok(vec![])
+        }
+
+        fn capture_region(&self, _geometry: &str) -> Result<Vec<u8>> {
+            self.calls.borrow_mut().push("capture_region");
+            self.region_result
+                .clone()
+                .ok_or_else(|| anyhow!("region capture failed"))
+        }
+
+        fn active_window_geometry(&self) -> Result<String> {
+            self.calls.borrow_mut().push("active_window_geometry");
+            self.geometry_result
+                .clone()
+                .ok_or_else(|| anyhow!("geometry lookup failed"))
+        }
+    }
+
+    #[test]
+    fn uses_geometry_then_region_capture() {
+        let backend = FakeBackend {
+            geometry_result: Some("5,6 7x8".to_string()),
+            region_result: Some(vec![9, 8, 7]),
+            ..FakeBackend::default()
+        };
+
+        let result = capture(&backend).unwrap();
+
+        assert_eq!(result.png_data, vec![9, 8, 7]);
+        assert_eq!(
+            backend.calls.borrow().as_slice(),
+            &["active_window_geometry", "capture_region"]
+        );
+    }
+
+    #[test]
+    fn returns_geometry_errors_without_region_capture() {
+        let backend = FakeBackend {
+            geometry_result: None,
+            region_result: Some(vec![1, 2, 3]),
+            ..FakeBackend::default()
+        };
+
+        let err = capture(&backend).unwrap_err();
+
+        assert!(err
+            .to_string()
+            .contains("failed to resolve active window geometry from Hyprland"));
+        assert_eq!(
+            backend.calls.borrow().as_slice(),
+            &["active_window_geometry"]
+        );
+    }
+}

src/diagnostics/mod.rs

@@ -254,10 +254,6 @@ pub struct PortalRepairResult {
     pub message: String,
 }
 
-pub fn auto_repair_portals() -> PortalRepairResult {
-    repair_portals_with_path(env::var_os("PATH"))
-}
-
 pub fn repair_portals() -> PortalRepairResult {
     repair_portals_with_path(env::var_os("PATH"))
 }
@@ -382,11 +378,11 @@ fn colorize_doctor_report(report: &str) -> String {
         let colored = if line == "Kiekje Doctor Report" || line == "Desktop Portal Report" {
             format!("\x1b[1;36m{line}\x1b[0m")
         } else if line.starts_with("[OK]") {
-            format!("\x1b[32m{}\x1b[0m", line.replacen("[OK]", "[OK]", 1))
+            format!("\x1b[32m{line}\x1b[0m")
         } else if line.starts_with("[MISS]") {
-            format!("\x1b[33m{}\x1b[0m", line.replacen("[MISS]", "[MISS]", 1))
+            format!("\x1b[33m{line}\x1b[0m")
         } else if line.starts_with("[WARN]") {
-            format!("\x1b[35m{}\x1b[0m", line.replacen("[WARN]", "[WARN]", 1))
+            format!("\x1b[35m{line}\x1b[0m")
         } else if line.trim_start().starts_with("Install:")
             || line.trim_start().starts_with("Hint:")
         {

src/editor/canvas.rs

@@ -526,16 +526,19 @@ fn cairo_surface_to_rgba_image(surface: &mut cairo::ImageSurface) -> Result<Rgba
             let g = data[offset + 1] as u16;
             let r = data[offset + 2] as u16;
             let a = data[offset + 3] as u16;
-            let pixel = if a == 0 {
-                [0, 0, 0, 0]
-            } else {
-                [
-                    ((r * 255) / a).min(255) as u8,
-                    ((g * 255) / a).min(255) as u8,
-                    ((b * 255) / a).min(255) as u8,
-                    a as u8,
-                ]
+            let unpremultiply = |channel: u16| {
+                channel
+                    .saturating_mul(255)
+                    .checked_div(a)
+                    .unwrap_or(0)
+                    .min(255) as u8
             };
+            let pixel = [
+                unpremultiply(r),
+                unpremultiply(g),
+                unpremultiply(b),
+                a as u8,
+            ];
             image.put_pixel(x, y, Rgba(pixel));
         }
     }

src/main.rs

@@ -257,6 +257,7 @@ fn print_settings(settings: &Settings) {
     );
     println!("copy_to_clipboard: {}", settings.copy_to_clipboard);
     println!("close_after_copy: {}", settings.close_after_copy);
+    println!("close_after_save: {}", settings.close_after_save);
     println!("open_after_save: {}", settings.open_after_save);
     println!("open_editor: {}", settings.open_editor);
     println!(

src/platform/linux/backend.rs

@@ -2,14 +2,9 @@
 
 use super::grim::{GrimCli, ScreenshotTool};
 use super::hyprctl::{ActiveWindowGeometrySource, HyprctlCli};
+use crate::capture::CaptureBackend;
 use anyhow::Result;
 
-pub trait LinuxCaptureBackend {
-    fn capture_fullscreen(&self) -> Result<Vec<u8>>;
-    fn capture_region(&self, geometry: &str) -> Result<Vec<u8>>;
-    fn active_window_geometry(&self) -> Result<String>;
-}
-
 #[derive(Debug, Clone, Default)]
 pub struct GrimHyprlandBackend<S = GrimCli, W = HyprctlCli> {
     screenshot_tool: S,
@@ -25,7 +20,11 @@ impl<S, W> GrimHyprlandBackend<S, W> {
     }
 }
 
-impl<S, W> LinuxCaptureBackend for GrimHyprlandBackend<S, W>
+pub fn current_backend() -> GrimHyprlandBackend {
+    GrimHyprlandBackend::new(GrimCli, HyprctlCli)
+}
+
+impl<S, W> CaptureBackend for GrimHyprlandBackend<S, W>
 where
     S: ScreenshotTool,
     W: ActiveWindowGeometrySource,
@@ -45,7 +44,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::{GrimHyprlandBackend, LinuxCaptureBackend};
+    use super::GrimHyprlandBackend;
+use crate::capture::CaptureBackend;
     use crate::platform::linux::grim::ScreenshotTool;
     use crate::platform::linux::hyprctl::ActiveWindowGeometrySource;
     use anyhow::Result;

src/platform/linux/grim.rs

@@ -51,6 +51,7 @@ pub fn capture_region(geometry: &str) -> Result<Vec<u8>> {
     GrimCli.capture_region(geometry)
 }
 
+#[allow(dead_code)]
 pub fn capture_fullscreen() -> Result<Vec<u8>> {
     GrimCli.capture_fullscreen()
 }

src/services/capture.rs

@@ -34,6 +34,10 @@ pub fn run(mode: CaptureMode, settings: &Settings) -> AppResult<CaptureExecution
     )
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "test hook injection keeps the production workflow free of trait-object plumbing"
+)]
 fn run_with_hooks<Req, Sleep, Capture, Validate, Copy, Save>(
     mode: CaptureMode,
     settings: &Settings,