feat(ui): add tabbed forms with height validation

- Implement General/Advanced tabs for add/edit forms
- Add terminal height detection with user-friendly warnings
- Add Ctrl+J/K tab navigation and SSH RemoteCommand/RequestTTY fields

README.md

@@ -30,7 +30,7 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect
 - **⚡ Quick Connect** - Connect to any host instantly through the TUI or the CLI with `sshm <host>`
 - **🔄 Port Forwarding** - Easy setup for Local, Remote, and Dynamic (SOCKS) forwarding with history persistence
 - **📝 Easy Management** - Add, edit, move, and manage SSH configurations seamlessly
-- **🏷️ Tag Support** - Organize your hosts with custom tags for better categorization; use the special `hidden` tag to exclude hosts from the list while keeping them connectable
+- **🏷️ Tag Support** - Organize your hosts with custom tags for better categorization
 - **🔍 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
@@ -44,7 +44,7 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect
 - **🔄 Automatic Conversion** - Seamlessly converts between command-line and config formats
 - **🔄 Automatic Backups** - Backup configurations automatically before changes
 - **✅ Validation** - Prevent configuration errors with built-in validation
-- **🔗 ProxyJump/ProxyCommand Support** - Secure connection tunneling through bastion hosts
+- **🔗 ProxyJump Support** - Secure connection tunneling through bastion hosts
 - **⌨️ Keyboard Shortcuts** - Power user navigation with vim-like shortcuts
 - **🌐 Cross-platform** - Supports Linux, macOS (Intel & Apple Silicon), and Windows
 - **⚡ Lightweight** - Single binary with no dependencies, zero configuration required
@@ -106,7 +106,6 @@ sshm
 - `d` - Delete selected host
 - `m` - Move host to another config file (requires SSH Include directives)
 - `f` - Port forwarding setup
-- `H` - Toggle hidden hosts visibility
 - `q` - Quit
 - `/` - Search/filter hosts
 
@@ -130,7 +129,6 @@ The interactive forms will guide you through configuration:
 - **Port** - SSH port (default: 22)
 - **Identity File** - Private key path
 - **ProxyJump** - Jump server for connection tunneling
-- **ProxyCommand** - Jump command for connection tunneling
 - **SSH Options** - Additional SSH options in `-o` format (e.g., `-o Compression=yes -o ServerAliveInterval=60`)
 - **Tags** - Comma-separated tags for organization
 
@@ -230,15 +228,6 @@ sshm
 # Connect directly to a specific host (with history tracking)
 sshm my-server
 
-# Execute a command on a remote host
-sshm my-server uptime
-
-# Execute command with arguments
-sshm my-server ls -la /var/log
-
-# Force TTY allocation for interactive commands
-sshm -t my-server sudo systemctl restart nginx
-
 # Launch TUI with custom SSH config file
 sshm -c /path/to/custom/ssh_config
 
@@ -269,87 +258,13 @@ sshm move my-server -c /path/to/custom/ssh_config
 # Search for hosts (interactive filter)
 sshm search
 
-# Print machine-readable info (JSON) for scripting
+# Show version information (includes update check)
-sshm info prod-server
-sshm info prod-server --pretty
-
-# With a custom SSH config file
-sshm -c /path/to/custom/ssh_config info prod-server
-
-# Pipe to jq
-sshm info prod-server | jq -r '.result.target.hostname'
-sshm info prod-server | jq -r '.result.target.user'
-
-# Show version information
 sshm --version
 
-# Disable automatic update check (useful on air-gapped machines)
-sshm --no-update-check
-
 # Show help and available commands
 sshm --help
 ```
 
-### Host Info (JSON)
-
-`sshm info <hostname>` prints a single JSON object to stdout so you can script against it with `jq`.
-
-```bash
-# Extract fields
-sshm info prod-server | jq -r '.result.target.hostname'
-sshm info prod-server | jq -r '.result.target.port'
-
-# Check not-found (exit code 2)
-sshm info does-not-exist | jq -r '.error.code'
-```
-
-### Shell Completion
-
-SSHM supports shell completion for host names, making it easy to connect to hosts without typing full names:
-
-```bash
-sshm <TAB>           # Lists all available hosts
-sshm pro<TAB>        # Completes to hosts starting with "pro" (e.g., prod-server)
-```
-
-**Setup Instructions:**
-
-**Bash:**
-```bash
-# Enable for current session
-source <(sshm completion bash)
-
-# Enable permanently (add to ~/.bashrc)
-echo 'source <(sshm completion bash)' >> ~/.bashrc
-```
-
-**Zsh:**
-```bash
-# Enable for current session
-source <(sshm completion zsh)
-
-# Enable permanently (add to ~/.zshrc)
-echo 'source <(sshm completion zsh)' >> ~/.zshrc
-```
-
-**Fish:**
-```bash
-# Enable for current session
-sshm completion fish | source
-
-# Enable permanently
-sshm completion fish > ~/.config/fish/completions/sshm.fish
-```
-
-**PowerShell:**
-```powershell
-# Enable for current session
-sshm completion powershell | Out-String | Invoke-Expression
-
-# Enable permanently (add to your PowerShell profile)
-Add-Content $PROFILE 'sshm completion powershell | Out-String | Invoke-Expression'
-```
-
 ### Direct Host Connection
 
 SSHM supports direct connection to hosts via the command line, making it easy to integrate into your existing workflow:
@@ -370,33 +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
 
-### Remote Command Execution
-
-Execute commands on remote hosts without opening an interactive shell:
-
-```bash
-# Execute a single command
-sshm prod-server uptime
-
-# Execute command with arguments
-sshm prod-server ls -la /var/log
-
-# Check disk usage
-sshm prod-server df -h
-
-# View logs (pipe to local commands)
-sshm prod-server 'cat /var/log/nginx/access.log' | grep 404
-
-# Force TTY allocation for interactive commands (sudo, vim, etc.)
-sshm -t prod-server sudo systemctl restart nginx
-```
-
-**Features:**
-- **Exit code propagation** - Remote command exit codes are passed through
-- **TTY support** - Use `-t` flag for commands requiring terminal interaction
-- **Pipe-friendly** - Output can be piped to local commands for processing
-- **History tracking** - Command executions are recorded in connection history
-
 ### Backup Configuration
 
 SSHM automatically creates backups of your SSH configuration files before making any changes to ensure your configurations are safe.
@@ -503,31 +391,17 @@ SSHM features asynchronous SSH connectivity checking that provides visual indica
 SSHM includes built-in version checking that notifies you of available updates:
 
 **Features:**
-- **Background checking** - Version check happens asynchronously, never blocking startup
+- **Background checking** - Version check happens asynchronously
 - **Release notifications** - Clear indicators when updates are available
 - **Pre-release detection** - Identifies beta and development versions
 - **GitHub integration** - Direct links to release pages
 - **Non-intrusive** - Updates don't interrupt your workflow
-- **Configurable** - Can be disabled for air-gapped or offline environments
 
 **Update notifications appear:**
 - In the main TUI interface as a subtle notification
+- In the `sshm --version` command output
 - Only when a newer stable version is available
 
-**Disabling update checks:**
-
-Via the CLI flag (one-time):
-```bash
-sshm --no-update-check
-```
-
-Via `~/.config/sshm/config.json` (persistent):
-```json
-{
-  "check_for_updates": false
-}
-```
-
 #### Port Forwarding History
 
 SSHM remembers your port forwarding configurations for easy reuse:
@@ -630,7 +504,6 @@ Host backend-prod
     User app
     Port 22
     ProxyJump bastion.company.com
-    ProxyCommand ssh -W %h:%p Jumphost
     IdentityFile ~/.ssh/production_key
     Compression yes
     ServerAliveInterval 300
@@ -647,8 +520,7 @@ SSHM supports all standard SSH configuration options:
 - `Port` - SSH port number
 - `IdentityFile` - Path to private key file
 - `ProxyJump` - Jump server for connection tunneling (e.g., `user@jumphost:port`)
-- `ProxyCommand` - Jump command for connection tunneling (e.g, `ssh -W %h:%p Jumphost`)
+- `Tags` - Custom tags (SSHM extension)
-- `Tags` - Custom tags (SSHM extension); the special tag `hidden` hides the host from the TUI and `sshm search` while keeping it connectable via `sshm <host>`
 
 **Additional SSH Options:**
 You can add any valid SSH option using the "SSH Options" field in the interactive forms. Enter them in command-line format (e.g., `-o Compression=yes -o ServerAliveInterval=60`) and SSHM will automatically convert them to the proper SSH config format.
@@ -681,9 +553,9 @@ This will be automatically converted to:
     StrictHostKeyChecking no
 ```
 
-### Application Configuration
+### Custom Key Bindings
 
