feat: add configurable Tools menu with external tool shortcuts

Add a Tools menu to both macOS and GTK4 with configurable external tool
shortcuts (e.g. "Open in Finder", "Open in VS Code"). Shortcuts are
stored in platform-specific config files and can be edited in the
Preferences dialog. Each shortcut launches its command in the active
terminal's working directory.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: MagicalTux

crates/cterm-app/src/config.rs

@@ -3,7 +3,7 @@
 //! Handles loading, saving, and managing configuration files.
 
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use directories::ProjectDirs;
 use serde::{Deserialize, Serialize};
@@ -903,6 +903,150 @@ pub fn save_config_with_sync(config: &Config, sync: bool) -> Result<(), ConfigEr
     Ok(())
 }
 
+/// An external tool shortcut entry for the Tools menu
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolShortcutEntry {
+    pub name: String,
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+}
+
+impl ToolShortcutEntry {
+    /// Execute this shortcut in the given working directory.
+    /// Spawns the process detached (stdin/stdout/stderr null).
+    pub fn execute(&self, cwd: &Path) -> Result<(), std::io::Error> {
+        std::process::Command::new(&self.command)
+            .args(&self.args)
+            .current_dir(cwd)
+            .stdin(std::process::Stdio::null())
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .spawn()?;
+        Ok(())
+    }
+}
+
+/// Get the platform-specific tool shortcuts file path
+pub fn tool_shortcuts_path() -> Option<PathBuf> {
+    let filename = if cfg!(target_os = "macos") {
+        "shortcuts_macos.toml"
+    } else if cfg!(target_os = "windows") {
+        "shortcuts_windows.toml"
+    } else {
+        "shortcuts_linux.toml"
+    };
+    config_dir().map(|p| p.join(filename))
+}
+
+/// Return default tool shortcuts for the current platform
+pub fn default_tool_shortcuts() -> Vec<ToolShortcutEntry> {
+    #[cfg(target_os = "macos")]
+    {
+        vec![
+            ToolShortcutEntry {
+                name: "Open in Finder".into(),
+                command: "open".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in Xcode".into(),
+                command: "xed".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in VS Code".into(),
+                command: "code".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in Terminal".into(),
+                command: "open".into(),
+                args: vec!["-a".into(), "Terminal".into(), ".".into()],
+            },
+        ]
+    }
+    #[cfg(target_os = "windows")]
+    {
+        vec![
+            ToolShortcutEntry {
+                name: "Open in Explorer".into(),
+                command: "explorer".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in VS Code".into(),
+                command: "code".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in PowerShell".into(),
+                command: "powershell".into(),
+                args: vec!["-NoExit".into(), "-Command".into(), "cd .".into()],
+            },
+        ]
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+    {
+        vec![
+            ToolShortcutEntry {
+                name: "Open File Manager".into(),
+                command: "xdg-open".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in VS Code".into(),
+                command: "code".into(),
+                args: vec![".".into()],
+            },
+            ToolShortcutEntry {
+                name: "Open in Terminal".into(),
+                command: "x-terminal-emulator".into(),
+                args: vec![".".into()],
+            },
+        ]
+    }
+}
+
+/// Load tool shortcuts from the platform-specific config file.
+/// Returns defaults if the file doesn't exist.
+pub fn load_tool_shortcuts() -> Result<Vec<ToolShortcutEntry>, ConfigError> {
+    let path = tool_shortcuts_path().ok_or(ConfigError::NoConfigDir)?;
+
+    if !path.exists() {
+        return Ok(default_tool_shortcuts());
+    }
+
+    let content = std::fs::read_to_string(&path)?;
+
+    #[derive(Deserialize)]
+    struct ToolShortcutsFile {
+        tools: Vec<ToolShortcutEntry>,
+    }
+
+    let file: ToolShortcutsFile = toml::from_str(&content)?;
+    Ok(file.tools)
+}
+
+/// Save tool shortcuts to the platform-specific config file
+pub fn save_tool_shortcuts(tools: &[ToolShortcutEntry]) -> Result<(), ConfigError> {
+    let dir = config_dir().ok_or(ConfigError::NoConfigDir)?;
+    std::fs::create_dir_all(&dir)?;
+
+    let path = tool_shortcuts_path().ok_or(ConfigError::NoConfigDir)?;
+
+    #[derive(Serialize)]
+    struct ToolShortcutsFile<'a> {
+        tools: &'a [ToolShortcutEntry],
+    }
+
+    let file = ToolShortcutsFile { tools };
+    let content = toml::to_string_pretty(&file)?;
+    std::fs::write(&path, content)?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1260,4 +1404,59 @@ mod tests {
         let visibility = TabBarVisibility::default();
         assert!(matches!(visibility, TabBarVisibility::Always));
     }
+
+    #[test]
+    fn test_default_tool_shortcuts_not_empty() {
+        let shortcuts = default_tool_shortcuts();
+        assert!(!shortcuts.is_empty());
+        // First entry should always have a name and command
+        assert!(!shortcuts[0].name.is_empty());
+        assert!(!shortcuts[0].command.is_empty());
+    }
+
+    #[test]
+    fn test_tool_shortcut_serialize() {
+        let shortcut = ToolShortcutEntry {
+            name: "Test".into(),
+            command: "echo".into(),
+            args: vec!["hello".into()],
+        };
+        let serialized = toml::to_string(&shortcut).unwrap();
+        assert!(serialized.contains("name = \"Test\""));
+        assert!(serialized.contains("command = \"echo\""));
+    }
+
+    #[test]
+    fn test_tool_shortcut_deserialize() {
+        let toml_str = r#"
+            [[tools]]
+            name = "Open Finder"
+            command = "open"
+            args = ["."]
+        "#;
+
+        #[derive(Deserialize)]
+        struct File {
+            tools: Vec<ToolShortcutEntry>,
+        }
+
+        let file: File = toml::from_str(toml_str).unwrap();
+        assert_eq!(file.tools.len(), 1);
+        assert_eq!(file.tools[0].name, "Open Finder");
+        assert_eq!(file.tools[0].command, "open");
+        assert_eq!(file.tools[0].args, vec!["."]);
+    }
+
+    #[test]
+    fn test_tool_shortcut_deserialize_no_args() {
+        let toml_str = r#"
+            name = "Test"
+            command = "ls"
+        "#;
+
+        let entry: ToolShortcutEntry = toml::from_str(toml_str).unwrap();
+        assert_eq!(entry.name, "Test");
+        assert_eq!(entry.command, "ls");
+        assert!(entry.args.is_empty());
+    }
 }

