🐛 fix: fix: browser detection, mode switch persistence, UX polish

Browser detection:
- Add multi-path probe: /usr/bin/brave, brave-browser, brave-browser-stable
- Normalize browser_id to "brave" (match BigLinux convention)
- Fix xdg-settings mapping: brave-browser.desktop → "brave"

Mode switch (App ↔ Browser):
- Preserve browser field on App mode toggle (no __viewer__ override)
- Update browser_row subtitle on mode change
- Rewrite same .desktop file on mode switch (no duplicate entries)
- Call update-desktop-database after install/remove

Version:
- APP_VERSION reads from Cargo.toml via env!("CARGO_PKG_VERSION")

UI/UX:
- Globe icon → "Detect" text button with auto-detect on URL change (800ms debounce)
- "+" icon → "Add" text button with suggested-action styling
- Template icon → "Templates" text button with suggested-action styling
- App mode icon: big-webapps colorful SVG (not grey symbolic)
- System accent color (blue) on action buttons via suggested-action CSS
- Dialog: 3 PreferencesGroup cards (Website, Appearance, Behavior)

Translations (pt-BR):
- "Modo do App" → "Modo App"
- Add "Adicionar", Detect "Detectar"

Viewer:
- Chrome 131 User-Agent string (fix Spotify WebKitGTK block)

Fixes:
- RefCell panic: Rc<RefCell<Option<SourceId>>> for debounce timer
- URL normalization: prepend https:// if missing scheme
- Icon resolution: hostname fallback + Google Favicon API
- Cookie persistence: ephemeral → default data manager
- Desktop entry: sanitize fields, proper WM class derivation

Author: talesam

biglinux-webapps/locale/pt-BR.po

@@ -98,7 +98,7 @@ msgstr "Categoria"
 
 #: /home/talesam/Servidor/GitHub/biglinux-webapps/crates/webapps-manager/src/webapp_dialog.rs:171
 msgid "App Mode"
-msgstr "Modo do App"
+msgstr "Modo App"
 
 #: /home/talesam/Servidor/GitHub/biglinux-webapps/crates/webapps-manager/src/webapp_dialog.rs:172
 msgid "Opens as a native window without browser interface"
@@ -352,3 +352,11 @@ msgstr "Download Concluído"
 #: /home/talesam/Servidor/GitHub/biglinux-webapps/crates/webapps-viewer/src/window.rs:406
 msgid "Save File"
 msgstr "Salvar Arquivo"
+
+#: /home/talesam/Servidor/GitHub/biglinux-webapps/crates/webapps-manager/src/window.rs:58
+msgid "Add"
+msgstr "Adicionar"
+
+#: /home/talesam/Servidor/GitHub/biglinux-webapps/crates/webapps-manager/src/webapp_dialog.rs:112
+msgid "Detect"
+msgstr "Detectar"

biglinux-webapps/usr/share/locale/pt_BR/LC_MESSAGES/biglinux-webapps.mo

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-pub const APP_VERSION: &str = "4.0.0";
+pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const APP_ID: &str = "br.com.biglinux.webapps";
 
 /// Config dir: ~/.config/biglinux-webapps/

crates/webapps-core/src/config.rs

@@ -123,6 +123,7 @@ pub fn install_desktop_entry(webapp: &WebApp) -> Result<()> {
     let content = generate_desktop_entry(webapp);
     fs::write(&path, content)?;
     log::info!("Installed desktop entry: {}", path.display());
+    refresh_desktop_database();
     Ok(())
 }
 
@@ -132,10 +133,29 @@ pub fn remove_desktop_entry(webapp: &WebApp) -> Result<()> {
     if path.exists() {
         fs::remove_file(&path)?;
         log::info!("Removed desktop entry: {}", path.display());
+        refresh_desktop_database();
     }
     Ok(())
 }
 