-SSHM supports a configuration file to customize its behavior, including key bindings and update checking.
+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`
@@ -692,7 +564,6 @@ SSHM supports a configuration file to customize its behavior, including key bind
 **Example Configuration:**
 ```json
 {
-  "check_for_updates": false,
   "key_bindings": {
     "quit_keys": ["q", "ctrl+c"],
     "disable_esc_quit": true
@@ -701,16 +572,12 @@ SSHM supports a configuration file to customize its behavior, including key bind
 ```
 
 **Available Options:**
-- **check_for_updates**: Boolean to enable or disable the automatic update check at startup. Default: `true`. Set to `false` on air-gapped or offline machines to avoid connection delays.
 - **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.
 
-**For Air-gapped Machines:**
-If SSHM is slow to start due to DNS timeouts when reaching GitHub, set `check_for_updates` to `false`. You can also use the `--no-update-check` CLI flag for a one-time override without editing the config file.
-
 **Default Configuration:**
 If no configuration file exists, SSHM will automatically create one with default settings that maintain backward compatibility.
 

cmd/completion.go

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

cmd/completion_test.go

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

cmd/info.go

@@ -1,199 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/Gu1llaum-3/sshm/internal/config"
-
-	"github.com/spf13/cobra"
-)
-
-type infoResponse struct {
-	Schema   string      `json:"schema"`
-	OK       bool        `json:"ok"`
-	Hostname string      `json:"hostname"`
-	Result   *infoResult `json:"result"`
-	Error    *infoError  `json:"error"`
-}
-
-type infoResult struct {
-	CanonicalName string      `json:"canonical_name"`
-	Target        infoTarget  `json:"target"`
-	IdentityFile  *string     `json:"identity_file"`
-	ProxyJump     *string     `json:"proxy_jump"`
-	ProxyCommand  *string     `json:"proxy_command"`
-	Options       *string     `json:"options"`
-	Tags          []string    `json:"tags"`
-	RemoteCommand *string     `json:"remote_command"`
-	RequestTTY    *string     `json:"request_tty"`
-	Source        *infoSource `json:"source"`
-}
-
-type infoTarget struct {
-	Host     string  `json:"host"`
-	Hostname *string `json:"hostname"`
-	User     *string `json:"user"`
-	Port     *int    `json:"port"`
-}
-
-type infoSource struct {
-	File string `json:"file"`
-	Line int    `json:"line"`
-}
-
-type infoError struct {
-	Code    string          `json:"code"`
-	Message string          `json:"message"`
-	Details json.RawMessage `json:"details"`
-}
-
-func maybeString(v string) *string {
-	trimmed := strings.TrimSpace(v)
-	if trimmed == "" {
-		return nil
-	}
-	return &trimmed
-}
-
-func maybePort(v string) (*int, error) {
-	trimmed := strings.TrimSpace(v)
-	if trimmed == "" {
-		return nil, nil
-	}
-	port, err := strconv.Atoi(trimmed)
-	if err != nil {
-		return nil, err
-	}
-	return &port, nil
-}
-
-func writeInfoJSON(out io.Writer, pretty bool, resp infoResponse) {
-	var b []byte
-	var err error
-	if pretty {
-		b, err = json.MarshalIndent(resp, "", "  ")
-	} else {
-		b, err = json.Marshal(resp)
-	}
-	if err != nil {
-		_, _ = io.WriteString(out, `{"schema":"sshm.info.v1","ok":false,"hostname":"","result":null,"error":{"code":"INTERNAL","message":"failed to marshal JSON","details":null}}\n`)
-		return
-	}
-	_, _ = out.Write(append(b, '\n'))
-}
-
-func runInfo(out io.Writer, hostnameArg string, cfgFile string, pretty bool) int {
-	resp := infoResponse{
-		Schema:   "sshm.info.v1",
-		OK:       false,
-		Hostname: hostnameArg,
-		Result:   nil,
-		Error:    nil,
-	}
-
-	var host *config.SSHHost
-	var err error
-	if cfgFile != "" {
-		host, err = config.GetSSHHostFromFile(hostnameArg, cfgFile)
-	} else {
-		host, err = config.GetSSHHost(hostnameArg)
-	}
-	if err != nil {
-		code := 1
-		errCode := "CONFIG_ERROR"
-		msg := err.Error()
-		if strings.Contains(msg, "not found") {
-			code = 2
-			errCode = "NOT_FOUND"
-		}
-
-		resp.Error = &infoError{Code: errCode, Message: msg, Details: nil}
-		writeInfoJSON(out, pretty, resp)
-		return code
-	}
-
-	port, portErr := maybePort(host.Port)
-	if portErr != nil {
-		resp.Error = &infoError{Code: "CONFIG_ERROR", Message: "invalid port in host configuration", Details: nil}
-		writeInfoJSON(out, pretty, resp)
-		return 1
-	}
-
-	res := infoResult{
-		CanonicalName: host.Name,
-		Target: infoTarget{
-			Host:     hostnameArg,
-			Hostname: maybeString(host.Hostname),
-			User:     maybeString(host.User),
-			Port:     port,
-		},
-		IdentityFile:  maybeString(host.Identity),
-		ProxyJump:     maybeString(host.ProxyJump),
-		ProxyCommand:  maybeString(host.ProxyCommand),
-		Options:       maybeString(host.Options),
-		Tags:          host.Tags,
-		RemoteCommand: maybeString(host.RemoteCommand),
-		RequestTTY:    maybeString(host.RequestTTY),
-		Source: &infoSource{
-			File: host.SourceFile,
-			Line: host.LineNumber,
-		},
-	}
-
-	resp.OK = true
-	resp.Result = &res
-	writeInfoJSON(out, pretty, resp)
-	return 0
-}
-
-var infoPretty bool
-
-var infoCmd = &cobra.Command{
-	Use:           "info <hostname>",
-	Short:         "Print machine-readable information about a host",
-	Long:          "Print machine-readable information (JSON) about a configured SSH host.",
-	Args:          cobra.ExactArgs(1),
-	SilenceUsage:  true,
-	SilenceErrors: true,
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		if len(args) != 0 {
-			return nil, cobra.ShellCompDirectiveNoFileComp
-		}
-
-		var hosts []config.SSHHost
-		var err error
-		if configFile != "" {
-			hosts, err = config.ParseSSHConfigFile(configFile)
-		} else {
-			hosts, err = config.ParseSSHConfig()
-		}
-		if err != nil {
-			return nil, cobra.ShellCompDirectiveError
-		}
-
-		var completions []string
-		toCompleteLower := strings.ToLower(toComplete)
-		for _, host := range hosts {
-			if strings.HasPrefix(strings.ToLower(host.Name), toCompleteLower) {
-				completions = append(completions, host.Name)
-			}
-		}
-		return completions, cobra.ShellCompDirectiveNoFileComp
-	},
-	RunE: func(cmd *cobra.Command, args []string) error {
-		exitCode := runInfo(cmd.OutOrStdout(), args[0], configFile, infoPretty)
-		if exitCode != 0 {
-			os.Exit(exitCode)
-		}
-		return nil
-	},
-}
-
-func init() {
-	infoCmd.Flags().BoolVar(&infoPretty, "pretty", false, "Pretty-print JSON output")
-	RootCmd.AddCommand(infoCmd)
-}

cmd/info_test.go

@@ -1,321 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-type infoResponseForTest struct {
-	Schema   string             `json:"schema"`
-	OK       bool               `json:"ok"`
-	Hostname string             `json:"hostname"`
-	Result   *infoResultForTest `json:"result"`
-	Error    *infoErrorForTest  `json:"error"`
-}
-
-type infoResultForTest struct {
-	CanonicalName string             `json:"canonical_name"`
-	Target        infoTargetForTest  `json:"target"`
-	IdentityFile  *string            `json:"identity_file"`
-	ProxyJump     *string            `json:"proxy_jump"`
-	ProxyCommand  *string            `json:"proxy_command"`
-	Options       *string            `json:"options"`
-	Tags          []string           `json:"tags"`
-	RemoteCommand *string            `json:"remote_command"`
-	RequestTTY    *string            `json:"request_tty"`
-	Source        *infoSourceForTest `json:"source"`
-}
-
-type infoTargetForTest struct {
-	Host     string  `json:"host"`
-	Hostname *string `json:"hostname"`
-	User     *string `json:"user"`
-	Port     *int    `json:"port"`
-}
-
-type infoSourceForTest struct {
-	File string `json:"file"`
-	Line int    `json:"line"`
-}
-
-type infoErrorForTest struct {
-	Code    string          `json:"code"`
-	Message string          `json:"message"`
-	Details json.RawMessage `json:"details"`
-}
-
-func TestInfoCommandConfig(t *testing.T) {
-	if infoCmd.Use != "info <hostname>" {
-		t.Fatalf("infoCmd.Use=%q", infoCmd.Use)
-	}
-
-	err := infoCmd.Args(infoCmd, []string{})
-	if err == nil {
-		t.Fatalf("expected args error for no args")
-	}
-
-	err = infoCmd.Args(infoCmd, []string{"one", "two"})
-	if err == nil {
-		t.Fatalf("expected args error for too many args")
-	}
-
-	err = infoCmd.Args(infoCmd, []string{"host"})
-	if err != nil {
-		t.Fatalf("expected no args error, got %v", err)
-	}
-}
-
-func TestInfoCommandRegistration(t *testing.T) {
-	found := false
-	for _, c := range RootCmd.Commands() {
-		if c.Name() == "info" {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Fatalf("info command not registered")
-	}
-}
-
-func TestRunInfoSuccessJSON(t *testing.T) {
-	tempDir := t.TempDir()
-	cfg := filepath.Join(tempDir, "config")
-
-	cfgContent := `# Tags: prod, web
-Host prod-web
-    HostName 10.0.0.10
-    User deploy
-    Port 2222
-    IdentityFile ~/.ssh/id_prod
-    ProxyJump bastion
-    ServerAliveInterval 60
-`
-
-	if err := os.WriteFile(cfg, []byte(cfgContent), 0600); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	buf := new(bytes.Buffer)
-	exitCode := runInfo(buf, "prod-web", cfg, false)
-	if exitCode != 0 {
-		t.Fatalf("exitCode=%d", exitCode)
-	}
-
-	out := buf.String()
-	if strings.TrimSpace(out) == "" {
-		t.Fatalf("expected output")
-	}
-
-	var resp infoResponseForTest
-	if err := json.Unmarshal([]byte(out), &resp); err != nil {
-		t.Fatalf("output not JSON: %v\noutput=%q", err, out)
-	}
-
-	if resp.Schema != "sshm.info.v1" {
-		t.Fatalf("schema=%q", resp.Schema)
-	}
-	if !resp.OK {
-		t.Fatalf("ok=false")
-	}
-	if resp.Result == nil {
-		t.Fatalf("result is nil")
-	}
-	if resp.Error != nil {
-		t.Fatalf("error is non-nil")
-	}
-
-	if resp.Result.CanonicalName != "prod-web" {
-		t.Fatalf("canonical_name=%q", resp.Result.CanonicalName)
-	}
-	if resp.Result.Target.Host != "prod-web" {
-		t.Fatalf("target.host=%q", resp.Result.Target.Host)
-	}
-	if resp.Result.Target.Hostname == nil || *resp.Result.Target.Hostname != "10.0.0.10" {
-		t.Fatalf("target.hostname=%v", resp.Result.Target.Hostname)
-	}
-	if resp.Result.Target.User == nil || *resp.Result.Target.User != "deploy" {
-		t.Fatalf("target.user=%v", resp.Result.Target.User)
-	}
-	if resp.Result.Target.Port == nil || *resp.Result.Target.Port != 2222 {
-		t.Fatalf("target.port=%v", resp.Result.Target.Port)
-	}
-	if resp.Result.Source == nil || resp.Result.Source.File == "" || resp.Result.Source.Line == 0 {
-		t.Fatalf("source missing: %#v", resp.Result.Source)
-	}
-	if resp.Result.IdentityFile == nil || *resp.Result.IdentityFile != "~/.ssh/id_prod" {
-		t.Fatalf("identity_file=%v", resp.Result.IdentityFile)
-	}
-	if resp.Result.ProxyJump == nil || *resp.Result.ProxyJump != "bastion" {
-		t.Fatalf("proxy_jump=%v", resp.Result.ProxyJump)
-	}
-}
-
-func TestRunInfoNotFoundJSON(t *testing.T) {
-	tempDir := t.TempDir()
-	cfg := filepath.Join(tempDir, "config")
-	cfgContent := `Host known
-    HostName example.com
-`
-	if err := os.WriteFile(cfg, []byte(cfgContent), 0600); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	buf := new(bytes.Buffer)
-	exitCode := runInfo(buf, "missing", cfg, false)
-	if exitCode != 2 {
-		t.Fatalf("exitCode=%d", exitCode)
-	}
-
-	var resp infoResponseForTest
-	if err := json.Unmarshal(buf.Bytes(), &resp); err != nil {
-		t.Fatalf("output not JSON: %v", err)
-	}
-	if resp.OK {
-		t.Fatalf("ok=true")
-	}
-	if resp.Error == nil {
-		t.Fatalf("error is nil")
-	}
-	if resp.Error.Code != "NOT_FOUND" {
-		t.Fatalf("error.code=%q", resp.Error.Code)
-	}
-}
-
-func TestRunInfoPrettyJSON(t *testing.T) {
-	tempDir := t.TempDir()
-	cfg := filepath.Join(tempDir, "config")
-	cfgContent := `Host known
-    HostName 127.0.0.1
-`
-	if err := os.WriteFile(cfg, []byte(cfgContent), 0600); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	buf := new(bytes.Buffer)
-	exitCode := runInfo(buf, "known", cfg, true)
-	if exitCode != 0 {
-		t.Fatalf("exitCode=%d", exitCode)
-	}
-
-	out := buf.String()
-	if !strings.Contains(out, "\n") {
-		t.Fatalf("expected pretty output")
-	}
-
-	var resp infoResponseForTest
-	if err := json.Unmarshal(buf.Bytes(), &resp); err != nil {
-		t.Fatalf("output not JSON: %v", err)
-	}
-	if !resp.OK {
-		t.Fatalf("ok=false")
-	}
-}
-
-func TestInfoValidArgsFunction(t *testing.T) {
-	if infoCmd.ValidArgsFunction == nil {
-		t.Fatalf("expected ValidArgsFunction to be set on infoCmd")
-	}
-}
-
-func TestInfoValidArgsFunctionWithSSHConfig(t *testing.T) {
-	tmpDir := t.TempDir()
-	testConfigFile := filepath.Join(tmpDir, "config")
-
-	sshConfig := `Host prod-server
-    HostName 192.168.1.1
-    User admin
-
-Host dev-server
-    HostName 192.168.1.2
-    User developer
-
-Host staging-db
-    HostName 192.168.1.3
-    User dbadmin
-`
-	if err := os.WriteFile(testConfigFile, []byte(sshConfig), 0600); err != nil {
-		t.Fatalf("Failed to write test config: %v", err)
-	}
-
-	originalConfigFile := configFile
-	defer func() { configFile = originalConfigFile }()
-	configFile = testConfigFile
-
-	tests := []struct {
-		name       string
-		toComplete string
-		args       []string
-		wantCount  int
-		wantHosts  []string
-	}{
-		{
-			name:       "empty prefix returns all hosts",
-			toComplete: "",
-			args:       []string{},
-			wantCount:  3,
-			wantHosts:  []string{"prod-server", "dev-server", "staging-db"},
-		},
-		{
-			name:       "prefix filters hosts",
-			toComplete: "prod",
-			args:       []string{},
-			wantCount:  1,
-			wantHosts:  []string{"prod-server"},
-		},
-		{
-			name:       "prefix case insensitive",
-			toComplete: "DEV",
-			args:       []string{},
-			wantCount:  1,
-			wantHosts:  []string{"dev-server"},
-		},
-		{
-			name:       "no match returns empty",
-			toComplete: "nonexistent",
-			args:       []string{},
-			wantCount:  0,
-			wantHosts:  []string{},
-		},
-		{
-			name:       "already has host arg returns nothing",
-			toComplete: "",
-			args:       []string{"existing-host"},
-			wantCount:  0,
-			wantHosts:  []string{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			completions, directive := infoCmd.ValidArgsFunction(infoCmd, tt.args, tt.toComplete)
-
-			if len(completions) != tt.wantCount {
-				t.Fatalf("Expected %d completions, got %d: %v", tt.wantCount, len(completions), completions)
-			}
-
-			if directive != cobra.ShellCompDirectiveNoFileComp {
-				t.Fatalf("Expected ShellCompDirectiveNoFileComp, got %v", directive)
-			}
-
-			for _, wantHost := range tt.wantHosts {
-				found := false
-				for _, comp := range completions {
-					if comp == wantHost {
-						found = true
-						break
-					}
-				}
-				if !found {
-					t.Fatalf("Expected completion %q not found in %v", wantHost, completions)
-				}
-			}
-		})
-	}
-}

cmd/root.go

@@ -1,16 +1,19 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"os"
 	"os/exec"
 	"strings"
 	"syscall"
+	"time"
 
 	"github.com/Gu1llaum-3/sshm/internal/config"
 	"github.com/Gu1llaum-3/sshm/internal/history"
 	"github.com/Gu1llaum-3/sshm/internal/ui"
+	"github.com/Gu1llaum-3/sshm/internal/version"
 
 	"github.com/spf13/cobra"
 )
@@ -21,84 +24,33 @@ var AppVersion = "dev"
 // configFile holds the path to the SSH config file
 var configFile string
 
-// forceTTY forces pseudo-TTY allocation for remote commands
-var forceTTY bool
-
-// searchMode enables the focus on search mode at startup
-var searchMode bool
-
-// noUpdateCheck disables the async update check in the TUI
-var noUpdateCheck bool
-
 // RootCmd is the base command when called without any subcommands
 var RootCmd = &cobra.Command{
-	Use:   "sshm [host] [command...]",
+	Use:   "sshm [host]",
 	Short: "SSH Manager - A modern SSH connection manager",
 	Long: `SSHM is a modern SSH manager for your terminal.
 
 Main usage:
   Running 'sshm' (without arguments) opens the interactive TUI window to browse, search, and connect to your SSH hosts graphically.
   Running 'sshm <host>' connects directly to the specified host and records the connection in your history.
-  Running 'sshm <host> <command>' executes the command on the remote host and returns the output.
 
 You can also use sshm in CLI mode for other operations like adding, editing, or searching hosts.
 
-Hosts are read from your ~/.ssh/config file by default.
+Hosts are read from your ~/.ssh/config file by default.`,
-
-Examples:
-  sshm                           # Open interactive TUI
-  sshm prod-server               # Connect to host interactively
-  sshm prod-server uptime        # Execute 'uptime' on remote host
-  sshm prod-server ls -la /var   # Execute command with arguments
-  sshm -t prod-server sudo reboot # Force TTY for interactive commands`,
 	Version:       AppVersion,
 	Args:          cobra.ArbitraryArgs,
 	SilenceUsage:  true,
 	SilenceErrors: true, // We'll handle errors ourselves
-	// ValidArgsFunction provides shell completion for host names
-	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		// Only complete the first positional argument (host name)
-		if len(args) != 0 {
-			return nil, cobra.ShellCompDirectiveNoFileComp
-		}
-
-		var hosts []config.SSHHost
-		var err error
-
-		if configFile != "" {
-			hosts, err = config.ParseSSHConfigFile(configFile)
-		} else {
-			hosts, err = config.ParseSSHConfig()
-		}
-
-		if err != nil {
-			return nil, cobra.ShellCompDirectiveError
-		}
-
-		hosts = config.FilterVisibleHosts(hosts)
-
-		var completions []string
-		toCompleteLower := strings.ToLower(toComplete)
-		for _, host := range hosts {
-			if strings.HasPrefix(strings.ToLower(host.Name), toCompleteLower) {
-				completions = append(completions, host.Name)
-			}
-		}
-
-		return completions, cobra.ShellCompDirectiveNoFileComp
-	},
 	RunE: func(cmd *cobra.Command, args []string) error {
+		// If no arguments provided, run interactive mode
 		if len(args) == 0 {
 			runInteractiveMode()
 			return nil
 		}
 
+		// If a host name is provided, connect directly
 		hostName := args[0]
-		var remoteCommand []string
+		connectToHost(hostName)
-		if len(args) > 1 {
-			remoteCommand = args[1:]
-		}
-		connectToHost(hostName, remoteCommand)
 		return nil
 	},
 }