crates/cterm-cocoa/src/app.rs

@@ -479,6 +479,71 @@ define_class!(
             }
         }
 
+        #[unsafe(method(runToolShortcut:))]
+        fn action_run_tool_shortcut(&self, sender: Option<&objc2::runtime::AnyObject>) {
+            use objc2_app_kit::NSMenuItem;
+
+            if let Some(sender) = sender {
+                let item: &NSMenuItem = unsafe { &*(sender as *const _ as *const NSMenuItem) };
+                let index = item.tag() as usize;
+
+                if let Ok(shortcuts) = cterm_app::config::load_tool_shortcuts() {
+                    if let Some(shortcut) = shortcuts.get(index) {
+                        // Get CWD from active terminal in the key window
+                        let mtm = MainThreadMarker::from(self);
+                        let app = NSApplication::sharedApplication(mtm);
+                        let cwd = app.keyWindow().and_then(|key_window| {
+                            let is_cterm: bool = unsafe {
+                                msg_send![&key_window, isKindOfClass: objc2::class!(CtermWindow)]
+                            };
+                            if is_cterm {
+                                let cterm_window: &CtermWindow = unsafe {
+                                    &*(&*key_window as *const NSWindow as *const CtermWindow)
+                                };
+                                #[cfg(unix)]
+                                {
+                                    cterm_window
+                                        .active_terminal()
+                                        .and_then(|t| t.foreground_cwd())
+                                }
+                                #[cfg(not(unix))]
+                                {
+                                    let _ = cterm_window;
+                                    None
+                                }
+                            } else {
+                                None
+                            }
+                        });
+
+                        let cwd = cwd.unwrap_or_else(|| {
+                            std::env::var("HOME").unwrap_or_else(|_| "/".to_string())
+                        });
+
+                        if let Err(e) =
+                            shortcut.execute(std::path::Path::new(&cwd))
+                        {
+                            // Show error alert
+                            let alert = objc2_app_kit::NSAlert::new(mtm);
+                            alert.setMessageText(&NSString::from_str(&format!(
+                                "Failed to launch \"{}\"",
+                                shortcut.name
+                            )));
+                            alert.setInformativeText(&NSString::from_str(&format!(
+                                "Command '{}' failed: {}",
+                                shortcut.command, e
+                            )));
+                            alert.setAlertStyle(
+                                objc2_app_kit::NSAlertStyle::Warning,
+                            );
+                            alert.addButtonWithTitle(&NSString::from_str("OK"));
+                            alert.runModal();
+                        }
+                    }
+                }
+            }
+        }
+
         #[unsafe(method(newWindow:))]
         fn action_new_window(&self, _sender: Option<&objc2::runtime::AnyObject>) {
             use objc2_app_kit::NSWindowTabbingMode;

crates/cterm-cocoa/src/menu.rs

@@ -61,6 +61,9 @@ pub fn create_menu_bar(mtm: MainThreadMarker) -> Retained<NSMenu> {
     // Terminal menu
     menu_bar.addItem(&create_terminal_menu(mtm));
 
+    // Tools menu
+    menu_bar.addItem(&create_tools_menu(mtm));
+
     // Window menu
     menu_bar.addItem(&create_window_menu(mtm));
 
@@ -484,6 +487,53 @@ fn create_terminal_menu(mtm: MainThreadMarker) -> Retained<NSMenuItem> {
     menu_item
 }
 
+fn create_tools_menu(mtm: MainThreadMarker) -> Retained<NSMenuItem> {
+    let menu = NSMenu::new(mtm);
+    menu.setTitle(&NSString::from_str("Tools"));
+
+    populate_tools_menu(&menu, mtm);
+
+    let menu_item = NSMenuItem::new(mtm);
+    menu_item.setSubmenu(Some(&menu));
+    menu_item
+}
+
+/// Populate (or repopulate) the Tools menu with shortcut entries
+fn populate_tools_menu(menu: &NSMenu, mtm: MainThreadMarker) {
+    if let Ok(shortcuts) = cterm_app::config::load_tool_shortcuts() {
+        for (i, shortcut) in shortcuts.iter().enumerate() {
+            let item = NSMenuItem::new(mtm);
+            item.setTitle(&NSString::from_str(&shortcut.name));
+            unsafe { item.setAction(Some(sel!(runToolShortcut:))) };
+            item.setTag(i as isize);
+            menu.addItem(&item);
+        }
+    }
+}
+
+/// Rebuild the Tools menu items (called after preferences save)
+pub fn rebuild_tools_menu(mtm: MainThreadMarker) {
+    use objc2_app_kit::NSApplication;
+
+    let app = NSApplication::sharedApplication(mtm);
+    if let Some(main_menu) = app.mainMenu() {
+        // Find the "Tools" menu
+        let tools_title = NSString::from_str("Tools");
+        let count = main_menu.numberOfItems();
+        for i in 0..count {
+            if let Some(item) = main_menu.itemAtIndex(i) {
+                if let Some(submenu) = item.submenu() {
+                    if submenu.title().to_string() == tools_title.to_string() {
+                        submenu.removeAllItems();
+                        populate_tools_menu(&submenu, mtm);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn create_window_menu(mtm: MainThreadMarker) -> Retained<NSMenuItem> {
     let menu = NSMenu::new(mtm);
     menu.setTitle(&NSString::from_str("Window"));