Merge b43a67eb1a into 3d746ec49a

.goreleaser.yaml

@@ -19,9 +19,6 @@ builds:
   - arm64
   - "386"
   - arm
-  goarm:
-  - "6"
-  - "7"
   ignore:
   # Skip ARM for Windows (not commonly used)
   - goos: windows
@@ -107,43 +104,26 @@ release:
   header: |
     ## SSHM {{.Version}}
 
-    Thank you for downloading SSHM!
+    Thank you for downloading SSHM! 
 
-  footer: |
-    ## Installation
+    ### Installation
 
-    ### Homebrew (macOS/Linux)
+    **Homebrew (macOS/Linux):**
     ```bash
     brew tap Gu1llaum-3/sshm
     brew install sshm
     ```
 
-    ### Installation Script (Recommended)
-    **Unix/Linux/macOS:**
-    ```bash
-    curl -sSL https://github.com/Gu1llaum-3/sshm/raw/main/install/unix.sh | bash
-    ```
-
-    **Windows (PowerShell):**
-    ```powershell
-    iwr -useb https://github.com/Gu1llaum-3/sshm/raw/main/install/windows.ps1 | iex
-    ```
-
-    ### Manual Installation
-    Download the appropriate binary for your platform from the assets above, extract it, and place it in your PATH.
+    **Manual Installation:**
+    Download the appropriate binary for your platform from the assets below.
 
+  footer: |
     ## Full Changelog
 
     See all changes at https://github.com/Gu1llaum-3/sshm/compare/{{.PreviousTag}}...{{.Tag}}
 
     ---
 
-    📖 **Documentation:** See the updated [README](https://github.com/Gu1llaum-3/sshm/blob/main/README.md)
-
-    🐛 **Issues:** Found a bug? Open an [issue](https://github.com/Gu1llaum-3/sshm/issues)
-
-    ---
-
     Released with ❤️ by [GoReleaser](https://github.com/goreleaser/goreleaser)
 
 # Snapshot builds (for non-tag builds)

CONFIG.md

@@ -0,0 +1,66 @@
+# SSHM Configuration
+
+SSHM supports configurable key bindings through a configuration file located at:
+- Linux/macOS: `~/.config/sshm/config.json`
+- Windows: `%APPDATA%\sshm\config.json`
+
+## Configuration Options
+
+### Key Bindings
+
+The key bindings section allows you to customize how you exit the application.
+
+#### Example Configuration
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": true
+  }
+}
+```
+
+#### Options
+
+- **quit_keys**: Array of keys that will quit the application. Default: `["q", "ctrl+c"]`
+- **disable_esc_quit**: Boolean flag to disable ESC key from quitting the application. Default: `false`
+
+## For Vim Users
+
+If you're a vim user and frequently press ESC accidentally causing the application to quit, set `disable_esc_quit` to `true`:
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": true
+  }
+}
+```
+
+With this configuration:
+- ESC will no longer quit the application
+- You can still quit using 'q' or Ctrl+C
+- All other functionality remains the same
+
+## Default Configuration
+
+If no configuration file exists, SSHM will create one with these defaults:
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": false
+  }
+}
+```
+
+This ensures backward compatibility - ESC will continue to work as a quit key by default.
+
+## Configuration Location
+
+The configuration file will be automatically created when you first run SSHM. You can manually edit it to customize the key bindings to your preference.
+
+If you encounter any issues with the configuration file, you can delete it and SSHM will recreate it with default settings on the next run.

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
@@ -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
 
@@ -286,47 +285,6 @@ 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
-
-SSHM automatically tracks all your SSH connections, including both configured hosts and manual connections made outside of SSHM.
-
-**Access History:**
-Press `Ctrl+H` from the main interface to switch to the history view. Press `Ctrl+L` to return to the main host list.
-
-**Features:**
-- **Automatic tracking** - Records all SSH connections with timestamps and connection counts
-- **Manual connection detection** - Captures `ssh user@host -p port -i key` commands made in your terminal
-- **Visual indicators** - Manual connections (not in your SSH config) are marked with ★
-- **Search & filter** - Find connections quickly using the search bar
-- **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
 
 SSHM automatically creates backups of your SSH configuration files before making any changes to ensure your configurations are safe.
@@ -595,34 +553,6 @@ This will be automatically converted to:
     StrictHostKeyChecking no
 ```
 
-### Custom Key Bindings
-
-SSHM supports customizable key bindings through a configuration file. This is particularly useful for users who want to modify the default quit behavior.
-
-**Configuration File Location:**
-- **Linux/macOS**: `~/.config/sshm/config.json`
-- **Windows**: `%APPDATA%\sshm\config.json`
-
-**Example Configuration:**
-```json
-{
-  "key_bindings": {
-    "quit_keys": ["q", "ctrl+c"],
-    "disable_esc_quit": true
-  }
-}
-```
-
-**Available Options:**
-- **quit_keys**: Array of keys that will quit the application. Default: `["q", "ctrl+c"]`
-- **disable_esc_quit**: Boolean flag to disable ESC key from quitting the application. Default: `false`
-
-**For Vim Users:**
-If you frequently press ESC accidentally causing the application to quit, set `disable_esc_quit` to `true`. This will disable ESC as a quit key while preserving all other functionality.
-
-**Default Configuration:**
-If no configuration file exists, SSHM will automatically create one with default settings that maintain backward compatibility.
-
 ## 🛠️ Development
 
 ### Prerequisites