@@ -145,12 +97,13 @@ func runInteractiveMode() {
 	}
 
 	// Run the interactive TUI
-	if err := ui.RunInteractiveMode(hosts, configFile, searchMode, AppVersion, noUpdateCheck); err != nil {
+	if err := ui.RunInteractiveMode(hosts, configFile, AppVersion); err != nil {
 		log.Fatalf("Error running interactive mode: %v", err)
 	}
 }
 
-func connectToHost(hostName string, remoteCommand []string) {
+func connectToHost(hostName string) {
+	// Quick check if host exists without full parsing (optimized for connection)
 	var hostFound bool
 	var err error
 
@@ -170,51 +123,45 @@ func connectToHost(hostName string, remoteCommand []string) {
 		os.Exit(1)
 	}
 
+	// Record the connection in history
 	historyManager, err := history.NewHistoryManager()
 	if err != nil {
+		// Log the error but don't prevent the connection
 		fmt.Printf("Warning: Could not initialize connection history: %v\n", err)
 	} else {
 		err = historyManager.RecordConnection(hostName)
 		if err != nil {
+			// Log the error but don't prevent the connection
 			fmt.Printf("Warning: Could not record connection history: %v\n", err)
 		}
 	}
 
+	// Build and execute the SSH command
+	fmt.Printf("Connecting to %s...\n", hostName)
+
+	var sshCmd *exec.Cmd
 	var args []string
 
 	if configFile != "" {
 		args = append(args, "-F", configFile)
 	}
-
-	if forceTTY {
-		args = append(args, "-t")
-	}
-
 	args = append(args, hostName)
 
-	if len(remoteCommand) > 0 {
+	// Note: We don't add RemoteCommand here because if it's configured in SSH config,
-		args = append(args, remoteCommand...)
+	// SSH will handle it automatically. Adding it as a command line argument would conflict.
-	} else {
-		fmt.Printf("Connecting to %s...\n", hostName)
-	}
 
-	sshPath, lookErr := exec.LookPath("ssh")
+	sshCmd = exec.Command("ssh", args...)
-	if lookErr == nil {
-		argv := append([]string{"ssh"}, args...)
-		// On Unix, Exec replaces the process and never returns on success.
-		// On Windows, Exec is not supported and returns an error; fall through to the exec.Command fallback.
-		_ = syscall.Exec(sshPath, argv, os.Environ())
-	}
 
-	// Fallback for Windows or if LookPath failed
+	// Set up the command to use the same stdin, stdout, and stderr as the parent process
-	sshCmd := exec.Command("ssh", args...)
 	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())
 			}
@@ -224,15 +171,43 @@ func connectToHost(hostName string, remoteCommand []string) {
 	}
 }
 
