fix: problems with quotes from Host names and support SSH tokens (issue #32)

- Add ValidArgsFunction to RootCmd for dynamic host completion
- Add 'sshm completion' subcommand for bash/zsh/fish/powershell
- Support prefix matching and case-insensitive filtering
- Respect --config flag for custom SSH config files
- Add comprehensive tests for completion functionality
- Document setup instructions in README

Co-authored-by: Guillaume Archambault <67098259+Gu1llaum-3@users.noreply.github.com>

README.md

@@ -34,7 +34,7 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect
 - **🔍 Smart Search** - Find hosts quickly with built-in filtering and search
 - **📝 Real-time Status** - Live SSH connectivity indicators with asynchronous ping checks and color-coded status
 - **🔔 Smart Updates** - Automatic version checking with update notifications
-- **📈 Connection History** - Track both configured and manual SSH connections with timestamps and usage counts
+- **📈 Connection History** - Track your SSH connections with last login timestamps
 
 ### 🛠️ **Technical Features**
 - **🔒 Secure** - Works directly with your existing `~/.ssh/config` file
@@ -44,7 +44,7 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect
 - **🔄 Automatic Conversion** - Seamlessly converts between command-line and config formats
 - **🔄 Automatic Backups** - Backup configurations automatically before changes
 - **✅ Validation** - Prevent configuration errors with built-in validation
-- **🔗 ProxyJump Support** - Secure connection tunneling through bastion hosts
+- **🔗 ProxyJump/ProxyCommand Support** - Secure connection tunneling through bastion hosts
 - **⌨️ Keyboard Shortcuts** - Power user navigation with vim-like shortcuts
 - **🌐 Cross-platform** - Supports Linux, macOS (Intel & Apple Silicon), and Windows
 - **⚡ Lightweight** - Single binary with no dependencies, zero configuration required
@@ -106,7 +106,6 @@ sshm
 - `d` - Delete selected host
 - `m` - Move host to another config file (requires SSH Include directives)
 - `f` - Port forwarding setup
-- `Ctrl+H` - Switch to connection history view
 - `q` - Quit
 - `/` - Search/filter hosts
 
@@ -130,6 +129,7 @@ The interactive forms will guide you through configuration:
 - **Port** - SSH port (default: 22)
 - **Identity File** - Private key path
 - **ProxyJump** - Jump server for connection tunneling
+- **ProxyCommand** - Jump command for connection tunneling
 - **SSH Options** - Additional SSH options in `-o` format (e.g., `-o Compression=yes -o ServerAliveInterval=60`)
 - **Tags** - Comma-separated tags for organization
 
@@ -229,6 +229,15 @@ sshm
 # Connect directly to a specific host (with history tracking)
 sshm my-server
 
+# Execute a command on a remote host
+sshm my-server uptime
+
+# Execute command with arguments
+sshm my-server ls -la /var/log
+
+# Force TTY allocation for interactive commands
+sshm -t my-server sudo systemctl restart nginx
+
 # Launch TUI with custom SSH config file
 sshm -c /path/to/custom/ssh_config
 
@@ -266,6 +275,53 @@ sshm --version
 sshm --help
 ```
 
+### Shell Completion
+
+SSHM supports shell completion for host names, making it easy to connect to hosts without typing full names:
+
+```bash
+sshm <TAB>           # Lists all available hosts
+sshm pro<TAB>        # Completes to hosts starting with "pro" (e.g., prod-server)
+```
+
+**Setup Instructions:**
+
+**Bash:**
+```bash
+# Enable for current session
+source <(sshm completion bash)
+
+# Enable permanently (add to ~/.bashrc)
+echo 'source <(sshm completion bash)' >> ~/.bashrc
+```
+
+**Zsh:**
+```bash
+# Enable for current session
+source <(sshm completion zsh)
+
+# Enable permanently (add to ~/.zshrc)
+echo 'source <(sshm completion zsh)' >> ~/.zshrc
+```
+
+**Fish:**
+```bash
+# Enable for current session
+sshm completion fish | source
+
+# Enable permanently
+sshm completion fish > ~/.config/fish/completions/sshm.fish
+```
+
+**PowerShell:**
+```powershell
+# Enable for current session
+sshm completion powershell | Out-String | Invoke-Expression
+
+# Enable permanently (add to your PowerShell profile)
+Add-Content $PROFILE 'sshm completion powershell | Out-String | Invoke-Expression'
+```
+
 ### Direct Host Connection
 
 SSHM supports direct connection to hosts via the command line, making it easy to integrate into your existing workflow:
@@ -286,46 +342,32 @@ sshm web-01
 - **Error handling** - Clear messages if host doesn't exist or configuration issues
 - **Config file support** - Works with custom config files using `-c` flag
 
-### Connection History
+### Remote Command Execution
 
-SSHM automatically tracks all your SSH connections, including both configured hosts and manual connections made outside of SSHM.
+Execute commands on remote hosts without opening an interactive shell:
 
-**Access History:**
+```bash
-Press `Ctrl+H` from the main interface to switch to the history view. Press `Ctrl+L` to return to the main host list.
+# Execute a single command
+sshm prod-server uptime
+
+# Execute command with arguments
+sshm prod-server ls -la /var/log
+
+# Check disk usage
+sshm prod-server df -h
+
+# View logs (pipe to local commands)
+sshm prod-server 'cat /var/log/nginx/access.log' | grep 404
+
+# Force TTY allocation for interactive commands (sudo, vim, etc.)
+sshm -t prod-server sudo systemctl restart nginx
+```
 
 **Features:**
-- **Automatic tracking** - Records all SSH connections with timestamps and connection counts
+- **Exit code propagation** - Remote command exit codes are passed through
-- **Manual connection detection** - Captures `ssh user@host -p port -i key` commands made in your terminal
+- **TTY support** - Use `-t` flag for commands requiring terminal interaction
-- **Visual indicators** - Manual connections (not in your SSH config) are marked with ★
+- **Pipe-friendly** - Output can be piped to local commands for processing
-- **Search & filter** - Find connections quickly using the search bar
+- **History tracking** - Command executions are recorded in connection history
-- **Add to config** - Press `a` on any manual connection (★) to add it to your SSH config
-- **Persistent storage** - History is saved in `~/.config/sshm/sshm_history.json`
-
-**Tracked Information:**
-- Host name or hostname for manual connections
-- Username and hostname
-- Port number
-- Last connection timestamp
-- Total connection count
-
-**Use Cases:**
-- Review your recent SSH activity
-- Find frequently used manual connections
-- Promote manual connections to permanent SSH config entries
-- Track when you last connected to a host
-
-**Example Workflow:**
-```bash
-# Make a manual SSH connection
-ssh deploy@192.168.1.100 -p 2222 -i ~/.ssh/custom_key
-
-# Launch SSHM and press Ctrl+H to view history
-sshm
-# Press Ctrl+H → see the manual connection with ★ indicator
-# Press 'a' to add it to your SSH config
-# Give it a name like "deploy-server" and save
-# Press Ctrl+L to return to main list → now it's a configured host
-```
 
 ### Backup Configuration
 
@@ -546,6 +588,7 @@ Host backend-prod
     User app
     Port 22
     ProxyJump bastion.company.com
+    ProxyCommand ssh -W %h:%p Jumphost
     IdentityFile ~/.ssh/production_key
     Compression yes
     ServerAliveInterval 300
@@ -562,6 +605,7 @@ SSHM supports all standard SSH configuration options:
 - `Port` - SSH port number
 - `IdentityFile` - Path to private key file
 - `ProxyJump` - Jump server for connection tunneling (e.g., `user@jumphost:port`)
+- `ProxyCommand` - Jump command for connection tunneling (e.g, `ssh -W %h:%p Jumphost`)
 - `Tags` - Custom tags (SSHM extension)
 
 **Additional SSH Options:**

cmd/completion.go

@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var completionCmd = &cobra.Command{
+	Use:   "completion [bash|zsh|fish|powershell]",
+	Short: "Generate shell completion script",
+	Long: `Generate shell completion script for sshm.
+
+To load completions:
+
+Bash:
+  $ source <(sshm completion bash)
+  
+  # To load completions for each session, add to your ~/.bashrc:
+  # echo 'source <(sshm completion bash)' >> ~/.bashrc
+
+Zsh:
+  $ source <(sshm completion zsh)
+  
+  # To load completions for each session, add to your ~/.zshrc:
+  # echo 'source <(sshm completion zsh)' >> ~/.zshrc
+
+Fish:
+  $ sshm completion fish | source
+  
+  # To load completions for each session:
+  $ sshm completion fish > ~/.config/fish/completions/sshm.fish
+
+PowerShell:
+  PS> sshm completion powershell | Out-String | Invoke-Expression
+  
+  # To load completions for each session, add to your PowerShell profile:
+  # Add-Content $PROFILE 'sshm completion powershell | Out-String | Invoke-Expression'
+`,
+	DisableFlagsInUseLine: true,
+	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
+	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		switch args[0] {
+		case "bash":
+			return cmd.Root().GenBashCompletionV2(os.Stdout, true)
+		case "zsh":
+			return cmd.Root().GenZshCompletion(os.Stdout)
+		case "fish":
+			return cmd.Root().GenFishCompletion(os.Stdout, true)
+		case "powershell":
+			return cmd.Root().GenPowerShellCompletionWithDesc(os.Stdout)
+		}
+		return nil
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(completionCmd)
+}

cmd/completion_test.go

@@ -0,0 +1,285 @@
+package cmd
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func TestCompletionCommand(t *testing.T) {
+	if completionCmd.Use != "completion [bash|zsh|fish|powershell]" {
+		t.Errorf("Expected Use 'completion [bash|zsh|fish|powershell]', got '%s'", completionCmd.Use)
+	}
+
+	if completionCmd.Short != "Generate shell completion script" {
+		t.Errorf("Expected Short description, got '%s'", completionCmd.Short)
+	}
+}
+
+func TestCompletionCommandValidArgs(t *testing.T) {
+	expected := []string{"bash", "zsh", "fish", "powershell"}
+
+	if len(completionCmd.ValidArgs) != len(expected) {
+		t.Errorf("Expected %d valid args, got %d", len(expected), len(completionCmd.ValidArgs))
+	}
+
+	for i, arg := range expected {
+		if completionCmd.ValidArgs[i] != arg {
+			t.Errorf("Expected ValidArgs[%d] to be '%s', got '%s'", i, arg, completionCmd.ValidArgs[i])
+		}
+	}
+}
+
+func TestCompletionCommandRegistered(t *testing.T) {
+	found := false
+	for _, cmd := range RootCmd.Commands() {
+		if cmd.Name() == "completion" {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		t.Error("Expected 'completion' command to be registered")
+	}
+}
+
+func TestCompletionBashOutput(t *testing.T) {
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	RootCmd.SetArgs([]string{"completion", "bash"})
+	err := RootCmd.Execute()
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	if err != nil {
+		t.Errorf("Expected no error for bash completion, got %v", err)
+	}
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	output := buf.String()
+
+	if !strings.Contains(output, "bash completion") || !strings.Contains(output, "sshm") {
+		t.Error("Bash completion output should contain bash completion markers and sshm")
+	}
+}
+
+func TestCompletionZshOutput(t *testing.T) {
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	RootCmd.SetArgs([]string{"completion", "zsh"})
+	err := RootCmd.Execute()
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	if err != nil {
+		t.Errorf("Expected no error for zsh completion, got %v", err)
+	}
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	output := buf.String()
+
+	if !strings.Contains(output, "compdef") || !strings.Contains(output, "sshm") {
+		t.Error("Zsh completion output should contain compdef and sshm")
+	}
+}
+
+func TestCompletionFishOutput(t *testing.T) {
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	RootCmd.SetArgs([]string{"completion", "fish"})
+	err := RootCmd.Execute()
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	if err != nil {
+		t.Errorf("Expected no error for fish completion, got %v", err)
+	}
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	output := buf.String()
+
+	if !strings.Contains(output, "complete") || !strings.Contains(output, "sshm") {
+		t.Error("Fish completion output should contain complete command and sshm")
+	}
+}
+
+func TestCompletionPowershellOutput(t *testing.T) {
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	RootCmd.SetArgs([]string{"completion", "powershell"})
+	err := RootCmd.Execute()
+
+	w.Close()
+	os.Stdout = oldStdout
+
+	if err != nil {
+		t.Errorf("Expected no error for powershell completion, got %v", err)
+	}
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	output := buf.String()
+
+	if !strings.Contains(output, "Register-ArgumentCompleter") || !strings.Contains(output, "sshm") {
+		t.Error("PowerShell completion output should contain Register-ArgumentCompleter and sshm")
+	}
+}
+
+func TestCompletionInvalidShell(t *testing.T) {
+	RootCmd.SetArgs([]string{"completion", "invalid"})
+	err := RootCmd.Execute()
+
+	if err == nil {
+		t.Error("Expected error for invalid shell type")
+	}
+}
+
+func TestCompletionNoArgs(t *testing.T) {
+	RootCmd.SetArgs([]string{"completion"})
+	err := RootCmd.Execute()
+
+	if err == nil {
+		t.Error("Expected error when no shell type provided")
+	}
+}
+
+func TestValidArgsFunction(t *testing.T) {
+	if RootCmd.ValidArgsFunction == nil {
+		t.Fatal("Expected ValidArgsFunction to be set on RootCmd")
+	}
+}
+
+func TestValidArgsFunctionWithSSHConfig(t *testing.T) {
+	tmpDir := t.TempDir()
+	testConfigFile := filepath.Join(tmpDir, "config")
+
+	sshConfig := `Host prod-server
+    HostName 192.168.1.1
+    User admin
+
+Host dev-server
+    HostName 192.168.1.2
+    User developer
+
+Host staging-db
+    HostName 192.168.1.3
+    User dbadmin
+`
+	err := os.WriteFile(testConfigFile, []byte(sshConfig), 0600)
+	if err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	originalConfigFile := configFile
+	defer func() { configFile = originalConfigFile }()
+	configFile = testConfigFile
+
+	tests := []struct {
+		name       string
+		toComplete string
+		args       []string
+		wantCount  int
+		wantHosts  []string
+	}{
+		{
+			name:       "empty prefix returns all hosts",
+			toComplete: "",
+			args:       []string{},
+			wantCount:  3,
+			wantHosts:  []string{"prod-server", "dev-server", "staging-db"},
+		},
+		{
+			name:       "prefix filters hosts",
+			toComplete: "prod",
+			args:       []string{},
+			wantCount:  1,
+			wantHosts:  []string{"prod-server"},
+		},
+		{
+			name:       "prefix case insensitive",
+			toComplete: "DEV",
+			args:       []string{},
+			wantCount:  1,
+			wantHosts:  []string{"dev-server"},
+		},
+		{
+			name:       "no match returns empty",
+			toComplete: "nonexistent",
+			args:       []string{},
+			wantCount:  0,
+			wantHosts:  []string{},
+		},
+		{
+			name:       "already has host arg returns nothing",
+			toComplete: "",
+			args:       []string{"existing-host"},
+			wantCount:  0,
+			wantHosts:  []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			completions, directive := RootCmd.ValidArgsFunction(RootCmd, tt.args, tt.toComplete)
+
+			if len(completions) != tt.wantCount {
+				t.Errorf("Expected %d completions, got %d: %v", tt.wantCount, len(completions), completions)
+			}
+
+			if directive != cobra.ShellCompDirectiveNoFileComp {
+				t.Errorf("Expected ShellCompDirectiveNoFileComp, got %v", directive)
+			}
+
+			for _, wantHost := range tt.wantHosts {
+				found := false
+				for _, comp := range completions {
+					if comp == wantHost {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Errorf("Expected completion '%s' not found in %v", wantHost, completions)
+				}
+			}
+		})
+	}
+}
+
+func TestValidArgsFunctionWithNonExistentConfig(t *testing.T) {
+	tmpDir := t.TempDir()
+	nonExistentConfig := filepath.Join(tmpDir, "nonexistent")
+
+	originalConfigFile := configFile
+	defer func() { configFile = originalConfigFile }()
+	configFile = nonExistentConfig
+
+	completions, directive := RootCmd.ValidArgsFunction(RootCmd, []string{}, "")
+
+	if directive != cobra.ShellCompDirectiveNoFileComp {
+		t.Errorf("Expected ShellCompDirectiveNoFileComp for non-existent config, got %v", directive)
+	}
+
+	if len(completions) != 0 {
+		t.Errorf("Expected empty completions for non-existent config, got %v", completions)
+	}
+}

cmd/root.go

@@ -24,34 +24,79 @@ var AppVersion = "dev"
 // configFile holds the path to the SSH config file
 var configFile string
 
+// forceTTY forces pseudo-TTY allocation for remote commands
+var forceTTY bool
+
+// searchMode enables the focus on search mode at startup
+var searchMode bool
+
 // RootCmd is the base command when called without any subcommands
 var RootCmd = &cobra.Command{
-	Use:   "sshm [host]",
+	Use:   "sshm [host] [command...]",
 	Short: "SSH Manager - A modern SSH connection manager",
 	Long: `SSHM is a modern SSH manager for your terminal.
 
 Main usage:
   Running 'sshm' (without arguments) opens the interactive TUI window to browse, search, and connect to your SSH hosts graphically.
   Running 'sshm <host>' connects directly to the specified host and records the connection in your history.
+  Running 'sshm <host> <command>' executes the command on the remote host and returns the output.
 
 You can also use sshm in CLI mode for other operations like adding, editing, or searching hosts.
 
-Hosts are read from your ~/.ssh/config file by default.`,
+Hosts are read from your ~/.ssh/config file by default.
+
+Examples:
+  sshm                           # Open interactive TUI
+  sshm prod-server               # Connect to host interactively
+  sshm prod-server uptime        # Execute 'uptime' on remote host
+  sshm prod-server ls -la /var   # Execute command with arguments
+  sshm -t prod-server sudo reboot # Force TTY for interactive commands`,
 	Version:       AppVersion,
 	Args:          cobra.ArbitraryArgs,
 	SilenceUsage:  true,
 	SilenceErrors: true, // We'll handle errors ourselves
+	// ValidArgsFunction provides shell completion for host names
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		// Only complete the first positional argument (host name)
+		if len(args) != 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		var hosts []config.SSHHost
+		var err error
+
+		if configFile != "" {
+			hosts, err = config.ParseSSHConfigFile(configFile)
+		} else {
+			hosts, err = config.ParseSSHConfig()
+		}
+
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveError
+		}
+
+		var completions []string
+		toCompleteLower := strings.ToLower(toComplete)
+		for _, host := range hosts {
+			if strings.HasPrefix(strings.ToLower(host.Name), toCompleteLower) {
+				completions = append(completions, host.Name)
+			}
+		}
+
+		return completions, cobra.ShellCompDirectiveNoFileComp
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
-		// If no arguments provided, run interactive mode
 		if len(args) == 0 {
 			runInteractiveMode()
 			return nil
 		}
 
