feat(settings): expose update_check + open_settings_file via commands

Promotes the last hand-edit-only knob (update_check) into the Settings
GUI and gives the "reveal settings.json" affordance its own Tauri
command so it can live inside the Settings window instead of cluttering
the tray with a second "Settings*" entry.

Backend changes:
- AppSettings now carries `update_check` (Enabled/Manual/Disabled) and
  `updater_available` (false for Scoop/MSIX installs so the frontend
  can hide the section).
- New `set_update_check` command: persists + calls `refresh_indicator`
  so the tray dot reacts immediately.
- New `open_settings_file` command: same logic as the tray's previous
  private helper, now reachable from the frontend.
- `refresh_indicator` honours `update_check == Disabled` (returns no
  version, so the dot + "Update available" item disappear).
- `build_menu` drops the "Open settings file…" entry and additionally
  omits "Check for updates" when update_check is Disabled — matching
  the enum's "no tray affordances" doc.

Tray menu becomes: [Update available?] Check for updates | Settings… |
Reset panel position | Quit gitwink. One Settings entry, no duplicate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: var-gg

src-tauri/src/commands.rs

@@ -768,6 +768,15 @@ pub struct AppSettings {
     /// When true, the panel is "pinned" — no blur auto-hide, shows in
     /// the taskbar, not always-on-top. False = tray-glance default.
     pub panel_pinned: bool,
+    /// Self-update behaviour. Serialized as "enabled" / "manual" /
+    /// "disabled" via the enum's lowercase rename. Meaningful only when
+    /// `updater_available` is true.
+    pub update_check: settings::UpdateCheckMode,
+    /// False for Scoop and Microsoft Store (MSIX) installs — those
+    /// channels manage their own updates, so the Updates section in
+    /// the Settings window is hidden and the `update_check` knob is
+    /// inert. The frontend uses this flag to gate the UI.
+    pub updater_available: bool,
 }
 
 #[tauri::command]
@@ -781,6 +790,8 @@ pub fn get_settings(app: AppHandle) -> AppSettings {
             .filter(|h| !h.trim().is_empty())
             .unwrap_or_else(|| settings::DEFAULT_PANEL_HOTKEY.to_string()),
         panel_pinned: s.panel_pinned.unwrap_or(false),
+        update_check: s.update_check,
+        updater_available: !update::installed_via_scoop() && !update::installed_via_msix(),
     }
 }
 
@@ -881,6 +892,31 @@ pub async fn open_settings_window(app: AppHandle) {
     });
 }
 
+/// Persist the self-update mode and refresh the tray dot immediately
+/// (Disabled hides the indicator + tray "Check for updates" item via
+/// build_menu; refresh_indicator drives the rebuild).
+#[tauri::command]
+pub fn set_update_check(app: AppHandle, mode: settings::UpdateCheckMode) {
+    settings::save_update_check_mode(&app, mode);
+    update::refresh_indicator(&app);
+}
+
+/// Reveal `settings.json` in the user's default editor (or the OS file
+/// handler for `.json`). Exposed for the "Open settings.json" link in
+/// the Settings window's footer — the tray menu used to host this but
+/// it was demoted to keep the tray to one Settings entry.
+#[tauri::command]
+pub fn open_settings_file(app: AppHandle) -> Result<(), String> {
+    use tauri_plugin_opener::OpenerExt;
+    // ensure_path writes a default file if missing so the editor never
+    // opens to a "file not found" dialog on a fresh install.
+    let path = settings::ensure_path(&app).map_err(|e| e.to_string())?;
+    let path_str = path.to_string_lossy().into_owned();
+    app.opener()
+        .open_path(&path_str, None::<&str>)
+        .map_err(|e| e.to_string())
+}
+
 fn unix_now() -> i64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)

src-tauri/src/lib.rs

@@ -357,6 +357,8 @@ pub fn run() {
             commands::set_panel_hotkey,
             commands::set_panel_pinned,
             commands::open_settings_window,
+            commands::set_update_check,
+            commands::open_settings_file,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/settings.rs

@@ -237,3 +237,14 @@ pub fn save_panel_pinned(app: &AppHandle, pinned: bool) {
         eprintln!("settings: failed to persist panel_pinned: {e:#}");
     }
 }
+
+/// Persist the self-update mode (`Enabled` / `Manual` / `Disabled`).
+/// Refreshing the tray indicator + menu is the caller's job — see
+/// `set_update_check` in commands.rs.
+pub fn save_update_check_mode(app: &AppHandle, mode: UpdateCheckMode) {
+    let mut s = load(app);
+    s.update_check = mode;
+    if let Err(e) = save(app, &s) {
+        eprintln!("settings: failed to persist update_check: {e:#}");
+    }
+}

src-tauri/src/tray.rs

@@ -4,9 +4,9 @@ use tauri::{
     tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
     App, AppHandle, Wry,
 };
-use tauri_plugin_opener::OpenerExt;
 
-use crate::{settings, update, window};
+use crate::settings::{self, UpdateCheckMode};
+use crate::{update, window};
 
 const TRAY_ID: &str = "main";
 