+// getVersionWithUpdateCheck returns a custom version string with update check
+func getVersionWithUpdateCheck() string {
+	versionText := fmt.Sprintf("sshm version %s", AppVersion)
+
+	// Check for updates
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	updateInfo, err := version.CheckForUpdates(ctx, AppVersion)
+	if err != nil {
+		// Return just version if check fails
+		return versionText + "\n"
+	}
+
+	if updateInfo != nil && updateInfo.Available {
+		versionText += fmt.Sprintf("\n🚀 Update available: %s → %s (%s)",
+			updateInfo.CurrentVer,
+			updateInfo.LatestVer,
+			updateInfo.ReleaseURL)
+	}
+
+	return versionText + "\n"
+}
+
 // Execute adds all child commands to the root command and sets flags appropriately.
 func Execute() {
+	// Custom error handling for unknown commands that might be host names
 	if err := RootCmd.Execute(); err != nil {
+		// Check if this is an "unknown command" error and the argument might be a host name
 		errStr := err.Error()
 		if strings.Contains(errStr, "unknown command") {
+			// Extract the command name from the error
 			parts := strings.Split(errStr, "\"")
 			if len(parts) >= 2 {
 				potentialHost := parts[1]
-				connectToHost(potentialHost, nil)
+				// Try to connect to this as a host
+				connectToHost(potentialHost)
 				return
 			}
 		}
@@ -242,10 +217,9 @@ func Execute() {
 }
 
 func init() {
+	// Add the config file flag
 	RootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "SSH config file to use (default: ~/.ssh/config)")
-	RootCmd.Flags().BoolVarP(&forceTTY, "tty", "t", false, "Force pseudo-TTY allocation (useful for interactive remote commands)")
-	RootCmd.PersistentFlags().BoolVarP(&searchMode, "search", "s", false, "Focus on search input at startup")
-	RootCmd.PersistentFlags().BoolVar(&noUpdateCheck, "no-update-check", false, "Disable automatic update check")
 
-	RootCmd.SetVersionTemplate("{{.Name}} version {{.Version}}\n")
+	// Set custom version template with update check
+	RootCmd.SetVersionTemplate(getVersionWithUpdateCheck())
 }

cmd/root_test.go

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

cmd/search.go

@@ -55,9 +55,6 @@ func runSearch(cmd *cobra.Command, args []string) {
 		os.Exit(1)
 	}
 
-	// Filter out hidden hosts
-	hosts = config.FilterVisibleHosts(hosts)
-
 	// Get search query
 	var query string
 	if len(args) > 0 {
@@ -208,7 +205,6 @@ func outputJSON(hosts []config.SSHHost) {
 		fmt.Printf("    \"port\": \"%s\",\n", escapeJSON(host.Port))
 		fmt.Printf("    \"identity\": \"%s\",\n", escapeJSON(host.Identity))
 		fmt.Printf("    \"proxy_jump\": \"%s\",\n", escapeJSON(host.ProxyJump))
-		fmt.Printf("    \"proxy_command\": \"%s\",\n", escapeJSON(host.ProxyCommand))
 		fmt.Printf("    \"options\": \"%s\",\n", escapeJSON(host.Options))
 		fmt.Printf("    \"tags\": [")
 		for j, tag := range host.Tags {

internal/config/keybindings.go

@@ -18,16 +18,7 @@ type KeyBindings struct {
 
 // AppConfig represents the main application configuration
 type AppConfig struct {
-	CheckForUpdates *bool       `json:"check_for_updates,omitempty"`
+	KeyBindings KeyBindings `json:"key_bindings"`
-	KeyBindings     KeyBindings `json:"key_bindings"`
-}
-
-// IsUpdateCheckEnabled returns true if the update check is enabled (default: true)
-func (c *AppConfig) IsUpdateCheckEnabled() bool {
-	if c == nil || c.CheckForUpdates == nil {
-		return true
-	}
-	return *c.CheckForUpdates
 }
 
 // GetDefaultKeyBindings returns the default key bindings configuration

internal/config/keybindings_test.go

@@ -104,58 +104,6 @@ func TestAppConfigBasics(t *testing.T) {
 	if len(defaultConfig.KeyBindings.QuitKeys) != len(expectedQuitKeys) {
 		t.Errorf("Expected %d quit keys, got %d", len(expectedQuitKeys), len(defaultConfig.KeyBindings.QuitKeys))
 	}
-
-	// CheckForUpdates should be nil by default
-	if defaultConfig.CheckForUpdates != nil {
-		t.Error("Default configuration should have CheckForUpdates as nil")
-	}
-
-	// IsUpdateCheckEnabled should return true by default
-	if !defaultConfig.IsUpdateCheckEnabled() {
-		t.Error("IsUpdateCheckEnabled should return true when CheckForUpdates is nil")
-	}
-}
-
-func boolPtr(b bool) *bool {
-	return &b
-}
-
-func TestIsUpdateCheckEnabled(t *testing.T) {
-	tests := []struct {
-		name     string
-		config   *AppConfig
-		expected bool
-	}{
-		{
-			name:     "nil AppConfig returns true",
-			config:   nil,
-			expected: true,
-		},
-		{
-			name:     "CheckForUpdates nil returns true",
-			config:   &AppConfig{},
-			expected: true,
-		},
-		{
-			name:     "CheckForUpdates true returns true",
-			config:   &AppConfig{CheckForUpdates: boolPtr(true)},
-			expected: true,
-		},
-		{
-			name:     "CheckForUpdates false returns false",
-			config:   &AppConfig{CheckForUpdates: boolPtr(false)},
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := tt.config.IsUpdateCheckEnabled()
-			if result != tt.expected {
-				t.Errorf("IsUpdateCheckEnabled() = %v, expected %v", result, tt.expected)
-			}
-		})
-	}
 }
 
 func TestMergeWithDefaults(t *testing.T) {
@@ -193,7 +141,6 @@ func TestSaveAndLoadAppConfigIntegration(t *testing.T) {
 	configPath := filepath.Join(tempDir, "config.json")
 
 	customConfig := AppConfig{
-		CheckForUpdates: boolPtr(false),
 		KeyBindings: KeyBindings{
 			QuitKeys:       []string{"q"},
 			DisableEscQuit: true,
@@ -231,15 +178,4 @@ func TestSaveAndLoadAppConfigIntegration(t *testing.T) {
 	if len(loadedConfig.KeyBindings.QuitKeys) != 1 || loadedConfig.KeyBindings.QuitKeys[0] != "q" {
 		t.Errorf("Expected quit keys to be ['q'], got %v", loadedConfig.KeyBindings.QuitKeys)
 	}
-
-	// Verify CheckForUpdates is correctly persisted and reloaded
-	if loadedConfig.CheckForUpdates == nil {
-		t.Fatal("CheckForUpdates should not be nil after round-trip")
-	}
-	if *loadedConfig.CheckForUpdates != false {
-		t.Errorf("CheckForUpdates should be false after round-trip, got %v", *loadedConfig.CheckForUpdates)
-	}
-	if loadedConfig.IsUpdateCheckEnabled() {
-		t.Error("IsUpdateCheckEnabled should return false when CheckForUpdates is false")
-	}
 }

internal/config/ssh.go

@@ -11,18 +11,6 @@ import (
 	"sync"
 )
 
-func getHomeDir() (string, error) {
-	home := os.Getenv("HOME")
-	if home != "" {
-		return home, nil
-	}
-	home = os.Getenv("USERPROFILE")
-	if home != "" {
-		return home, nil
-	}
-	return os.UserHomeDir()
-}
-
 // SSHHost represents an SSH host configuration
 type SSHHost struct {
 	Name          string
@@ -31,13 +19,11 @@ type SSHHost struct {
 	Port          string
 	Identity      string
 	ProxyJump     string
-	ProxyCommand  string
 	Options       string
 	RemoteCommand string // Command to execute after SSH connection
 	RequestTTY    string // Request TTY (yes, no, force, auto)
 	Tags          []string
 	SourceFile    string // Path to the config file where this host is defined
-	LineNumber    int    // Line number in the source file where this host block starts (1-indexed)
 
 	// Temporary field to handle multiple aliases during parsing
 	aliasNames []string `json:"-"` // Do not serialize this field
@@ -45,7 +31,7 @@ type SSHHost struct {
 
 // GetDefaultSSHConfigPath returns the default SSH config path for the current platform
 func GetDefaultSSHConfigPath() (string, error) {
-	homeDir, err := getHomeDir()
+	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
 	}
@@ -61,7 +47,7 @@ func GetDefaultSSHConfigPath() (string, error) {
 
 // GetSSHMConfigDir returns the SSHM config directory
 func GetSSHMConfigDir() (string, error) {
-	homeDir, err := getHomeDir()
+	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
 	}
@@ -100,7 +86,7 @@ func GetSSHMBackupDir() (string, error) {
 
 // GetSSHDirectory returns the .ssh directory path
 func GetSSHDirectory() (string, error) {
-	homeDir, err := getHomeDir()
+	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
 	}
@@ -225,10 +211,8 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 	var currentHost *SSHHost
 	var pendingTags []string
 	scanner := bufio.NewScanner(file)
-	lineNumber := 0
 
 	for scanner.Scan() {
-		lineNumber++
 		line := strings.TrimSpace(scanner.Text())
 
 		// Ignore empty lines
@@ -295,12 +279,8 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 			hostNames := strings.Fields(value)
 
 			// Skip hosts with wildcards (*, ?) as they are typically patterns, not actual hosts
-			// Also remove surrounding quotes from host names
 			var validHostNames []string
 			for _, hostName := range hostNames {
-				// Remove surrounding double quotes if present
-				hostName = strings.Trim(hostName, `"`)
-
 				if !strings.ContainsAny(hostName, "*?") {
 					validHostNames = append(validHostNames, hostName)
 				}
@@ -319,7 +299,6 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 				Port:       "22",              // Default port
 				Tags:       pendingTags,       // Assign pending tags to this host
 				SourceFile: absPath,           // Track which file this host comes from
-				LineNumber: lineNumber,        // Track the line number where Host declaration starts
 			}
 
 			// Store additional host names for later processing
@@ -349,10 +328,6 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 			if currentHost != nil {
 				currentHost.ProxyJump = value
 			}
-		case "proxycommand":
-			if currentHost != nil {
-				currentHost.ProxyCommand = value
-			}
 		case "remotecommand":
 			if currentHost != nil {
 				currentHost.RemoteCommand = value
@@ -398,7 +373,7 @@ func parseSSHConfigFileWithProcessedFiles(configPath string, processedFiles map[
 func processIncludeDirective(pattern string, baseConfigPath string, processedFiles map[string]bool) ([]SSHHost, error) {
 	// Expand tilde to home directory
 	if strings.HasPrefix(pattern, "~") {
-		homeDir, err := getHomeDir()
+		homeDir, err := os.UserHomeDir()
 		if err != nil {
 			return nil, fmt.Errorf("failed to get home directory: %w", err)
 		}
@@ -638,13 +613,6 @@ func AddSSHHostToFile(host SSHHost, configPath string) error {
 		}
 	}
 
-	if host.ProxyCommand != "" {
-		_, err = file.WriteString(fmt.Sprintf("    ProxyCommand=%s\n", host.ProxyCommand))
-		if err != nil {
-			return err
-		}
-	}
-
 	if host.RemoteCommand != "" {
 		_, err = file.WriteString(fmt.Sprintf("    RemoteCommand %s\n", host.RemoteCommand))
 		if err != nil {
@@ -678,34 +646,13 @@ func AddSSHHostToFile(host SSHHost, configPath string) error {
 }
 
 // ParseSSHOptionsFromCommand converts SSH command line options to config format
-// Input: "-o Compression=yes -o ServerAliveInterval=60" or "ForwardX11 true" or "Compression yes"
+// Input: "-o Compression=yes -o ServerAliveInterval=60"
 // Output: "Compression yes\nServerAliveInterval 60"
 func ParseSSHOptionsFromCommand(options string) string {
 	if options == "" {
 		return ""
 	}
 
-	options = strings.TrimSpace(options)
-
-	// If it doesn't contain -o, assume it's already in config format
-	if !strings.Contains(options, "-o") {
-		// Just normalize spaces and ensure newlines between options
-		lines := strings.Split(options, "\n")
-		var result []string
-		for _, line := range lines {
-			line = strings.TrimSpace(line)
-			if line == "" {
-				continue
-			}
-			// Normalize spacing (replace multiple spaces with single space)
-			parts := strings.Fields(line)
-			if len(parts) > 0 {
-				result = append(result, strings.Join(parts, " "))
-			}
-		}
-		return strings.Join(result, "\n")
-	}
-
 	var result []string
 	parts := strings.Split(options, "-o")
 
@@ -731,12 +678,6 @@ func FormatSSHOptionsForCommand(options string) string {
 		return ""
 	}
 
-	// If already in command format (starts with -o), return as is
-	trimmed := strings.TrimSpace(options)
-	if strings.HasPrefix(trimmed, "-o ") {
-		return trimmed
-	}
-
 	var result []string
 	lines := strings.Split(options, "\n")
 
@@ -912,9 +853,6 @@ func quickHostSearchInFile(hostName string, configPath string, processedFiles ma
 
 			// Check if our target host is in this Host declaration
 			for _, candidateHostName := range hostNames {
-				// Remove surrounding double quotes if present
-				candidateHostName = strings.Trim(candidateHostName, `"`)
-
 				// Skip hosts with wildcards (*, ?) as they are typically patterns
 				if !strings.ContainsAny(candidateHostName, "*?") && candidateHostName == hostName {
 					return true, nil // Found the host!
@@ -930,7 +868,7 @@ func quickHostSearchInFile(hostName string, configPath string, processedFiles ma
 func quickSearchInclude(hostName, pattern, baseConfigPath string, processedFiles map[string]bool) (bool, error) {
 	// Expand tilde to home directory
 	if strings.HasPrefix(pattern, "~") {
-		homeDir, err := getHomeDir()
+		homeDir, err := os.UserHomeDir()
 		if err != nil {
 			return false, fmt.Errorf("failed to get home directory: %w", err)
 		}
@@ -1106,9 +1044,6 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 						if newHost.ProxyJump != "" {
 							newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 						}
-						if newHost.ProxyCommand != "" {
-							newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
-						}
 						if newHost.RemoteCommand != "" {
 							newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 						}
@@ -1163,9 +1098,6 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 						if newHost.ProxyJump != "" {
 							newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 						}
-						if newHost.ProxyCommand != "" {
-							newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
-						}
 						if newHost.RemoteCommand != "" {
 							newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 						}
@@ -1256,9 +1188,6 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 					if newHost.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 					}
-					if newHost.ProxyCommand != "" {
-						newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
-					}
 					if newHost.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 					}
@@ -1313,9 +1242,6 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 					if newHost.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+newHost.ProxyJump)
 					}
-					if newHost.ProxyCommand != "" {
-						newLines = append(newLines, "    ProxyCommand="+newHost.ProxyCommand)
-					}
 					if newHost.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+newHost.RemoteCommand)
 					}
@@ -1357,21 +1283,11 @@ func UpdateSSHHostInFile(oldName string, newHost SSHHost, configPath string) err
 
 // DeleteSSHHost removes an SSH host configuration from the config file
 func DeleteSSHHost(hostName string) error {
-	return DeleteSSHHostV2(hostName, 0) // Legacy: without line number
+	return DeleteSSHHostV2(hostName)
-}
-
-// DeleteSSHHostWithLine deletes a specific SSH host by name and line number
-func DeleteSSHHostWithLine(host SSHHost) error {
-	return DeleteSSHHostFromFileWithLine(host.Name, host.SourceFile, host.LineNumber)
 }
 
 // DeleteSSHHostFromFile deletes an SSH host from a specific config file
 func DeleteSSHHostFromFile(hostName, configPath string) error {
-	return DeleteSSHHostFromFileWithLine(hostName, configPath, 0) // Legacy: without line number
-}
-
-// DeleteSSHHostFromFileWithLine deletes an SSH host from a specific config file at a specific line
-func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber int) error {
 	configMutex.Lock()
 	defer configMutex.Unlock()
 
@@ -1398,13 +1314,11 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 	hostFound := false
 
 	for i < len(lines) {
-		currentLineNumber := i + 1 // Convert 0-indexed to 1-indexed
 		line := strings.TrimSpace(lines[i])
 
 		// Check for tags comment followed by Host
 		if strings.HasPrefix(line, "# Tags:") && i+1 < len(lines) {
 			nextLine := strings.TrimSpace(lines[i+1])
-			nextLineNumber := i + 2 // The Host line is at i+1, so its 1-indexed number is i+2
 
 			// Check if this is a Host line that contains our target host
 			if strings.HasPrefix(nextLine, "Host ") {
@@ -1420,10 +1334,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 					}
 				}
 
-				// Only proceed if:
+				if targetHostIndex != -1 {
-				// 1. We found the host name
-				// 2. Either no line number was specified (targetLineNumber == 0) OR the line numbers match
-				if targetHostIndex != -1 && (targetLineNumber == 0 || nextLineNumber == targetLineNumber) {
 					hostFound = true
 
 					if isMultiHost && len(hostNames) > 1 {
@@ -1461,12 +1372,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 							i++
 						}
 
-						// Copy remaining lines and break to prevent deleting other duplicates
+						continue
-						for i < len(lines) {
-							newLines = append(newLines, lines[i])
-							i++
-						}
-						break
 					} else {
 						// Single host or last host in multi-host block, delete entire block
 						// Skip tags comment and Host line
@@ -1482,12 +1388,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 							i++
 						}
 
-						// Copy remaining lines and break to prevent deleting other duplicates
+						continue
-						for i < len(lines) {
-							newLines = append(newLines, lines[i])
-							i++
-						}
-						break
 					}
 				}
 			}
@@ -1507,10 +1408,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 				}
 			}
 
-			// Only proceed if:
+			if targetHostIndex != -1 {
-			// 1. We found the host name
-			// 2. Either no line number was specified (targetLineNumber == 0) OR the line numbers match
-			if targetHostIndex != -1 && (targetLineNumber == 0 || currentLineNumber == targetLineNumber) {
 				hostFound = true
 
 				if isMultiHost && len(hostNames) > 1 {
@@ -1545,12 +1443,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 						i++
 					}
 
-					// Copy remaining lines and break to prevent deleting other duplicates
+					continue
-					for i < len(lines) {
-						newLines = append(newLines, lines[i])
-						i++
-					}
-					break
 				} else {
 					// Single host, delete entire block
 					// Skip Host line
@@ -1566,12 +1459,7 @@ func DeleteSSHHostFromFileWithLine(hostName, configPath string, targetLineNumber
 						i++
 					}
 
-					// Copy remaining lines and break to prevent deleting other duplicates
+					continue
-					for i < len(lines) {
-						newLines = append(newLines, lines[i])
-						i++
-					}
-					break
 				}
 			}
 		}
@@ -1624,27 +1512,6 @@ func GetAllConfigFiles() ([]string, error) {
 	return files, nil
 }
 
-// FilterVisibleHosts returns only hosts that do not have the "hidden" tag.
-func FilterVisibleHosts(hosts []SSHHost) []SSHHost {
-	var visible []SSHHost
-	for _, h := range hosts {
-		if !hostHasTag(h.Tags, "hidden") {
-			visible = append(visible, h)
-		}
-	}
-	return visible
-}
-
-// hostHasTag reports whether the given tag list contains the target tag (case-insensitive).
-func hostHasTag(tags []string, target string) bool {
-	for _, t := range tags {
-		if strings.EqualFold(t, target) {
-			return true
-		}
-	}
-	return false
-}
-
 // GetAllConfigFilesFromBase returns all SSH config files starting from a specific base config file
 func GetAllConfigFilesFromBase(baseConfigPath string) ([]string, error) {
 	if baseConfigPath == "" {
@@ -1675,15 +1542,15 @@ func UpdateSSHHostV2(oldName string, newHost SSHHost) error {
 }
 
 // DeleteSSHHostV2 removes an SSH host configuration, searching in all config files
-func DeleteSSHHostV2(hostName string, targetLineNumber int) error {
+func DeleteSSHHostV2(hostName string) error {
 	// Find the host to determine which file it's in
 	existingHost, err := FindHostInAllConfigs(hostName)
 	if err != nil {
 		return err
 	}
 
-	// Delete the host from its source file using line number if provided
+	// Delete the host from its source file
-	return DeleteSSHHostFromFileWithLine(hostName, existingHost.SourceFile, targetLineNumber)
+	return DeleteSSHHostFromFile(hostName, existingHost.SourceFile)
 }
 
 // AddSSHHostWithFileSelection adds a new SSH host to a user-specified config file
@@ -1875,9 +1742,6 @@ func UpdateMultiHostBlock(originalHosts, newHosts []string, commonProperties SSH
 					if commonProperties.ProxyJump != "" {
 						newLines = append(newLines, "    ProxyJump "+commonProperties.ProxyJump)
 					}
-					if commonProperties.ProxyCommand != "" {
-						newLines = append(newLines, "    ProxyCommand="+commonProperties.ProxyCommand)
-					}
 					if commonProperties.RemoteCommand != "" {
 						newLines = append(newLines, "    RemoteCommand "+commonProperties.RemoteCommand)
 					}
@@ -1964,9 +1828,6 @@ func UpdateMultiHostBlock(originalHosts, newHosts []string, commonProperties SSH
 				if commonProperties.ProxyJump != "" {
 					newLines = append(newLines, "    ProxyJump "+commonProperties.ProxyJump)
 				}
-				if commonProperties.ProxyCommand != "" {
-					newLines = append(newLines, "    ProxyCommand="+commonProperties.ProxyCommand)
-				}
 				if commonProperties.RemoteCommand != "" {
 					newLines = append(newLines, "    RemoteCommand "+commonProperties.RemoteCommand)
 				}

internal/config/ssh_test.go

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

internal/connectivity/ping.go

@@ -2,15 +2,12 @@ package connectivity
 
 import (
 	"context"
-	"fmt"
 	"net"
-	"os/exec"
+	"github.com/Gu1llaum-3/sshm/internal/config"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/Gu1llaum-3/sshm/internal/config"
-
 	"golang.org/x/crypto/ssh"
 )
 
@@ -48,18 +45,16 @@ type HostPingResult struct {
 
 // PingManager manages SSH connectivity checks for multiple hosts
 type PingManager struct {
-	results    map[string]*HostPingResult
+	results map[string]*HostPingResult
-	mutex      sync.RWMutex
+	mutex   sync.RWMutex
-	timeout    time.Duration
+	timeout time.Duration
-	configFile string
 }
 
 // NewPingManager creates a new ping manager with the specified timeout
-func NewPingManager(timeout time.Duration, configFile string) *PingManager {
+func NewPingManager(timeout time.Duration) *PingManager {
 	return &PingManager{
-		results:    make(map[string]*HostPingResult),
+		results: make(map[string]*HostPingResult),
-		timeout:    timeout,
+		timeout: timeout,
-		configFile: configFile,
 	}
 }
 
@@ -103,14 +98,6 @@ func (pm *PingManager) PingHost(ctx context.Context, host config.SSHHost) *HostP
 	// Mark as connecting
 	pm.updateStatus(host.Name, StatusConnecting, nil, 0)
 
-	// If the host uses a ProxyJump or ProxyCommand, we need to use the external SSH command
-	// because implementing jump host support with pure Go ssh library requires
-	// handling authentication for the jump host, which is complex and requires
-	// access to the user's SSH agent or keys.
-	if host.ProxyJump != "" || host.ProxyCommand != "" {
-		return pm.pingWithExternalCommand(ctx, host, start)
-	}
-
 	// Determine the actual hostname and port
 	hostname := host.Hostname
 	if hostname == "" {
@@ -172,53 +159,6 @@ func (pm *PingManager) PingHost(ctx context.Context, host config.SSHHost) *HostP
 	}
 }
 
-// pingWithExternalCommand pings a host using the external SSH command
-func (pm *PingManager) pingWithExternalCommand(ctx context.Context, host config.SSHHost, start time.Time) *HostPingResult {
-	// Construct the SSH command
-	// ssh -q -o BatchMode=yes -o StrictHostKeyChecking=no -o ConnectTimeout=5 host exit
-	args := []string{"-q", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=no"}
-
-	// Set timeout matching the manager's timeout
-	// Convert duration to seconds (rounding up to ensure we don't timeout too early in the command)
-	timeoutSec := int(pm.timeout.Seconds())
-	if timeoutSec < 1 {
-		timeoutSec = 1
-	}
-	args = append(args, "-o", fmt.Sprintf("ConnectTimeout=%d", timeoutSec))
-
-	// If we have a specific config file, use it
-	if pm.configFile != "" {
-		args = append(args, "-F", pm.configFile)
-	}
-
-	// Add the host name and the command to run (exit)
-	args = append(args, host.Name, "exit")
-
-	// Create command with context for timeout cancellation
-	// Note: We used pm.timeout for the ssh command option, but we also respect the context deadline
-	cmd := exec.CommandContext(ctx, "ssh", args...)
-
-	// Run the command
-	err := cmd.Run()
-	duration := time.Since(start)
-
-	var status PingStatus
-	if err != nil {
-		// SSH returns non-zero exit code on connection failure
-		status = StatusOffline
-	} else {
-		status = StatusOnline
-	}
-
-	pm.updateStatus(host.Name, status, err, duration)
-	return &HostPingResult{
-		HostName: host.Name,
-		Status:   status,
-		Error:    err,
-		Duration: duration,
-	}
-}
-
 // PingAllHosts pings all hosts concurrently and returns a channel of results
 func (pm *PingManager) PingAllHosts(ctx context.Context, hosts []config.SSHHost) <-chan *HostPingResult {
 	resultChan := make(chan *HostPingResult, len(hosts))

internal/connectivity/ping_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestNewPingManager(t *testing.T) {
-	pm := NewPingManager(5*time.Second, "")
+	pm := NewPingManager(5 * time.Second)
 	if pm == nil {
 		t.Error("NewPingManager() returned nil")
 	}
@@ -19,16 +19,16 @@ func TestNewPingManager(t *testing.T) {
 }
 
 func TestPingManager_PingHost(t *testing.T) {
-	pm := NewPingManager(1*time.Second, "")
+	pm := NewPingManager(1 * time.Second)
 	ctx := context.Background()
-
+	
 	// Test ping method exists and doesn't panic
 	host := config.SSHHost{Name: "test", Hostname: "127.0.0.1", Port: "22"}
 	result := pm.PingHost(ctx, host)
 	if result == nil {
 		t.Error("Expected ping result to be returned")
 	}
-
+	
 	// Test with invalid host
 	invalidHost := config.SSHHost{Name: "invalid", Hostname: "invalid.host.12345", Port: "22"}
 	result = pm.PingHost(ctx, invalidHost)
@@ -38,14 +38,14 @@ func TestPingManager_PingHost(t *testing.T) {
 }
 
 func TestPingManager_GetStatus(t *testing.T) {
-	pm := NewPingManager(1*time.Second, "")
+	pm := NewPingManager(1 * time.Second)
-
+	
 	// Test unknown host
 	status := pm.GetStatus("unknown.host")
 	if status != StatusUnknown {
 		t.Errorf("Expected StatusUnknown for unknown host, got %v", status)
 	}
-
+	
 	// Test after ping
 	ctx := context.Background()
 	host := config.SSHHost{Name: "test", Hostname: "127.0.0.1", Port: "22"}
@@ -57,21 +57,21 @@ func TestPingManager_GetStatus(t *testing.T) {
 }
 
 func TestPingManager_PingMultipleHosts(t *testing.T) {
-	pm := NewPingManager(1*time.Second, "")
+	pm := NewPingManager(1 * time.Second)
 	hosts := []config.SSHHost{
 		{Name: "localhost", Hostname: "127.0.0.1", Port: "22"},
 		{Name: "invalid", Hostname: "invalid.host.12345", Port: "22"},
 	}
-
+	
 	ctx := context.Background()
-
+	
 	// Ping each host individually
 	for _, host := range hosts {
 		result := pm.PingHost(ctx, host)
 		if result == nil {
 			t.Errorf("Expected ping result for host %s", host.Name)
 		}
-
+		
 		// Check that status was set
 		status := pm.GetStatus(host.Name)
 		if status == StatusUnknown {
@@ -81,19 +81,19 @@ func TestPingManager_PingMultipleHosts(t *testing.T) {
 }
 
 func TestPingManager_GetResult(t *testing.T) {
-	pm := NewPingManager(1*time.Second, "")
+	pm := NewPingManager(1 * time.Second)
 	ctx := context.Background()
-
+	
 	// Test getting result for unknown host
 	result, exists := pm.GetResult("unknown")
 	if exists || result != nil {
 		t.Error("Expected no result for unknown host")
 	}
-
+	
 	// Test after ping
 	host := config.SSHHost{Name: "test", Hostname: "127.0.0.1", Port: "22"}
 	pm.PingHost(ctx, host)
-
+	
 	result, exists = pm.GetResult("test")
 	if !exists || result == nil {
 		t.Error("Expected result to exist after ping")
@@ -114,7 +114,7 @@ func TestPingStatus_String(t *testing.T) {
 		{StatusOffline, "offline"},
 		{PingStatus(999), "unknown"}, // Invalid status
 	}
-
+	
 	for _, tt := range tests {
 		t.Run(tt.expected, func(t *testing.T) {
 			if got := tt.status.String(); got != tt.expected {
@@ -126,19 +126,19 @@ func TestPingStatus_String(t *testing.T) {
 
 func TestPingHost_Basic(t *testing.T) {
 	// Test that the ping functionality exists
-	pm := NewPingManager(1*time.Second, "")
+	pm := NewPingManager(1 * time.Second)
 	ctx := context.Background()
 	host := config.SSHHost{Name: "test", Hostname: "127.0.0.1", Port: "22"}
-
+	
 	// Just ensure the function doesn't panic
 	result := pm.PingHost(ctx, host)
 	if result == nil {
 		t.Error("Expected ping result to be returned")
 	}
-
+	
 	// Test that status is set
 	status := pm.GetStatus("test")
 	if status == StatusUnknown {
 		t.Error("Expected status to be set after ping attempt")
 	}
-}
+}

internal/ui/add_form.go

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

internal/ui/edit_form.go

@@ -91,7 +91,7 @@ func NewEditForm(hostName string, styles Styles, width, height int, configFile s
 		}
 	}
 
-	inputs := make([]textinput.Model, 10)
+	inputs := make([]textinput.Model, 9) // Increased from 8 to 9 for RequestTTY
 
 	// Hostname input
 	inputs[0] = textinput.New()
@@ -128,44 +128,37 @@ func NewEditForm(hostName string, styles Styles, width, height int, configFile s
 	inputs[4].Width = 30
 	inputs[4].SetValue(host.ProxyJump)
 
-	// ProxyCommand input
+	// Options input
 	inputs[5] = textinput.New()
-	inputs[5].Placeholder = "ssh -W %h:%p Jumphost"
+	inputs[5].Placeholder = "-o StrictHostKeyChecking=no"
 	inputs[5].CharLimit = 200
 	inputs[5].Width = 50
-	inputs[5].SetValue(host.ProxyCommand)
-
-	// Options input
-	inputs[6] = textinput.New()
-	inputs[6].Placeholder = "-o StrictHostKeyChecking=no"
-	inputs[6].CharLimit = 200
-	inputs[6].Width = 50
 	if host.Options != "" {
-		inputs[6].SetValue(config.FormatSSHOptionsForCommand(host.Options))
+		inputs[5].SetValue(config.FormatSSHOptionsForCommand(host.Options))
 	}
 
 	// Tags input
-	inputs[7] = textinput.New()
+	inputs[6] = textinput.New()
-	inputs[7].Placeholder = "production, web, database"
+	inputs[6].Placeholder = "production, web, database"
-	inputs[7].CharLimit = 200
+	inputs[6].CharLimit = 200
-	inputs[7].Width = 50
+	inputs[6].Width = 50
 	if len(host.Tags) > 0 {
-		inputs[7].SetValue(strings.Join(host.Tags, ", "))
+		inputs[6].SetValue(strings.Join(host.Tags, ", "))
 	}
 
 	// Remote Command input
-	inputs[8] = textinput.New()
+	inputs[7] = textinput.New()
-	inputs[8].Placeholder = "ls -la, htop, bash"
+	inputs[7].Placeholder = "ls -la, htop, bash"
-	inputs[8].CharLimit = 300
+	inputs[7].CharLimit = 300
-	inputs[8].Width = 70
+	inputs[7].Width = 70
-	inputs[8].SetValue(host.RemoteCommand)
+	inputs[7].SetValue(host.RemoteCommand)
 
 	// RequestTTY input
-	inputs[9] = textinput.New()
+	inputs[8] = textinput.New()
-	inputs[9].Placeholder = "yes, no, force, auto"
+	inputs[8].Placeholder = "yes, no, force, auto"
-	inputs[9].CharLimit = 10
+	inputs[8].CharLimit = 10
-	inputs[9].Width = 30
+	inputs[8].Width = 30
-	inputs[9].SetValue(host.RequestTTY)
+	inputs[8].SetValue(host.RequestTTY)
 
 	return &editFormModel{
 		hostInputs:       hostInputs,
@@ -260,19 +253,19 @@ func (m *editFormModel) updateFocus() tea.Cmd {
 func (m *editFormModel) getPropertiesForCurrentTab() []int {
 	switch m.currentTab {
 	case 0: // General
-		return []int{0, 1, 2, 3, 4, 5, 7} // hostname, user, port, identity, proxyjump, proxycommand, tags
+		return []int{0, 1, 2, 3, 4, 6} // hostname, user, port, identity, proxyjump, tags
 	case 1: // Advanced
-		return []int{6, 8, 9} // options, remotecommand, requesttty
+		return []int{5, 7, 8} // options, remotecommand, requesttty
 	default:
-		return []int{0, 1, 2, 3, 4, 5, 7}
+		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, 5, 7} // General tab
+	properties := []int{0, 1, 2, 3, 4, 6} // General tab
 	if tab == 1 {
-		properties = []int{6, 8, 9} // Advanced tab
+		properties = []int{5, 7, 8} // Advanced tab
 	}
 	if len(properties) > 0 {
 		return properties[0]
@@ -291,10 +284,10 @@ func (m *editFormModel) handleEditNavigation(key string) tea.Cmd {
 		}
 
 		if m.focused >= len(m.hostInputs) {
-			// Move to properties area, keep current tab
+			// Move to properties area, first tab
 			m.focusArea = focusAreaProperties
-			// Keep the current tab instead of forcing it to 0
+			m.currentTab = 0
-			m.focused = m.getFirstPropertyForTab(m.currentTab)
+			m.focused = m.getFirstPropertyForTab(0)
 		} else if m.focused < 0 {
 			m.focused = len(m.hostInputs) - 1
 		}
@@ -587,8 +580,7 @@ func (m *editFormModel) renderEditGeneralTab() string {
 		{2, "Port"},
 		{3, "Identity File"},
 		{4, "Proxy Jump"},
-		{5, "Proxy Command"},
+		{6, "Tags (comma-separated)"},
-		{7, "Tags (comma-separated)"},
 	}
 
 	for _, field := range fields {
@@ -599,12 +591,7 @@ func (m *editFormModel) renderEditGeneralTab() string {
 		b.WriteString(fieldStyle.Render(field.label))
 		b.WriteString("\n")
 		b.WriteString(m.inputs[field.index].View())
-		b.WriteString("\n")
+		b.WriteString("\n\n")
-		if field.index == 7 && m.focusArea == focusAreaProperties && m.focused == 7 {
-			b.WriteString(m.styles.FormHelp.Render(`  tip: use "hidden" to hide this host from the list`))
-			b.WriteString("\n")
-		}
-		b.WriteString("\n")
 	}
 
 	return b.String()
@@ -618,9 +605,9 @@ func (m *editFormModel) renderEditAdvancedTab() string {
 		index int
 		label string
 	}{
-		{6, "SSH Options"},
+		{5, "SSH Options"},
-		{8, "Remote Command"},
+		{7, "Remote Command"},
-		{9, "Request TTY"},
+		{8, "Request TTY"},
 	}
 
 	for _, field := range fields {
@@ -691,15 +678,14 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 		}
 
 		// Get property values using direct indices
-		hostname := strings.TrimSpace(m.inputs[0].Value())                                   // hostnameInput
+		hostname := strings.TrimSpace(m.inputs[0].Value())      // hostnameInput
-		user := strings.TrimSpace(m.inputs[1].Value())                                       // userInput
+		user := strings.TrimSpace(m.inputs[1].Value())          // userInput
-		port := strings.TrimSpace(m.inputs[2].Value())                                       // portInput
+		port := strings.TrimSpace(m.inputs[2].Value())          // portInput
-		identity := strings.TrimSpace(m.inputs[3].Value())                                   // identityInput
+		identity := strings.TrimSpace(m.inputs[3].Value())      // identityInput
-		proxyJump := strings.TrimSpace(m.inputs[4].Value())                                  // proxyJumpInput
+		proxyJump := strings.TrimSpace(m.inputs[4].Value())     // proxyJumpInput
-		proxyCommand := strings.TrimSpace(m.inputs[5].Value())                               // proxyCommandInput
+		options := strings.TrimSpace(m.inputs[5].Value())       // optionsInput
-		options := config.ParseSSHOptionsFromCommand(strings.TrimSpace(m.inputs[6].Value())) // optionsInput
+		remoteCommand := strings.TrimSpace(m.inputs[7].Value()) // remoteCommandInput
-		remoteCommand := strings.TrimSpace(m.inputs[8].Value())                              // remoteCommandInput
+		requestTTY := strings.TrimSpace(m.inputs[8].Value())    // requestTTYInput
-		requestTTY := strings.TrimSpace(m.inputs[9].Value())                                 // requestTTYInput
 
 		// Set defaults
 		if port == "" {
@@ -719,7 +705,7 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 		}
 
 		// Parse tags
-		tagsStr := strings.TrimSpace(m.inputs[7].Value()) // tagsInput
+		tagsStr := strings.TrimSpace(m.inputs[6].Value()) // tagsInput
 		var tags []string
 		if tagsStr != "" {
 			for _, tag := range strings.Split(tagsStr, ",") {
@@ -737,7 +723,6 @@ func (m *editFormModel) submitEditForm() tea.Cmd {
 			Port:          port,
 			Identity:      identity,
 			ProxyJump:     proxyJump,
-			ProxyCommand:  proxyCommand,
 			Options:       options,
 			RemoteCommand: remoteCommand,
 			RequestTTY:    requestTTY,

internal/ui/help_form.go

@@ -81,9 +81,6 @@ func (m *helpModel) View() string {
 		lipgloss.JoinHorizontal(lipgloss.Left,
 			m.styles.FocusedLabel.Render("p  "),
 			m.styles.HelpText.Render("ping all hosts")),
-		lipgloss.JoinHorizontal(lipgloss.Left,
-			m.styles.FocusedLabel.Render("H  "),
-			m.styles.HelpText.Render("toggle hidden hosts visibility")),
 		lipgloss.JoinHorizontal(lipgloss.Left,
 			m.styles.FocusedLabel.Render("f  "),
 			m.styles.HelpText.Render("setup port forwarding")),

internal/ui/info_form.go

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

internal/ui/model.go

@@ -70,20 +70,18 @@ func (p PortForwardType) String() string {
 type Model struct {
 	table          table.Model
 	searchInput    textinput.Model
-	allHosts       []config.SSHHost // all parsed hosts, including hidden ones
+	hosts          []config.SSHHost
-	hosts          []config.SSHHost // visible hosts (filtered by showHidden)
 	filteredHosts  []config.SSHHost
-	showHidden     bool // when true, hidden-tagged hosts are shown
 	searchMode     bool
 	deleteMode     bool
-	deleteHost     *config.SSHHost // Host to be deleted (with line number for precise targeting)
+	deleteHost     string
 	historyManager *history.HistoryManager
 	pingManager    *connectivity.PingManager
 	sortMode       SortMode
 	configFile     string // Path to the SSH config file
 
 	// Application configuration
-	appConfig *config.AppConfig
+	appConfig      *config.AppConfig
 
 	// Version update information
 	updateInfo     *version.UpdateInfo
@@ -110,14 +108,6 @@ type Model struct {
 	showingError bool
 }
 
-// applyVisibilityFilter returns hosts filtered according to the showHidden flag.
-func (m Model) applyVisibilityFilter(hosts []config.SSHHost) []config.SSHHost {
-	if m.showHidden {
-		return hosts
-	}
-	return config.FilterVisibleHosts(hosts)
-}
-
 // updateTableStyles updates the table header border color based on focus state
 func (m *Model) updateTableStyles() {
 	s := table.DefaultStyles()

internal/ui/tui.go

@@ -16,7 +16,7 @@ import (
 )
 
 // NewModel creates a new TUI model with the given SSH hosts
-func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, currentVersion string, noUpdateCheck bool) Model {
+func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
 	// Load application configuration
 	appConfig, err := config.LoadAppConfig()
 	if err != nil {
@@ -26,12 +26,6 @@ func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, curren
 		appConfig = &defaultConfig
 	}
 
-	// CLI flag overrides config file setting
-	if noUpdateCheck {
-		f := false
-		appConfig.CheckForUpdates = &f
-	}
-
 	// Initialize the history manager
 	historyManager, err := history.NewHistoryManager()
 	if err != nil {
@@ -44,11 +38,11 @@ func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, curren
 	styles := NewStyles(80) // Default width
 
 	// Initialize ping manager with 5 second timeout
-	pingManager := connectivity.NewPingManager(5*time.Second, configFile)
+	pingManager := connectivity.NewPingManager(5 * time.Second)
 
 	// Create the model with default sorting by name
 	m := Model{
-		allHosts:       hosts,
+		hosts:          hosts,
 		historyManager: historyManager,
 		pingManager:    pingManager,
 		sortMode:       SortByName,
@@ -60,24 +54,16 @@ func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, curren
 		height:         24,
 		ready:          false,
 		viewMode:       ViewList,
-		searchMode:     searchMode,
 	}
 
-	// Apply visibility filter (showHidden is false by default)
-	visibleHosts := m.applyVisibilityFilter(hosts)
-	m.hosts = visibleHosts
-
 	// Sort hosts according to the default sort mode
-	sortedHosts := m.sortHosts(visibleHosts)
+	sortedHosts := m.sortHosts(hosts)
 
 	// Create the search input
 	ti := textinput.New()
 	ti.Placeholder = "Search hosts or tags..."
 	ti.CharLimit = 50
 	ti.Width = 25
-	if searchMode {
-		ti.Focus()
-	}
 
 	// Use dynamic column width calculation (will fallback to static if width not available)
 	nameWidth, hostnameWidth, tagsWidth, lastLoginWidth := m.calculateDynamicColumnWidths(sortedHosts)
@@ -161,8 +147,8 @@ func NewModel(hosts []config.SSHHost, configFile string, searchMode bool, curren
 }
 
 // RunInteractiveMode starts the interactive TUI interface
-func RunInteractiveMode(hosts []config.SSHHost, configFile string, searchMode bool, currentVersion string, noUpdateCheck bool) error {
+func RunInteractiveMode(hosts []config.SSHHost, configFile, currentVersion string) error {
-	m := NewModel(hosts, configFile, searchMode, currentVersion, noUpdateCheck)
+	m := NewModel(hosts, configFile, currentVersion)
 
 	// Start the application in alt screen mode for clean output
 	p := tea.NewProgram(m, tea.WithAltScreen())

internal/ui/update.go

@@ -74,8 +74,8 @@ func (m Model) Init() tea.Cmd {
 	// Basic initialization commands
 	cmds = append(cmds, textinput.Blink)
 
-	// Check for version updates if we have a current version and updates are enabled
+	// Check for version updates if we have a current version
-	if m.currentVersion != "" && m.appConfig.IsUpdateCheckEnabled() {
+	if m.currentVersion != "" {
 		cmds = append(cmds, checkVersionCmd(m.currentVersion))
 	}
 
@@ -187,8 +187,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if err != nil {
 				return m, tea.Quit
 			}
-			m.allHosts = hosts
+			m.hosts = m.sortHosts(hosts)
-			m.hosts = m.sortHosts(m.applyVisibilityFilter(hosts))
 
 			// Reapply search filter if there is one active
 			if m.searchInput.Value() != "" {
@@ -232,8 +231,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if err != nil {
 				return m, tea.Quit
 			}
-			m.allHosts = hosts
+			m.hosts = m.sortHosts(hosts)
-			m.hosts = m.sortHosts(m.applyVisibilityFilter(hosts))
 
 			// Reapply search filter if there is one active
 			if m.searchInput.Value() != "" {
@@ -278,8 +276,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if err != nil {
 				return m, tea.Quit
 			}
-			m.allHosts = hosts
+			m.hosts = m.sortHosts(hosts)
-			m.hosts = m.sortHosts(m.applyVisibilityFilter(hosts))
 
 			// Reapply search filter if there is one active
 			if m.searchInput.Value() != "" {
@@ -455,7 +452,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		if m.deleteMode {
 			// Exit delete mode
 			m.deleteMode = false
-			m.deleteHost = nil
+			m.deleteHost = ""
 			m.table.Focus()
 			return m, nil
 		}
@@ -511,13 +508,15 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		} else if m.deleteMode {
 			// Confirm deletion
 			var err error
-			if m.deleteHost != nil {
+			if m.configFile != "" {
-				err = config.DeleteSSHHostWithLine(*m.deleteHost)
+				err = config.DeleteSSHHostFromFile(m.deleteHost, m.configFile)
+			} else {
+				err = config.DeleteSSHHost(m.deleteHost)
 			}
 			if err != nil {
 				// Could display an error message here
 				m.deleteMode = false
-				m.deleteHost = nil
+				m.deleteHost = ""
 				m.table.Focus()
 				return m, nil
 			}
@@ -534,12 +533,11 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			if parseErr != nil {
 				// Could display an error message here
 				m.deleteMode = false
-				m.deleteHost = nil
+				m.deleteHost = ""
 				m.table.Focus()
 				return m, nil
 			}
-			m.allHosts = hosts
+			m.hosts = m.sortHosts(hosts)
-			m.hosts = m.sortHosts(m.applyVisibilityFilter(hosts))
 
 			// Reapply search filter if there is one active
 			if m.searchInput.Value() != "" {
@@ -550,7 +548,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 
 			m.updateTableRows()
 			m.deleteMode = false
-			m.deleteHost = nil
+			m.deleteHost = ""
 			m.table.Focus()
 			return m, nil
 		} else {
@@ -675,13 +673,11 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case "d":
 		if !m.searchMode && !m.deleteMode {
 			// Delete the selected host
-			cursor := m.table.Cursor()
+			selected := m.table.SelectedRow()
-			if cursor >= 0 && cursor < len(m.filteredHosts) {
+			if len(selected) > 0 {
-				// Get the host at the cursor position (which corresponds to filteredHosts index)
+				hostName := extractHostNameFromTableRow(selected[0]) // Extract hostname from first column
-				targetHost := &m.filteredHosts[cursor]
-
 				m.deleteMode = true
-				m.deleteHost = targetHost
+				m.deleteHost = hostName
 				m.table.Blur()
 				return m, nil
 			}
@@ -709,19 +705,6 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.viewMode = ViewHelp
 			return m, nil
 		}
-	case "H":
-		if !m.searchMode && !m.deleteMode {
-			// Toggle visibility of hidden hosts
-			m.showHidden = !m.showHidden
-			m.hosts = m.sortHosts(m.applyVisibilityFilter(m.allHosts))
-			if m.searchInput.Value() != "" {
-				m.filteredHosts = m.filterHosts(m.searchInput.Value())
-			} else {
-				m.filteredHosts = m.hosts
-			}
-			m.updateTableRows()
-			return m, nil
-		}
 	case "s":
 		if !m.searchMode && !m.deleteMode {
 			// Cycle through sort modes (only 2 modes now)

internal/ui/view.go

@@ -86,14 +86,6 @@ func (m Model) renderListView() string {
 		components = append(components, errorStyle.Render("❌ "+m.errorMessage))
 	}
 
-	// Add indicator when hidden hosts are shown
-	if m.showHidden {
-		hiddenBannerStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("11")).
-			Bold(true)
-		components = append(components, hiddenBannerStyle.Render("  [showing hidden hosts — press H to hide]"))
-	}
-
 	// Add the search bar with the appropriate style based on focus
 	searchPrompt := "Search (/ to focus): "
 	if m.searchMode {
@@ -152,11 +144,7 @@ func (m Model) renderListView() string {
 func (m Model) renderDeleteConfirmation() string {
 	// Remove emojis (uncertain width depending on terminal) to stabilize the frame
 	title := "DELETE SSH HOST"
-	hostName := ""
+	question := fmt.Sprintf("Are you sure you want to delete host '%s'?", m.deleteHost)
-	if m.deleteHost != nil {
-		hostName = m.deleteHost.Name
-	}
-	question := fmt.Sprintf("Are you sure you want to delete host '%s'?", hostName)
 	action := "This action cannot be undone."
 	help := "Enter: confirm • Esc: cancel"
 

internal/validation/ssh.go

@@ -11,7 +11,6 @@ import (
 )
 
 // ValidateHostname checks if a hostname is valid
-// Accepts regular hostnames, IP addresses, and SSH tokens like %h, %p, %r, %u, %n, %C, %d, %i, %k, %L, %l, %T
 func ValidateHostname(hostname string) bool {
 	if len(hostname) == 0 || len(hostname) > 253 {
 		return false
@@ -23,18 +22,7 @@ func ValidateHostname(hostname string) bool {
 		return false
 	}
 
-	// Check if hostname contains SSH tokens (e.g., %h, %p, %r, %u, %n, etc.)
+	hostnameRegex := regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$`)
-	// SSH tokens are documented in ssh_config(5) man page
-	sshTokenRegex := regexp.MustCompile(`%[hprunCdiklLT]`)
-	if sshTokenRegex.MatchString(hostname) {
-		// If it contains SSH tokens, it's a valid SSH config construct
-		return true
-	}
-
-	// RFC 1123: each label must start with alphanumeric, end with alphanumeric,
-	// and contain only alphanumeric and hyphens. Labels are 1-63 chars.
-	// A hostname is one or more labels separated by dots.
-	hostnameRegex := regexp.MustCompile(`^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]|[a-zA-Z0-9]{0,62})?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]|[a-zA-Z0-9]{0,62})?)*$`)
 	return hostnameRegex.MatchString(hostname)
 }
 
@@ -66,25 +54,6 @@ func ValidateIdentityFile(path string) bool {
 	if path == "" {
 		return true // Optional field
 	}
-	// SSH tokens (e.g. %d, %h, %r, %u) are resolved by SSH at connection time
-	sshTokenRegex := regexp.MustCompile(`%[hprunCdiklLT]`)
-	if sshTokenRegex.MatchString(path) {
-		return true
-	}
-	// Expand environment variables ($VAR and ${VAR}); track undefined ones
-	hasUndefined := false
-	path = os.Expand(path, func(key string) string {
-		val, ok := os.LookupEnv(key)
-		if !ok {
-			hasUndefined = true
-			return "$" + key
-		}
-		return val
-	})
-	// If any variable was undefined, accept the path (SSH will report the error)
-	if hasUndefined {
-		return true
-	}
 	// Expand ~ to home directory
 	if strings.HasPrefix(path, "~/") {
 		homeDir, err := os.UserHomeDir()

internal/validation/ssh_test.go

@@ -24,19 +24,6 @@ func TestValidateHostname(t *testing.T) {
 		{"hostname ending with dot", "example.com.", false},
 		{"hostname with hyphen", "my-server.com", true},
 		{"hostname starting with number", "1example.com", true},
-		{"multiple hyphens and subdomains", "my-host-name-01.cwd.pub.domain.net", true},
-		{"multiple hyphens", "my-host-name-01", true},
-		{"complex hostname with hyphens", "server-01-prod.data-center.example.com", true},
-		{"hostname with consecutive hyphens", "my--server.com", true},
-		{"single char labels", "a.b.c.d.com", true},
-		// SSH tokens support (issue #32 comment)
-		{"SSH token %h", "%h.server.com", true},
-		{"SSH token %p", "server.com:%p", true},
-		{"SSH token %r", "%r@server.com", true},
-		{"SSH token %u", "%u.example.com", true},
-		{"SSH token %n", "%n.domain.net", true},
-		{"SSH token %C", "host-%C.com", true},
-		{"multiple SSH tokens", "%h.%u.server.com", true},
 	}
 
 	for _, tt := range tests {
@@ -133,9 +120,6 @@ func TestValidateIdentityFile(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	// Set up an env var pointing to the valid file's directory for env var tests
-	t.Setenv("TEST_SSHM_DIR", tmpDir)
-
 	tests := []struct {
 		name string
 		path string
@@ -146,13 +130,6 @@ func TestValidateIdentityFile(t *testing.T) {
 		{"non-existent file", "/path/to/nonexistent", false},
 		// Skip tilde path test in CI environments where ~/.ssh/id_rsa may not exist
 		// {"tilde path", "~/.ssh/id_rsa", true}, // Will pass if file exists
-		// Environment variable expansion (issue #33)
-		{"env var $VAR/key defined", "$TEST_SSHM_DIR/test_key", true},
-		{"env var ${VAR}/key defined", "${TEST_SSHM_DIR}/test_key", true},
-		{"env var undefined", "$UNDEFINED_SSHM_VAR_XYZ/key", true},
-		// SSH tokens
-		{"SSH token %d", "%d/.ssh/id_rsa", true},
-		{"SSH token %h", "%h-key", true},
 	}
 
 	for _, tt := range tests {
@@ -180,7 +157,6 @@ func TestValidateHost(t *testing.T) {
 	if err := os.WriteFile(validIdentity, []byte("test"), 0600); err != nil {
 		t.Fatal(err)
 	}
-	t.Setenv("TEST_SSHM_HOST_DIR", tmpDir)
 
 	tests := []struct {
 		name     string
@@ -198,9 +174,6 @@ func TestValidateHost(t *testing.T) {
 		{"invalid hostname", "myserver", "invalid..hostname", "22", "", true},
 		{"invalid port", "myserver", "example.com", "99999", "", true},
 		{"invalid identity", "myserver", "example.com", "22", "/nonexistent", true},
-		// Environment variables and SSH tokens in identity (issue #33)
-		{"identity with env var", "myserver", "example.com", "22", "$TEST_SSHM_HOST_DIR/test_key", false},
-		{"identity with SSH token", "myserver", "example.com", "22", "%d/.ssh/id_rsa", false},
 	}
 
 	for _, tt := range tests {