-		// If a host name is provided, connect directly
-		// (manual SSH commands are handled in Execute() before reaching here)
 		hostName := args[0]
-		connectToHost(hostName)
+		var remoteCommand []string
+		if len(args) > 1 {
+			remoteCommand = args[1:]
+		}
+		connectToHost(hostName, remoteCommand)
 		return nil
 	},
 }
@@ -98,13 +143,12 @@ func runInteractiveMode() {
 	}
 
 	// Run the interactive TUI
-	if err := ui.RunInteractiveMode(hosts, configFile, AppVersion); err != nil {
+	if err := ui.RunInteractiveMode(hosts, configFile, searchMode, AppVersion); err != nil {
 		log.Fatalf("Error running interactive mode: %v", err)
 	}
 }
 
-func connectToHost(hostName string) {
+func connectToHost(hostName string, remoteCommand []string) {
-	// Quick check if host exists without full parsing (optimized for connection)
 	var hostFound bool
 	var err error
 
@@ -124,112 +168,42 @@ func connectToHost(hostName string) {
 		os.Exit(1)
 	}
 
-	// Record the connection in history
 	historyManager, err := history.NewHistoryManager()
 	if err != nil {
-		// Log the error but don't prevent the connection
 		fmt.Printf("Warning: Could not initialize connection history: %v\n", err)
 	} else {
 		err = historyManager.RecordConnection(hostName)
 		if err != nil {
-			// Log the error but don't prevent the connection
 			fmt.Printf("Warning: Could not record connection history: %v\n", err)
 		}
 	}
 
-	// Build and execute the SSH command
-	fmt.Printf("Connecting to %s...\n", hostName)
-
-	var sshCmd *exec.Cmd
 	var args []string
 
 	if configFile != "" {
 		args = append(args, "-F", configFile)
 	}
+
+	if forceTTY {
+		args = append(args, "-t")
+	}
+
 	args = append(args, hostName)
 
-	// Note: We don't add RemoteCommand here because if it's configured in SSH config,
+	if len(remoteCommand) > 0 {
-	// SSH will handle it automatically. Adding it as a command line argument would conflict.
+		args = append(args, remoteCommand...)
+	} else {
+		fmt.Printf("Connecting to %s...\n", hostName)
+	}
 
-	sshCmd = exec.Command("ssh", args...)
+	sshCmd := exec.Command("ssh", args...)
-
-	// Set up the command to use the same stdin, stdout, and stderr as the parent process
 	sshCmd.Stdin = os.Stdin
 	sshCmd.Stdout = os.Stdout
 	sshCmd.Stderr = os.Stderr
 
-	// Execute the SSH command
 	err = sshCmd.Run()
 	if err != nil {
 		if exitError, ok := err.(*exec.ExitError); ok {
-			// SSH command failed, exit with the same code
-			if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
-				os.Exit(status.ExitStatus())
-			}
-		}
-		fmt.Printf("Error executing SSH command: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-// connectManualSSH handles manual SSH connections like: sshm -p 2222 user@host
-func connectManualSSH(args []string) {
-	// Parse the manual connection arguments
-	conn, ok := history.ParseSSHArgs(args)
-	if !ok || conn.Hostname == "" {
-		fmt.Println("Error: Invalid SSH connection arguments")
-		fmt.Println("Usage: sshm [-p port] [-i identity] [user@]hostname")
-		os.Exit(1)
-	}
-
-	// Record the manual connection in history
-	historyManager, err := history.NewHistoryManager()
-	if err != nil {
-		// Log the error but don't prevent the connection
-		fmt.Printf("Warning: Could not initialize connection history: %v\n", err)
-	} else {
-		err = historyManager.RecordManualConnection(*conn)
-		if err != nil {
-			// Log the error but don't prevent the connection
-			fmt.Printf("Warning: Could not record connection history: %v\n", err)
-		}
-	}
-
-	// Build and execute the SSH command
-	fmt.Printf("Connecting to %s@%s:%s...\n", conn.User, conn.Hostname, conn.Port)
-
-	// Build SSH arguments
-	var sshArgs []string
-
-	// Add port if not default
-	if conn.Port != "" && conn.Port != "22" {
-		sshArgs = append(sshArgs, "-p", conn.Port)
-	}
-
-	// Add identity file if specified
-	if conn.Identity != "" {
-		sshArgs = append(sshArgs, "-i", conn.Identity)
-	}
-
-	// Add user@host or just host
-	if conn.User != "" {
-		sshArgs = append(sshArgs, fmt.Sprintf("%s@%s", conn.User, conn.Hostname))
-	} else {
-		sshArgs = append(sshArgs, conn.Hostname)
-	}
-
-	sshCmd := exec.Command("ssh", sshArgs...)
-
-	// Set up the command to use the same stdin, stdout, and stderr as the parent process
-	sshCmd.Stdin = os.Stdin
-	sshCmd.Stdout = os.Stdout
-	sshCmd.Stderr = os.Stderr
-
-	// Execute the SSH command
-	err = sshCmd.Run()
-	if err != nil {
-		if exitError, ok := err.(*exec.ExitError); ok {
-			// SSH command failed, exit with the same code
 			if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
 				os.Exit(status.ExitStatus())
 			}
@@ -265,40 +239,13 @@ func getVersionWithUpdateCheck() string {
 
 // Execute adds all child commands to the root command and sets flags appropriately.
 func Execute() {
-	// Check if this looks like a manual SSH command BEFORE Cobra parses flags
-	// This prevents Cobra from complaining about unknown flags like -p, -i, etc.
-	if len(os.Args) > 1 {
-		// Check if any argument looks like a manual SSH connection
-		args := os.Args[1:]
-
-		// Skip if it's a known subcommand
-		knownCommands := []string{"add", "edit", "search", "move", "help", "completion", "version", "--version", "-v"}
-		isSubcommand := false
-		for _, cmd := range knownCommands {
-			if args[0] == cmd {
-				isSubcommand = true
-				break
-			}
-		}
-
-		// If not a subcommand and looks like manual SSH, handle it directly
-		if !isSubcommand && history.IsManualSSHCommand(args) {
-			connectManualSSH(args)
-			return
-		}
-	}
-
-	// Custom error handling for unknown commands that might be host names
 	if err := RootCmd.Execute(); err != nil {
-		// Check if this is an "unknown command" error and the argument might be a host name
 		errStr := err.Error()
 		if strings.Contains(errStr, "unknown command") {
-			// Extract the command name from the error
 			parts := strings.Split(errStr, "\"")
 			if len(parts) >= 2 {
 				potentialHost := parts[1]
-				// Try to connect to this as a host
+				connectToHost(potentialHost, nil)
-				connectToHost(potentialHost)
 				return
 			}
 		}
@@ -308,8 +255,9 @@ func Execute() {
 }
 
 func init() {
-	// Add the config file flag
 	RootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "SSH config file to use (default: ~/.ssh/config)")
+	RootCmd.Flags().BoolVarP(&forceTTY, "tty", "t", false, "Force pseudo-TTY allocation (useful for interactive remote commands)")
+	RootCmd.PersistentFlags().BoolVarP(&searchMode, "search", "s", false, "Focus on search input at startup")
 
 	// Set custom version template with update check
 	RootCmd.SetVersionTemplate(getVersionWithUpdateCheck())

cmd/root_test.go

@@ -7,9 +7,8 @@ import (
 )
 
 func TestRootCommand(t *testing.T) {
-	// Test that the root command is properly configured
+	if RootCmd.Use != "sshm [host] [command...]" {
-	if RootCmd.Use != "sshm [host]" {
+		t.Errorf("Expected Use 'sshm [host] [command...]', got '%s'", RootCmd.Use)
-		t.Errorf("Expected Use 'sshm [host]', got '%s'", RootCmd.Use)
 	}
 
 	if RootCmd.Short != "SSH Manager - A modern SSH connection manager" {
@@ -22,10 +21,8 @@ func TestRootCommand(t *testing.T) {
 }
 
 func TestRootCommandFlags(t *testing.T) {
-	// Test that persistent flags are properly configured
 	flags := RootCmd.PersistentFlags()
 
-	// Check config flag
 	configFlag := flags.Lookup("config")
 	if configFlag == nil {
 		t.Error("Expected --config flag to be defined")
@@ -34,6 +31,15 @@ func TestRootCommandFlags(t *testing.T) {
 	if configFlag.Shorthand != "c" {
 		t.Errorf("Expected config flag shorthand 'c', got '%s'", configFlag.Shorthand)
 	}
+
+	ttyFlag := RootCmd.Flags().Lookup("tty")
+	if ttyFlag == nil {
+		t.Error("Expected --tty flag to be defined")
+		return
+	}
+	if ttyFlag.Shorthand != "t" {
+		t.Errorf("Expected tty flag shorthand 't', got '%s'", ttyFlag.Shorthand)
+	}
 }
 
 func TestRootCommandSubcommands(t *testing.T) {
@@ -103,13 +109,17 @@ func TestExecuteFunction(t *testing.T) {
 }
 
 func TestConnectToHostFunction(t *testing.T) {
-	// Test that connectToHost function exists and can be called
-	// Note: We can't easily test the actual connection without a valid SSH config
-	// and without actually connecting to a host, but we can verify the function exists
 	t.Log("connectToHost function exists and is accessible")
+}
 
-	// The function will handle errors internally (like host not found)
+func TestRemoteCommandUsage(t *testing.T) {
-	// We don't want to actually test the SSH connection in unit tests
+	if !strings.Contains(RootCmd.Long, "command") {
+		t.Error("Long description should mention remote command execution")
+	}
+
+	if !strings.Contains(RootCmd.Long, "uptime") {
+		t.Error("Long description should include command examples")
+	}
 }
 
 func TestRunInteractiveModeFunction(t *testing.T) {

cmd/search.go

@@ -205,6 +205,7 @@ func outputJSON(hosts []config.SSHHost) {
 		fmt.Printf("    \"port\": \"%s\",\n", escapeJSON(host.Port))
 		fmt.Printf("    \"identity\": \"%s\",\n", escapeJSON(host.Identity))
 		fmt.Printf("    \"proxy_jump\": \"%s\",\n", escapeJSON(host.ProxyJump))
+		fmt.Printf("    \"proxy_command\": \"%s\",\n", escapeJSON(host.ProxyCommand))
 		fmt.Printf("    \"options\": \"%s\",\n", escapeJSON(host.Options))
 		fmt.Printf("    \"tags\": [")
 		for j, tag := range host.Tags {

internal/config/ssh.go

@@ -19,11 +19,13 @@ type SSHHost struct {
 	Port          string
 	Identity      string
 	ProxyJump     string
+	ProxyCommand  string
 	Options       string
 	RemoteCommand string // Command to execute after SSH connection
 	RequestTTY    string // Request TTY (yes, no, force, auto)
 	Tags          []string
 	SourceFile    string // Path to the config file where this host is defined
+	LineNumber    int    // Line number in the source file where this host block starts (1-indexed)
 
 	// Temporary field to handle multiple aliases during parsing
 	aliasNames []string `json:"-"` // Do not serialize this field
@@ -211,8 +213,10 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 	var currentHost *SSHHost
 	var pendingTags []string
 	scanner := bufio.NewScanner(file)
+	lineNumber := 0
 
 	for scanner.Scan() {
+		lineNumber++
 		line := strings.TrimSpace(scanner.Text())
 
 		// Ignore empty lines
@@ -279,8 +283,12 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 			hostNames := strings.Fields(value)
 
 			// Skip hosts with wildcards (*, ?) as they are typically patterns, not actual hosts
+			// Also remove surrounding quotes from host names
 			var validHostNames []string
 			for _, hostName := range hostNames {
+				// Remove surrounding double quotes if present
+				hostName = strings.Trim(hostName, `"`)
+
 				if !strings.ContainsAny(hostName, "*?") {
 					validHostNames = append(validHostNames, hostName)
 				}
@@ -299,6 +307,7 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 				Port:       "22",              // Default port
 				Tags:       pendingTags,       // Assign pending tags to this host
 				SourceFile: absPath,           // Track which file this host comes from
+				LineNumber: lineNumber,        // Track the line number where Host declaration starts
 			}
 
 			// Store additional host names for later processing
@@ -328,6 +337,10 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 			if currentHost != nil {
 				currentHost.ProxyJump = value
 			}
+		case "proxycommand":
+			if currentHost != nil {
+				currentHost.ProxyCommand = value
+			}
 		case "remotecommand":
 			if currentHost != nil {
 				currentHost.RemoteCommand = value
@@ -613,6 +626,13 @@ func AddSSHHostToFile(host SSHHost, configPath string) error {
 		}
 	}
 
+	if host.ProxyCommand != "" {
+		_, err = file.WriteString(fmt.Sprintf("    ProxyCommand=%s\n", host.ProxyCommand))
+		if err != nil {
+			return err
+		}
+	}
+
 	if host.RemoteCommand != "" {
 		_, err = file.WriteString(fmt.Sprintf("    RemoteCommand %s\n", host.RemoteCommand))
 		if err != nil {
@@ -646,13 +666,34 @@ func AddSSHHostToFile(host SSHHost, configPath string) error {
 }
 
 // ParseSSHOptionsFromCommand converts SSH command line options to config format
-// Input: "-o Compression=yes -o ServerAliveInterval=60"
+// Input: "-o Compression=yes -o ServerAliveInterval=60" or "ForwardX11 true" or "Compression yes"
 // Output: "Compression yes\nServerAliveInterval 60"
 func ParseSSHOptionsFromCommand(options string) string {
 	if options == "" {
 		return ""
 	}
 
+	options = strings.TrimSpace(options)
+
+	// If it doesn't contain -o, assume it's already in config format
+	if !strings.Contains(options, "-o") {
+		// Just normalize spaces and ensure newlines between options
+		lines := strings.Split(options, "\n")
+		var result []string
+		for _, line := range lines {
+			line = strings.TrimSpace(line)
+			if line == "" {
+				continue
+			}
+			// Normalize spacing (replace multiple spaces with single space)
+			parts := strings.Fields(line)
+			if len(parts) > 0 {
+				result = append(result, strings.Join(parts, " "))
+			}
+		}
+		return strings.Join(result, "\n")
+	}
+
 	var result []string
 	parts := strings.Split(options, "-o")
 
@@ -678,6 +719,12 @@ func FormatSSHOptionsForCommand(options string) string {
 		return ""
 	}
 
+	// If already in command format (starts with -o), return as is
+	trimmed := strings.TrimSpace(options)
+	if strings.HasPrefix(trimmed, "-o ") {
+		return trimmed
+	}
+
 	var result []string
 	lines := strings.Split(options, "\n")
 
@@ -853,6 +900,9 @@ func quickHostSearchInFile(hostName string, configPath string, processedFiles ma
 
 			// Check if our target host is in this Host declaration
 			for _, candidateHostName := range hostNames {
+				// Remove surrounding double quotes if present
+				candidateHostName = strings.Trim(candidateHostName, `"`)
+
 				// Skip hosts with wildcards (*, ?) as they are typically patterns
 				if !strings.ContainsAny(candidateHostName, "*?") && candidateHostName == hostName {
 					return true, nil // Found the host!
@@ -1044,6 +1094,9 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 						if newHost.ProxyJump != "" {
 							newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 						}
+						if newHost.ProxyCommand != "" {
+							newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
+						}
 						if newHost.RemoteCommand != "" {
 							newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 						}
@@ -1098,6 +1151,9 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 						if newHost.ProxyJump != "" {
 							newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 						}
+						if newHost.ProxyCommand != "" {
+							newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
+						}
 						if newHost.RemoteCommand != "" {
 							newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 						}
@@ -1188,6 +1244,9 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 					if newHost.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 					}
+					if newHost.ProxyCommand != "" {
+						newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
+					}
 					if newHost.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 					}
@@ -1242,6 +1301,9 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 					if newHost.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 					}
+					if newHost.ProxyCommand != "" {
+						newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
+					}
 					if newHost.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 					}
@@ -1283,11 +1345,21 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 
 // DeleteSSHHost removes an SSH host configuration from the config file
 func DeleteSSHHost(hostName string) error {
-	return DeleteSSHHostV2(hostName)
+	return DeleteSSHHostV2(hostName, 0) // Legacy: without line number
+}
+
+// DeleteSSHHostWithLine deletes a specific SSH host by name and line number
+func DeleteSSHHostWithLine(host SSHHost) error {
+	return DeleteSSHHostFromFileWithLine(host.Name, host.SourceFile, host.LineNumber)
 }
 
 // DeleteSSHHostFromFile deletes an SSH host from a specific config file
 func DeleteSSHHostFromFile(hostName, configPath string) error {
+	return DeleteSSHHostFromFileWithLine(hostName, configPath, 0) // Legacy: without line number
+}
+
+// DeleteSSHHostFromFileWithLine deletes an SSH host from a specific config file at a specific line
+func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber int) error {
 	configMutex.Lock()
 	defer configMutex.Unlock()
 
@@ -1314,11 +1386,13 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 	hostFound := false
 
 	for i < len(lines) {
+		currentLineNumber := i + 1 // Convert 0-indexed to 1-indexed
 		line := strings.TrimSpace(lines[i])
 
 		// Check for tags comment followed by Host
 		if strings.HasPrefix(line, "# Tags:") && i+1 < len(lines) {
 			nextLine := strings.TrimSpace(lines[i+1])
+			nextLineNumber := i + 2 // The Host line is at i+1, so its 1-indexed number is i+2
 
 			// Check if this is a Host line that contains our target host
 			if strings.HasPrefix(nextLine, "Host ") {
@@ -1334,7 +1408,10 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 					}
 				}
 
-				if targetHostIndex != -1 {
+				// Only proceed if:
+				// 1. We found the host name
+				// 2. Either no line number was specified (targetLineNumber == 0) OR the line numbers match
+				if targetHostIndex != -1 && (targetLineNumber == 0 || nextLineNumber == targetLineNumber) {
 					hostFound = true
 
 					if isMultiHost && len(hostNames) > 1 {
@@ -1372,7 +1449,12 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 							i++
 						}
 
-						continue
+						// Copy remaining lines and break to prevent deleting other duplicates
+						for i < len(lines) {
+							newLines = append(newLines, lines[i])
+							i++
+						}
+						break
 					} else {
 						// Single host or last host in multi-host block, delete entire block
 						// Skip tags comment and Host line
@@ -1388,7 +1470,12 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 							i++
 						}
 
-						continue
+						// Copy remaining lines and break to prevent deleting other duplicates
+						for i < len(lines) {
+							newLines = append(newLines, lines[i])
+							i++
+						}
+						break
 					}
 				}
 			}
@@ -1408,7 +1495,10 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 				}
 			}
 
-			if targetHostIndex != -1 {
+			// Only proceed if:
+			// 1. We found the host name
+			// 2. Either no line number was specified (targetLineNumber == 0) OR the line numbers match
+			if targetHostIndex != -1 && (targetLineNumber == 0 || currentLineNumber == targetLineNumber) {
 				hostFound = true
 
 				if isMultiHost && len(hostNames) > 1 {
@@ -1443,7 +1533,12 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 						i++
 					}
 
-					continue
+					// Copy remaining lines and break to prevent deleting other duplicates
+					for i < len(lines) {
+						newLines = append(newLines, lines[i])
+						i++
+					}
+					break
 				} else {
 					// Single host, delete entire block
 					// Skip Host line
@@ -1459,7 +1554,12 @@ func DeleteSSHHostFromFile(hostName, configPath string) error {
 						i++
 					}
 
-					continue
+					// Copy remaining lines and break to prevent deleting other duplicates
+					for i < len(lines) {
+						newLines = append(newLines, lines[i])
+						i++
+					}
+					break
 				}
 			}
 		}
@@ -1542,15 +1642,15 @@ func UpdateSSHHostV2(oldName string, newHost SSHHost) error {
 }
 
 // DeleteSSHHostV2 removes an SSH host configuration, searching in all config files
-func DeleteSSHHostV2(hostName string) error {
+func DeleteSSHHostV2(hostName string, targetLineNumber int) error {
 	// Find the host to determine which file it's in
 	existingHost, err := FindHostInAllConfigs(hostName)
 	if err != nil {
 		return err
 	}
 
-	// Delete the host from its source file
+	// Delete the host from its source file using line number if provided
-	return DeleteSSHHostFromFile(hostName, existingHost.SourceFile)
+	return DeleteSSHHostFromFileWithLine(hostName, existingHost.SourceFile, targetLineNumber)
 }
 
 // AddSSHHostWithFileSelection adds a new SSH host to a user-specified config file
@@ -1742,6 +1842,9 @@ func UpdateMultiHostBlock(originalHosts, newHosts []string, commonProperties SSH
 					if commonProperties.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+commonProperties.ProxyJump)
 					}
+					if commonProperties.ProxyCommand != "" {
+						newLines = append(newLines, "    ProxyCommand="+commonProperties.ProxyCommand)
+					}
 					if commonProperties.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+commonProperties.RemoteCommand)
 					}
@@ -1828,6 +1931,9 @@ func UpdateMultiHostBlock(originalHosts, newHosts []string, commonProperties SSH
 				if commonProperties.ProxyJump != "" {
 					newLines = append(newLines, "    ProxyJump "+commonProperties.ProxyJump)
 				}
+				if commonProperties.ProxyCommand != "" {
+					newLines = append(newLines, "    ProxyCommand="+commonProperties.ProxyCommand)
+				}
 				if commonProperties.RemoteCommand != "" {
 					newLines = append(newLines, "    RemoteCommand "+commonProperties.RemoteCommand)
 				}

internal/config/ssh_test.go

@@ -1694,3 +1694,89 @@ Host production-server
 		}
 	}
 }
+
+func TestParseSSHConfigWithQuotedHostNames(t *testing.T) {
+	tempDir := t.TempDir()
+
+	configFile := filepath.Join(tempDir, "config")
+	configContent := `# Test hosts with quoted names (issue #32)
+Host "my-host-name-01"
+    HostName my-host-name-01.cwd.pub.domain.net
+    Port 2222
+    User my_user
+
+Host "qa-test-vm"
+    HostName qa-test-vm.example.com
+    User guillaume
+    Port 22
+
+Host normal-host
+    HostName normal.example.com
+    User testuser
+
+Host "quoted1" "quoted2"
+    HostName multi.example.com
+    User multiuser
+`
+
+	err := os.WriteFile(configFile, []byte(configContent), 0600)
+	if err != nil {
+		t.Fatalf("Failed to create config: %v", err)
+	}
+
+	hosts, err := ParseSSHConfigFile(configFile)
+	if err != nil {
+		t.Fatalf("ParseSSHConfigFile() error = %v", err)
+	}
+
+	// Should get 5 hosts: my-host-name-01, qa-test-vm, normal-host, quoted1, quoted2
+	// All without quotes
+	expectedHosts := map[string]struct{}{
+		"my-host-name-01": {},
+		"qa-test-vm":      {},
+		"normal-host":     {},
+		"quoted1":         {},
+		"quoted2":         {},
+	}
+
+	if len(hosts) != len(expectedHosts) {
+		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
+		for _, host := range hosts {
+			t.Logf("Found host: %q", host.Name)
+		}
+	}
+
+	hostMap := make(map[string]SSHHost)
+	for _, host := range hosts {
+		// Verify no quotes in host names
+		if strings.Contains(host.Name, `"`) {
+			t.Errorf("Host name %q still contains quotes", host.Name)
+		}
+		hostMap[host.Name] = host
+	}
+
+	for expectedHostName := range expectedHosts {
+		if _, found := hostMap[expectedHostName]; !found {
+			t.Errorf("Expected host %q not found", expectedHostName)
+		}
+	}
+
+	// Verify specific host details
+	if host, found := hostMap["my-host-name-01"]; found {
+		if host.Hostname != "my-host-name-01.cwd.pub.domain.net" {
+			t.Errorf("Host my-host-name-01 has wrong hostname: %q", host.Hostname)
+		}
+		if host.Port != "2222" {
+			t.Errorf("Host my-host-name-01 has wrong port: %q", host.Port)
+		}
+		if host.User != "my_user" {
+			t.Errorf("Host my-host-name-01 has wrong user: %q", host.User)
+		}
+	}
+
+	if host, found := hostMap["qa-test-vm"]; found {
+		if host.Hostname != "qa-test-vm.example.com" {
+			t.Errorf("Host qa-test-vm has wrong hostname: %q", host.Hostname)
+		}
+	}
+}

internal/history/history.go

@@ -2,7 +2,6 @@ package history
 
 import (
 	"encoding/json"
-	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
@@ -307,99 +306,3 @@ func (hm *HistoryManager) GetPortForwardingConfig(hostName string) *PortForwardC
 	}
 	return nil
 }
-
-// ManualConnection represents a manual SSH connection (e.g., ssh user@host -p 2222)
-type ManualConnection struct {
-	User     string
-	Hostname string
-	Port     string
-	Identity string
-}
-
-// RecordManualConnection records a manual SSH connection (like ssh user@host -p 2222 -i key)
-// These are stored with a generated host name like "manual:user@host:port"
-func (hm *HistoryManager) RecordManualConnection(conn ManualConnection) error {
-	// Generate a unique identifier for this manual connection
-	hostID := generateManualHostID(conn)
-
-	now := time.Now()
-
-	if existingConn, exists := hm.history.Connections[hostID]; exists {
-		// Update existing connection
-		existingConn.LastConnect = now
-		existingConn.ConnectCount++
-		hm.history.Connections[hostID] = existingConn
-	} else {
-		// Create new connection record
-		hm.history.Connections[hostID] = ConnectionInfo{
-			HostName:     hostID,
-			LastConnect:  now,
-			ConnectCount: 1,
-		}
-	}
-
-	return hm.saveHistory()
-}
-
-// generateManualHostID generates a unique ID for manual connections
-func generateManualHostID(conn ManualConnection) string {
-	// Format: manual:user@hostname:port
-	user := conn.User
-	if user == "" {
-		user = "default"
-	}
-	port := conn.Port
-	if port == "" {
-		port = "22"
-	}
-	return fmt.Sprintf("manual:%s@%s:%s", user, conn.Hostname, port)
-}
-
-// IsManualConnection checks if a hostname represents a manual connection
-func IsManualConnection(hostName string) bool {
-	return len(hostName) > 7 && hostName[:7] == "manual:"
-}
-
-// ParseManualConnectionID parses a manual connection ID back into its components
-func ParseManualConnectionID(hostID string) (user, hostname, port string, ok bool) {
-	if !IsManualConnection(hostID) {
-		return "", "", "", false
-	}
-
-	// Remove "manual:" prefix
-	parts := hostID[7:] // Skip "manual:"
-
-	// Split by last ':'
-	lastColon := -1
-	for i := len(parts) - 1; i >= 0; i-- {
-		if parts[i] == ':' {
-			lastColon = i
-			break
-		}
-	}
-
-	if lastColon == -1 {
-		return "", "", "", false
-	}
-
-	port = parts[lastColon+1:]
-	userHost := parts[:lastColon]
-
-	// Split user@host
-	atSign := -1
-	for i := 0; i < len(userHost); i++ {
-		if userHost[i] == '@' {
-			atSign = i
-			break
-		}
-	}
-
-	if atSign == -1 {
-		return "", "", "", false
-	}
-
-	user = userHost[:atSign]
-	hostname = userHost[atSign+1:]
-
-	return user, hostname, port, true
-}

internal/history/parser.go

@@ -1,95 +0,0 @@
-package history
-
-import (
-	"os/user"
-	"strings"
-)
-
-// ParseSSHArgs parses SSH command line arguments and extracts connection details
-// It handles formats like: user@host, -p port, -i identity, etc.
-func ParseSSHArgs(args []string) (*ManualConnection, bool) {
-	if len(args) == 0 {
-		return nil, false
-	}
-
-	conn := &ManualConnection{
-		Port: "22", // Default SSH port
-	}
-
-	// Get current user as default
-	currentUser, err := user.Current()
-	if err == nil {
-		conn.User = currentUser.Username
-	}
-
-	// Parse arguments
-	for i := 0; i < len(args); i++ {
-		arg := args[i]
-
-		// Handle -p <port> or -p<port>
-		if arg == "-p" {
-			if i+1 < len(args) {
-				conn.Port = args[i+1]
-				i++
-			}
-		} else if strings.HasPrefix(arg, "-p") {
-			conn.Port = arg[2:]
-		} else if arg == "-i" {
-			// Handle -i <identity>
-			if i+1 < len(args) {
-				conn.Identity = args[i+1]
-				i++
-			}
-		} else if arg == "-F" || arg == "-c" || arg == "--config" {
-			// Skip config file arguments - these are handled separately
-			if i+1 < len(args) {
-				i++
-			}
-			return nil, false
-		} else if strings.HasPrefix(arg, "-") {
-			// Skip other SSH options like -v, -A, -X, etc.
-			// If they have a value, skip it too
-			if i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
-				i++
-			}
-			continue
-		} else if strings.Contains(arg, "@") {
-			// Parse user@hostname
-			parts := strings.SplitN(arg, "@", 2)
-			if len(parts) == 2 {
-				conn.User = parts[0]
-				conn.Hostname = parts[1]
-			}
-		} else if conn.Hostname == "" {
-			// If no @, treat as just hostname
-			conn.Hostname = arg
-		}
-	}
-
-	// If we got a hostname, this is a valid manual connection
-	if conn.Hostname != "" {
-		return conn, true
-	}
-
-	return nil, false
-}
-
-// IsManualSSHCommand checks if the arguments represent a manual SSH connection
-// (not a configured host name)
-func IsManualSSHCommand(args []string) bool {
-	if len(args) == 0 {
-		return false
-	}
-
-	// Check for SSH flags that indicate manual connection
-	for _, arg := range args {
-		if arg == "-p" || strings.HasPrefix(arg, "-p") {
-			return true
-		}
-		if strings.Contains(arg, "@") {
-			return true
-		}
-	}
-
-	return false
-}

internal/history/parser_test.go

@@ -1,277 +0,0 @@
-package history
-
-import (
-	"testing"
-)
-
-func TestParseSSHArgs(t *testing.T) {
-	tests := []struct {
-		name     string
-		args     []string
-		wantConn *ManualConnection
-		wantOk   bool
-	}{
-		{
-			name: "user@host",
-			args: []string{"user@example.com"},
-			wantConn: &ManualConnection{
-				User:     "user",
-				Hostname: "example.com",
-				Port:     "22",
-			},
-			wantOk: true,
-		},
-		{
-			name: "user@host with -p port",
-			args: []string{"-p", "2222", "user@example.com"},
-			wantConn: &ManualConnection{
-				User:     "user",
-				Hostname: "example.com",
-				Port:     "2222",
-			},
-			wantOk: true,
-		},
-		{
-			name: "user@host with -p2222 (no space)",
-			args: []string{"-p2222", "user@example.com"},
-			wantConn: &ManualConnection{
-				User:     "user",
-				Hostname: "example.com",
-				Port:     "2222",
-			},
-			wantOk: true,
-		},
-		{
-			name: "user@host with -i identity",
-			args: []string{"-i", "~/.ssh/id_rsa", "user@example.com"},
-			wantConn: &ManualConnection{
-				User:     "user",
-				Hostname: "example.com",
-				Port:     "22",
-				Identity: "~/.ssh/id_rsa",
-			},
-			wantOk: true,
-		},
-		{
-			name: "complete connection",
-			args: []string{"-p", "2222", "-i", "~/.ssh/id_rsa", "guillaume@127.0.0.1"},
-			wantConn: &ManualConnection{
-				User:     "guillaume",
-				Hostname: "127.0.0.1",
-				Port:     "2222",
-				Identity: "~/.ssh/id_rsa",
-			},
-			wantOk: true,
-		},
-		{
-			name: "just hostname (no user)",
-			args: []string{"example.com"},
-			wantConn: &ManualConnection{
-				Hostname: "example.com",
-				Port:     "22",
-				// User will be current system user, so we don't check it
-			},
-			wantOk: true,
-		},
-		{
-			name:     "config file args should return false",
-			args:     []string{"-F", "~/.ssh/config", "host"},
-			wantConn: nil,
-			wantOk:   false,
-		},
-		{
-			name:     "empty args",
-			args:     []string{},
-			wantConn: nil,
-			wantOk:   false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotConn, gotOk := ParseSSHArgs(tt.args)
-
-			if gotOk != tt.wantOk {
-				t.Errorf("ParseSSHArgs() gotOk = %v, want %v", gotOk, tt.wantOk)
-				return
-			}
-
-			if !tt.wantOk {
-				if gotConn != nil {
-					t.Errorf("ParseSSHArgs() gotConn = %v, want nil", gotConn)
-				}
-				return
-			}
-
-			if gotConn == nil {
-				t.Errorf("ParseSSHArgs() gotConn = nil, want non-nil")
-				return
-			}
-
-			if gotConn.User != tt.wantConn.User {
-				// Skip user check if wantConn.User is empty (current user)
-				if tt.wantConn.User != "" {
-					t.Errorf("ParseSSHArgs() User = %v, want %v", gotConn.User, tt.wantConn.User)
-				}
-			}
-			if gotConn.Hostname != tt.wantConn.Hostname {
-				t.Errorf("ParseSSHArgs() Hostname = %v, want %v", gotConn.Hostname, tt.wantConn.Hostname)
-			}
-			if gotConn.Port != tt.wantConn.Port {
-				t.Errorf("ParseSSHArgs() Port = %v, want %v", gotConn.Port, tt.wantConn.Port)
-			}
-			if gotConn.Identity != tt.wantConn.Identity {
-				t.Errorf("ParseSSHArgs() Identity = %v, want %v", gotConn.Identity, tt.wantConn.Identity)
-			}
-		})
-	}
-}
-
-func TestIsManualSSHCommand(t *testing.T) {
-	tests := []struct {
-		name string
-		args []string
-		want bool
-	}{
-		{
-			name: "user@host is manual",
-			args: []string{"user@example.com"},
-			want: true,
-		},
-		{
-			name: "with -p flag is manual",
-			args: []string{"-p", "2222", "host"},
-			want: true,
-		},
-		{
-			name: "with -p2222 is manual",
-			args: []string{"-p2222", "host"},
-			want: true,
-		},
-		{
-			name: "just hostname is not manual",
-			args: []string{"myhost"},
-			want: false,
-		},
-		{
-			name: "empty is not manual",
-			args: []string{},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := IsManualSSHCommand(tt.args); got != tt.want {
-				t.Errorf("IsManualSSHCommand() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestManualConnectionID(t *testing.T) {
-	tests := []struct {
-		name         string
-		conn         ManualConnection
-		wantHostID   string
-		wantUser     string
-		wantHostname string
-		wantPort     string
-	}{
-		{
-			name: "complete connection",
-			conn: ManualConnection{
-				User:     "guillaume",
-				Hostname: "127.0.0.1",
-				Port:     "2222",
-				Identity: "~/.ssh/id_rsa",
-			},
-			wantHostID:   "manual:guillaume@127.0.0.1:2222",
-			wantUser:     "guillaume",
-			wantHostname: "127.0.0.1",
-			wantPort:     "2222",
-		},
-		{
-			name: "default port",
-			conn: ManualConnection{
-				User:     "user",
-				Hostname: "example.com",
-				Port:     "",
-			},
-			wantHostID:   "manual:user@example.com:22",
-			wantUser:     "user",
-			wantHostname: "example.com",
-			wantPort:     "22",
-		},
-		{
-			name: "no user specified",
-			conn: ManualConnection{
-				Hostname: "example.com",
-				Port:     "2222",
-			},
-			wantHostID:   "manual:default@example.com:2222",
-			wantUser:     "default",
-			wantHostname: "example.com",
-			wantPort:     "2222",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Test generation
-			gotHostID := generateManualHostID(tt.conn)
-			if gotHostID != tt.wantHostID {
-				t.Errorf("generateManualHostID() = %v, want %v", gotHostID, tt.wantHostID)
-			}
-
-			// Test IsManualConnection
-			if !IsManualConnection(gotHostID) {
-				t.Errorf("IsManualConnection(%v) = false, want true", gotHostID)
-			}
-
-			// Test parsing
-			user, hostname, port, ok := ParseManualConnectionID(gotHostID)
-			if !ok {
-				t.Errorf("ParseManualConnectionID() ok = false, want true")
-			}
-			if user != tt.wantUser {
-				t.Errorf("ParseManualConnectionID() user = %v, want %v", user, tt.wantUser)
-			}
-			if hostname != tt.wantHostname {
-				t.Errorf("ParseManualConnectionID() hostname = %v, want %v", hostname, tt.wantHostname)
-			}
-			if port != tt.wantPort {
-				t.Errorf("ParseManualConnectionID() port = %v, want %v", port, tt.wantPort)
-			}
-		})
-	}
-}
-
-func TestParseManualConnectionID_Invalid(t *testing.T) {
-	tests := []struct {
-		name   string
-		hostID string
-	}{
-		{
-			name:   "not a manual connection",
-			hostID: "myhost",
-		},
-		{
-			name:   "missing components",
-			hostID: "manual:invalid",
-		},
-		{
-			name:   "no @ sign",
-			hostID: "manual:hostname:22",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, _, _, ok := ParseManualConnectionID(tt.hostID)
-			if ok {
-				t.Errorf("ParseManualConnectionID() ok = true, want false for invalid input")
-			}
-		})
-	}
-}

internal/ui/add_form.go

@@ -49,7 +49,7 @@ func NewAddForm(hostname string, styles Styles, width, height int, configFile st
 		}
 	}
 
-	inputs := make([]textinput.Model, 10) // Increased from 9 to 10 for RequestTTY
+	inputs := make([]textinput.Model, 11)
 
 	// Name input
 	inputs[nameInput] = textinput.New()
@@ -91,6 +91,12 @@ func NewAddForm(hostname string, styles Styles, width, height int, configFile st
 	inputs[proxyJumpInput].CharLimit = 200
 	inputs[proxyJumpInput].Width = 50
 
+	// ProxyCommand input
+	inputs[proxyCommandInput] = textinput.New()
+	inputs[proxyCommandInput].Placeholder = "ssh -W %h:%p Jumphost"
+	inputs[proxyCommandInput].CharLimit = 200
+	inputs[proxyCommandInput].Width = 50
+
 	// SSH Options input
 	inputs[optionsInput] = textinput.New()
 	inputs[optionsInput].Placeholder = "-o Compression=yes -o ServerAliveInterval=60"
@@ -138,9 +144,10 @@ const (
 	portInput
 	identityInput
 	proxyJumpInput
+	proxyCommandInput
+	optionsInput
 	tagsInput
 	// Advanced tab inputs
-	optionsInput
 	remoteCommandInput
 	requestTTYInput
 )
@@ -229,11 +236,11 @@ func (m *addFormModel) getFirstInputForTab(tab int) int {
 func (m *addFormModel) getInputsForCurrentTab() []int {
 	switch m.currentTab {
 	case tabGeneral:
-		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, tagsInput}
+		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, proxyCommandInput, tagsInput}
 	case tabAdvanced:
 		return []int{optionsInput, remoteCommandInput, requestTTYInput}
 	default:
-		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, tagsInput}
+		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, proxyCommandInput, tagsInput}
 	}
 }
 
@@ -275,11 +282,29 @@ func (m *addFormModel) handleNavigation(key string) tea.Cmd {
 		currentPos++
 	}
 
-	// Wrap around within current tab
+	// Handle transitions between tabs
 	if currentPos >= len(currentTabInputs) {
-		currentPos = 0
+		// Move to next tab
+		if m.currentTab == tabGeneral {
+			// Move to advanced tab
+			m.currentTab = tabAdvanced
+			m.focused = m.getFirstInputForTab(tabAdvanced)
+			return m.updateFocus()
+		} else {
+			// Wrap around to first field of current tab
+			currentPos = 0
+		}
 	} else if currentPos < 0 {
-		currentPos = len(currentTabInputs) - 1
+		// Move to previous tab
+		if m.currentTab == tabAdvanced {
+			// Move to general tab
+			m.currentTab = tabGeneral
+			currentTabInputs = m.getInputsForCurrentTab()
+			currentPos = len(currentTabInputs) - 1
+		} else {
+			// Wrap around to last field of current tab
+			currentPos = len(currentTabInputs) - 1
+		}
 	}
 
 	m.focused = currentTabInputs[currentPos]
@@ -401,6 +426,7 @@ func (m *addFormModel) renderGeneralTab() string {
 		{portInput, "Port"},
 		{identityInput, "Identity File"},
 		{proxyJumpInput, "ProxyJump"},
+		{proxyCommandInput, "ProxyCommand"},
 		{tagsInput, "Tags (comma-separated)"},
 	}
 
@@ -489,6 +515,7 @@ func (m *addFormModel) submitForm() tea.Cmd {
 		port := strings.TrimSpace(m.inputs[portInput].Value())
 		identity := strings.TrimSpace(m.inputs[identityInput].Value())
 		proxyJump := strings.TrimSpace(m.inputs[proxyJumpInput].Value())
+		proxyCommand := strings.TrimSpace(m.inputs[proxyCommandInput].Value())
 		options := strings.TrimSpace(m.inputs[optionsInput].Value())
 		remoteCommand := strings.TrimSpace(m.inputs[remoteCommandInput].Value())
 		requestTTY := strings.TrimSpace(m.inputs[requestTTYInput].Value())
@@ -526,6 +553,7 @@ func (m *addFormModel) submitForm() tea.Cmd {
 			Port:          port,
 			Identity:      identity,
 			ProxyJump:     proxyJump,
+			ProxyCommand:  proxyCommand,
 			Options:       config.ParseSSHOptionsFromCommand(options),
 			RemoteCommand: remoteCommand,
 			RequestTTY:    requestTTY,

internal/ui/edit_form.go

@@ -91,7 +91,7 @@ func NewEditForm(hostName string, styles Styles, width, height int, configFile s
 		}
 	}
 
-	inputs := make([]textinput.Model, 9) // Increased from 8 to 9 for RequestTTY
+	inputs := make([]textinput.Model, 10)
 
 	// Hostname input
 	inputs[0] = textinput.New()
@@ -128,37 +128,44 @@ func NewEditForm(hostName string, styles Styles, width, height int, configFile s
 	inputs[4].Width = 30
 	inputs[4].SetValue(host.ProxyJump)
 
-	// Options input
+	// ProxyCommand input
 	inputs[5] = textinput.New()
-	inputs[5].Placeholder = "-o StrictHostKeyChecking=no"
+	inputs[5].Placeholder = "ssh -W %h:%p Jumphost"
 	inputs[5].CharLimit = 200
 	inputs[5].Width = 50
+	inputs[5].SetValue(host.ProxyCommand)
+
+	// Options input
+	inputs[6] = textinput.New()
+	inputs[6].Placeholder = "-o StrictHostKeyChecking=no"
+	inputs[6].CharLimit = 200
+	inputs[6].Width = 50
 	if host.Options != "" {
-		inputs[5].SetValue(config.FormatSSHOptionsForCommand(host.Options))
+		inputs[6].SetValue(config.FormatSSHOptionsForCommand(host.Options))
 	}
 
 	// Tags input
-	inputs[6] = textinput.New()
+	inputs[7] = textinput.New()
-	inputs[6].Placeholder = "production, web, database"
+	inputs[7].Placeholder = "production, web, database"
-	inputs[6].CharLimit = 200
+	inputs[7].CharLimit = 200
-	inputs[6].Width = 50
+	inputs[7].Width = 50
 	if len(host.Tags) > 0 {
-		inputs[6].SetValue(strings.Join(host.Tags, ", "))
+		inputs[7].SetValue(strings.Join(host.Tags, ", "))
 	}
 
 	// Remote Command input
-	inputs[7] = textinput.New()
+	inputs[8] = textinput.New()
-	inputs[7].Placeholder = "ls -la, htop, bash"
+	inputs[8].Placeholder = "ls -la, htop, bash"
-	inputs[7].CharLimit = 300
+	inputs[8].CharLimit = 300
-	inputs[7].Width = 70
+	inputs[8].Width = 70
-	inputs[7].SetValue(host.RemoteCommand)
+	inputs[8].SetValue(host.RemoteCommand)
 
 	// RequestTTY input
-	inputs[8] = textinput.New()
+	inputs[9] = textinput.New()
-	inputs[8].Placeholder = "yes, no, force, auto"
+	inputs[9].Placeholder = "yes, no, force, auto"
-	inputs[8].CharLimit = 10
+	inputs[9].CharLimit = 10
-	inputs[8].Width = 30
+	inputs[9].Width = 30
-	inputs[8].SetValue(host.RequestTTY)
+	inputs[9].SetValue(host.RequestTTY)
 
 	return &editFormModel{
 		hostInputs:       hostInputs,
@@ -253,19 +260,19 @@ func (m *editFormModel) updateFocus() tea.Cmd {
 func (m *editFormModel) getPropertiesForCurrentTab() []int {
 	switch m.currentTab {
 	case 0: // General
-		return []int{0, 1, 2, 3, 4, 6} // hostname, user, port, identity, proxyjump, tags
+		return []int{0, 1, 2, 3, 4, 5, 7} // hostname, user, port, identity, proxyjump, proxycommand, tags
 	case 1: // Advanced
-		return []int{5, 7, 8} // options, remotecommand, requesttty
+		return []int{6, 8, 9} // options, remotecommand, requesttty
 	default:
-		return []int{0, 1, 2, 3, 4, 6}
+		return []int{0, 1, 2, 3, 4, 5, 7}
 	}
 }
 
 // getFirstPropertyForTab returns the first property index for a given tab
 func (m *editFormModel) getFirstPropertyForTab(tab int) int {
-	properties := []int{0, 1, 2, 3, 4, 6} // General tab
+	properties := []int{0, 1, 2, 3, 4, 5, 7} // General tab
 	if tab == 1 {
-		properties = []int{5, 7, 8} // Advanced tab
+		properties = []int{6, 8, 9} // Advanced tab
 	}
 	if len(properties) > 0 {
 		return properties[0]
@@ -580,7 +587,8 @@ func (m *editFormModel) renderEditGeneralTab() string {
 		{2, "Port"},
 		{3, "Identity File"},
 		{4, "Proxy Jump"},
-		{6, "Tags (comma-separated)"},
+		{5, "Proxy Command"},
+		{7, "Tags (comma-separated)"},
 	}
 
 	for _, field := range fields {
@@ -605,9 +613,9 @@ func (m *editFormModel) renderEditAdvancedTab() string {
 		index int
 		label string
 	}{
-		{5, "SSH Options"},
+		{6, "SSH Options"},
-		{7, "Remote Command"},
+		{8, "Remote Command"},
-		{8, "Request TTY"},
+		{9, "Request TTY"},
 	}
 
 	for _, field := range fields {
@@ -678,14 +686,15 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 		}
 
 		// Get property values using direct indices
-		hostname := strings.TrimSpace(m.inputs[0].Value())      // hostnameInput
+		hostname := strings.TrimSpace(m.inputs[0].Value())                                   // hostnameInput
-		user := strings.TrimSpace(m.inputs[1].Value())          // userInput
+		user := strings.TrimSpace(m.inputs[1].Value())                                       // userInput
-		port := strings.TrimSpace(m.inputs[2].Value())          // portInput
+		port := strings.TrimSpace(m.inputs[2].Value())                                       // portInput
-		identity := strings.TrimSpace(m.inputs[3].Value())      // identityInput
+		identity := strings.TrimSpace(m.inputs[3].Value())                                   // identityInput
-		proxyJump := strings.TrimSpace(m.inputs[4].Value())     // proxyJumpInput
+		proxyJump := strings.TrimSpace(m.inputs[4].Value())                                  // proxyJumpInput
-		options := strings.TrimSpace(m.inputs[5].Value())       // optionsInput
+		proxyCommand := strings.TrimSpace(m.inputs[5].Value())                               // proxyCommandInput
-		remoteCommand := strings.TrimSpace(m.inputs[7].Value()) // remoteCommandInput
+		options := config.ParseSSHOptionsFromCommand(strings.TrimSpace(m.inputs[6].Value())) // optionsInput
-		requestTTY := strings.TrimSpace(m.inputs[8].Value())    // requestTTYInput
+		remoteCommand := strings.TrimSpace(m.inputs[8].Value())                              // remoteCommandInput
+		requestTTY := strings.TrimSpace(m.inputs[9].Value())                                 // requestTTYInput
 
 		// Set defaults
 		if port == "" {
@@ -705,7 +714,7 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 		}
 
 		// Parse tags
-		tagsStr := strings.TrimSpace(m.inputs[6].Value()) // tagsInput
+		tagsStr := strings.TrimSpace(m.inputs[7].Value()) // tagsInput
 		var tags []string
 		if tagsStr != "" {
 			for _, tag := range strings.Split(tagsStr, ",") {
@@ -723,6 +732,7 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 			Port:          port,
 			Identity:      identity,
 			ProxyJump:     proxyJump,
+			ProxyCommand:  proxyCommand,
 			Options:       options,
 			RemoteCommand: remoteCommand,
 			RequestTTY:    requestTTY,

internal/ui/help_form.go

@@ -47,34 +47,31 @@ func (m *helpModel) View() string {
 		m.styles.FocusedLabel.Render("Navigation & Connection"),
 		"",
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("⏎      "),
+			m.styles.FocusedLabel.Render("⏎  "),
 			m.styles.HelpText.Render("connect to selected host")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("i      "),
+			m.styles.FocusedLabel.Render("i  "),
 			m.styles.HelpText.Render("show host information")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("/      "),
+			m.styles.FocusedLabel.Render("/  "),
 			m.styles.HelpText.Render("search hosts")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("Tab    "),
+			m.styles.FocusedLabel.Render("Tab "),
 			m.styles.HelpText.Render("switch focus")),
-		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("Ctrl+H "),
-			m.styles.HelpText.Render("switch to history view")),
 		"",
 		m.styles.FocusedLabel.Render("Host Management"),
 		"",
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("a      "),
+			m.styles.FocusedLabel.Render("a  "),
 			m.styles.HelpText.Render("add new host")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("e      "),
+			m.styles.FocusedLabel.Render("e  "),
 			m.styles.HelpText.Render("edit selected host")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("m      "),
+			m.styles.FocusedLabel.Render("m  "),
 			m.styles.HelpText.Render("move host to another config")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("d      "),
+			m.styles.FocusedLabel.Render("d  "),
 			m.styles.HelpText.Render("delete selected host")),
 	)
 
@@ -82,31 +79,31 @@ func (m *helpModel) View() string {
 		m.styles.FocusedLabel.Render("Advanced Features"),
 		"",
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("p      "),
+			m.styles.FocusedLabel.Render("p  "),
 			m.styles.HelpText.Render("ping all hosts")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("f      "),
+			m.styles.FocusedLabel.Render("f  "),
 			m.styles.HelpText.Render("setup port forwarding")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("s      "),
+			m.styles.FocusedLabel.Render("s  "),
 			m.styles.HelpText.Render("cycle sort modes")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("n      "),
+			m.styles.FocusedLabel.Render("n  "),
 			m.styles.HelpText.Render("sort by name")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("r      "),
+			m.styles.FocusedLabel.Render("r  "),
 			m.styles.HelpText.Render("sort by recent connection")),
 		"",
 		m.styles.FocusedLabel.Render("System"),
 		"",
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("h      "),
+			m.styles.FocusedLabel.Render("h  "),
 			m.styles.HelpText.Render("show this help")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("q      "),
+			m.styles.FocusedLabel.Render("q  "),
 			m.styles.HelpText.Render("quit application")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("ESC    "),
+			m.styles.FocusedLabel.Render("ESC "),
 			m.styles.HelpText.Render("exit current view")),
 	)
 

internal/ui/history_tui.go

@@ -1,530 +0,0 @@
-package ui
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-	"time"
-
-	"github.com/Gu1llaum-3/sshm/internal/config"
-	"github.com/Gu1llaum-3/sshm/internal/history"
-
-	"github.com/charmbracelet/bubbles/table"
-	"github.com/charmbracelet/bubbles/textinput"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-)
-
-// HistoryModel represents the TUI model for history view
-type HistoryModel struct {
-	table          table.Model
-	connections    []history.ConnectionInfo
-	searchInput    textinput.Model
-	searchActive   bool
-	filteredConns  []history.ConnectionInfo
-	configFile     string
-	currentVersion string
-	styles         Styles
-	width          int
-	height         int
-	showAddForm    bool
-	addForm        *addFormModel
-	selectedConn   *history.ConnectionInfo
-	err            string
-}
-
-// NewHistoryModel creates a new history TUI model
-func NewHistoryModel(connections []history.ConnectionInfo, configFile, currentVersion string) HistoryModel {
-	styles := NewStyles(80)
-
-	// Create search input (different placeholder than main interface)
-	searchInput := textinput.New()
-	searchInput.Placeholder = "Search connections..."
-	searchInput.CharLimit = 50
-	searchInput.Width = 25 // Same width as main interface
-
-	m := HistoryModel{
-		connections:    connections,
-		filteredConns:  connections,
-		searchInput:    searchInput,
-		configFile:     configFile,
-		currentVersion: currentVersion,
-		styles:         styles,
-	}
-
-	m.updateTable()
-	return m
-}
-
-// Init initializes the history model
-func (m HistoryModel) Init() tea.Cmd {
-	return nil
-}
-
-// Update handles messages for the history model
-func (m HistoryModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmd tea.Cmd
-	var cmds []tea.Cmd
-
-	// Handle add form if active
-	if m.showAddForm && m.addForm != nil {
-		switch msg := msg.(type) {
-		case addFormSubmitMsg:
-			if msg.err != nil {
-				m.err = msg.err.Error()
-			} else {
-				m.showAddForm = false
-				m.addForm = nil
-				// Return to main list and refresh hosts
-				return m, func() tea.Msg { return refreshHostsMsg{} }
-			}
-		case addFormCancelMsg:
-			m.showAddForm = false
-			m.addForm = nil
-			return m, nil
-		}
-
-		newForm, cmd := m.addForm.Update(msg)
-		m.addForm = newForm
-		return m, cmd
-	}
-
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
-		m.styles = NewStyles(m.width)
-		m.updateTable()
-		return m, nil
-
-	case tea.KeyMsg:
-		// Handle search mode
-		if m.searchActive {
-			switch msg.String() {
-			case "esc", "ctrl+c":
-				m.searchActive = false
-				m.searchInput.Blur()
-				m.searchInput.SetValue("")
-				m.filteredConns = m.connections
-				m.updateTable()
-				return m, nil
-			case "enter":
-				m.searchActive = false
-				m.searchInput.Blur()
-				return m, nil
-			default:
-				m.searchInput, cmd = m.searchInput.Update(msg)
-				cmds = append(cmds, cmd)
-				m.filterConnections()
-				m.updateTable()
-				return m, tea.Batch(cmds...)
-			}
-		}
-
-		// Normal mode key handling
-		switch msg.String() {
-		case "ctrl+c", "q", "esc":
-			return m, tea.Quit
-
-		case "ctrl+l":
-			// Return to main list view
-			return m, func() tea.Msg { return returnToListMsg{} }
-
-		case "enter":
-			// Connect to selected host
-			if len(m.filteredConns) > 0 {
-				selectedIdx := m.table.Cursor()
-				if selectedIdx < len(m.filteredConns) {
-					conn := m.filteredConns[selectedIdx]
-					return m, m.connectToHistory(conn)
-				}
-			}
-
-		case "a":
-			// Add manual connection to config
-			if len(m.filteredConns) > 0 {
-				selectedIdx := m.table.Cursor()
-				if selectedIdx < len(m.filteredConns) {
-					conn := m.filteredConns[selectedIdx]
-					// Only allow adding manual connections to config
-					if history.IsManualConnection(conn.HostName) {
-						m.selectedConn = &conn
-						m.showAddForm = true
-						m.addForm = m.createAddFormFromConnection(conn)
-						return m, m.addForm.Init()
-					}
-				}
-			}
-
-		case "d":
-			// Delete connection from history
-			if len(m.filteredConns) > 0 {
-				selectedIdx := m.table.Cursor()
-				if selectedIdx < len(m.filteredConns) {
-					conn := m.filteredConns[selectedIdx]
-					return m, m.deleteFromHistory(conn)
-				}
-			}
-
-		case "/":
-			// Activate search
-			m.searchActive = true
-			m.searchInput.Focus()
-			return m, textinput.Blink
-		}
-	}
-
-	// Update table
-	m.table, cmd = m.table.Update(msg)
-	cmds = append(cmds, cmd)
-
-	return m, tea.Batch(cmds...)
-}
-
-// View renders the history TUI
-func (m HistoryModel) View() string {
-	if m.showAddForm && m.addForm != nil {
-		return m.addForm.View()
-	}
-
-	// Build the interface components (same structure as main view)
-	components := []string{}
-
-	// Add the ASCII title
-	components = append(components, m.styles.Header.Render(asciiTitle))
-
-	// Add error message if there's one to show
-	if m.err != "" {
-		errorStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("9")). // Red color
-			Background(lipgloss.Color("1")). // Dark red background
-			Bold(true).
-			Padding(0, 1).
-			Border(lipgloss.RoundedBorder()).
-			BorderForeground(lipgloss.Color("9")).
-			Align(lipgloss.Center)
-
-		components = append(components, errorStyle.Render("❌ "+m.err))
-	}
-
-	// Add the search bar with the appropriate style based on focus
-	searchPrompt := "Search (/ to focus): "
-	if m.searchActive {
-		components = append(components, m.styles.SearchFocused.Render(searchPrompt+m.searchInput.View()))
-	} else {
-		components = append(components, m.styles.SearchUnfocused.Render(searchPrompt+m.searchInput.View()))
-	}
-
-	// Add the table with the appropriate style based on focus
-	if m.searchActive {
-		// The table is not focused, use the unfocused style
-		components = append(components, m.styles.TableUnfocused.Render(m.table.View()))
-	} else {
-		// The table is focused, use the focused style
-		components = append(components, m.styles.TableFocused.Render(m.table.View()))
-	}
-
-	// Add the help text
-	var helpText string
-	if !m.searchActive {
-		helpText = " ↑/↓: navigate • Enter: connect • Ctrl+L: list • a: add to config (★) • d: delete • q: quit"
-	} else {
-		helpText = " Type to filter • Enter: validate • Tab: switch • ESC: quit"
-	}
-	components = append(components, m.styles.HelpText.Render(helpText))
-
-	// Join all components vertically with appropriate spacing
-	mainView := m.styles.App.Render(
-		lipgloss.JoinVertical(
-			lipgloss.Left,
-			components...,
-		),
-	)
-
-	return mainView
-} // updateTable updates the table with current filtered connections
-func (m *HistoryModel) updateTable() {
-	columns := []table.Column{
-		{Title: "Host", Width: 22}, // Host name with ★ for manual connections
-		{Title: "User", Width: 15},
-		{Title: "Hostname", Width: 25},
-		{Title: "Port", Width: 6},
-		{Title: "Last Connect", Width: 20},
-		{Title: "Count", Width: 6},
-	}
-
-	// Load SSH hosts to get details for configured connections
-	var sshHosts []config.SSHHost
-	var err error
-	if m.configFile != "" {
-		sshHosts, err = config.ParseSSHConfigFile(m.configFile)
-	} else {
-		sshHosts, err = config.ParseSSHConfig()
-	}
-	if err != nil {
-		sshHosts = []config.SSHHost{}
-	}
-
-	// Create a map for quick lookup
-	hostsMap := make(map[string]config.SSHHost)
-	for _, host := range sshHosts {
-		hostsMap[host.Name] = host
-	}
-
-	rows := []table.Row{}
-	for _, conn := range m.filteredConns {
-		var hostDisplay, user, hostname, port string
-
-		// Parse manual connections
-		if history.IsManualConnection(conn.HostName) {
-			u, h, p, ok := history.ParseManualConnectionID(conn.HostName)
-			if ok {
-				hostDisplay = "★" // Star indicates this can be added to config
-				user = u
-				hostname = h
-				port = p
-			}
-		} else {
-			// For configured hosts, show the host name
-			hostDisplay = conn.HostName
-
-			if host, exists := hostsMap[conn.HostName]; exists {
-				user = host.User
-				hostname = host.Hostname
-				port = host.Port
-				if port == "" {
-					port = "22"
-				}
-			}
-		}
-
-		lastConnect := formatTimeSince(conn.LastConnect)
-
-		rows = append(rows, table.Row{
-			hostDisplay,
-			user,
-			hostname,
-			port,
-			lastConnect,
-			fmt.Sprintf("%d", conn.ConnectCount),
-		})
-	}
-
-	// Calculate dynamic table height (same logic as main interface)
-	tableHeight := m.calculateTableHeight(len(rows))
-
-	t := table.New(
-		table.WithColumns(columns),
-		table.WithRows(rows),
-		table.WithFocused(true),
-		table.WithHeight(tableHeight),
-	)
-
-	s := table.DefaultStyles()
-	s.Header = s.Header.
-		BorderStyle(lipgloss.NormalBorder()).
-		BorderForeground(lipgloss.Color(PrimaryColor)).
-		BorderBottom(true).
-		Bold(true)
-	s.Selected = s.Selected.
-		Foreground(lipgloss.Color("229")).
-		Background(lipgloss.Color(PrimaryColor)).
-		Bold(false)
-
-	t.SetStyles(s)
-	m.table = t
-}
-
-// calculateTableHeight calculates the appropriate height for the table based on terminal size
-func (m *HistoryModel) calculateTableHeight(rowCount int) int {
-	// Calculate dynamic table height based on terminal size
-	// Layout breakdown (same as main interface):
-	// - ASCII title: 5 lines (1 empty + 4 text lines)
-	// - Search bar: 1 line
-	// - Help text: 1 line
-	// - App margins/spacing: 3 lines
-	// - Safety margin: 3 lines
-	// Total reserved: 13 lines
-	reservedHeight := 13
-	availableHeight := m.height - reservedHeight
-
-	// Add 1 if there's an error message showing
-	if m.err != "" {
-		availableHeight -= 3 // Error box takes about 3 lines
-	}
-
-	// Minimum height should be at least 3 rows for basic usability
-	minTableHeight := 4 // 1 header + 3 data rows minimum
-	maxTableHeight := availableHeight
-	if maxTableHeight < minTableHeight {
-		maxTableHeight = minTableHeight
-	}
-
-	tableHeight := 1 // header
-	dataRowsNeeded := rowCount
-	maxDataRows := maxTableHeight - 1 // subtract 1 for header
-
-	if dataRowsNeeded <= maxDataRows {
-		// We have enough space for all connections
-		tableHeight += dataRowsNeeded
-	} else {
-		// We need to limit to available space
-		tableHeight += maxDataRows
-	}
-
-	// Add one extra line to prevent the last row from being hidden
-	tableHeight += 1
-
-	return tableHeight
-}
-
-// filterConnections filters connections based on search input
-func (m *HistoryModel) filterConnections() {
-	searchTerm := strings.ToLower(m.searchInput.Value())
-	if searchTerm == "" {
-		m.filteredConns = m.connections
-		return
-	}
-
-	m.filteredConns = []history.ConnectionInfo{}
-	for _, conn := range m.connections {
-		// Search in hostname
-		if strings.Contains(strings.ToLower(conn.HostName), searchTerm) {
-			m.filteredConns = append(m.filteredConns, conn)
-			continue
-		}
-
-		// For manual connections, search in parsed fields
-		if history.IsManualConnection(conn.HostName) {
-			user, hostname, _, ok := history.ParseManualConnectionID(conn.HostName)
-			if ok {
-				if strings.Contains(strings.ToLower(user), searchTerm) ||
-					strings.Contains(strings.ToLower(hostname), searchTerm) {
-					m.filteredConns = append(m.filteredConns, conn)
-				}
-			}
-		}
-	}
-}
-
-// connectToHistory connects to a host from history
-func (m HistoryModel) connectToHistory(conn history.ConnectionInfo) tea.Cmd {
-	var sshArgs []string
-
-	if history.IsManualConnection(conn.HostName) {
-		// Manual connection
-		user, hostname, port, ok := history.ParseManualConnectionID(conn.HostName)
-		if !ok {
-			return nil
-		}
-
-		if port != "" && port != "22" {
-			sshArgs = append(sshArgs, "-p", port)
-		}
-
-		if user != "" {
-			sshArgs = append(sshArgs, fmt.Sprintf("%s@%s", user, hostname))
-		} else {
-			sshArgs = append(sshArgs, hostname)
-		}
-	} else {
-		// Configured host
-		if m.configFile != "" {
-			sshArgs = append(sshArgs, "-F", m.configFile)
-		}
-		sshArgs = append(sshArgs, conn.HostName)
-	}
-
-	// Execute SSH using tea.ExecProcess for proper terminal handling
-	sshCmd := exec.Command("ssh", sshArgs...)
-	return tea.ExecProcess(sshCmd, func(err error) tea.Msg {
-		return tea.Quit()
-	})
-}
-
-// deleteFromHistory removes a connection from history
-func (m HistoryModel) deleteFromHistory(conn history.ConnectionInfo) tea.Cmd {
-	return func() tea.Msg {
-		historyManager, err := history.NewHistoryManager()
-		if err != nil {
-			return tea.Quit
-		}
-
-		// Remove from history
-		// This would need a new method in history manager
-		// For now, just quit
-		_ = historyManager
-
-		return tea.Quit
-	}
-}
-
-// createAddFormFromConnection creates an add form pre-filled with connection details
-func (m *HistoryModel) createAddFormFromConnection(conn history.ConnectionInfo) *addFormModel {
-	user, hostname, port, ok := history.ParseManualConnectionID(conn.HostName)
-	if !ok {
-		return nil
-	}
-
-	// Create form with empty name (user will choose)
-	form := NewAddForm("", m.styles, m.width, m.height, m.configFile)
-
-	// Pre-fill the form with connection details
-	form.inputs[hostnameInput].SetValue(hostname)
-	form.inputs[userInput].SetValue(user)
-	if port != "22" && port != "" {
-		form.inputs[portInput].SetValue(port)
-	}
-
-	// Leave name field empty for user to choose
-	// form.inputs[nameInput].SetValue("")  // Already empty by default
-
-	return form
-}
-
-// formatTimeSince formats a time duration in human-readable format
-func formatTimeSince(t time.Time) string {
-	duration := time.Since(t)
-
-	switch {
-	case duration < time.Minute:
-		return "just now"
-	case duration < time.Hour:
-		mins := int(duration.Minutes())
-		if mins == 1 {
-			return "1 minute ago"
-		}
-		return fmt.Sprintf("%d minutes ago", mins)
-	case duration < 24*time.Hour:
-		hours := int(duration.Hours())
-		if hours == 1 {
-			return "1 hour ago"
-		}
-		return fmt.Sprintf("%d hours ago", hours)
-	case duration < 7*24*time.Hour:
-		days := int(duration.Hours() / 24)
-		if days == 1 {
-			return "1 day ago"
-		}
-		return fmt.Sprintf("%d days ago", days)
-	case duration < 30*24*time.Hour:
-		weeks := int(duration.Hours() / 24 / 7)
-		if weeks == 1 {
-			return "1 week ago"
-		}
-		return fmt.Sprintf("%d weeks ago", weeks)
-	default:
-		months := int(duration.Hours() / 24 / 30)
-		if months == 1 {
-			return "1 month ago"
-		}
-		if months < 12 {
-			return fmt.Sprintf("%d months ago", months)
-		}
-		years := months / 12
-		if years == 1 {
-			return "1 year ago"
-		}
-		return fmt.Sprintf("%d years ago", years)
-	}
-}

internal/ui/info_form.go

@@ -97,6 +97,7 @@ func (m *infoFormModel) View() string {
 		{"Port", formatOptionalValue(m.host.Port)},
 		{"Identity File", formatOptionalValue(m.host.Identity)},
 		{"ProxyJump", formatOptionalValue(m.host.ProxyJump)},
+		{"ProxyCommand", formatOptionalValue(m.host.ProxyCommand)},
 		{"SSH Options", formatSSHOptions(m.host.Options)},
 		{"Tags", formatTags(m.host.Tags)},
 	}

internal/ui/model.go

@@ -42,7 +42,6 @@ const (
 	ViewPortForward
 	ViewHelp
 	ViewFileSelector
-	ViewHistory
 )
 
 // PortForwardType defines the type of port forwarding
@@ -75,7 +74,7 @@ type Model struct {
 	filteredHosts  []config.SSHHost
 	searchMode     bool
 	deleteMode     bool
-	deleteHost     string
+	deleteHost     *config.SSHHost // Host to be deleted (with line number for precise targeting)
 	historyManager *history.HistoryManager
 	pingManager    *connectivity.PingManager
 	sortMode       SortMode
@@ -97,7 +96,6 @@ type Model struct {
 	portForwardForm  *portForwardModel
 	helpForm         *helpModel
 	fileSelectorForm *fileSelectorModel
-	historyView      *HistoryModel
 
 	// Terminal size and styles
 	width  int

internal/ui/styles.go

@@ -63,14 +63,12 @@ func NewStyles(width int) Styles {
 		SearchFocused: lipgloss.NewStyle().
 			BorderStyle(lipgloss.RoundedBorder()).
 			BorderForeground(lipgloss.Color(PrimaryColor)).
-			Padding(0, 1).
+			Padding(0, 1),
-			Width(50), // Fixed width to prevent expansion
 
 		SearchUnfocused: lipgloss.NewStyle().
 			BorderStyle(lipgloss.RoundedBorder()).
 			BorderForeground(lipgloss.Color(SecondaryColor)).
-			Padding(0, 1).
+			Padding(0, 1),
-			Width(50), // Fixed width to prevent expansion
 
 		// Table styles
 		TableFocused: lipgloss.NewStyle().

internal/ui/tui.go

@@ -16,7 +16,7 @@ import (
 )
 
 // NewModel creates a new TUI model with the given SSH hosts
-func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
+func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, currentVersion string) Model {
 	// Load application configuration
 	appConfig, err := config.LoadAppConfig()
 	if err != nil {
@@ -54,6 +54,7 @@ func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
 		height:         24,
 		ready:          false,
 		viewMode:       ViewList,
+		searchMode:     searchMode,
 	}
 
 	// Sort hosts according to the default sort mode
@@ -64,6 +65,9 @@ func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
 	ti.Placeholder = "Search hosts or tags..."
 	ti.CharLimit = 50
 	ti.Width = 25
+	if searchMode {
+		ti.Focus()
+	}
 
 	// Use dynamic column width calculation (will fallback to static if width not available)
 	nameWidth, hostnameWidth, tagsWidth, lastLoginWidth := m.calculateDynamicColumnWidths(sortedHosts)
@@ -147,8 +151,8 @@ func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
 }
 
 // RunInteractiveMode starts the interactive TUI interface
-func RunInteractiveMode(hosts []config.SSHHost, configFile, currentVersion string) error {
+func RunInteractiveMode(hosts []config.SSHHost, configFile string, searchMode bool, currentVersion string) error {
-	m := NewModel(hosts, configFile, currentVersion)
+	m := NewModel(hosts, configFile, searchMode, currentVersion)
 
 	// Start the application in alt screen mode for clean output
 	p := tea.NewProgram(m, tea.WithAltScreen())

internal/ui/update.go

@@ -20,8 +20,6 @@ type (
 	versionCheckMsg *version.UpdateInfo
 	versionErrorMsg error
 	errorMsg        string
-	returnToListMsg struct{}
-	refreshHostsMsg struct{}
 )
 
 // startPingAllCmd creates a command to ping all hosts concurrently
@@ -168,40 +166,6 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
-	case returnToListMsg:
-		// Return to list view from history
-		m.viewMode = ViewList
-		m.historyView = nil
-		return m, nil
-
-	case refreshHostsMsg:
-		// Refresh hosts after adding from history
-		var hosts []config.SSHHost
-		var err error
-
-		if m.configFile != "" {
-			hosts, err = config.ParseSSHConfigFile(m.configFile)
-		} else {
-			hosts, err = config.ParseSSHConfig()
-		}
-
-		if err != nil {
-			return m, nil
-		}
-		m.hosts = m.sortHosts(hosts)
-
-		// Reapply search filter if there is one active
-		if m.searchInput.Value() != "" {
-			m.filteredHosts = m.filterHosts(m.searchInput.Value())
-		} else {
-			m.filteredHosts = m.hosts
-		}
-
-		m.updateTableRows()
-		m.viewMode = ViewList
-		m.historyView = nil
-		return m, nil
-
 	case addFormSubmitMsg:
 		if msg.err != nil {
 			// Show error in form
@@ -470,14 +434,6 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.fileSelectorForm = newForm
 				return m, cmd
 			}
-		case ViewHistory:
-			if m.historyView != nil {
-				newView, cmd := m.historyView.Update(msg)
-				if histView, ok := newView.(HistoryModel); ok {
-					m.historyView = &histView
-					return m, cmd
-				}
-			}
 		case ViewList:
 			// Handle list view keys
 			return m.handleListViewKeys(msg)
@@ -496,7 +452,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		if m.deleteMode {
 			// Exit delete mode
 			m.deleteMode = false
-			m.deleteHost = ""
+			m.deleteHost = nil
 			m.table.Focus()
 			return m, nil
 		}
@@ -552,15 +508,13 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		} else if m.deleteMode {
 			// Confirm deletion
 			var err error
-			if m.configFile != "" {
+			if m.deleteHost != nil {
-				err = config.DeleteSSHHostFromFile(m.deleteHost, m.configFile)
+				err = config.DeleteSSHHostWithLine(*m.deleteHost)
-			} else {
-				err = config.DeleteSSHHost(m.deleteHost)
 			}
 			if err != nil {
 				// Could display an error message here
 				m.deleteMode = false
-				m.deleteHost = ""
+				m.deleteHost = nil
 				m.table.Focus()
 				return m, nil
 			}
@@ -577,7 +531,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			if parseErr != nil {
 				// Could display an error message here
 				m.deleteMode = false
-				m.deleteHost = ""
+				m.deleteHost = nil
 				m.table.Focus()
 				return m, nil
 			}
@@ -592,7 +546,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 
 			m.updateTableRows()
 			m.deleteMode = false
-			m.deleteHost = ""
+			m.deleteHost = nil
 			m.table.Focus()
 			return m, nil
 		} else {
@@ -717,11 +671,13 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case "d":
 		if !m.searchMode && !m.deleteMode {
 			// Delete the selected host
-			selected := m.table.SelectedRow()
+			cursor := m.table.Cursor()
-			if len(selected) > 0 {
+			if cursor >= 0 && cursor < len(m.filteredHosts) {
-				hostName := extractHostNameFromTableRow(selected[0]) // Extract hostname from first column
+				// Get the host at the cursor position (which corresponds to filteredHosts index)
+				targetHost := &m.filteredHosts[cursor]
+
 				m.deleteMode = true
-				m.deleteHost = hostName
+				m.deleteHost = targetHost
 				m.table.Blur()
 				return m, nil
 			}
@@ -749,22 +705,6 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.viewMode = ViewHelp
 			return m, nil
 		}
-	case "ctrl+h":
-		if !m.searchMode && !m.deleteMode {
-			// Switch to history view
-			if m.historyManager != nil {
-				connections := m.historyManager.GetAllConnectionsInfo()
-				historyView := NewHistoryModel(connections, m.configFile, m.currentVersion)
-				historyView.width = m.width
-				historyView.height = m.height
-				historyView.styles = m.styles
-				// Force table update with correct dimensions
-				historyView.updateTable()
-				m.historyView = &historyView
-				m.viewMode = ViewHistory
-				return m, nil
-			}
-		}
 	case "s":
 		if !m.searchMode && !m.deleteMode {
 			// Cycle through sort modes (only 2 modes now)

internal/ui/view.go

@@ -43,10 +43,6 @@ func (m Model) View() string {
 		if m.fileSelectorForm != nil {
 			return m.fileSelectorForm.View()
 		}
-	case ViewHistory:
-		if m.historyView != nil {
-			return m.historyView.View()
-		}
 	case ViewList:
 		return m.renderListView()
 	}
@@ -110,7 +106,7 @@ func (m Model) renderListView() string {
 	// Add the help text
 	var helpText string
 	if !m.searchMode {
-		helpText = " ↑/↓: navigate • Enter: connect • Ctrl+H: history • i: info • h: help • q: quit"
+		helpText = " ↑/↓: navigate • Enter: connect • p: ping all • i: info • h: help • q: quit"
 	} else {
 		helpText = " Type to filter • Enter: validate • Tab: switch • ESC: quit"
 	}
@@ -148,7 +144,11 @@ func (m Model) renderListView() string {
 func (m Model) renderDeleteConfirmation() string {
 	// Remove emojis (uncertain width depending on terminal) to stabilize the frame
 	title := "DELETE SSH HOST"
-	question := fmt.Sprintf("Are you sure you want to delete host '%s'?", m.deleteHost)
+	hostName := ""
+	if m.deleteHost != nil {
+		hostName = m.deleteHost.Name
+	}
+	question := fmt.Sprintf("Are you sure you want to delete host '%s'?", hostName)
 	action := "This action cannot be undone."
 	help := "Enter: confirm • Esc: cancel"
 

internal/validation/ssh.go

@@ -11,6 +11,7 @@ import (
 )
 
 // ValidateHostname checks if a hostname is valid
+// Accepts regular hostnames, IP addresses, and SSH tokens like %h, %p, %r, %u, %n, %C, %d, %i, %k, %L, %l, %T
 func ValidateHostname(hostname string) bool {
 	if len(hostname) == 0 || len(hostname) > 253 {
 		return false
@@ -22,7 +23,18 @@ func ValidateHostname(hostname string) bool {
 		return false
 	}
 
-	hostnameRegex := regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$`)
+	// Check if hostname contains SSH tokens (e.g., %h, %p, %r, %u, %n, etc.)
+	// SSH tokens are documented in ssh_config(5) man page
+	sshTokenRegex := regexp.MustCompile(`%[hprunCdiklLT]`)
+	if sshTokenRegex.MatchString(hostname) {
+		// If it contains SSH tokens, it's a valid SSH config construct
+		return true
+	}
+
+	// RFC 1123: each label must start with alphanumeric, end with alphanumeric,
+	// and contain only alphanumeric and hyphens. Labels are 1-63 chars.
+	// A hostname is one or more labels separated by dots.
+	hostnameRegex := regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]|[a-zA-Z0-9]{0,62})?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]|[a-zA-Z0-9]{0,62})?)*$`)
 	return hostnameRegex.MatchString(hostname)
 }
 

internal/validation/ssh_test.go

@@ -24,6 +24,19 @@ func TestValidateHostname(t *testing.T) {
 		{"hostname ending with dot", "example.com.", false},
 		{"hostname with hyphen", "my-server.com", true},
 		{"hostname starting with number", "1example.com", true},
+		{"multiple hyphens and subdomains", "my-host-name-01.cwd.pub.domain.net", true},
+		{"multiple hyphens", "my-host-name-01", true},
+		{"complex hostname with hyphens", "server-01-prod.data-center.example.com", true},
+		{"hostname with consecutive hyphens", "my--server.com", true},
+		{"single char labels", "a.b.c.d.com", true},
+		// SSH tokens support (issue #32 comment)
+		{"SSH token %h", "%h.server.com", true},
+		{"SSH token %p", "server.com:%p", true},
+		{"SSH token %r", "%r@server.com", true},
+		{"SSH token %u", "%u.example.com", true},
+		{"SSH token %n", "%n.domain.net", true},
+		{"SSH token %C", "host-%C.com", true},
+		{"multiple SSH tokens", "%h.%u.server.com", true},
 	}
 
 	for _, tt := range tests {