+/// Remove a desktop file by filename directly
+pub fn remove_desktop_file(filename: &str) -> Result<()> {
+    let path = config::applications_dir().join(filename);
+    if path.exists() {
+        fs::remove_file(&path)?;
+        log::info!("Removed old desktop entry: {}", path.display());
+    }
+    Ok(())
+}
+
+/// Notify desktop environment of .desktop changes
+fn refresh_desktop_database() {
+    let apps_dir = config::applications_dir();
+    let _ = std::process::Command::new("update-desktop-database")
+        .arg(&apps_dir)
+        .spawn();
+}
+
 /// Strip chars that could break desktop file Exec or shell parsing
 fn sanitize_desktop_field(s: &str) -> String {
     s.chars()

crates/webapps-core/src/desktop.rs

@@ -38,7 +38,26 @@ pub fn fetch_site_info(url: &str) -> Result<SiteInfo> {
     let html_text = resp.text()?;
     let doc = Html::parse_document(&html_text);
 
-    let title = extract_title(&doc).unwrap_or_default();
+    let mut title = extract_title(&doc).unwrap_or_default();
+
+    // fallback: if title is empty/generic (SPA stub), derive from hostname
+    let generic_titles = ["ok", "loading", "redirect", "please wait", ""];
+    if generic_titles
+        .iter()
+        .any(|g| title.trim().to_lowercase() == *g)
+        || title.len() < 3
+    {
+        if let Some(host) = parsed.host_str() {
+            // strip www. prefix, capitalize first letter
+            let clean = host.strip_prefix("www.").unwrap_or(host);
+            let mut chars = clean.chars();
+            title = match chars.next() {
+                Some(c) => c.to_uppercase().to_string() + chars.as_str(),
+                None => clean.to_string(),
+            };
+        }
+    }
+
     let icon_urls = extract_icon_urls(&doc, &url);
 
     // download icons to cache
@@ -67,6 +86,17 @@ pub fn fetch_site_info(url: &str) -> Result<SiteInfo> {
         }
     }
 
+    // last resort: Google favicon service
+    if icon_paths.is_empty() {
+        if let Some(host) = parsed.host_str() {
+            let google_url =
+                format!("https://www.google.com/s2/favicons?domain={host}&sz=128");
+            if let Ok(path) = download_icon(&client, &google_url, &cache, 100) {
+                icon_paths.push(path);
+            }
+        }
+    }
+
     Ok(SiteInfo { title, icon_paths })
 }
 
@@ -135,6 +165,20 @@ fn download_icon(
         anyhow::bail!("HTTP {}", resp.status());
     }
 