@@ -54,6 +54,11 @@ pub fn setup(app: &App) -> tauri::Result<()> {
 /// "Update available" item is prepended above a separator. The menu is
 /// rebuilt wholesale (rather than toggling item visibility) whenever the
 /// update state changes — see `set_update_indicator`.
+///
+/// The "Open settings file…" entry used to live here next to "Settings…"
+/// but was demoted to a footer link inside the Settings window itself —
+/// two "Settings*" items in a small tray menu were redundant. The same
+/// affordance is still reachable: tray → Settings… → "Open settings.json".
 fn build_menu(app: &AppHandle, update_version: Option<&str>) -> tauri::Result<Menu<Wry>> {
     let reset = MenuItem::with_id(
         app,
@@ -62,22 +67,20 @@ fn build_menu(app: &AppHandle, update_version: Option<&str>) -> tauri::Result<Me
         true,
         None::<&str>,
     )?;
-    let settings = MenuItem::with_id(app, "settings", "Settings…", true, None::<&str>)?;
-    let open_settings = MenuItem::with_id(
-        app,
-        "open_settings",
-        "Open settings file…",
-        true,
-        None::<&str>,
-    )?;
+    let settings_item =
+        MenuItem::with_id(app, "settings", "Settings…", true, None::<&str>)?;
     let quit = MenuItem::with_id(app, "quit", "Quit gitwink", true, None::<&str>)?;
     let sep = PredefinedMenuItem::separator(app)?;
 
-    // Microsoft Store installs update via the Store itself — gitwink shows
-    // no in-app updater UI. Scoop and direct installs keep the
-    // "Check for updates" item.
-    if update::installed_via_msix() {
-        return Menu::with_items(app, &[&settings, &reset, &open_settings, &sep, &quit]);
+    // Microsoft Store installs update via the Store itself — gitwink
+    // shows no in-app updater UI. Same goes for the Disabled mode the
+    // user picked in Settings ("no tray affordances" per UpdateCheckMode
+    // doc). Scoop installs keep the item since manual_check still
+    // surfaces the modal with the `scoop update` hint.
+    let hide_updater =
+        update::installed_via_msix() || settings::load(app).update_check == UpdateCheckMode::Disabled;
+    if hide_updater {
+        return Menu::with_items(app, &[&settings_item, &reset, &sep, &quit]);
     }
 
     let check =
@@ -98,17 +101,14 @@ fn build_menu(app: &AppHandle, update_version: Option<&str>) -> tauri::Result<Me
                     &update_item,
                     &sep_top,
                     &check,
-                    &settings,
+                    &settings_item,
                     &reset,
-                    &open_settings,
                     &sep,
                     &quit,
                 ],
             )
         }
-        None => {
-            Menu::with_items(app, &[&check, &settings, &reset, &open_settings, &sep, &quit])
-        }
+        None => Menu::with_items(app, &[&check, &settings_item, &reset, &sep, &quit]),
     }
 }
 
@@ -117,7 +117,6 @@ fn handle_menu_event(app: &AppHandle, event: MenuEvent) {
         "quit" => app.exit(0),
         "reset_position" => settings::clear_panel_position(app),
         "settings" => window::open_settings(app),
-        "open_settings" => open_settings_file(app),
         "check_updates" => update::manual_check(app),
         "update_available" => update::open_modal(app),
         _ => {}
@@ -196,20 +195,3 @@ fn with_dot(base: &Image<'_>) -> Image<'static> {
     Image::new_owned(rgba, w, h)
 }
 
-/// Reveal settings.json in the user's default editor (or the OS file
-/// handler for `.json`). We `ensure_path` first so the file always exists
-/// when the editor opens — otherwise the user would land on a blank
-/// "file not found" dialog the first time they try this.
-fn open_settings_file(app: &AppHandle) {
-    let path = match settings::ensure_path(app) {
-        Ok(p) => p,
-        Err(e) => {
-            eprintln!("gitwink: failed to ensure settings file: {e:#}");
-            return;
-        }
-    };
-    let path_str = path.to_string_lossy().into_owned();
-    if let Err(e) = app.opener().open_path(&path_str, None::<&str>) {
-        eprintln!("gitwink: failed to open settings file {path_str:?}: {e}");
-    }
-}

src-tauri/src/update.rs

@@ -143,11 +143,14 @@ async fn run_check(app: &AppHandle, manual: bool) -> anyhow::Result<()> {
 }
 
 /// Recompute the tray dot + menu item from current state + settings.
-/// Shown iff an update exists, isn't the skipped version, and isn't
-/// snoozed.
+/// Shown iff an update exists, isn't the skipped version, isn't
+/// snoozed, and the user hasn't switched update_check to Disabled
+/// (Disabled means "no tray affordances", per the enum doc).
 pub fn refresh_indicator(app: &AppHandle) {
     let s = settings::load(app);
-    let version = {
+    let version = if s.update_check == UpdateCheckMode::Disabled {
+        None
+    } else {
         let state = app.state::<UpdateState>();
         let slot = state.available.lock().unwrap();
         slot.as_ref().and_then(|u| {