@@ -739,8 +669,6 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - [Charm](https://charm.sh/) for the amazing TUI libraries
 - [Cobra](https://cobra.dev/) for the excellent CLI framework
 - [@yimeng](https://github.com/yimeng) for contributing SSH Include directive support
-- [@ldreux](https://github.com/ldreux) for contributing multi-word search functionality
-- [@qingfengzxr](https://github.com/qingfengzxr) for contributing custom key bindings support
 - The Go community for building such fantastic tools
 
 ---

cmd/root.go

@@ -49,7 +49,6 @@ Hosts are read from your ~/.ssh/config file by default.`,
 		}
 
 		// If a host name is provided, connect directly
-		// (manual SSH commands are handled in Execute() before reaching here)
 		hostName := args[0]
 		connectToHost(hostName)
 		return nil
@@ -104,18 +103,27 @@ func runInteractiveMode() {
 }
 
 func connectToHost(hostName string) {
-	// Quick check if host exists without full parsing (optimized for connection)
-	var hostFound bool
+	// Parse SSH configurations to verify host exists
+	var hosts []config.SSHHost
 	var err error
 
 	if configFile != "" {
-		hostFound, err = config.QuickHostExistsInFile(hostName, configFile)
+		hosts, err = config.ParseSSHConfigFile(configFile)
 	} else {
-		hostFound, err = config.QuickHostExists(hostName)
+		hosts, err = config.ParseSSHConfig()
 	}
 
 	if err != nil {
-		log.Fatalf("Error checking SSH config: %v", err)
+		log.Fatalf("Error reading SSH config file: %v", err)
+	}
+
+	// Check if host exists
+	var hostFound bool
+	for _, host := range hosts {
+		if host.Name == hostName {
+			hostFound = true
+			break
+		}
 	}
 
 	if !hostFound {
@@ -141,85 +149,12 @@ func connectToHost(hostName string) {
 	fmt.Printf("Connecting to %s...\n", hostName)
 
 	var sshCmd *exec.Cmd
-	var args []string
-
 	if configFile != "" {
-		args = append(args, "-F", configFile)
-	}
-	args = append(args, hostName)
-
-	// Note: We don't add RemoteCommand here because if it's configured in SSH config,
-	// SSH will handle it automatically. Adding it as a command line argument would conflict.
-
-	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)
+		sshCmd = exec.Command("ssh", "-F", configFile, hostName)
 	} 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)
-		}
+		sshCmd = exec.Command("ssh", hostName)
 	}
 
-	// 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
@@ -265,29 +200,6 @@ 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

install/unix.sh

@@ -7,7 +7,6 @@ USE_SUDO="false"
 OS=""
 ARCH=""
 FORCE_INSTALL="${FORCE_INSTALL:-false}"
-SSHM_VERSION="${SSHM_VERSION:-latest}"
 
 RED='\033[0;31m'
 PURPLE='\033[0;35m'
@@ -15,27 +14,13 @@ GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m'
 
-usage() {
-    printf "${PURPLE}SSHM Installation Script${NC}\n\n"
-    printf "Usage:\n"
-    printf "  Default (latest stable):     ${GREEN}bash install.sh${NC}\n"
-    printf "  Specific version:            ${GREEN}SSHM_VERSION=v1.8.0 bash install.sh${NC}\n"
-    printf "  Beta/pre-release:            ${GREEN}SSHM_VERSION=v1.8.1-beta bash install.sh${NC}\n"
-    printf "  Force install:               ${GREEN}FORCE_INSTALL=true bash install.sh${NC}\n"
-    printf "  Custom install directory:    ${GREEN}INSTALL_DIR=/opt/bin bash install.sh${NC}\n\n"
-    printf "Environment variables:\n"
-    printf "  SSHM_VERSION    - Version to install (default: latest)\n"
-    printf "  FORCE_INSTALL   - Skip confirmation prompts (default: false)\n"
-    printf "  INSTALL_DIR     - Installation directory (default: /usr/local/bin)\n\n"
-}
-
 setSystem() {
     ARCH=$(uname -m)
     case $ARCH in
         i386|i686) ARCH="amd64" ;;
         x86_64) ARCH="amd64";;
-        armv6*) ARCH="armv6" ;;
-        armv7*) ARCH="armv7" ;;
+        armv6*) ARCH="arm64" ;;
+        armv7*) ARCH="arm64" ;;
         aarch64*) ARCH="arm64" ;;
         arm64) ARCH="arm64" ;;
     esac
@@ -61,25 +46,13 @@ runAsRoot() {
 }
 
 getLatestVersion() {
-    if [ "$SSHM_VERSION" = "latest" ]; then
-        printf "${YELLOW}Fetching latest stable version...${NC}\n"
-        LATEST_VERSION=$(curl -s https://api.github.com/repos/Gu1llaum-3/sshm/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
-        if [ -z "$LATEST_VERSION" ]; then
-            printf "${RED}Failed to fetch latest version${NC}\n"
-            exit 1
-        fi
-    else
-        printf "${YELLOW}Using specified version: $SSHM_VERSION${NC}\n"
-        # Validate that the specified version exists
-        RELEASE_CHECK=$(curl -s "https://api.github.com/repos/Gu1llaum-3/sshm/releases/tags/$SSHM_VERSION" | grep '"tag_name":')
-        if [ -z "$RELEASE_CHECK" ]; then
-            printf "${RED}Version $SSHM_VERSION not found. Available versions:${NC}\n"
-            curl -s https://api.github.com/repos/Gu1llaum-3/sshm/releases | grep '"tag_name":' | head -10 | sed -E 's/.*"([^"]+)".*/  - \1/'
-            exit 1
-        fi
-        LATEST_VERSION="$SSHM_VERSION"
+    printf "${YELLOW}Fetching latest version...${NC}\n"
+    LATEST_VERSION=$(curl -s https://api.github.com/repos/Gu1llaum-3/sshm/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
+    if [ -z "$LATEST_VERSION" ]; then
+        printf "${RED}Failed to fetch latest version${NC}\n"
+        exit 1
     fi
-    printf "${GREEN}Installing version: $LATEST_VERSION${NC}\n"
+    printf "${GREEN}Latest version: $LATEST_VERSION${NC}\n"
 }
 
 downloadBinary() {
@@ -97,11 +70,10 @@ downloadBinary() {
         "amd64") GORELEASER_ARCH="x86_64" ;;
         "arm64") GORELEASER_ARCH="arm64" ;;
         "386") GORELEASER_ARCH="i386" ;;
-        "armv6") GORELEASER_ARCH="armv6" ;;
-        "armv7") GORELEASER_ARCH="armv7" ;;
+        "arm") GORELEASER_ARCH="armv6" ;;
     esac
     
-    # GoReleaser format: sshm_Linux_armv7.tar.gz
+    # GoReleaser format: sshm_Darwin_arm64.tar.gz
     GITHUB_FILE="sshm_${GORELEASER_OS}_${GORELEASER_ARCH}.tar.gz"
     GITHUB_URL="https://github.com/Gu1llaum-3/sshm/releases/download/$LATEST_VERSION/$GITHUB_FILE"
     
@@ -204,24 +176,18 @@ checkExisting() {
 }
 
 main() {
-    # Check for help argument
-    if [ "$1" = "-h" ] || [ "$1" = "--help" ] || [ "$1" = "help" ]; then
-        usage
-        exit 0
-    fi
-    
     printf "${PURPLE}Installing SSHM - SSH Connection Manager${NC}\n\n"
     
+    # Check if already installed
+    checkExisting
+    
     # Set up system detection
     setSystem
     printf "${GREEN}Detected system: $OS ($ARCH)${NC}\n"
     
-    # Get and validate version FIRST (this can fail early)
+    # Get latest version
     getLatestVersion
     
-    # Check if already installed (this might prompt user)
-    checkExisting
-    
     # Download and install
     downloadBinary
     install

internal/config/ssh_test.go

@@ -987,710 +987,3 @@ func TestMoveHostToFile(t *testing.T) {
 	// Test that the component functions work for the move operation
 	t.Log("MoveHostToFile() error handling works correctly")
 }
-
-func TestParseSSHConfigWithMultipleHostsOnSameLine(t *testing.T) {
-	tempDir := t.TempDir()
-
-	configFile := filepath.Join(tempDir, "config")
-	configContent := `# Test multiple hosts on same line
-Host local1 local2
-    HostName ::1
-    User myuser
-
-Host root-server
-    User root
-    HostName root.example.com
-
-Host web1 web2 web3
-    HostName ::1
-    User webuser
-    Port 8080
-
-Host single-host
-    HostName single.example.com
-    User singleuser
-`
-
-	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 7 hosts: local1, local2, root-server, web1, web2, web3, single-host
-	expectedHosts := map[string]struct{}{
-		"local1":      {},
-		"local2":      {},
-		"root-server": {},
-		"web1":        {},
-		"web2":        {},
-		"web3":        {},
-		"single-host": {},
-	}
-
-	if len(hosts) != len(expectedHosts) {
-		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
-		for _, host := range hosts {
-			t.Logf("Found host: %s", host.Name)
-		}
-	}
-
-	hostMap := make(map[string]SSHHost)
-	for _, host := range hosts {
-		hostMap[host.Name] = host
-	}
-
-	for expectedHostName := range expectedHosts {
-		if _, found := hostMap[expectedHostName]; !found {
-			t.Errorf("Expected host %s not found", expectedHostName)
-		}
-	}
-
-	// Verify properties based on host name
-	if host, found := hostMap["local1"]; found {
-		if host.Hostname != "::1" || host.User != "myuser" {
-			t.Errorf("local1 properties incorrect: hostname=%s, user=%s", host.Hostname, host.User)
-		}
-	}
-
-	if host, found := hostMap["local2"]; found {
-		if host.Hostname != "::1" || host.User != "myuser" {
-			t.Errorf("local2 properties incorrect: hostname=%s, user=%s", host.Hostname, host.User)
-		}
-	}
-
-	if host, found := hostMap["web1"]; found {
-		if host.Hostname != "::1" || host.User != "webuser" || host.Port != "8080" {
-			t.Errorf("web1 properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	if host, found := hostMap["web2"]; found {
-		if host.Hostname != "::1" || host.User != "webuser" || host.Port != "8080" {
-			t.Errorf("web2 properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	if host, found := hostMap["web3"]; found {
-		if host.Hostname != "::1" || host.User != "webuser" || host.Port != "8080" {
-			t.Errorf("web3 properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	if host, found := hostMap["root-server"]; found {
-		if host.User != "root" || host.Hostname != "root.example.com" {
-			t.Errorf("root-server properties incorrect: user=%s, hostname=%s", host.User, host.Hostname)
-		}
-	}
-}
-
-func TestUpdateSSHHostInFileWithMultiHost(t *testing.T) {
-	tempDir := t.TempDir()
-
-	configFile := filepath.Join(tempDir, "config")
-	configContent := `# Test config with multi-host
-Host web1 web2 web3
-    HostName webserver.example.com
-    User webuser
-    Port 2222
-
-Host database
-    HostName db.example.com
-    User dbuser
-`
-
-	err := os.WriteFile(configFile, []byte(configContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create config: %v", err)
-	}
-
-	// Update web2 in the multi-host line
-	newHost := SSHHost{
-		Name:     "web2-updated",
-		Hostname: "newweb.example.com",
-		User:     "newuser",
-		Port:     "22",
-	}
-
-	err = UpdateSSHHostInFile("web2", newHost, configFile)
-	if err != nil {
-		t.Fatalf("UpdateSSHHostInFile() error = %v", err)
-	}
-
-	// Parse the updated config
-	hosts, err := ParseSSHConfigFile(configFile)
-	if err != nil {
-		t.Fatalf("ParseSSHConfigFile() error = %v", err)
-	}
-
-	// Should have: web1, web3, web2-updated, database
-	expectedHosts := []string{"web1", "web3", "web2-updated", "database"}
-
-	hostMap := make(map[string]SSHHost)
-	for _, host := range hosts {
-		hostMap[host.Name] = host
-	}
-
-	if len(hosts) != len(expectedHosts) {
-		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
-		for _, host := range hosts {
-			t.Logf("Found host: %s", host.Name)
-		}
-	}
-
-	for _, expectedHostName := range expectedHosts {
-		if _, found := hostMap[expectedHostName]; !found {
-			t.Errorf("Expected host %s not found", expectedHostName)
-		}
-	}
-
-	// Verify web1 and web3 still have original properties
-	if host, found := hostMap["web1"]; found {
-		if host.Hostname != "webserver.example.com" || host.User != "webuser" || host.Port != "2222" {
-			t.Errorf("web1 properties changed: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	if host, found := hostMap["web3"]; found {
-		if host.Hostname != "webserver.example.com" || host.User != "webuser" || host.Port != "2222" {
-			t.Errorf("web3 properties changed: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	// Verify web2-updated has new properties
-	if host, found := hostMap["web2-updated"]; found {
-		if host.Hostname != "newweb.example.com" || host.User != "newuser" || host.Port != "22" {
-			t.Errorf("web2-updated properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	// Verify database is unchanged
-	if host, found := hostMap["database"]; found {
-		if host.Hostname != "db.example.com" || host.User != "dbuser" {
-			t.Errorf("database properties changed: hostname=%s, user=%s", host.Hostname, host.User)
-		}
-	}
-}
-
-func TestIsPartOfMultiHostDeclaration(t *testing.T) {
-	tempDir := t.TempDir()
-
-	configFile := filepath.Join(tempDir, "config")
-	configContent := `Host single
-    HostName single.example.com
-
-Host multi1 multi2 multi3
-    HostName multi.example.com
-
-Host another
-    HostName another.example.com
-`
-
-	err := os.WriteFile(configFile, []byte(configContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create config: %v", err)
-	}
-
-	tests := []struct {
-		hostName      string
-		expectedMulti bool
-		expectedHosts []string
-	}{
-		{"single", false, []string{"single"}},
-		{"multi1", true, []string{"multi1", "multi2", "multi3"}},
-		{"multi2", true, []string{"multi1", "multi2", "multi3"}},
-		{"multi3", true, []string{"multi1", "multi2", "multi3"}},
-		{"another", false, []string{"another"}},
-		{"nonexistent", false, nil},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.hostName, func(t *testing.T) {
-			isMulti, hostNames, err := IsPartOfMultiHostDeclaration(tt.hostName, configFile)
-			if err != nil {
-				t.Fatalf("IsPartOfMultiHostDeclaration() error = %v", err)
-			}
-
-			if isMulti != tt.expectedMulti {
-				t.Errorf("Expected isMulti=%v, got %v", tt.expectedMulti, isMulti)
-			}
-
-			if tt.expectedHosts == nil && hostNames != nil {
-				t.Errorf("Expected hostNames to be nil, got %v", hostNames)
-			} else if tt.expectedHosts != nil {
-				if len(hostNames) != len(tt.expectedHosts) {
-					t.Errorf("Expected %d hostNames, got %d", len(tt.expectedHosts), len(hostNames))
-				} else {
-					for i, expectedHost := range tt.expectedHosts {
-						if i < len(hostNames) && hostNames[i] != expectedHost {
-							t.Errorf("Expected hostNames[%d]=%s, got %s", i, expectedHost, hostNames[i])
-						}
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestDeleteSSHHostFromFileWithMultiHost(t *testing.T) {
-	tempDir := t.TempDir()
-
-	configFile := filepath.Join(tempDir, "config")
-	configContent := `# Test config with multi-host deletion
-Host web1 web2 web3
-    HostName webserver.example.com
-    User webuser
-    Port 2222
-
-Host database
-    HostName db.example.com
-    User dbuser
-
-# Tags: production, critical
-Host app1 app2
-    HostName appserver.example.com
-    User appuser
-`
-
-	err := os.WriteFile(configFile, []byte(configContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create config: %v", err)
-	}
-
-	// Test 1: Delete one host from multi-host block (should keep others)
-	err = DeleteSSHHostFromFile("web2", configFile)
-	if err != nil {
-		t.Fatalf("DeleteSSHHostFromFile() error = %v", err)
-	}
-
-	// Parse the updated config
-	hosts, err := ParseSSHConfigFile(configFile)
-	if err != nil {
-		t.Fatalf("ParseSSHConfigFile() error = %v", err)
-	}
-
-	// Should have: web1, web3, database, app1, app2 (web2 removed)
-	expectedHosts := []string{"web1", "web3", "database", "app1", "app2"}
-
-	hostMap := make(map[string]SSHHost)
-	for _, host := range hosts {
-		hostMap[host.Name] = host
-	}
-
-	if len(hosts) != len(expectedHosts) {
-		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
-		for _, host := range hosts {
-			t.Logf("Found host: %s", host.Name)
-		}
-	}
-
-	for _, expectedHostName := range expectedHosts {
-		if _, found := hostMap[expectedHostName]; !found {
-			t.Errorf("Expected host %s not found", expectedHostName)
-		}
-	}
-
-	// Verify web2 is not present
-	if _, found := hostMap["web2"]; found {
-		t.Error("web2 should have been deleted")
-	}
-
-	// Verify web1 and web3 still have original properties
-	if host, found := hostMap["web1"]; found {
-		if host.Hostname != "webserver.example.com" || host.User != "webuser" || host.Port != "2222" {
-			t.Errorf("web1 properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	if host, found := hostMap["web3"]; found {
-		if host.Hostname != "webserver.example.com" || host.User != "webuser" || host.Port != "2222" {
-			t.Errorf("web3 properties incorrect: hostname=%s, user=%s, port=%s", host.Hostname, host.User, host.Port)
-		}
-	}
-
-	// Test 2: Delete one host from multi-host block with tags
-	err = DeleteSSHHostFromFile("app1", configFile)
-	if err != nil {
-		t.Fatalf("DeleteSSHHostFromFile() error = %v", err)
-	}
-
-	// Parse again
-	hosts, err = ParseSSHConfigFile(configFile)
-	if err != nil {
-		t.Fatalf("ParseSSHConfigFile() error = %v", err)
-	}
-
-	// Should have: web1, web3, database, app2 (app1 removed)
-	expectedHosts = []string{"web1", "web3", "database", "app2"}
-
-	hostMap = make(map[string]SSHHost)
-	for _, host := range hosts {
-		hostMap[host.Name] = host
-	}
-
-	if len(hosts) != len(expectedHosts) {
-		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
-		for _, host := range hosts {
-			t.Logf("Found host: %s", host.Name)
-		}
-	}
-
-	// Verify app2 still has tags
-	if host, found := hostMap["app2"]; found {
-		if !contains(host.Tags, "production") || !contains(host.Tags, "critical") {
-			t.Errorf("app2 tags incorrect: %v", host.Tags)
-		}
-	}
-}
-
-func TestUpdateMultiHostBlock(t *testing.T) {
-	tempDir := t.TempDir()
-
-	configFile := filepath.Join(tempDir, "config")
-	configContent := `# Test config for multi-host block update
-Host server1 server2 server3
-    HostName cluster.example.com
-    User clusteruser
-    Port 2222
-
-Host single
-    HostName single.example.com
-    User singleuser
-`
-
-	err := os.WriteFile(configFile, []byte(configContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create config: %v", err)
-	}
-
-	// Update the multi-host block
-	originalHosts := []string{"server1", "server2", "server3"}
-	newHosts := []string{"server1", "server4", "server5"} // Remove server2, server3 and add server4, server5
-	commonProperties := SSHHost{
-		Hostname: "newcluster.example.com",
-		User:     "newuser",
-		Port:     "22",
-		Tags:     []string{"updated", "cluster"},
-	}
-
-	err = UpdateMultiHostBlock(originalHosts, newHosts, commonProperties, configFile)
-	if err != nil {
-		t.Fatalf("UpdateMultiHostBlock() error = %v", err)
-	}
-
-	// Parse the updated config
-	hosts, err := ParseSSHConfigFile(configFile)
-	if err != nil {
-		t.Fatalf("ParseSSHConfigFile() error = %v", err)
-	}
-
-	// Should have: server1, server4, server5, single
-	expectedHosts := []string{"server1", "server4", "server5", "single"}
-
-	hostMap := make(map[string]SSHHost)
-	for _, host := range hosts {
-		hostMap[host.Name] = host
-	}
-
-	if len(hosts) != len(expectedHosts) {
-		t.Errorf("Expected %d hosts, got %d", len(expectedHosts), len(hosts))
-		for _, host := range hosts {
-			t.Logf("Found host: %s", host.Name)
-		}
-	}
-
-	// Verify new hosts have updated properties
-	for _, hostName := range []string{"server1", "server4", "server5"} {
-		if host, found := hostMap[hostName]; found {
-			if host.Hostname != "newcluster.example.com" || host.User != "newuser" || host.Port != "22" {
-				t.Errorf("%s properties incorrect: hostname=%s, user=%s, port=%s",
-					hostName, host.Hostname, host.User, host.Port)
-			}
-			if !contains(host.Tags, "updated") || !contains(host.Tags, "cluster") {
-				t.Errorf("%s tags incorrect: %v", hostName, host.Tags)
-			}
-		} else {
-			t.Errorf("Expected host %s not found", hostName)
-		}
-	}
-
-	// Verify single host is unchanged
-	if host, found := hostMap["single"]; found {
-		if host.Hostname != "single.example.com" || host.User != "singleuser" {
-			t.Errorf("single host properties changed: hostname=%s, user=%s", host.Hostname, host.User)
-		}
-	}
-
-	// Verify old hosts are gone
-	for _, oldHost := range []string{"server2", "server3"} {
-		if _, found := hostMap[oldHost]; found {
-			t.Errorf("Old host %s should have been removed", oldHost)
-		}
-	}
-}
-
-// Helper function to check if slice contains a string
-func contains(slice []string, item string) bool {
-	for _, s := range slice {
-		if s == item {
-			return true
-		}
-	}
-	return false
-}
-
-// Helper function to create temporary config files for testing
-func createTempConfigFile(content string) (string, error) {
-	tempFile, err := os.CreateTemp("", "ssh_config_test_*.conf")
-	if err != nil {
-		return "", err
-	}
-	defer tempFile.Close()
-
-	_, err = tempFile.WriteString(content)
-	if err != nil {
-		os.Remove(tempFile.Name())
-		return "", err
-	}
-
-	return tempFile.Name(), nil
-}
-
-func TestFormatSSHConfigValue(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected string
-	}{
-		{
-			name:     "simple path without spaces",
-			input:    "/home/user/.ssh/id_rsa",
-			expected: "/home/user/.ssh/id_rsa",
-		},
-		{
-			name:     "path with spaces",
-			input:    "/home/user/My Documents/ssh key",
-			expected: "\"/home/user/My Documents/ssh key\"",
-		},
-		{
-			name:     "Windows path with spaces",
-			input:    `G:\My Drive\7 - Tech\9 - SSH Keys\Server_WF.opk`,
-			expected: `"G:\My Drive\7 - Tech\9 - SSH Keys\Server_WF.opk"`,
-		},
-		{
-			name:     "path with quotes but no spaces",
-			input:    `/home/user/key"with"quotes`,
-			expected: `/home/user/key"with"quotes`,
-		},
-		{
-			name:     "path with spaces and quotes",
-			input:    `/home/user/key "with" quotes`,
-			expected: `"/home/user/key "with" quotes"`,
-		},
-		{
-			name:     "empty path",
-			input:    "",
-			expected: "",
-		},
-		{
-			name:     "path with single space at end",
-			input:    "/home/user/key ",
-			expected: "\"/home/user/key \"",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := formatSSHConfigValue(tt.input)
-			if result != tt.expected {
-				t.Errorf("formatSSHConfigValue(%q) = %q, want %q", tt.input, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestAddSSHHostWithSpacesInPath(t *testing.T) {
-	// Create temporary config file
-	configFile, err := createTempConfigFile(`Host existing
-    HostName existing.com
-`)
-	if err != nil {
-		t.Fatalf("Failed to create config file: %v", err)
-	}
-	defer os.Remove(configFile)
-
-	// Test adding host with path containing spaces
-	host := SSHHost{
-		Name:     "test-spaces",
-		Hostname: "test.com",
-		User:     "testuser",
-		Identity: "/path/with spaces/key file",
-	}
-
-	err = AddSSHHostToFile(host, configFile)
-	if err != nil {
-		t.Fatalf("AddSSHHostToFile failed: %v", err)
-	}
-
-	// Read the file and verify quotes are added
-	content, err := os.ReadFile(configFile)
-	if err != nil {
-		t.Fatalf("Failed to read config file: %v", err)
-	}
-
-	contentStr := string(content)
-	expectedIdentityLine := `    IdentityFile "/path/with spaces/key file"`
-	if !strings.Contains(contentStr, expectedIdentityLine) {
-		t.Errorf("Expected identity file line with quotes not found.\nContent:\n%s\nExpected line: %s", contentStr, expectedIdentityLine)
-	}
-}
-
-func TestIsNonSSHConfigFile(t *testing.T) {
-	tests := []struct {
-		fileName string
-		expected bool
-	}{
-		// Should be excluded
-		{"README", true},
-		{"README.txt", true},
-		{"README.md", true},
-		{"script.sh", true},
-		{"data.json", true},
-		{"notes.txt", true},
-		{".gitignore", true},
-		{"backup.bak", true},
-		{"old.orig", true},
-		{"log.log", true},
-		{"temp.tmp", true},
-		{"archive.zip", true},
-		{"image.jpg", true},
-		{"python.py", true},
-		{"golang.go", true},
-		{"config.yaml", true},
-		{"config.yml", true},
-		{"config.toml", true},
-
-		// Should NOT be excluded (valid SSH config files)
-		{"config", false},
-		{"servers.conf", false},
-		{"production", false},
-		{"staging", false},
-		{"hosts", false},
-		{"ssh_config", false},
-		{"work-servers", false},
-	}
-
-	for _, test := range tests {
-		// Create a temporary file for content testing
-		tempDir := t.TempDir()
-		filePath := filepath.Join(tempDir, test.fileName)
-
-		// Write appropriate content based on expected result
-		var content string
-		if test.expected {
-			// Write non-SSH content for files that should be excluded
-			content = "# This is not an SSH config file\nSome random content"
-		} else {
-			// Write SSH-like content for files that should be included
-			content = "Host example\n    HostName example.com\n    User testuser"
-		}
-
-		err := os.WriteFile(filePath, []byte(content), 0600)
-		if err != nil {
-			t.Fatalf("Failed to create test file %s: %v", test.fileName, err)
-		}
-
-		result := isNonSSHConfigFile(filePath)
-		if result != test.expected {
-			t.Errorf("isNonSSHConfigFile(%q) = %v, want %v", test.fileName, result, test.expected)
-		}
-	}
-}
-
-func TestQuickHostExists(t *testing.T) {
-	// Create temporary directory for test files
-	tempDir := t.TempDir()
-
-	// Create main config file
-	mainConfig := filepath.Join(tempDir, "config")
-	mainConfigContent := `Host main-host
-    HostName example.com
-
-Include config.d/*
-
-Host another-host
-    HostName another.example.com
-`
-
-	err := os.WriteFile(mainConfig, []byte(mainConfigContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create main config: %v", err)
-	}
-
-	// Create config.d directory
-	configDir := filepath.Join(tempDir, "config.d")
-	err = os.MkdirAll(configDir, 0700)
-	if err != nil {
-		t.Fatalf("Failed to create config.d: %v", err)
-	}
-
-	// Create valid SSH config file in config.d
-	validConfig := filepath.Join(configDir, "servers.conf")
-	validConfigContent := `Host included-host
-    HostName included.example.com
-    User includeduser
-
-Host production-server
-    HostName prod.example.com
-    User produser
-`
-
-	err = os.WriteFile(validConfig, []byte(validConfigContent), 0600)
-	if err != nil {
-		t.Fatalf("Failed to create valid config: %v", err)
-	}
-
-	// Create files that should be excluded (README, etc.)
-	excludedFiles := map[string]string{
-		"README":    "# This is a README file\nDocumentation goes here",
-		"README.md": "# SSH Configuration\nThis directory contains...",
-		"script.sh": "#!/bin/bash\necho 'hello world'",
-		"data.json": `{"key": "value"}`,
-	}
-
-	for fileName, content := range excludedFiles {
-		filePath := filepath.Join(configDir, fileName)
-		err = os.WriteFile(filePath, []byte(content), 0600)
-		if err != nil {
-			t.Fatalf("Failed to create %s: %v", fileName, err)
-		}
-	}
-
-	// Test hosts that should be found
-	existingHosts := []string{"main-host", "another-host", "included-host", "production-server"}
-	for _, hostName := range existingHosts {
-		found, err := QuickHostExistsInFile(hostName, mainConfig)
-		if err != nil {
-			t.Errorf("QuickHostExistsInFile(%q) error = %v", hostName, err)
-		}
-		if !found {
-			t.Errorf("QuickHostExistsInFile(%q) = false, want true", hostName)
-		}
-	}
-
-	// Test hosts that should NOT be found
-	nonExistingHosts := []string{"nonexistent-host", "fake-server", "unknown"}
-	for _, hostName := range nonExistingHosts {
-		found, err := QuickHostExistsInFile(hostName, mainConfig)
-		if err != nil {
-			t.Errorf("QuickHostExistsInFile(%q) error = %v", hostName, err)
-		}
-		if found {
-			t.Errorf("QuickHostExistsInFile(%q) = true, want false", 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

@@ -1,7 +1,6 @@
 package ui
 
 import (
-	"fmt"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -17,7 +16,6 @@ import (
 type addFormModel struct {
 	inputs     []textinput.Model
 	focused    int
-	currentTab int // 0 = General, 1 = Advanced
 	err        string
 	styles     Styles
 	success    bool
@@ -49,7 +47,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, 8)
 
 	// Name input
 	inputs[nameInput] = textinput.New()
@@ -103,22 +101,9 @@ func NewAddForm(hostname string, styles Styles, width, height int, configFile st
 	inputs[tagsInput].CharLimit = 200
 	inputs[tagsInput].Width = 50
 
-	// Remote Command input
-	inputs[remoteCommandInput] = textinput.New()
-	inputs[remoteCommandInput].Placeholder = "ls -la, htop, bash"
-	inputs[remoteCommandInput].CharLimit = 300
-	inputs[remoteCommandInput].Width = 70
-
-	// RequestTTY input
-	inputs[requestTTYInput] = textinput.New()
-	inputs[requestTTYInput].Placeholder = "yes, no, force, auto"
-	inputs[requestTTYInput].CharLimit = 10
-	inputs[requestTTYInput].Width = 30
-
 	return &addFormModel{
 		inputs:     inputs,
 		focused:    nameInput,
-		currentTab: tabGeneral, // Start on General tab
 		styles:     styles,
 		width:      width,
 		height:     height,
@@ -126,11 +111,6 @@ func NewAddForm(hostname string, styles Styles, width, height int, configFile st
 	}
 }
 
-const (
-	tabGeneral = iota
-	tabAdvanced
-)
-
 const (
 	nameInput = iota
 	hostnameInput
@@ -138,11 +118,8 @@ const (
 	portInput
 	identityInput
 	proxyJumpInput
-	tagsInput
-	// Advanced tab inputs
 	optionsInput
-	remoteCommandInput
-	requestTTYInput
+	tagsInput
 )
 
 // Messages for communication with parent model
@@ -176,20 +153,36 @@ func (m *addFormModel) Update(msg tea.Msg) (*addFormModel, tea.Cmd) {
 			// Allow submission from any field with Ctrl+S (Save)
 			return m, m.submitForm()
 
-		case "ctrl+j":
-			// Switch to next tab
-			m.currentTab = (m.currentTab + 1) % 2
-			m.focused = m.getFirstInputForTab(m.currentTab)
-			return m, m.updateFocus()
-
-		case "ctrl+k":
-			// Switch to previous tab
-			m.currentTab = (m.currentTab - 1 + 2) % 2
-			m.focused = m.getFirstInputForTab(m.currentTab)
-			return m, m.updateFocus()
-
 		case "tab", "shift+tab", "enter", "up", "down":
-			return m, m.handleNavigation(msg.String())
+			s := msg.String()
+
+			// Handle form submission
+			if s == "enter" && m.focused == len(m.inputs)-1 {
+				return m, m.submitForm()
+			}
+
+			// Cycle inputs
+			if s == "up" || s == "shift+tab" {
+				m.focused--
+			} else {
+				m.focused++
+			}
+
+			if m.focused > len(m.inputs)-1 {
+				m.focused = 0
+			} else if m.focused < 0 {
+				m.focused = len(m.inputs) - 1
+			}
+
+			for i := range m.inputs {
+				if i == m.focused {
+					cmds = append(cmds, m.inputs[i].Focus())
+					continue
+				}
+				m.inputs[i].Blur()
+			}
+
+			return m, tea.Batch(cmds...)
 		}
 
 	case addFormSubmitMsg:
@@ -213,104 +206,32 @@ func (m *addFormModel) Update(msg tea.Msg) (*addFormModel, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
-// getFirstInputForTab returns the first input index for a given tab
-func (m *addFormModel) getFirstInputForTab(tab int) int {
-	switch tab {
-	case tabGeneral:
-		return nameInput
-	case tabAdvanced:
-		return optionsInput
-	default:
-		return nameInput
-	}
-}
-
-// getInputsForCurrentTab returns the input indices for the current tab
-func (m *addFormModel) getInputsForCurrentTab() []int {
-	switch m.currentTab {
-	case tabGeneral:
-		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, tagsInput}
-	case tabAdvanced:
-		return []int{optionsInput, remoteCommandInput, requestTTYInput}
-	default:
-		return []int{nameInput, hostnameInput, userInput, portInput, identityInput, proxyJumpInput, tagsInput}
-	}
-}
-
-// updateFocus updates focus for inputs
-func (m *addFormModel) updateFocus() tea.Cmd {
-	var cmds []tea.Cmd
-	for i := range m.inputs {
-		if i == m.focused {
-			cmds = append(cmds, m.inputs[i].Focus())
-		} else {
-			m.inputs[i].Blur()
-		}
-	}
-	return tea.Batch(cmds...)
-}
-
-// handleNavigation handles tab/arrow navigation within the current tab
-func (m *addFormModel) handleNavigation(key string) tea.Cmd {
-	currentTabInputs := m.getInputsForCurrentTab()
-
-	// Find current position within the tab
-	currentPos := 0
-	for i, input := range currentTabInputs {
-		if input == m.focused {
-			currentPos = i
-			break
-		}
-	}
-
-	// Handle form submission on last field of Advanced tab
-	if key == "enter" && m.currentTab == tabAdvanced && currentPos == len(currentTabInputs)-1 {
-		return m.submitForm()
-	}
-
-	// Navigate within current tab
-	if key == "up" || key == "shift+tab" {
-		currentPos--
-	} else {
-		currentPos++
-	}
-
-	// Wrap around within current tab
-	if currentPos >= len(currentTabInputs) {
-		currentPos = 0
-	} else if currentPos < 0 {
-		currentPos = len(currentTabInputs) - 1
-	}
-
-	m.focused = currentTabInputs[currentPos]
-	return m.updateFocus()
-}
-
 func (m *addFormModel) View() string {
 	if m.success {
 		return ""
 	}
 
-	// Check if terminal height is sufficient
-	if !m.isHeightSufficient() {
-		return m.renderHeightWarning()
-	}
-
 	var b strings.Builder
 
 	b.WriteString(m.styles.FormTitle.Render("Add SSH Host Configuration"))
 	b.WriteString("\n\n")
 
-	// Render tabs
-	b.WriteString(m.renderTabs())
-	b.WriteString("\n\n")
+	fields := []string{
+		"Host Name *",
+		"Hostname/IP *",
+		"User",
+		"Port",
+		"Identity File",
+		"ProxyJump",
+		"SSH Options",
+		"Tags (comma-separated)",
+	}
 
-	// Render current tab content
-	switch m.currentTab {
-	case tabGeneral:
-		b.WriteString(m.renderGeneralTab())
-	case tabAdvanced:
-		b.WriteString(m.renderAdvancedTab())
+	for i, field := range fields {
+		b.WriteString(m.styles.FormField.Render(field))
+		b.WriteString("\n")
+		b.WriteString(m.inputs[i].View())
+		b.WriteString("\n\n")
 	}
 
 	if m.err != "" {
@@ -318,133 +239,13 @@ func (m *addFormModel) View() string {
 		b.WriteString("\n\n")
 	}
 
-	// Help text
-	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Ctrl+J/K: switch tabs"))
-	b.WriteString("\n")
-	b.WriteString(m.styles.FormHelp.Render("Enter on last field: submit • Ctrl+S: save • Ctrl+C/Esc: cancel"))
+	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+S: save • Ctrl+C/Esc: cancel"))
 	b.WriteString("\n")
 	b.WriteString(m.styles.FormHelp.Render("* Required fields"))
 
 	return b.String()
 }
 
-// getMinimumHeight calculates the minimum height needed to display the form
-func (m *addFormModel) getMinimumHeight() int {
-	// Title: 1 line + 2 newlines = 3
-	titleLines := 3
-	// Tabs: 1 line + 2 newlines = 3
-	tabLines := 3
-	// Fields in current tab
-	var fieldsCount int
-	if m.currentTab == tabGeneral {
-		fieldsCount = 7 // 7 fields in general tab
-	} else {
-		fieldsCount = 3 // 3 fields in advanced tab
-	}
-	// Each field: label (1) + input (1) + spacing (2) = 4 lines per field, but let's be more conservative
-	fieldsLines := fieldsCount * 3 // Reduced from 4 to 3
-	// Help text: 3 lines
-	helpLines := 3
-	// Error message space when needed: 2 lines
-	errorLines := 0 // Only count when there's actually an error
-	if m.err != "" {
-		errorLines = 2
-	}
-
-	return titleLines + tabLines + fieldsLines + helpLines + errorLines + 1 // +1 minimal safety margin
-}
-
-// isHeightSufficient checks if the current terminal height is sufficient
-func (m *addFormModel) isHeightSufficient() bool {
-	return m.height >= m.getMinimumHeight()
-}
-
-// renderHeightWarning renders a warning message when height is insufficient
-func (m *addFormModel) renderHeightWarning() string {
-	required := m.getMinimumHeight()
-	current := m.height
-
-	warning := m.styles.ErrorText.Render("⚠️  Terminal height is too small!")
-	details := m.styles.FormField.Render(fmt.Sprintf("Current: %d lines, Required: %d lines", current, required))
-	instruction := m.styles.FormHelp.Render("Please resize your terminal window and try again.")
-	instruction2 := m.styles.FormHelp.Render("Press Ctrl+C to cancel or resize terminal window.")
-
-	return warning + "\n\n" + details + "\n\n" + instruction + "\n" + instruction2
-}
-
-// renderTabs renders the tab headers
-func (m *addFormModel) renderTabs() string {
-	var generalTab, advancedTab string
-
-	if m.currentTab == tabGeneral {
-		generalTab = m.styles.FocusedLabel.Render("[ General ]")
-		advancedTab = m.styles.FormField.Render("  Advanced  ")
-	} else {
-		generalTab = m.styles.FormField.Render("  General  ")
-		advancedTab = m.styles.FocusedLabel.Render("[ Advanced ]")
-	}
-
-	return generalTab + "  " + advancedTab
-}
-
-// renderGeneralTab renders the general tab content
-func (m *addFormModel) renderGeneralTab() string {
-	var b strings.Builder
-
-	fields := []struct {
-		index int
-		label string
-	}{
-		{nameInput, "Host Name *"},
-		{hostnameInput, "Hostname/IP *"},
-		{userInput, "User"},
-		{portInput, "Port"},
-		{identityInput, "Identity File"},
-		{proxyJumpInput, "ProxyJump"},
-		{tagsInput, "Tags (comma-separated)"},
-	}
-
-	for _, field := range fields {
-		fieldStyle := m.styles.FormField
-		if m.focused == field.index {
-			fieldStyle = m.styles.FocusedLabel
-		}
-		b.WriteString(fieldStyle.Render(field.label))
-		b.WriteString("\n")
-		b.WriteString(m.inputs[field.index].View())
-		b.WriteString("\n\n")
-	}
-
-	return b.String()
-}
-
-// renderAdvancedTab renders the advanced tab content
-func (m *addFormModel) renderAdvancedTab() string {
-	var b strings.Builder
-
-	fields := []struct {
-		index int
-		label string
-	}{
-		{optionsInput, "SSH Options"},
-		{remoteCommandInput, "Remote Command"},
-		{requestTTYInput, "Request TTY"},
-	}
-
-	for _, field := range fields {
-		fieldStyle := m.styles.FormField
-		if m.focused == field.index {
-			fieldStyle = m.styles.FocusedLabel
-		}
-		b.WriteString(fieldStyle.Render(field.label))
-		b.WriteString("\n")
-		b.WriteString(m.inputs[field.index].View())
-		b.WriteString("\n\n")
-	}
-
-	return b.String()
-}
-
 // Standalone wrapper for add form
 type standaloneAddForm struct {
 	*addFormModel
@@ -490,8 +291,6 @@ func (m *addFormModel) submitForm() tea.Cmd {
 		identity := strings.TrimSpace(m.inputs[identityInput].Value())
 		proxyJump := strings.TrimSpace(m.inputs[proxyJumpInput].Value())
 		options := strings.TrimSpace(m.inputs[optionsInput].Value())
-		remoteCommand := strings.TrimSpace(m.inputs[remoteCommandInput].Value())
-		requestTTY := strings.TrimSpace(m.inputs[requestTTYInput].Value())
 
 		// Set defaults
 		if user == "" {
@@ -520,16 +319,14 @@ func (m *addFormModel) submitForm() tea.Cmd {
 
 		// Create host configuration
 		host := config.SSHHost{
-			Name:          name,
-			Hostname:      hostname,
-			User:          user,
-			Port:          port,
-			Identity:      identity,
-			ProxyJump:     proxyJump,
-			Options:       config.ParseSSHOptionsFromCommand(options),
-			RemoteCommand: remoteCommand,
-			RequestTTY:    requestTTY,
-			Tags:          tags,
+			Name:      name,
+			Hostname:  hostname,
+			User:      user,
+			Port:      port,
+			Identity:  identity,
+			ProxyJump: proxyJump,
+			Options:   config.ParseSSHOptionsFromCommand(options),
+			Tags:      tags,
 		}
 
 		// Add to config

internal/ui/edit_form.go

@@ -1,7 +1,6 @@
 package ui
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/Gu1llaum-3/sshm/internal/config"
@@ -9,38 +8,23 @@ import (
 
 	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
-const (
-	focusAreaHosts = iota
-	focusAreaProperties
-)
-
-type editFormSubmitMsg struct {
-	hostname string
-	err      error
-}
-
-type editFormCancelMsg struct{}
-
 type editFormModel struct {
-	hostInputs       []textinput.Model // Support for multiple hosts
-	inputs           []textinput.Model
-	focusArea        int // 0=hosts, 1=properties
-	focused          int
-	currentTab       int // 0=General, 1=Advanced (only applies when focusArea == focusAreaProperties)
-	err              string
-	styles           Styles
-	originalName     string
-	originalHosts    []string        // Store original host names for multi-host detection
-	host             *config.SSHHost // Store the original host with SourceFile
-	configFile       string          // Configuration file path passed by user
-	actualConfigFile string          // Actual config file to use (either configFile or host.SourceFile)
-	width            int
-	height           int
+	inputs       []textinput.Model
+	focused      int
+	err          string
+	success      bool
+	styles       Styles
+	originalName string
+	host         *config.SSHHost // Store the original host with SourceFile
+	width        int
+	height       int
+	configFile   string
 }
 
-// NewEditForm creates a new edit form model that supports both single and multi-host editing
+// NewEditForm creates a new edit form model
 func NewEditForm(hostName string, styles Styles, width, height int, configFile string) (*editFormModel, error) {
 	// Get the existing host configuration
 	var host *config.SSHHost
@@ -56,482 +40,207 @@ func NewEditForm(hostName string, styles Styles, width, height int, configFile s
 		return nil, err
 	}
 
-	// Check if this host is part of a multi-host declaration
-	var actualConfigFile string
-	var hostNames []string
-	var isMulti bool
+	inputs := make([]textinput.Model, 8)
 
-	if configFile != "" {
-		actualConfigFile = configFile
-	} else {
-		actualConfigFile = host.SourceFile
-	}
-
-	if actualConfigFile != "" {
-		isMulti, hostNames, err = config.IsPartOfMultiHostDeclaration(hostName, actualConfigFile)
-		if err != nil {
-			// If we can't determine multi-host status, treat as single host
-			isMulti = false
-			hostNames = []string{hostName}
-		}
-	}
-
-	if !isMulti {
-		hostNames = []string{hostName}
-	}
-
-	// Create host inputs
-	hostInputs := make([]textinput.Model, len(hostNames))
-	for i, name := range hostNames {
-		hostInputs[i] = textinput.New()
-		hostInputs[i].Placeholder = "host-name"
-		hostInputs[i].SetValue(name)
-		if i == 0 {
-			hostInputs[i].Focus()
-		}
-	}
-
-	inputs := make([]textinput.Model, 9) // Increased from 8 to 9 for RequestTTY
+	// Name input
+	inputs[nameInput] = textinput.New()
+	inputs[nameInput].Placeholder = "server-name"
+	inputs[nameInput].Focus()
+	inputs[nameInput].CharLimit = 50
+	inputs[nameInput].Width = 30
+	inputs[nameInput].SetValue(host.Name)
 
 	// Hostname input
-	inputs[0] = textinput.New()
-	inputs[0].Placeholder = "192.168.1.100 or example.com"
-	inputs[0].CharLimit = 100
-	inputs[0].Width = 30
-	inputs[0].SetValue(host.Hostname)
+	inputs[hostnameInput] = textinput.New()
+	inputs[hostnameInput].Placeholder = "192.168.1.100 or example.com"
+	inputs[hostnameInput].CharLimit = 100
+	inputs[hostnameInput].Width = 30
+	inputs[hostnameInput].SetValue(host.Hostname)
 
 	// User input
-	inputs[1] = textinput.New()
-	inputs[1].Placeholder = "root"
-	inputs[1].CharLimit = 50
-	inputs[1].Width = 30
-	inputs[1].SetValue(host.User)
+	inputs[userInput] = textinput.New()
+	inputs[userInput].Placeholder = "root"
+	inputs[userInput].CharLimit = 50
+	inputs[userInput].Width = 30
+	inputs[userInput].SetValue(host.User)
 
 	// Port input
-	inputs[2] = textinput.New()
-	inputs[2].Placeholder = "22"
-	inputs[2].CharLimit = 5
-	inputs[2].Width = 30
-	inputs[2].SetValue(host.Port)
+	inputs[portInput] = textinput.New()
+	inputs[portInput].Placeholder = "22"
+	inputs[portInput].CharLimit = 5
+	inputs[portInput].Width = 30
+	inputs[portInput].SetValue(host.Port)
 
 	// Identity input
-	inputs[3] = textinput.New()
-	inputs[3].Placeholder = "~/.ssh/id_rsa"
-	inputs[3].CharLimit = 200
-	inputs[3].Width = 50
-	inputs[3].SetValue(host.Identity)
+	inputs[identityInput] = textinput.New()
+	inputs[identityInput].Placeholder = "~/.ssh/id_rsa"
+	inputs[identityInput].CharLimit = 200
+	inputs[identityInput].Width = 50
+	inputs[identityInput].SetValue(host.Identity)
 
 	// ProxyJump input
-	inputs[4] = textinput.New()
-	inputs[4].Placeholder = "jump-server"
-	inputs[4].CharLimit = 100
-	inputs[4].Width = 30
-	inputs[4].SetValue(host.ProxyJump)
+	inputs[proxyJumpInput] = textinput.New()
+	inputs[proxyJumpInput].Placeholder = "user@jump-host:port or existing-host-name"
+	inputs[proxyJumpInput].CharLimit = 200
+	inputs[proxyJumpInput].Width = 50
+	inputs[proxyJumpInput].SetValue(host.ProxyJump)
 
-	// Options input
-	inputs[5] = textinput.New()
-	inputs[5].Placeholder = "-o StrictHostKeyChecking=no"
-	inputs[5].CharLimit = 200
-	inputs[5].Width = 50
-	if host.Options != "" {
-		inputs[5].SetValue(config.FormatSSHOptionsForCommand(host.Options))
-	}
+	// SSH Options input
+	inputs[optionsInput] = textinput.New()
+	inputs[optionsInput].Placeholder = "-o Compression=yes -o ServerAliveInterval=60"
+	inputs[optionsInput].CharLimit = 500
+	inputs[optionsInput].Width = 70
+	inputs[optionsInput].SetValue(config.FormatSSHOptionsForCommand(host.Options))
 
 	// Tags input
-	inputs[6] = textinput.New()
-	inputs[6].Placeholder = "production, web, database"
-	inputs[6].CharLimit = 200
-	inputs[6].Width = 50
+	inputs[tagsInput] = textinput.New()
+	inputs[tagsInput].Placeholder = "production, web, database"
+	inputs[tagsInput].CharLimit = 200
+	inputs[tagsInput].Width = 50
 	if len(host.Tags) > 0 {
-		inputs[6].SetValue(strings.Join(host.Tags, ", "))
+		inputs[tagsInput].SetValue(strings.Join(host.Tags, ", "))
 	}
 
-	// Remote Command input
-	inputs[7] = textinput.New()
-	inputs[7].Placeholder = "ls -la, htop, bash"
-	inputs[7].CharLimit = 300
-	inputs[7].Width = 70
-	inputs[7].SetValue(host.RemoteCommand)
-
-	// RequestTTY input
-	inputs[8] = textinput.New()
-	inputs[8].Placeholder = "yes, no, force, auto"
-	inputs[8].CharLimit = 10
-	inputs[8].Width = 30
-	inputs[8].SetValue(host.RequestTTY)
-
 	return &editFormModel{
-		hostInputs:       hostInputs,
-		inputs:           inputs,
-		focusArea:        focusAreaHosts, // Start with hosts focused for multi-host editing
-		focused:          0,
-		currentTab:       0, // Start on General tab
-		originalName:     hostName,
-		originalHosts:    hostNames,
-		host:             host,
-		configFile:       configFile,
-		actualConfigFile: actualConfigFile,
-		styles:           styles,
-		width:            width,
-		height:           height,
+		inputs:       inputs,
+		focused:      nameInput,
+		originalName: hostName,
+		host:         host,
+		configFile:   configFile,
+		styles:       styles,
+		width:        width,
+		height:       height,
 	}, nil
 }
 
+// Messages for communication with parent model
+type editFormSubmitMsg struct {
+	hostname string
+	err      error
+}
+
+type editFormCancelMsg struct{}
+
 func (m *editFormModel) Init() tea.Cmd {
 	return textinput.Blink
 }
 
-// addHostInput adds a new empty host input
-func (m *editFormModel) addHostInput() tea.Cmd {
-	newInput := textinput.New()
-	newInput.Placeholder = "host-name"
-	newInput.Focus()
-
-	// Unfocus current input regardless of which area we're in
-	if m.focusArea == focusAreaHosts && m.focused < len(m.hostInputs) {
-		m.hostInputs[m.focused].Blur()
-	} else if m.focusArea == focusAreaProperties && m.focused < len(m.inputs) {
-		m.inputs[m.focused].Blur()
-	}
-
-	m.hostInputs = append(m.hostInputs, newInput)
-
-	// Move focus to the new host input
-	m.focusArea = focusAreaHosts
-	m.focused = len(m.hostInputs) - 1
-
-	return textinput.Blink
-}
-
-// deleteHostInput removes the currently focused host input
-func (m *editFormModel) deleteHostInput() tea.Cmd {
-	if len(m.hostInputs) <= 1 || m.focusArea != focusAreaHosts {
-		return nil // Can't delete if only one host or not in host area
-	}
-
-	// Remove the focused host input
-	m.hostInputs = append(m.hostInputs[:m.focused], m.hostInputs[m.focused+1:]...)
-
-	// Adjust focus
-	if m.focused >= len(m.hostInputs) {
-		m.focused = len(m.hostInputs) - 1
-	}
-
-	// Focus the new current input
-	if len(m.hostInputs) > 0 {
-		m.hostInputs[m.focused].Focus()
-	}
-
-	return nil
-}
-
-// updateFocus updates the focus state based on current area and index
-func (m *editFormModel) updateFocus() tea.Cmd {
-	// Blur all inputs first
-	for i := range m.hostInputs {
-		m.hostInputs[i].Blur()
-	}
-	for i := range m.inputs {
-		m.inputs[i].Blur()
-	}
-
-	// Focus the appropriate input
-	if m.focusArea == focusAreaHosts {
-		if m.focused < len(m.hostInputs) {
-			m.hostInputs[m.focused].Focus()
-		}
-	} else {
-		if m.focused < len(m.inputs) {
-			m.inputs[m.focused].Focus()
-		}
-	}
-
-	return textinput.Blink
-}
-
-// getPropertiesForCurrentTab returns the property input indices for the current tab
-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
-	case 1: // Advanced
-		return []int{5, 7, 8} // options, remotecommand, requesttty
-	default:
-		return []int{0, 1, 2, 3, 4, 6}
-	}
-}
-
-// 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
-	if tab == 1 {
-		properties = []int{5, 7, 8} // Advanced tab
-	}
-	if len(properties) > 0 {
-		return properties[0]
-	}
-	return 0
-}
-
-// handleEditNavigation handles navigation in the edit form with tab support
-func (m *editFormModel) handleEditNavigation(key string) tea.Cmd {
-	if m.focusArea == focusAreaHosts {
-		// Navigate in hosts area
-		if key == "up" || key == "shift+tab" {
-			m.focused--
-		} else {
-			m.focused++
-		}
-
-		if m.focused >= len(m.hostInputs) {
-			// Move to properties area, keep current tab
-			m.focusArea = focusAreaProperties
-			// Keep the current tab instead of forcing it to 0
-			m.focused = m.getFirstPropertyForTab(m.currentTab)
-		} else if m.focused < 0 {
-			m.focused = len(m.hostInputs) - 1
-		}
-	} else {
-		// Navigate in properties area within current tab
-		currentTabProperties := m.getPropertiesForCurrentTab()
-
-		// Find current position within the tab
-		currentPos := 0
-		for i, prop := range currentTabProperties {
-			if prop == m.focused {
-				currentPos = i
-				break
-			}
-		}
-
-		// Handle form submission on last field of Advanced tab
-		if key == "enter" && m.currentTab == 1 && currentPos == len(currentTabProperties)-1 {
-			return m.submitEditForm()
-		}
-
-		// Navigate within current tab
-		if key == "up" || key == "shift+tab" {
-			currentPos--
-		} else {
-			currentPos++
-		}
-
-		// Handle transitions between areas and tabs
-		if currentPos >= len(currentTabProperties) {
-			// Move to next area/tab
-			if m.currentTab == 0 {
-				// Move to advanced tab
-				m.currentTab = 1
-				m.focused = m.getFirstPropertyForTab(1)
-			} else {
-				// Move back to hosts area
-				m.focusArea = focusAreaHosts
-				m.focused = 0
-			}
-		} else if currentPos < 0 {
-			// Move to previous area/tab
-			if m.currentTab == 1 {
-				// Move to general tab
-				m.currentTab = 0
-				properties := m.getPropertiesForCurrentTab()
-				m.focused = properties[len(properties)-1]
-			} else {
-				// Move to hosts area
-				m.focusArea = focusAreaHosts
-				m.focused = len(m.hostInputs) - 1
-			}
-		} else {
-			m.focused = currentTabProperties[currentPos]
-		}
-	}
-
-	return m.updateFocus()
-}
-
-// getMinimumHeight calculates the minimum height needed to display the edit form
-func (m *editFormModel) getMinimumHeight() int {
-	// Title: 1 line + 2 newlines = 3
-	titleLines := 3
-	// Config file info: 1 line + 2 newlines = 3
-	configLines := 3
-	// Host Names section: title (1) + spacing (2) = 3
-	hostSectionLines := 3
-	// Host inputs: number of hosts * 3 lines each (reduced from 4)
-	hostLines := len(m.hostInputs) * 3
-	// Properties section: title (1) + spacing (2) = 3
-	propertiesSectionLines := 3
-	// Tabs: 1 line + 2 newlines = 3
-	tabLines := 3
-	// Fields in current tab
-	var fieldsCount int
-	if m.currentTab == 0 {
-		fieldsCount = 6 // 6 fields in general tab
-	} else {
-		fieldsCount = 3 // 3 fields in advanced tab
-	}
-	// Each field: reduced from 4 to 3 lines per field
-	fieldsLines := fieldsCount * 3
-	// Help text: 3 lines
-	helpLines := 3
-	// Error message space when needed: 2 lines
-	errorLines := 0 // Only count when there's actually an error
-	if m.err != "" {
-		errorLines = 2
-	}
-
-	return titleLines + configLines + hostSectionLines + hostLines + propertiesSectionLines + tabLines + fieldsLines + helpLines + errorLines + 1 // +1 minimal safety margin
-}
-
-// isHeightSufficient checks if the current terminal height is sufficient
-func (m *editFormModel) isHeightSufficient() bool {
-	return m.height >= m.getMinimumHeight()
-}
-
-// renderHeightWarning renders a warning message when height is insufficient
-func (m *editFormModel) renderHeightWarning() string {
-	required := m.getMinimumHeight()
-	current := m.height
-
-	warning := m.styles.ErrorText.Render("⚠️  Terminal height is too small!")
-	details := m.styles.FormField.Render(fmt.Sprintf("Current: %d lines, Required: %d lines", current, required))
-	instruction := m.styles.FormHelp.Render("Please resize your terminal window and try again.")
-	instruction2 := m.styles.FormHelp.Render("Press Ctrl+C to cancel or resize terminal window.")
-
-	return warning + "\n\n" + details + "\n\n" + instruction + "\n" + instruction2
-}
-
-func (m *editFormModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+func (m *editFormModel) Update(msg tea.Msg) (*editFormModel, tea.Cmd) {
 	var cmds []tea.Cmd
 
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
 		m.width = msg.Width
 		m.height = msg.Height
+		m.styles = NewStyles(m.width)
+		return m, nil
 
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "esc":
-			m.err = ""
 			return m, func() tea.Msg { return editFormCancelMsg{} }
 
 		case "ctrl+s":
 			// Allow submission from any field with Ctrl+S (Save)
 			return m, m.submitEditForm()
 
-		case "ctrl+j":
-			// Switch to next tab
-			m.currentTab = (m.currentTab + 1) % 2
-			// If we're in hosts area, stay there. If in properties, go to the first field of the new tab
-			if m.focusArea == focusAreaProperties {
-				m.focused = m.getFirstPropertyForTab(m.currentTab)
-			}
-			return m, m.updateFocus()
-
-		case "ctrl+k":
-			// Switch to previous tab
-			m.currentTab = (m.currentTab - 1 + 2) % 2
-			// If we're in hosts area, stay there. If in properties, go to the first field of the new tab
-			if m.focusArea == focusAreaProperties {
-				m.focused = m.getFirstPropertyForTab(m.currentTab)
-			}
-			return m, m.updateFocus()
-
 		case "tab", "shift+tab", "enter", "up", "down":
-			return m, m.handleEditNavigation(msg.String())
+			s := msg.String()
 
-		case "ctrl+a":
-			// Add a new host input
-			return m, m.addHostInput()
-
-		case "ctrl+d":
-			// Delete the currently focused host (if more than one exists)
-			if m.focusArea == focusAreaHosts && len(m.hostInputs) > 1 {
-				return m, m.deleteHostInput()
+			// Handle form submission
+			if s == "enter" && m.focused == len(m.inputs)-1 {
+				return m, m.submitEditForm()
 			}
+
+			// Cycle inputs
+			if s == "up" || s == "shift+tab" {
+				m.focused--
+			} else {
+				m.focused++
+			}
+
+			if m.focused > len(m.inputs)-1 {
+				m.focused = 0
+			} else if m.focused < 0 {
+				m.focused = len(m.inputs) - 1
+			}
+
+			for i := range m.inputs {
+				if i == m.focused {
+					cmds = append(cmds, m.inputs[i].Focus())
+					continue
+				}
+				m.inputs[i].Blur()
+			}
+
+			return m, tea.Batch(cmds...)
 		}
 
 	case editFormSubmitMsg:
 		if msg.err != nil {
 			m.err = msg.err.Error()
 		} else {
-			// Success: let the wrapper handle this
-			// In TUI mode, this will be handled by the parent
-			// In standalone mode, the wrapper will quit
+			m.success = true
+			m.err = ""
+			// Don't quit here, let parent handle the success
 		}
 		return m, nil
 	}
 
-	// Update host inputs
-	hostCmd := make([]tea.Cmd, len(m.hostInputs))
-	for i := range m.hostInputs {
-		m.hostInputs[i], hostCmd[i] = m.hostInputs[i].Update(msg)
-	}
-	cmds = append(cmds, hostCmd...)
-
-	// Update property inputs
-	propCmd := make([]tea.Cmd, len(m.inputs))
+	// Update inputs
+	cmd := make([]tea.Cmd, len(m.inputs))
 	for i := range m.inputs {
-		m.inputs[i], propCmd[i] = m.inputs[i].Update(msg)
+		m.inputs[i], cmd[i] = m.inputs[i].Update(msg)
 	}
-	cmds = append(cmds, propCmd...)
+	cmds = append(cmds, cmd...)
 
 	return m, tea.Batch(cmds...)
 }
 
 func (m *editFormModel) View() string {
-	// Check if terminal height is sufficient
-	if !m.isHeightSufficient() {
-		return m.renderHeightWarning()
+	if m.success {
+		return ""
 	}
 
 	var b strings.Builder
 
-	if m.err != "" {
-		b.WriteString(m.styles.Error.Render("Error: " + m.err))
-		b.WriteString("\n\n")
-	}
-
-	b.WriteString(m.styles.Header.Render("Edit SSH Host"))
-	b.WriteString("\n\n")
+	b.WriteString(m.styles.FormTitle.Render("Edit SSH Host Configuration"))
+	b.WriteString("\n")
 
+	// Show source file information
 	if m.host != nil && m.host.SourceFile != "" {
-		labelStyle := m.styles.FormField
-		pathStyle := m.styles.FormField
+		b.WriteString("\n") // Ligne d'espace avant Config file
+
+		// Style for "Config file:" label in primary color
+		labelStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#00ADD8")). // Primary color
+			Bold(true)
+
+		// Style for the file path in white
+		pathStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FFFFFF"))
+
 		configInfo := labelStyle.Render("Config file: ") + pathStyle.Render(formatConfigFile(m.host.SourceFile))
 		b.WriteString(configInfo)
 	}
-
 	b.WriteString("\n\n")
 
-	// Host Names Section
-	b.WriteString(m.styles.FormTitle.Render("Host Names"))
-	b.WriteString("\n\n")
-
-	for i, hostInput := range m.hostInputs {
-		hostStyle := m.styles.FormField
-		if m.focusArea == focusAreaHosts && m.focused == i {
-			hostStyle = m.styles.FocusedLabel
-		}
-		b.WriteString(hostStyle.Render(fmt.Sprintf("Host Name %d *", i+1)))
-		b.WriteString("\n")
-		b.WriteString(hostInput.View())
-		b.WriteString("\n\n")
+	fields := []string{
+		"Host Name *",
+		"Hostname/IP *",
+		"User",
+		"Port",
+		"Identity File",
+		"ProxyJump",
+		"SSH Options",
+		"Tags (comma-separated)",
 	}
 
-	// Properties Section
-	b.WriteString(m.styles.FormTitle.Render("Common Properties"))
-	b.WriteString("\n\n")
-
-	// Render tabs for properties
-	b.WriteString(m.renderEditTabs())
-	b.WriteString("\n\n")
-
-	// Render current tab content
-	switch m.currentTab {
-	case 0: // General
-		b.WriteString(m.renderEditGeneralTab())
-	case 1: // Advanced
-		b.WriteString(m.renderEditAdvancedTab())
+	for i, field := range fields {
+		b.WriteString(m.styles.FormField.Render(field))
+		b.WriteString("\n")
+		b.WriteString(m.inputs[i].View())
+		b.WriteString("\n\n")
 	}
 
 	if m.err != "" {
@@ -539,87 +248,9 @@ func (m *editFormModel) View() string {
 		b.WriteString("\n\n")
 	}
 
-	// Show different help based on number of hosts
-	if len(m.hostInputs) > 1 {
-		b.WriteString(m.styles.FormHelp.Render("Tab/↑↓/Enter: navigate • Ctrl+J/K: switch tabs • Ctrl+A: add host • Ctrl+D: delete host"))
-		b.WriteString("\n")
-	} else {
-		b.WriteString(m.styles.FormHelp.Render("Tab/↑↓/Enter: navigate • Ctrl+J/K: switch tabs • Ctrl+A: add host"))
-		b.WriteString("\n")
-	}
-	b.WriteString(m.styles.FormHelp.Render("Ctrl+S: save • Ctrl+C/Esc: cancel • * Required fields"))
-
-	return b.String()
-}
-
-// renderEditTabs renders the tab headers for properties
-func (m *editFormModel) renderEditTabs() string {
-	var generalTab, advancedTab string
-
-	if m.currentTab == 0 {
-		generalTab = m.styles.FocusedLabel.Render("[ General ]")
-		advancedTab = m.styles.FormField.Render("  Advanced  ")
-	} else {
-		generalTab = m.styles.FormField.Render("  General  ")
-		advancedTab = m.styles.FocusedLabel.Render("[ Advanced ]")
-	}
-
-	return generalTab + "  " + advancedTab
-}
-
-// renderEditGeneralTab renders the general tab content for properties
-func (m *editFormModel) renderEditGeneralTab() string {
-	var b strings.Builder
-
-	fields := []struct {
-		index int
-		label string
-	}{
-		{0, "Hostname/IP *"},
-		{1, "User"},
-		{2, "Port"},
-		{3, "Identity File"},
-		{4, "Proxy Jump"},
-		{6, "Tags (comma-separated)"},
-	}
-
-	for _, field := range fields {
-		fieldStyle := m.styles.FormField
-		if m.focusArea == focusAreaProperties && m.focused == field.index {
-			fieldStyle = m.styles.FocusedLabel
-		}
-		b.WriteString(fieldStyle.Render(field.label))
-		b.WriteString("\n")
-		b.WriteString(m.inputs[field.index].View())
-		b.WriteString("\n\n")
-	}
-
-	return b.String()
-}
-
-// renderEditAdvancedTab renders the advanced tab content for properties
-func (m *editFormModel) renderEditAdvancedTab() string {
-	var b strings.Builder
-
-	fields := []struct {
-		index int
-		label string
-	}{
-		{5, "SSH Options"},
-		{7, "Remote Command"},
-		{8, "Request TTY"},
-	}
-
-	for _, field := range fields {
-		fieldStyle := m.styles.FormField
-		if m.focusArea == focusAreaProperties && m.focused == field.index {
-			fieldStyle = m.styles.FocusedLabel
-		}
-		b.WriteString(fieldStyle.Render(field.label))
-		b.WriteString("\n")
-		b.WriteString(m.inputs[field.index].View())
-		b.WriteString("\n\n")
-	}
+	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+S: save • Ctrl+C/Esc: cancel"))
+	b.WriteString("\n")
+	b.WriteString(m.styles.FormHelp.Render("* Required fields"))
 
 	return b.String()
 }
@@ -634,29 +265,29 @@ func (m standaloneEditForm) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case editFormSubmitMsg:
 		if msg.err != nil {
 			m.editFormModel.err = msg.err.Error()
-			return m, nil
 		} else {
-			// Success: quit the program
+			m.editFormModel.success = true
 			return m, tea.Quit
 		}
+		return m, nil
 	case editFormCancelMsg:
 		return m, tea.Quit
 	}
 
 	newForm, cmd := m.editFormModel.Update(msg)
-	m.editFormModel = newForm.(*editFormModel)
+	m.editFormModel = newForm
 	return m, cmd
 }
 
-// RunEditForm runs the edit form as a standalone program
+// RunEditForm provides backward compatibility for standalone edit form
 func RunEditForm(hostName string, configFile string) error {
-	styles := NewStyles(80) // Default width
+	styles := NewStyles(80)
 	editForm, err := NewEditForm(hostName, styles, 80, 24, configFile)
 	if err != nil {
 		return err
 	}
-
 	m := standaloneEditForm{editForm}
+
 	p := tea.NewProgram(m, tea.WithAltScreen())
 	_, err = p.Run()
 	return err
@@ -664,48 +295,28 @@ func RunEditForm(hostName string, configFile string) error {
 
 func (m *editFormModel) submitEditForm() tea.Cmd {
 	return func() tea.Msg {
-		// Collect host names
-		var hostNames []string
-		for _, input := range m.hostInputs {
-			name := strings.TrimSpace(input.Value())
-			if name != "" {
-				hostNames = append(hostNames, name)
-			}
-		}
-
-		if len(hostNames) == 0 {
-			return editFormSubmitMsg{err: fmt.Errorf("at least one host name is required")}
-		}
-
-		// Get property values using direct indices
-		hostname := strings.TrimSpace(m.inputs[0].Value())      // hostnameInput
-		user := strings.TrimSpace(m.inputs[1].Value())          // userInput
-		port := strings.TrimSpace(m.inputs[2].Value())          // portInput
-		identity := strings.TrimSpace(m.inputs[3].Value())      // identityInput
-		proxyJump := strings.TrimSpace(m.inputs[4].Value())     // proxyJumpInput
-		options := strings.TrimSpace(m.inputs[5].Value())       // optionsInput
-		remoteCommand := strings.TrimSpace(m.inputs[7].Value()) // remoteCommandInput
-		requestTTY := strings.TrimSpace(m.inputs[8].Value())    // requestTTYInput
+		// Get values
+		name := strings.TrimSpace(m.inputs[nameInput].Value())
+		hostname := strings.TrimSpace(m.inputs[hostnameInput].Value())
+		user := strings.TrimSpace(m.inputs[userInput].Value())
+		port := strings.TrimSpace(m.inputs[portInput].Value())
+		identity := strings.TrimSpace(m.inputs[identityInput].Value())
+		proxyJump := strings.TrimSpace(m.inputs[proxyJumpInput].Value())
+		options := strings.TrimSpace(m.inputs[optionsInput].Value())
 
 		// Set defaults
 		if port == "" {
 			port = "22"
 		}
+		// Do not auto-fill identity with placeholder if left empty; keep it empty so it's optional
 
-		// Validate hostname
-		if hostname == "" {
-			return editFormSubmitMsg{err: fmt.Errorf("hostname is required")}
-		}
-
-		// Validate all host names
-		for _, hostName := range hostNames {
-			if err := validation.ValidateHost(hostName, hostname, port, identity); err != nil {
-				return editFormSubmitMsg{err: err}
-			}
+		// Validate all fields
+		if err := validation.ValidateHost(name, hostname, port, identity); err != nil {
+			return editFormSubmitMsg{err: err}
 		}
 
 		// Parse tags
-		tagsStr := strings.TrimSpace(m.inputs[6].Value()) // tagsInput
+		tagsStr := strings.TrimSpace(m.inputs[tagsInput].Value())
 		var tags []string
 		if tagsStr != "" {
 			for _, tag := range strings.Split(tagsStr, ",") {
@@ -716,33 +327,25 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 			}
 		}
 
-		// Create the common host configuration
-		commonHost := config.SSHHost{
-			Hostname:      hostname,
-			User:          user,
-			Port:          port,
-			Identity:      identity,
-			ProxyJump:     proxyJump,
-			Options:       options,
-			RemoteCommand: remoteCommand,
-			RequestTTY:    requestTTY,
-			Tags:          tags,
+		// Create updated host configuration
+		host := config.SSHHost{
+			Name:      name,
+			Hostname:  hostname,
+			User:      user,
+			Port:      port,
+			Identity:  identity,
+			ProxyJump: proxyJump,
+			Options:   config.ParseSSHOptionsFromCommand(options),
+			Tags:      tags,
 		}
 
+		// Update the configuration
 		var err error
-		if len(hostNames) == 1 && len(m.originalHosts) == 1 {
-			// Single host editing
-			commonHost.Name = hostNames[0]
-			if m.actualConfigFile != "" {
-				err = config.UpdateSSHHostInFile(m.originalName, commonHost, m.actualConfigFile)
-			} else {
-				err = config.UpdateSSHHost(m.originalName, commonHost)
-			}
+		if m.configFile != "" {
+			err = config.UpdateSSHHostInFile(m.originalName, host, m.configFile)
 		} else {
-			// Multi-host editing or conversion from single to multi
-			err = config.UpdateMultiHostBlock(m.originalHosts, hostNames, commonHost, m.actualConfigFile)
+			err = config.UpdateSSHHost(m.originalName, host)
 		}
-
-		return editFormSubmitMsg{hostname: hostNames[0], err: err}
+		return editFormSubmitMsg{hostname: name, err: err}
 	}
 }

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/model.go

@@ -42,7 +42,6 @@ const (
 	ViewPortForward
 	ViewHelp
 	ViewFileSelector
-	ViewHistory
 )
 
 // PortForwardType defines the type of port forwarding
@@ -82,7 +81,7 @@ type Model struct {
 	configFile     string // Path to the SSH config file
 
 	// Application configuration
-	appConfig *config.AppConfig
+	appConfig      *config.AppConfig
 
 	// Version update information
 	updateInfo     *version.UpdateInfo
@@ -97,7 +96,6 @@ type Model struct {
 	portForwardForm  *portForwardModel
 	helpForm         *helpModel
 	fileSelectorForm *fileSelectorModel
-	historyView      *HistoryModel
 
 	// Terminal size and styles
 	width  int

internal/ui/sort.go

@@ -37,64 +37,35 @@ func sortHostsByName(hosts []config.SSHHost) []config.SSHHost {
 
 // filterHosts filters hosts according to the search query (name or tags)
 func (m Model) filterHosts(query string) []config.SSHHost {
-	subqueries := strings.Split(query, " ")
-	subqueriesLength := len(subqueries)
-	subfilteredHosts := make([][]config.SSHHost, subqueriesLength)
-	for i, subquery := range subqueries {
-		subfilteredHosts[i] = m.filterHostsByWord(subquery)
-	}
-
-	// return the intersection of search results
-	result := make([]config.SSHHost, 0)
-	tempMap := map[string]int{}
-	for _, hosts := range subfilteredHosts {
-		for _, host := range hosts {
-			if _, ok := tempMap[host.Name]; !ok {
-				tempMap[host.Name] = 1
-			} else {
-				tempMap[host.Name] = tempMap[host.Name] + 1
-			}
-
-			if tempMap[host.Name] == subqueriesLength {
-				result = append(result, host)
-			}
-		}
-	}
-
-	return result
-}
-
-// filterHostsByWord filters hosts according to a single word
-func (m Model) filterHostsByWord(word string) []config.SSHHost {
 	var filtered []config.SSHHost
 
-	if word == "" {
+	if query == "" {
 		filtered = m.hosts
 	} else {
-		word = strings.ToLower(word)
+		query = strings.ToLower(query)
 
 		for _, host := range m.hosts {
 			// Check the hostname
-			if strings.Contains(strings.ToLower(host.Name), word) {
+			if strings.Contains(strings.ToLower(host.Name), query) {
 				filtered = append(filtered, host)
 				continue
 			}
 
 			// Check the hostname
-			if strings.Contains(strings.ToLower(host.Hostname), word) {
+			if strings.Contains(strings.ToLower(host.Hostname), query) {
 				filtered = append(filtered, host)
 				continue
 			}
 
 			// Check the user
-			if strings.Contains(strings.ToLower(host.User), word) {
+			if strings.Contains(strings.ToLower(host.User), query) {
 				filtered = append(filtered, host)
 				continue
 			}
 
 			// Check the tags
 			for _, tag := range host.Tags {
-				if strings.Contains(strings.ToLower(tag), word) {
+				if strings.Contains(strings.ToLower(tag), query) {
 					filtered = append(filtered, host)
 					break
 				}

internal/ui/styles.go

@@ -33,8 +33,7 @@ type Styles struct {
 	HelpText lipgloss.Style
 
 	// Error and confirmation styles
-	Error     lipgloss.Style
-	ErrorText lipgloss.Style
+	Error lipgloss.Style
 
 	// Form styles (for add/edit forms)
 	FormTitle     lipgloss.Style
@@ -63,14 +62,12 @@ func NewStyles(width int) Styles {
 		SearchFocused: lipgloss.NewStyle().
 			BorderStyle(lipgloss.RoundedBorder()).
 			BorderForeground(lipgloss.Color(PrimaryColor)).
-			Padding(0, 1).
-			Width(50), // Fixed width to prevent expansion
+			Padding(0, 1),
 
 		SearchUnfocused: lipgloss.NewStyle().
 			BorderStyle(lipgloss.RoundedBorder()).
 			BorderForeground(lipgloss.Color(SecondaryColor)).
-			Padding(0, 1).
-			Width(50), // Fixed width to prevent expansion
+			Padding(0, 1),
 
 		// Table styles
 		TableFocused: lipgloss.NewStyle().
@@ -100,11 +97,6 @@ func NewStyles(width int) Styles {
 			BorderForeground(lipgloss.Color(ErrorColor)).
 			Padding(1, 2),
 
-		// Error text style (no border, just red text)
-		ErrorText: lipgloss.NewStyle().
-			Foreground(lipgloss.Color(ErrorColor)).
-			Bold(true),
-
 		// Form styles
 		FormTitle: lipgloss.NewStyle().
 			Foreground(lipgloss.Color("#FFFDF5")).

internal/ui/tui.go

@@ -152,6 +152,12 @@ func RunInteractiveMode(hosts []config.SSHHost, configFile, currentVersion strin
 
 	// Start the application in alt screen mode for clean output
 	p := tea.NewProgram(m, tea.WithAltScreen())
+
+	// Send initial command to start auto-ping when the program starts
+	go func() {
+		p.Send(autoPingMsg{})
+	}()
+
 	_, err := p.Run()
 	if err != nil {
 		return fmt.Errorf("error running TUI: %w", err)

internal/ui/update.go

@@ -20,8 +20,7 @@ type (
 	versionCheckMsg *version.UpdateInfo
 	versionErrorMsg error
 	errorMsg        string
-	returnToListMsg struct{}
-	refreshHostsMsg struct{}
+	autoPingMsg     struct{}
 )
 
 // startPingAllCmd creates a command to ping all hosts concurrently
@@ -147,6 +146,10 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case autoPingMsg:
+		// Handle auto-ping on startup - start pinging all hosts
+		return m, m.startPingAllCmd()
+
 	case versionCheckMsg:
 		// Handle version check result
 		if msg != nil {
@@ -168,40 +171,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
@@ -430,9 +399,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 		case ViewEdit:
 			if m.editForm != nil {
-				var updatedModel tea.Model
-				updatedModel, cmd = m.editForm.Update(msg)
-				m.editForm = updatedModel.(*editFormModel)
+				var newForm *editFormModel
+				newForm, cmd = m.editForm.Update(msg)
+				m.editForm = newForm
 				return m, cmd
 			}
 		case ViewMove:
@@ -470,14 +439,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)
@@ -749,22 +710,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"
 	}