+    // reject non-image content types (e.g. HTML redirect pages)
+    if let Some(ct) = resp.headers().get(reqwest::header::CONTENT_TYPE) {
+        if let Ok(ct_str) = ct.to_str() {
+            let ct_lower = ct_str.to_lowercase();
+            if !ct_lower.starts_with("image/")
+                && !ct_lower.contains("svg")
+                && !ct_lower.contains("icon")
+                && !ct_lower.contains("octet-stream")
+            {
+                anyhow::bail!("Not an image: {ct_str}");
+            }
+        }
+    }
+
     // check content-length before downloading
     if let Some(cl) = resp.content_length() {
         if cl as usize > MAX_ICON_BYTES {

crates/webapps-manager/src/favicon.rs

@@ -42,10 +42,18 @@ pub fn save_webapps(collection: &WebAppCollection) -> Result<()> {
 }
 
 pub fn create_webapp(webapp: &WebApp) -> Result<()> {
+    let mut app = webapp.clone();
+    // ensure app_file is populated → needed for update/remove by file
+    if app.app_file.is_empty() {
+        app.app_file = format!(
+            "biglinux-webapp-{}.desktop",
+            desktop::desktop_file_id(&app.app_url)
+        );
+    }
     let mut col = load_webapps();
-    col.add(webapp.clone());
+    col.add(app.clone());
     save_webapps(&col)?;
-    desktop::install_desktop_entry(webapp)?;
+    desktop::install_desktop_entry(&app)?;
     Ok(())
 }
 
@@ -122,32 +130,46 @@ pub fn profile_shared(webapp: &WebApp) -> bool {
 // -- browser detection --
 
 pub fn detect_browsers() -> BrowserCollection {
-    let known_browsers = [
-        ("firefox", "/usr/bin/firefox"),
+    // (browser_id, [candidate_paths]) — first existing path wins
+    let known_browsers: &[(&str, &[&str])] = &[
+        ("firefox", &["/usr/bin/firefox"]),
         (
             "firefox-developer-edition",
-            "/usr/bin/firefox-developer-edition",
+            &["/usr/bin/firefox-developer-edition"],
+        ),
+        ("librewolf", &["/usr/bin/librewolf"]),
+        ("google-chrome-stable", &["/usr/bin/google-chrome-stable"]),
+        ("google-chrome-beta", &["/usr/bin/google-chrome-beta"]),
+        ("google-chrome-unstable", &["/usr/bin/google-chrome-unstable"]),
+        ("chromium", &["/usr/bin/chromium"]),
+        (
+            "brave",
+            &[
+                "/usr/bin/brave",
+                "/usr/bin/brave-browser",
+                "/usr/bin/brave-browser-stable",
+            ],
+        ),
+        (
+            "brave-beta",
+            &["/usr/bin/brave-browser-beta", "/usr/bin/brave-beta"],
+        ),
+        (
+            "brave-nightly",
+            &["/usr/bin/brave-browser-nightly", "/usr/bin/brave-nightly"],
         ),
-        ("librewolf", "/usr/bin/librewolf"),
-        ("google-chrome-stable", "/usr/bin/google-chrome-stable"),
-        ("google-chrome-beta", "/usr/bin/google-chrome-beta"),
-        ("google-chrome-unstable", "/usr/bin/google-chrome-unstable"),
-        ("chromium", "/usr/bin/chromium"),
-        ("brave-browser", "/usr/bin/brave-browser-stable"),
-        ("brave-browser-beta", "/usr/bin/brave-browser-beta"),
-        ("brave-browser-nightly", "/usr/bin/brave-browser-nightly"),
-        ("microsoft-edge-stable", "/usr/bin/microsoft-edge-stable"),
-        ("microsoft-edge-beta", "/usr/bin/microsoft-edge-beta"),
-        ("vivaldi-stable", "/usr/bin/vivaldi-stable"),
-        ("vivaldi-beta", "/usr/bin/vivaldi-beta"),
-        ("vivaldi-snapshot", "/usr/bin/vivaldi-snapshot"),
-        ("ungoogled-chromium", "/usr/bin/ungoogled-chromium"),
+        ("microsoft-edge-stable", &["/usr/bin/microsoft-edge-stable"]),
+        ("microsoft-edge-beta", &["/usr/bin/microsoft-edge-beta"]),
+        ("vivaldi-stable", &["/usr/bin/vivaldi-stable"]),
+        ("vivaldi-beta", &["/usr/bin/vivaldi-beta"]),
+        ("vivaldi-snapshot", &["/usr/bin/vivaldi-snapshot"]),
+        ("ungoogled-chromium", &["/usr/bin/ungoogled-chromium"]),
     ];
 
     let mut browsers: Vec<Browser> = Vec::new();
 
-    for (id, path) in &known_browsers {
-        if Path::new(path).exists() {
+    for (id, paths) in known_browsers {
+        if paths.iter().any(|p| Path::new(p).exists()) {
             browsers.push(Browser {
                 browser_id: id.to_string(),
                 is_default: false,
@@ -215,9 +237,7 @@ fn match_desktop_to_browser(desktop: &str) -> Option<String> {
         ("google-chrome-beta", "google-chrome-beta"),
         ("google-chrome-unstable", "google-chrome-unstable"),
         ("chromium", "chromium"),
-        ("brave-browser-stable", "brave-browser"),
-        ("brave-browser-beta", "brave-browser-beta"),
-        ("brave-browser-nightly", "brave-browser-nightly"),
+        ("brave", "brave"),
         ("microsoft-edge-stable", "microsoft-edge-stable"),
         ("microsoft-edge-beta", "microsoft-edge-beta"),
         ("vivaldi-stable", "vivaldi-stable"),

crates/webapps-manager/src/service.rs

@@ -61,9 +61,9 @@ pub fn show(
     let header = adw::HeaderBar::new();
     // placeholder for template button — will be wired after widgets exist
     let tmpl_btn = if is_new {
-        let btn = gtk::Button::from_icon_name("view-grid-symbolic");
-        btn.set_tooltip_text(Some(&gettext("Templates")));
-        btn.update_property(&[gtk::accessible::Property::Label(&gettext("Templates"))]);
+        let btn = gtk::Button::with_label(&gettext("Templates"));
+        btn.set_tooltip_text(Some(&gettext("Choose from templates")));
+        btn.add_css_class("suggested-action");
         header.pack_start(&btn);
         Some(btn)
     } else {
@@ -109,16 +109,9 @@ pub fn show(
         .title(gettext("URL"))
         .text(&webapp_cell.borrow().app_url)
         .build();
-    let detect_img = gtk::Image::from_icon_name("emblem-web-symbolic");
-    detect_img.set_pixel_size(24);
-    let detect_btn = gtk::Button::new();
-    detect_btn.set_child(Some(&detect_img));
+    let detect_btn = gtk::Button::with_label(&gettext("Detect"));
     detect_btn.set_tooltip_text(Some(&gettext("Detect name and icon from website")));
-    detect_btn.update_property(&[gtk::accessible::Property::Label(&gettext(
-        "Detect name and icon from website",
-    ))]);
     detect_btn.set_valign(gtk::Align::Center);
-    detect_btn.add_css_class("flat");
     url_row.add_suffix(&detect_btn);
     group_website.add(&url_row);
 
@@ -288,11 +281,33 @@ pub fn show(
         });
     }
 
-    // URL changed
+    // URL changed → update model + auto-detect with debounce
+    let debounce_handle: Rc<RefCell<Option<glib::SourceId>>> = Rc::new(RefCell::new(None));
     {
         let wc = webapp_cell.clone();
+        let db_handle = debounce_handle.clone();
+        let detect_btn_ref = detect_btn.clone();
         url_row.connect_changed(move |row| {
             wc.borrow_mut().app_url = row.text().to_string();
+            // cancel previous debounce
+            if let Some(id) = db_handle.borrow_mut().take() {
+                id.remove();
+            }
+            // schedule auto-detect after 800ms idle
+            let btn = detect_btn_ref.clone();
+            let handle = db_handle.clone();
+            let text = row.text().to_string();
+            let source = glib::timeout_add_local_once(
+                std::time::Duration::from_millis(800),
+                move || {
+                    handle.borrow_mut().take();
+                    // only trigger if URL looks valid (has a dot)
+                    if text.contains('.') && text.len() > 3 {
+                        btn.emit_clicked();
+                    }
+                },
+            );
+            *db_handle.borrow_mut() = Some(source);
         });
     }
 
@@ -320,12 +335,30 @@ pub fn show(
         let wc = webapp_cell.clone();
         let br = browser_row.clone();
         let pr = profile_row.clone();
+        let brs = browsers.clone();
+        let brow = browser_row.clone();
         mode_switch.connect_state_set(move |_, active| {
-            wc.borrow_mut().app_mode = if active {
-                AppMode::App
+            let mut app = wc.borrow_mut();
+            if active {
+                app.app_mode = AppMode::App;
+                // keep browser field unchanged → restored on switch back
             } else {
-                AppMode::Browser
-            };
+                app.app_mode = AppMode::Browser;
+                // if browser was __viewer__ (legacy data), pick default
+                if app.browser == "__viewer__" || app.browser.is_empty() {
+                    if let Some(def) = brs.borrow().default_browser() {
+                        app.browser = def.browser_id.clone();
+                    }
+                }
+                // update browser row subtitle
+                let name = brs
+                    .borrow()
+                    .get_by_id(&app.browser)
+                    .map(|b| b.display_name().to_string())
+                    .unwrap_or_else(|| app.browser.clone());
+                brow.set_subtitle(&name);
+            }
+            drop(app);
             br.set_visible(!active);
             pr.set_visible(!active);
             glib::Propagation::Proceed
@@ -518,35 +551,47 @@ pub fn show(
         let wc = webapp_cell.clone();
         let w = win.clone();
         save_btn.connect_clicked(move |_| {
-            let app = wc.borrow().clone();
+            let mut app = wc.borrow().clone();
 
             // validate
             if app.app_name.trim().is_empty() || app.app_url.trim().is_empty() {
                 return;
             }
 
-            // validate URL format
-            let url_str = app.app_url.trim();
-            let test_url = if !url_str.starts_with("http://")
+            // normalize URL: prepend https:// if missing scheme
+            let url_str = app.app_url.trim().to_string();
+            if !url_str.starts_with("http://")
                 && !url_str.starts_with("https://")
                 && !url_str.starts_with("file://")
             {
-                format!("https://{url_str}")
+                app.app_url = format!("https://{url_str}");
             } else {
-                url_str.to_string()
-            };
-            if url::Url::parse(&test_url).is_err() {
+                app.app_url = url_str;
+            }
+
+            // validate URL format
+            if url::Url::parse(&app.app_url).is_err() {
                 return;
             }
 
-            let ok = if is_new {
-                service::create_webapp(&app).is_ok()
+            let result = if is_new {
+                service::create_webapp(&app)
             } else {
-                service::update_webapp(&app).is_ok()
+                service::update_webapp(&app)
             };
+
+            match &result {
+                Ok(()) => log::info!(
+                    "Saved webapp '{}' mode={:?}",
+                    app.app_name,
+                    app.app_mode
+                ),
+                Err(e) => log::error!("Save webapp failed: {e}"),
+            }
+
             w.close();
             on_done(DialogResult {
-                saved: ok,
+                saved: result.is_ok(),
                 webapp: app,
             });
         });