Settings: Make shortcut editing really work

- Fix searching for shortcuts Settings-wide
- Fix saving/loading settings
- Update Tauri menus when changing shortcuts
- Some more fixes
- Improve MCP server along the way
- Also remove some excessive debug logs

Author: vdavid

.mcp.json

@@ -0,0 +1,17 @@
+{
+  "mcpServers": {
+    "cmdr": {
+      "type": "http",
+      "url": "http://127.0.0.1:9224/mcp"
+    },
+    "tauri": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@hypothesi/tauri-mcp-server"
+      ],
+      "env": {}
+    }
+  }
+}

CONTRIBUTING.md

@@ -126,6 +126,8 @@ This snippet will likely come handy:
 }
 ```
 
+Or add it via CLI like:
+
 Since the agent shares the context with your IDE/client, enabling the MCP server makes the tools available to the agent
 automatically.
 

apps/desktop/src-tauri/src/commands/settings.rs

@@ -2,7 +2,10 @@
 
 use std::net::TcpListener;
 
+use tauri::{AppHandle, Manager};
+
 use crate::file_system::update_debounce_ms;
+use crate::menu::{MenuState, frontend_shortcut_to_accelerator, update_view_mode_accelerator};
 #[cfg(target_os = "macos")]
 use crate::network::bonjour::update_resolve_timeout;
 
@@ -47,6 +50,59 @@ pub fn update_service_resolve_timeout(_timeout_ms: u64) {
     // No-op on non-macOS platforms
 }
 
+/// Update menu accelerator for a command.
+/// Called from frontend when keyboard shortcuts are changed.
+/// Currently supports: view.fullMode, view.briefMode
+#[tauri::command]
+pub fn update_menu_accelerator(app: AppHandle, command_id: &str, shortcut: &str) -> Result<(), String> {
+    let menu_state = app.state::<MenuState<tauri::Wry>>();
+
+    // Convert frontend shortcut format to Tauri accelerator format
+    let accelerator = frontend_shortcut_to_accelerator(shortcut);
+
+    match command_id {
+        "view.fullMode" => {
+            // Get current checked state before updating
+            let is_checked = menu_state
+                .view_mode_full
+                .lock()
+                .unwrap()
+                .as_ref()
+                .and_then(|item| item.is_checked().ok())
+                .unwrap_or(false);
+
+            let new_item = update_view_mode_accelerator(&app, &menu_state, true, accelerator.as_deref(), is_checked)
+                .map_err(|e| format!("Failed to update Full view accelerator: {e}"))?;
+
+            // Update the reference in MenuState
+            *menu_state.view_mode_full.lock().unwrap() = Some(new_item);
+            Ok(())
+        }
+        "view.briefMode" => {
+            // Get current checked state before updating
+            let is_checked = menu_state
+                .view_mode_brief
+                .lock()
+                .unwrap()
+                .as_ref()
+                .and_then(|item| item.is_checked().ok())
+                .unwrap_or(true);
+
+            let new_item = update_view_mode_accelerator(&app, &menu_state, false, accelerator.as_deref(), is_checked)
+                .map_err(|e| format!("Failed to update Brief view accelerator: {e}"))?;
+
+            // Update the reference in MenuState
+            *menu_state.view_mode_brief.lock().unwrap() = Some(new_item);
+            Ok(())
+        }
+        _ => {
+            // Silently succeed for commands that don't have menu items
+            // This allows the frontend to call this for all shortcuts without errors
+            Ok(())
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

apps/desktop/src-tauri/src/lib.rs

@@ -150,6 +150,9 @@ pub fn run() {
             *menu_state.show_hidden_files.lock().unwrap() = Some(menu_items.show_hidden_files);
             *menu_state.view_mode_full.lock().unwrap() = Some(menu_items.view_mode_full);
             *menu_state.view_mode_brief.lock().unwrap() = Some(menu_items.view_mode_brief);
+            *menu_state.view_submenu.lock().unwrap() = Some(menu_items.view_submenu);
+            *menu_state.view_mode_full_position.lock().unwrap() = menu_items.view_mode_full_position;
+            *menu_state.view_mode_brief_position.lock().unwrap() = menu_items.view_mode_brief_position;
             app.manage(menu_state);
 
             // Set window title based on license status
@@ -162,6 +165,9 @@ pub fn run() {
             // Initialize pane state store for MCP context tools
             app.manage(mcp::PaneStateStore::new());
 
+            // Initialize settings state store for MCP settings tools
+            app.manage(mcp::SettingsStateStore::new());
+
             // Start MCP server for AI agent integration
             // Use settings from user preferences, with env vars as override for dev
             let mcp_config = mcp::McpConfig::from_settings_and_env(
@@ -327,6 +333,12 @@ pub fn run() {
             mcp::pane_state::update_left_pane_state,
             mcp::pane_state::update_right_pane_state,
             mcp::pane_state::update_focused_pane,
+            mcp::settings_state::mcp_update_settings_state,
+            mcp::settings_state::mcp_update_settings_open,
+            mcp::settings_state::mcp_update_settings_section,
+            mcp::settings_state::mcp_update_settings_sections,
+            mcp::settings_state::mcp_update_current_settings,
+            mcp::settings_state::mcp_update_shortcuts,
             // Sync status (macOS uses real implementation, others use stub in commands)
             commands::sync_status::get_sync_status,
             // Volume commands (platform-specific)
@@ -447,7 +459,8 @@ pub fn run() {
             commands::settings::check_port_available,
             commands::settings::find_available_port,
             commands::settings::update_file_watcher_debounce,
-            commands::settings::update_service_resolve_timeout
+            commands::settings::update_service_resolve_timeout,
+            commands::settings::update_menu_accelerator
         ])
         .on_window_event(|window, event| {
             // When the main window is closed, quit the entire app (including settings/debug/viewer windows)

apps/desktop/src-tauri/src/mcp/executor.rs

@@ -8,6 +8,7 @@ use tauri::{AppHandle, Emitter, Manager, Runtime};
 
 use super::pane_state::PaneStateStore;
 use super::protocol::{INTERNAL_ERROR, INVALID_PARAMS};
+use super::settings_state::SettingsStateStore;
 use crate::commands::ui::{
     copy_to_clipboard, get_info, open_in_editor, quick_look, set_view_mode, show_in_finder, toggle_hidden_files,
 };
@@ -59,6 +60,10 @@ pub fn execute_tool<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value)
         n if n.starts_with("selection_") => execute_selection_command(app, n, params),
         // Context commands
         n if n.starts_with("context_") => execute_context_command(app, n),
+        // Settings commands
+        n if n.starts_with("settings_") => execute_settings_command(app, n, params),
+        // Shortcuts commands
+        n if n.starts_with("shortcuts_") => execute_shortcuts_command(app, n, params),
         _ => Err(ToolError::invalid_params(format!("Unknown tool: {name}"))),
     }
 }
@@ -355,6 +360,196 @@ fn execute_context_command<R: Runtime>(app: &AppHandle<R>, name: &str) -> ToolRe
     }
 }
 
+/// Execute a settings command.
+/// These manage the Settings window and its values.
+fn execute_settings_command<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value) -> ToolResult {
+    match name {
+        "settings_open" => {
+            // Emit event to main window to open settings
+            app.emit_to("main", "open-settings", ())
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "message": "Settings window opening"}))
+        }
+        "settings_close" => {
+            // Emit event to settings window to close
+            app.emit_to("settings", "mcp-settings-close", ())
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "message": "Settings window closing"}))
+        }
+        "settings_listSections" => {
+            let store = app
+                .try_state::<SettingsStateStore>()
+                .ok_or_else(|| ToolError::internal("Settings state not initialized"))?;
+
+            let state = store.get_state();
+            Ok(json!({
+                "sections": state.sections,
+                "selectedSection": state.selected_section
+            }))
+        }
+        "settings_selectSection" => {
+            let section_path = params
+                .get("sectionPath")
+                .and_then(|v| v.as_array())
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|v| v.as_str().map(String::from))
+                        .collect::<Vec<_>>()
+                })
+                .ok_or_else(|| ToolError::invalid_params("Missing 'sectionPath' parameter"))?;
+
+            // Emit event to settings window to select section
+            app.emit_to(
+                "settings",
+                "mcp-settings-select-section",
+                json!({"sectionPath": section_path}),
+            )
+            .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "selectedSection": section_path}))
+        }
+        "settings_listItems" => {
+            let store = app
+                .try_state::<SettingsStateStore>()
+                .ok_or_else(|| ToolError::internal("Settings state not initialized"))?;
+
+            let state = store.get_state();
+            Ok(json!({
+                "selectedSection": state.selected_section,
+                "settings": state.current_settings
+            }))
+        }
+        "settings_getValue" => {
+            let setting_id = params
+                .get("settingId")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'settingId' parameter"))?;
+
+            let store = app
+                .try_state::<SettingsStateStore>()
+                .ok_or_else(|| ToolError::internal("Settings state not initialized"))?;
+
+            let state = store.get_state();
+            let setting = state.current_settings.iter().find(|s| s.id == setting_id).cloned();
+
+            match setting {
+                Some(s) => Ok(json!({
+                    "settingId": s.id,
+                    "value": s.value,
+                    "isModified": s.is_modified,
+                    "defaultValue": s.default_value
+                })),
+                None => Err(ToolError::invalid_params(format!("Setting not found: {setting_id}"))),
+            }
+        }
+        "settings_setValue" => {
+            let setting_id = params
+                .get("settingId")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'settingId' parameter"))?;
+
+            let value = params
+                .get("value")
+                .ok_or_else(|| ToolError::invalid_params("Missing 'value' parameter"))?;
+
+            // Emit event to settings window to set the value
+            app.emit_to(
+                "settings",
+                "mcp-settings-set-value",
+                json!({"settingId": setting_id, "value": value}),
+            )
+            .map_err(|e| ToolError::internal(e.to_string()))?;
+
+            Ok(json!({"success": true, "settingId": setting_id, "value": value}))
+        }
+        _ => Err(ToolError::invalid_params(format!("Unknown settings command: {name}"))),
+    }
+}
+
+/// Execute a shortcuts command.
+/// These manage keyboard shortcuts configuration.
+fn execute_shortcuts_command<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value) -> ToolResult {
+    match name {
+        "shortcuts_list" => {
+            let store = app
+                .try_state::<SettingsStateStore>()
+                .ok_or_else(|| ToolError::internal("Settings state not initialized"))?;
+
+            let state = store.get_state();
+            Ok(json!({
+                "commands": state.shortcuts
+            }))
+        }
+        "shortcuts_set" => {
+            let command_id = params
+                .get("commandId")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'commandId' parameter"))?;
+
+            let index = params
+                .get("index")
+                .and_then(|v| v.as_i64())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'index' parameter"))?;
+
+            let shortcut = params
+                .get("shortcut")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'shortcut' parameter"))?;
+
+            // Emit event to settings window (or main window if settings is closed)
+            // to set the shortcut
+            app.emit(
+                "mcp-shortcuts-set",
+                json!({"commandId": command_id, "index": index, "shortcut": shortcut}),
+            )
+            .map_err(|e| ToolError::internal(e.to_string()))?;
+
+            Ok(json!({
+                "success": true,
+                "commandId": command_id,
+                "index": index,
+                "shortcut": shortcut
+            }))
+        }
+        "shortcuts_remove" => {
+            let command_id = params
+                .get("commandId")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'commandId' parameter"))?;
+
+            let index = params
+                .get("index")
+                .and_then(|v| v.as_i64())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'index' parameter"))?;
+
+            // Emit event to remove the shortcut
+            app.emit("mcp-shortcuts-remove", json!({"commandId": command_id, "index": index}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+
+            Ok(json!({
+                "success": true,
+                "commandId": command_id,
+                "index": index
+            }))
+        }
+        "shortcuts_reset" => {
+            let command_id = params
+                .get("commandId")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'commandId' parameter"))?;
+
+            // Emit event to reset the shortcut
+            app.emit("mcp-shortcuts-reset", json!({"commandId": command_id}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+
+            Ok(json!({
+                "success": true,
+                "commandId": command_id
+            }))
+        }
+        _ => Err(ToolError::invalid_params(format!("Unknown shortcuts command: {name}"))),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

apps/desktop/src-tauri/src/mcp/mod.rs

@@ -9,6 +9,7 @@ pub mod pane_state;
 mod protocol;
 mod resources;
 mod server;
+pub mod settings_state;
 mod tools;
 
 #[cfg(test)]
@@ -17,3 +18,4 @@ mod tests;
 pub use config::McpConfig;
 pub use pane_state::PaneStateStore;
 pub use server::start_mcp_server;
+pub use settings_state::SettingsStateStore;