Merge b43a67eb1a into 3d746ec49a

feat: auto ping after sshm turn on.
feat: add configurable key bindings with ESC quit disable option
2026-01-27 03:04:21 +01:00 · 2025-09-30 03:32:03 +00:00 · 2025-09-30 11:27:32 +08:00 · 2025-09-29 11:05:26 +08:00 · 2025-09-17 15:24:17 +02:00 · 2025-09-17 14:44:50 +02:00
37 changed files with 2436 additions and 348 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,134 +0,0 @@
-name: Build Binaries
-
-on:
-  push:
-    tags:
-      - '*'
-  release:
-    types: [created]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          # Linux AMD64
-          - goos: linux
-            goarch: amd64
-            suffix: linux-amd64
-          # Linux ARM64
-          - goos: linux
-            goarch: arm64
-            suffix: linux-arm64
-          # macOS AMD64 (Intel)
-          - goos: darwin
-            goarch: amd64
-            suffix: darwin-amd64
-          # macOS ARM64 (Apple Silicon)
-          - goos: darwin
-            goarch: arm64
-            suffix: darwin-arm64
-          # Windows AMD64
-          - goos: windows
-            goarch: amd64
-            suffix: windows-amd64
-          # Windows ARM64
-          - goos: windows
-            goarch: arm64
-            suffix: windows-arm64
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-
-    - name: Set up Go
-      uses: actions/setup-go@v5
-      with:
-        go-version: '1.23'
-
-    - name: Cache Go modules
-      uses: actions/cache@v4
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-go-
-
-    - name: Build binary
-      env:
-        GOOS: ${{ matrix.goos }}
-        GOARCH: ${{ matrix.goarch }}
-        CGO_ENABLED: 0
-      run: |
-        mkdir -p dist
-        VERSION=${GITHUB_REF#refs/tags/}
-        if [ "${{ matrix.goos }}" = "windows" ]; then
-          go build -ldflags="-s -w -X github.com/Gu1llaum-3/sshm/cmd.version=${VERSION}" -o dist/sshm-${{ matrix.suffix }}.exe .
-        else
-          go build -ldflags="-s -w -X github.com/Gu1llaum-3/sshm/cmd.version=${VERSION}" -o dist/sshm-${{ matrix.suffix }} .
-        fi
-
-    - name: Create archive
-      run: |
-        cd dist
-        if [ "${{ matrix.goos }}" = "windows" ]; then
-          zip sshm-${{ matrix.suffix }}.zip sshm-${{ matrix.suffix }}.exe
-          rm sshm-${{ matrix.suffix }}.exe
-        else
-          tar -czf sshm-${{ matrix.suffix }}.tar.gz sshm-${{ matrix.suffix }}
-          rm sshm-${{ matrix.suffix }}
-        fi
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: sshm-${{ matrix.suffix }}
-        path: |
-          dist/sshm-${{ matrix.suffix }}.tar.gz
-          dist/sshm-${{ matrix.suffix }}.zip
-
-  release:
-    name: Create Release
-    needs: build
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    
-    steps:
-    - name: Download all artifacts
-      uses: actions/download-artifact@v4
-      with:
-        path: ./artifacts
-        merge-multiple: true
-
-    - name: Prepare release assets
-      run: |
-        mkdir -p release
-        find ./artifacts -name "*.tar.gz" -exec cp {} ./release/ \;
-        find ./artifacts -name "*.zip" -exec cp {} ./release/ \;
-        ls -la ./release/
-
-    - name: Check if pre-release
-      id: check_prerelease
-      run: |
-        if [[ "${GITHUB_REF#refs/tags/}" == *"-beta"* ]] || [[ "${GITHUB_REF#refs/tags/}" == *"-alpha"* ]] || [[ "${GITHUB_REF#refs/tags/}" == *"-rc"* ]]; then
-          echo "is_prerelease=true" >> $GITHUB_OUTPUT
-        else
-          echo "is_prerelease=false" >> $GITHUB_OUTPUT
-        fi
-
-    - name: Create Release
-      uses: softprops/action-gh-release@v2
-      with:
-        files: ./release/*
-        draft: false
-        prerelease: ${{ steps.check_prerelease.outputs.is_prerelease }}
-        generate_release_notes: true
-        name: ${{ github.ref_name }}${{ steps.check_prerelease.outputs.is_prerelease == 'true' && ' (Pre-release)' || '' }}
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,39 @@
+name: Release with GoReleaser
+
+on:
+  push:
+    tags:
+      - '*'
+
+permissions:
+  contents: write
+  # Required for Homebrew tap updates
+  issues: write
+  pull-requests: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          # Fetch full history for changelog generation
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache: true
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          distribution: goreleaser
+          version: '~> v2'
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # Token for updating Homebrew tap (create this secret in your repo settings)
+          HOMEBREW_TAP_GITHUB_TOKEN: ${{ secrets.HOMEBREW_TAP_GITHUB_TOKEN }}
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -0,0 +1,135 @@
+version: 2
+project_name: sshm
+
+before:
+  hooks:
+  - go mod tidy
+  - go test ./...
+
+builds:
+- id: sshm
+  main: ./main.go
+  binary: sshm
+  goos:
+  - linux
+  - windows
+  - darwin
+  goarch:
+  - amd64
+  - arm64
+  - "386"
+  - arm
+  ignore:
+  # Skip ARM for Windows (not commonly used)
+  - goos: windows
+    goarch: arm
+  - goos: windows
+    goarch: arm64
+  env:
+  - CGO_ENABLED=0
+  ldflags:
+  - -s -w
+  - -X github.com/Gu1llaum-3/sshm/cmd.AppVersion={{.Version}}
+  flags:
+  - -trimpath
+
+archives:
+- id: sshm
+  formats: [ "tar.gz" ]
+  # Use zip for Windows
+  format_overrides:
+  - goos: windows
+    formats: [ "zip" ]
+  # Template for archive name
+  name_template: >-
+    {{ .ProjectName }}_ {{- title .Os }}_ {{- if eq .Arch "amd64" }}x86_64 {{- else if eq .Arch "386" }}i386 {{- else }}{{ .Arch }}{{ end }} {{- if .Arm }}v{{ .Arm }}{{ end }}
+  files:
+  - LICENSE
+  - README.md
+
+checksum:
+  name_template: "checksums.txt"
+  algorithm: sha256
+
+changelog:
+  use: github
+  sort: asc
+  filters:
+    exclude:
+    - "^docs:"
+    - "^test:"
+    - "^ci:"
+    - "^chore:"
+    - "^build:"
+  groups:
+  - title: Features
+    regexp: '^.*?feat(\([[:word:]]+\))??!?:.+$'
+    order: 0
+  - title: Bug fixes
+    regexp: '^.*?fix(\([[:word:]]+\))??!?:.+$'
+    order: 1
+  - title: Others
+    order: 999
+
+# Homebrew tap configuration (Formula pour CLI)
+brews:
+- name: sshm
+  repository:
+    owner: Gu1llaum-3
+    name: homebrew-sshm
+    # Token with repo permissions for your homebrew-sshm repo
+    token: "{{ .Env.HOMEBREW_TAP_GITHUB_TOKEN }}"
+  commit_author:
+    name: goreleaserbot
+    email: bot@goreleaser.com
+  commit_msg_template: "Brew formula update for {{ .ProjectName }} version {{ .Tag }}"
+  homepage: "https://github.com/Gu1llaum-3/sshm"
+  description: "A modern SSH connection manager for your terminal"
+  license: MIT
+  skip_upload: auto
+  # Test command to verify installation
+  test: |
+    system "#{bin}/sshm --version"
+
+# Release configuration
+release:
+  github:
+    owner: Gu1llaum-3
+    name: sshm
+  prerelease: auto
+  draft: false
+  replace_existing_draft: true
+  target_commitish: "{{ .Commit }}"
+  name_template: "{{.ProjectName}} {{.Version}}"
+  header: |
+    ## SSHM {{.Version}}
+
+    Thank you for downloading SSHM! 
+
+    ### Installation
+
+    **Homebrew (macOS/Linux):**
+    ```bash
+    brew tap Gu1llaum-3/sshm
+    brew install sshm
+    ```
+
+    **Manual Installation:**
+    Download the appropriate binary for your platform from the assets below.
+
+  footer: |
+    ## Full Changelog
+
+    See all changes at https://github.com/Gu1llaum-3/sshm/compare/{{.PreviousTag}}...{{.Tag}}
+
+    ---
+
+    Released with ❤️ by [GoReleaser](https://github.com/goreleaser/goreleaser)
+
+# Snapshot builds (for non-tag builds)
+snapshot:
+  version_template: "{{ .Tag }}-snapshot-{{.ShortCommit}}"
+
+# Metadata for package managers
+metadata:
+  mod_timestamp: "{{ .CommitTimestamp }}"
--- a/CONFIG.md
+++ b/CONFIG.md
@@ -0,0 +1,66 @@
+# SSHM Configuration
+
+SSHM supports configurable key bindings through a configuration file located at:
+- Linux/macOS: `~/.config/sshm/config.json`
+- Windows: `%APPDATA%\sshm\config.json`
+
+## Configuration Options
+
+### Key Bindings
+
+The key bindings section allows you to customize how you exit the application.
+
+#### Example Configuration
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": true
+  }
+}
+```
+
+#### Options
+
+- **quit_keys**: Array of keys that will quit the application. Default: `["q", "ctrl+c"]`
+- **disable_esc_quit**: Boolean flag to disable ESC key from quitting the application. Default: `false`
+
+## For Vim Users
+
+If you're a vim user and frequently press ESC accidentally causing the application to quit, set `disable_esc_quit` to `true`:
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": true
+  }
+}
+```
+
+With this configuration:
+- ESC will no longer quit the application
+- You can still quit using 'q' or Ctrl+C
+- All other functionality remains the same
+
+## Default Configuration
+
+If no configuration file exists, SSHM will create one with these defaults:
+
+```json
+{
+  "key_bindings": {
+    "quit_keys": ["q", "ctrl+c"],
+    "disable_esc_quit": false
+  }
+}
+```
+
+This ensures backward compatibility - ESC will continue to work as a quit key by default.
+
+## Configuration Location
+
+The configuration file will be automatically created when you first run SSHM. You can manually edit it to customize the key bindings to your preference.
+
+If you encounter any issues with the configuration file, you can delete it and SSHM will recreate it with default settings on the next run.
--- a/44
+++ b/44
@@ -0,0 +1,44 @@
+.PHONY: build build-local test clean release snapshot
+
+# Version can be overridden via environment variable or command line
+VERSION ?= dev
+
+# Go build flags
+LDFLAGS := -s -w -X github.com/Gu1llaum-3/sshm/cmd.AppVersion=$(VERSION)
+
+# Build with specific version
+build:
+	@mkdir -p dist
+	go build -ldflags="$(LDFLAGS)" -o dist/sshm .
+
+# Build with git version
+build-local: VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+build-local: build
+
+# Run tests
+test:
+	go test ./...
+
+# Clean build artifacts
+clean:
+	rm -rf dist
+
+# Release with GoReleaser (requires tag)
+release:
+	@if [ -z "$(shell git tag --points-at HEAD)" ]; then \
+		echo "Error: No git tag found at current commit. Create a tag first with: git tag vX.Y.Z"; \
+		exit 1; \
+	fi
+	goreleaser release --clean
+
+# Build snapshot (without tag)
+snapshot:
+	goreleaser release --snapshot --clean
+
+# Check GoReleaser config
+release-check:
+	goreleaser check
+
+# Run GoReleaser in dry-run mode
+release-dry-run:
+	goreleaser release --snapshot --skip=publish --clean
--- a/README.md
+++ b/README.md
@@ -25,40 +25,39 @@ SSHM is a beautiful command-line tool that transforms how you manage and connect

 ## ✨ Features

-### 🎯 **Core Features**
+### 🚀 **Core Capabilities**
 - **🎨 Beautiful TUI Interface** - Navigate your SSH hosts with an elegant, interactive terminal UI
- **⚡ Quick Connect** - Connect to any host instantly
- **🔄 Port Forwarding** - Easy setup for Local, Remote, and Dynamic (SOCKS) forwarding
- **📝Easy Management** - Add, edit, and manage SSH configurations seamlessly
+- **⚡ 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
 - **🔍 Smart Search** - Find hosts quickly with built-in filtering and search
+- **📝 Real-time Status** - Live SSH connectivity indicators with asynchronous ping checks and color-coded status
+- **🔔 Smart Updates** - Automatic version checking with update notifications
+- **📈 Connection History** - Track your SSH connections with last login timestamps
+
+### 🛠️ **Technical Features**
 - **🔒 Secure** - Works directly with your existing `~/.ssh/config` file
 - **📁 Custom Config Support** - Use any SSH configuration file with the `-c` flag
 - **📂 SSH Include Support** - Full support for SSH Include directives to organize configurations across multiple files
 - **⚙️ SSH Options Support** - Add any SSH configuration option through intuitive forms
 - **🔄 Automatic Conversion** - Seamlessly converts between command-line and config formats
-
-### 🛠️ **Management Operations**
- **Add new SSH hosts** with interactive forms
- **Edit existing configurations** in-place
- **Delete hosts** with confirmation prompts
- **Port forwarding setup** with intuitive interface for Local (-L), Remote (-R), and Dynamic (-D) forwarding
- **Backup configurations** automatically before changes
- **Validate settings** to prevent configuration errors
- **ProxyJump support** for secure connection tunneling through bastion hosts
- **SSH Options management** - Add any SSH option with automatic format conversion
- **Full SSH compatibility** - Maintains compatibility with standard SSH tools
-
-### 🎮 **User Experience**
- **Zero configuration** - Works out of the box with your existing SSH setup
- **Keyboard shortcuts** for power users
- **Cross-platform** - Supports Linux, macOS (Intel & Apple Silicon), and Windows
- **Lightweight** - Single binary with no dependencies
+- **🔄 Automatic Backups** - Backup configurations automatically before changes
+- **✅ Validation** - Prevent configuration errors with built-in validation
+- **🔗 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

 ## 🚀 Quick Start

 ### Installation

+**Homebrew (Recommended for macOS):**
+```bash
+brew install Gu1llaum-3/sshm/sshm
+```
+
 **Unix/Linux/macOS (One-line install):**
 ```bash
 curl -sSL https://raw.githubusercontent.com/Gu1llaum-3/sshm/main/install/unix.sh | bash
@@ -105,10 +104,17 @@ sshm
 - `a` - Add new host
 - `e` - Edit selected host
 - `d` - Delete selected host
+- `m` - Move host to another config file (requires SSH Include directives)
 - `f` - Port forwarding setup
 - `q` - Quit
 - `/` - Search/filter hosts

+**Real-time Status Indicators:**
+- 🟢 **Online** - Host is reachable via SSH
+- 🟡 **Connecting** - Currently checking host connectivity
+- 🔴 **Offline** - Host is unreachable or SSH connection failed
+- ⚫ **Unknown** - Connectivity status not yet determined
+
 **Sorting & Filtering:**
 - `s` - Switch between sorting modes (name ↔ last login)
 - `n` - Sort by **name** (alphabetical)
@@ -158,6 +164,7 @@ SSHM provides an intuitive interface for setting up SSH port forwarding. Press `
 - Configure ports and addresses with guided forms
 - Optional bind address configuration (defaults to 127.0.0.1)
 - Real-time validation of port numbers and addresses
+- **Port forwarding history** - Save frequently used configurations for quick reuse
 - Connect automatically with configured forwarding options

 **Troubleshooting Port Forwarding:**
@@ -218,9 +225,15 @@ SSHM provides both command-line operations and an interactive TUI interface:
 # Launch interactive TUI mode for browsing and connecting to hosts
 sshm

+# Connect directly to a specific host (with history tracking)
+sshm my-server
+
 # Launch TUI with custom SSH config file
 sshm -c /path/to/custom/ssh_config

+# Connect directly with custom SSH config file
+sshm my-server -c /path/to/custom/ssh_config
+
 # Add a new host using interactive form
 sshm add

@@ -236,13 +249,42 @@ sshm edit my-server
 # Edit host with custom SSH config file
 sshm edit my-server -c /path/to/custom/ssh_config

-# Show version information
+# Move a host to another SSH config file (requires Include directives)
+sshm move my-server
+
+# Move host with custom SSH config file (requires Include directives)
+sshm move my-server -c /path/to/custom/ssh_config
+
+# Search for hosts (interactive filter)
+sshm search
+
+# Show version information (includes update check)
 sshm --version

 # Show help and available commands
 sshm --help
 ```

+### Direct Host Connection
+
+SSHM supports direct connection to hosts via the command line, making it easy to integrate into your existing workflow:
+
+```bash
+# Connect directly to any configured host
+sshm production-server
+sshm db-staging
+sshm web-01
+
+# All direct connections are tracked in your history
+# Use the TUI to see your most recently connected hosts
+```
+
+**Features of Direct Connection:**
+- **Instant connection** - No TUI navigation required
+- **History tracking** - All connections are recorded with timestamps
+- **Error handling** - Clear messages if host doesn't exist or configuration issues
+- **Config file support** - Works with custom config files using `-c` flag
+
 ### Backup Configuration

 SSHM automatically creates backups of your SSH configuration files before making any changes to ensure your configurations are safe.
@@ -257,6 +299,10 @@ SSHM automatically creates backups of your SSH configuration files before making
 - Stored separately to avoid SSH Include conflicts
 - Easy manual recovery if needed

+**Additional Storage:**
+- **Connection History**: Stored in the same config directory for persistent tracking
+- **Port Forwarding History**: Saved configurations for quick reuse of common forwarding setups
+
 **Quick Recovery:**
 ```bash
 # Unix/Linux/macOS
@@ -277,8 +323,96 @@ sshm -c /path/to/custom/ssh_config
 # Use custom config file with commands
 sshm add hostname -c /path/to/custom/ssh_config
 sshm edit hostname -c /path/to/custom/ssh_config
+sshm move hostname -c /path/to/custom/ssh_config
 ```

+### Advanced Features
+
+#### Host Movement Between Config Files
+
+SSHM provides a powerful `move` command to relocate SSH hosts between different configuration files. **This feature requires SSH Include directives to be present in your SSH configuration.**
+
+```bash
+# Move a host to another config file (requires Include directives)
+sshm move my-server
+
+# Move with custom config file (requires Include directives)
+sshm move my-server -c /path/to/custom/ssh_config
+```
+
+**⚠️ Important Requirements:**
+- **SSH Include directives must be present** in your SSH config file (either `~/.ssh/config` or the file specified with `-c`)
+- The config file must contain `Include` statements referencing other SSH configuration files
+- Without Include directives, the move command will display an error message
+
+**Features:**
+- **Interactive file selector** - Choose destination config file from Include directives
+- **Include support** - Works seamlessly with SSH Include directives structure
+- **Atomic operations** - Safe host movement with automatic backups
+- **Validation** - Prevents conflicts and ensures configuration integrity
+- **Error handling** - Clear messages when Include files are needed but not found
+
+**Use Cases:**
+- Reorganize hosts from main config to specialized include files
+- Move development hosts to separate environment-specific configs
+- Consolidate configurations for better organization
+
+**Example Setup Required:**
+Your main SSH config file must contain Include directives like:
+```ssh
+# ~/.ssh/config
+Include ~/.ssh/config.d/*
+Include work-servers.conf
+Include projects/*.conf
+
+Host personal-server
+    HostName personal.example.com
+    User myuser
+```
+
+#### Real-time Connectivity Status
+
+SSHM features asynchronous SSH connectivity checking that provides visual indicators of host availability:
+
+**Status Indicators:**
+- 🟢 **Online** - SSH connection successful (shows response time)
+- 🟡 **Connecting** - Currently testing connectivity
+- 🔴 **Offline** - SSH connection failed or host unreachable
+- ⚫ **Unknown** - Status not yet determined
+
+**Features:**
+- **Non-blocking checks** - Status updates happen in the background
+- **Response time tracking** - See connection latency for online hosts
+- **Automatic refresh** - Status indicators update continuously
+- **Error details** - Detailed error information for failed connections
+
+#### Automatic Update Checking
+
+SSHM includes built-in version checking that notifies you of available updates:
+
+**Features:**
+- **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
+
+**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
+
+#### Port Forwarding History
+
+SSHM remembers your port forwarding configurations for easy reuse:
+
+**Features:**
+- **Automatic saving** - Successful forwarding setups are saved automatically
+- **Quick reuse** - Previously used configurations appear as suggestions
+- **Per-host history** - Forwarding history is tracked per SSH host
+- **All forward types** - Supports Local (-L), Remote (-R), and Dynamic (-D) forwarding history
+- **Persistent storage** - History survives application restarts
+
 ### Platform-Specific Notes

 **Windows:**
@@ -449,20 +583,29 @@ sshm/
 │   ├── root.go         # Root command and interactive mode
 │   ├── add.go          # Add host command
 │   ├── edit.go         # Edit host command
+│   ├── move.go         # Move host command
 │   └── search.go       # Search command
 ├── internal/
 │   ├── config/         # SSH configuration management
 │   │   └── ssh.go      # Config parsing and manipulation
+│   ├── connectivity/   # SSH connectivity checking
+│   │   └── ping.go     # Asynchronous SSH ping functionality
 │   ├── history/        # Connection history tracking
-│   │   └── history.go  # History management and last login tracking
+│   │   ├── history.go  # History management and last login tracking
+│   │   └── port_forward_test.go # Port forwarding history tests
+│   ├── version/        # Version checking and updates
+│   │   ├── version.go  # GitHub release checking and version comparison
+│   │   └── version_test.go # Version parsing and comparison tests
 │   ├── ui/             # Terminal UI components (Bubble Tea)
 │   │   ├── tui.go      # Main TUI interface and program setup
 │   │   ├── model.go    # Core TUI model and state
 │   │   ├── update.go   # Message handling and state updates
 │   │   ├── view.go     # UI rendering and layout
-│   │   ├── table.go    # Host list table component
+│   │   ├── table.go    # Host list table component with status indicators
 │   │   ├── add_form.go # Add host form interface
 │   │   ├── edit_form.go# Edit host form interface
+│   │   ├── move_form.go# Move host form interface
+│   │   ├── port_forward_form.go # Port forwarding setup with history
 │   │   ├── styles.go   # Lip Gloss styling definitions
 │   │   ├── sort.go     # Sorting and filtering logic
 │   │   └── utils.go    # UI utility functions
@@ -490,6 +633,7 @@ sshm/
 - [Bubble Tea](https://github.com/charmbracelet/bubbletea) - TUI framework
 - [Bubbles](https://github.com/charmbracelet/bubbles) - TUI components
 - [Lipgloss](https://github.com/charmbracelet/lipgloss) - Styling
+- [Go Crypto SSH](https://golang.org/x/crypto/ssh) - SSH connectivity checking

 ## 📦 Releases

--- a/cmd/add.go
+++ b/cmd/add.go
@@ -2,6 +2,7 @@ package cmd

 import (
 	"fmt"
+
 	"github.com/Gu1llaum-3/sshm/internal/ui"

 	"github.com/spf13/cobra"
@@ -26,5 +27,5 @@ var addCmd = &cobra.Command{
 }

 func init() {
-	rootCmd.AddCommand(addCmd)
+	RootCmd.AddCommand(addCmd)
 }
--- a/cmd/add_test.go
+++ b/cmd/add_test.go
@@ -38,7 +38,7 @@ func TestAddCommand(t *testing.T) {
 func TestAddCommandRegistration(t *testing.T) {
 	// Check that add command is registered with root command
 	found := false
-	for _, cmd := range rootCmd.Commands() {
+	for _, cmd := range RootCmd.Commands() {
 		if cmd.Name() == "add" {
 			found = true
 			break
--- a/cmd/edit.go
+++ b/cmd/edit.go
@@ -2,6 +2,7 @@ package cmd

 import (
 	"fmt"
+
 	"github.com/Gu1llaum-3/sshm/internal/ui"

 	"github.com/spf13/cobra"
@@ -23,5 +24,5 @@ var editCmd = &cobra.Command{
 }

 func init() {
-	rootCmd.AddCommand(editCmd)
+	RootCmd.AddCommand(editCmd)
 }
--- a/cmd/edit_test.go
+++ b/cmd/edit_test.go
@@ -37,7 +37,7 @@ func TestEditCommand(t *testing.T) {
 func TestEditCommandRegistration(t *testing.T) {
 	// Check that edit command is registered with root command
 	found := false
-	for _, cmd := range rootCmd.Commands() {
+	for _, cmd := range RootCmd.Commands() {
 		if cmd.Name() == "edit" {
 			found = true
 			break
--- a/cmd/move.go
+++ b/cmd/move.go
@@ -0,0 +1,28 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/Gu1llaum-3/sshm/internal/ui"
+
+	"github.com/spf13/cobra"
+)
+
+var moveCmd = &cobra.Command{
+	Use:   "move <hostname>",
+	Short: "Move an existing SSH host configuration to another config file",
+	Long:  `Move an existing SSH host configuration to another config file with an interactive file selector.`,
+	Args:  cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		hostname := args[0]
+
+		err := ui.RunMoveForm(hostname, configFile)
+		if err != nil {
+			fmt.Printf("Error moving host: %v\n", err)
+		}
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(moveCmd)
+}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -1,45 +1,57 @@
 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"
 )

-// version will be set at build time via -ldflags
-var version = "dev"
+// AppVersion will be set at build time via -ldflags
+var AppVersion = "dev"

 // configFile holds the path to the SSH config file
 var configFile string

-var rootCmd = &cobra.Command{
-	Use:   "sshm",
+// RootCmd is the base command when called without any subcommands
+var RootCmd = &cobra.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.

-You can also use sshm in CLI mode for direct operations.
+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.`,
-	Version: version,
-	Run: func(cmd *cobra.Command, args []string) {
+	Version:       AppVersion,
+	Args:          cobra.ArbitraryArgs,
+	SilenceUsage:  true,
+	SilenceErrors: true, // We'll handle errors ourselves
+	RunE: func(cmd *cobra.Command, args []string) error {
 		// If no arguments provided, run interactive mode
 		if len(args) == 0 {
 			runInteractiveMode()
-			return
+			return nil
 		}

 		// If a host name is provided, connect directly
 		hostName := args[0]
 		connectToHost(hostName)
+		return nil
 	},
 }

@@ -85,7 +97,7 @@ func runInteractiveMode() {
 	}

 	// Run the interactive TUI
-	if err := ui.RunInteractiveMode(hosts, configFile); err != nil {
+	if err := ui.RunInteractiveMode(hosts, configFile, AppVersion); err != nil {
 		log.Fatalf("Error running interactive mode: %v", err)
 	}
 }
@@ -120,25 +132,88 @@ func connectToHost(hostName string) {
 		os.Exit(1)
 	}

-	// Connect to the host
-	fmt.Printf("Connecting to %s...\n", hostName)
-
-	// Build the SSH command with the appropriate config file
-	var sshCmd []string
-	if configFile != "" {
-		sshCmd = []string{"ssh", "-F", configFile, hostName}
+	// 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 {
-		sshCmd = []string{"ssh", hostName}
+		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)
+		}
 	}

-	// Note: In a real implementation, you'd use exec.Command here
-	// For now, just print the command that would be executed
-	fmt.Printf("%s\n", strings.Join(sshCmd, " "))
+	// Build and execute the SSH command
+	fmt.Printf("Connecting to %s...\n", hostName)
+
+	var sshCmd *exec.Cmd
+	if configFile != "" {
+		sshCmd = exec.Command("ssh", "-F", configFile, hostName)
+	} else {
+		sshCmd = exec.Command("ssh", hostName)
+	}
+
+	// Set up the command to use the same stdin, stdout, and stderr as the parent process
+	sshCmd.Stdin = os.Stdin
+	sshCmd.Stdout = os.Stdout
+	sshCmd.Stderr = os.Stderr
+
+	// Execute the SSH command
+	err = sshCmd.Run()
+	if err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			// SSH command failed, exit with the same code
+			if status, ok := exitError.Sys().(syscall.WaitStatus); ok {
+				os.Exit(status.ExitStatus())
+			}
+		}
+		fmt.Printf("Error executing SSH command: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+// 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() {
-	if err := rootCmd.Execute(); err != nil {
+	// Custom error handling for unknown commands that might be host names
+	if err := RootCmd.Execute(); err != nil {
+		// Check if this is an "unknown command" error and the argument might be a host name
+		errStr := err.Error()
+		if strings.Contains(errStr, "unknown command") {
+			// Extract the command name from the error
+			parts := strings.Split(errStr, "\"")
+			if len(parts) >= 2 {
+				potentialHost := parts[1]
+				// Try to connect to this as a host
+				connectToHost(potentialHost)
+				return
+			}
+		}
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		os.Exit(1)
 	}
@@ -146,5 +221,8 @@ func Execute() {

 func init() {
 	// Add the config file flag
-	rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "SSH config file to use (default: ~/.ssh/config)")
+	RootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "SSH config file to use (default: ~/.ssh/config)")
+
+	// Set custom version template with update check
+	RootCmd.SetVersionTemplate(getVersionWithUpdateCheck())
 }
--- a/cmd/root_test.go
+++ b/cmd/root_test.go
@@ -8,27 +8,28 @@ import (

 func TestRootCommand(t *testing.T) {
 	// Test that the root command is properly configured
-	if rootCmd.Use != "sshm" {
-		t.Errorf("Expected Use 'sshm', 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" {
-		t.Errorf("Expected Short description, got '%s'", rootCmd.Short)
+	if RootCmd.Short != "SSH Manager - A modern SSH connection manager" {
+		t.Errorf("Expected Short description, got '%s'", RootCmd.Short)
 	}

-	if rootCmd.Version != version {
-		t.Errorf("Expected Version '%s', got '%s'", version, rootCmd.Version)
+	if RootCmd.Version != AppVersion {
+		t.Errorf("Expected Version '%s', got '%s'", AppVersion, RootCmd.Version)
 	}
 }

 func TestRootCommandFlags(t *testing.T) {
 	// Test that persistent flags are properly configured
-	flags := rootCmd.PersistentFlags()
+	flags := RootCmd.PersistentFlags()

 	// Check config flag
 	configFlag := flags.Lookup("config")
 	if configFlag == nil {
 		t.Error("Expected --config flag to be defined")
+		return
 	}
 	if configFlag.Shorthand != "c" {
 		t.Errorf("Expected config flag shorthand 'c', got '%s'", configFlag.Shorthand)
@@ -40,7 +41,7 @@ func TestRootCommandSubcommands(t *testing.T) {
 	// Note: completion and help are automatically added by Cobra and may not always appear in Commands()
 	expectedCommands := []string{"add", "edit", "search"}

-	commands := rootCmd.Commands()
+	commands := RootCmd.Commands()
 	commandNames := make(map[string]bool)
 	for _, cmd := range commands {
 		commandNames[cmd.Name()] = true
@@ -61,11 +62,11 @@ func TestRootCommandSubcommands(t *testing.T) {
 func TestRootCommandHelp(t *testing.T) {
 	// Test help output
 	buf := new(bytes.Buffer)
-	rootCmd.SetOut(buf)
-	rootCmd.SetArgs([]string{"--help"})
+	RootCmd.SetOut(buf)
+	RootCmd.SetArgs([]string{"--help"})

 	// This should not return an error for help
-	err := rootCmd.Execute()
+	err := RootCmd.Execute()
 	if err != nil {
 		t.Errorf("Expected no error for help command, got %v", err)
 	}
@@ -82,16 +83,16 @@ func TestRootCommandHelp(t *testing.T) {
 func TestRootCommandVersion(t *testing.T) {
 	// Test that version command executes without error
 	// Note: Cobra handles version output internally, so we just check for no error
-	rootCmd.SetArgs([]string{"--version"})
+	RootCmd.SetArgs([]string{"--version"})

 	// This should not return an error for version
-	err := rootCmd.Execute()
+	err := RootCmd.Execute()
 	if err != nil {
 		t.Errorf("Expected no error for version command, got %v", err)
 	}

 	// Reset args for other tests
-	rootCmd.SetArgs([]string{})
+	RootCmd.SetArgs([]string{})
 }

 func TestExecuteFunction(t *testing.T) {
@@ -124,8 +125,8 @@ func TestConfigFileVariable(t *testing.T) {
 	defer func() { configFile = originalConfigFile }()

 	// Set config file through flag
-	rootCmd.SetArgs([]string{"--config", "/tmp/test-config"})
-	rootCmd.ParseFlags([]string{"--config", "/tmp/test-config"})
+	RootCmd.SetArgs([]string{"--config", "/tmp/test-config"})
+	RootCmd.ParseFlags([]string{"--config", "/tmp/test-config"})

 	// The configFile variable should be updated by the flag parsing
 	// Note: This test verifies the flag binding works
@@ -133,12 +134,12 @@ func TestConfigFileVariable(t *testing.T) {

 func TestVersionVariable(t *testing.T) {
 	// Test that version variable has a default value
-	if version == "" {
-		t.Error("version variable should have a default value")
+	if AppVersion == "" {
+		t.Error("AppVersion variable should have a default value")
 	}

 	// Test that version is set to "dev" by default
-	if version != "dev" {
-		t.Logf("version is set to '%s' (expected 'dev' for development)", version)
+	if AppVersion != "dev" {
+		t.Logf("AppVersion is set to '%s' (expected 'dev' for development)", AppVersion)
 	}
 }
--- a/cmd/search.go
+++ b/cmd/search.go
@@ -235,7 +235,7 @@ func escapeJSON(s string) string {

 func init() {
 	// Add search command to root
-	rootCmd.AddCommand(searchCmd)
+	RootCmd.AddCommand(searchCmd)

 	// Add flags
 	searchCmd.Flags().StringVarP(&outputFormat, "format", "f", "table", "Output format (table, json, simple)")
--- a/cmd/search_test.go
+++ b/cmd/search_test.go
@@ -36,7 +36,7 @@ func TestSearchCommand(t *testing.T) {
 func TestSearchCommandRegistration(t *testing.T) {
 	// Check that search command is registered with root command
 	found := false
-	for _, cmd := range rootCmd.Commands() {
+	for _, cmd := range RootCmd.Commands() {
 		if cmd.Name() == "search" {
 			found = true
 			break
--- a/install/unix.sh
+++ b/install/unix.sh
@@ -56,7 +56,25 @@ getLatestVersion() {
 }

 downloadBinary() {
-    GITHUB_FILE="sshm-${OS}-${ARCH}.tar.gz"
+    # Map OS names to match GoReleaser format
+    local GORELEASER_OS="$OS"
+    case $OS in
+        "darwin") GORELEASER_OS="Darwin" ;;
+        "linux") GORELEASER_OS="Linux" ;;
+        "windows") GORELEASER_OS="Windows" ;;
+    esac
+    
+    # Map architecture names to match GoReleaser format  
+    local GORELEASER_ARCH="$ARCH"
+    case $ARCH in
+        "amd64") GORELEASER_ARCH="x86_64" ;;
+        "arm64") GORELEASER_ARCH="arm64" ;;
+        "386") GORELEASER_ARCH="i386" ;;
+        "arm") GORELEASER_ARCH="armv6" ;;
+    esac
+    
+    # GoReleaser format: sshm_Darwin_arm64.tar.gz
+    GITHUB_FILE="sshm_${GORELEASER_OS}_${GORELEASER_ARCH}.tar.gz"
    GITHUB_URL="https://github.com/Gu1llaum-3/sshm/releases/download/$LATEST_VERSION/$GITHUB_FILE"
    
    printf "${YELLOW}Downloading $GITHUB_FILE...${NC}\n"
@@ -74,8 +92,8 @@ downloadBinary() {
        exit 1
    fi
    
-    # Check if the expected binary exists (no find needed)
-    EXTRACTED_BINARY="./sshm-${OS}-${ARCH}"
+    # GoReleaser extracts the binary as just "sshm", not with the platform suffix
+    EXTRACTED_BINARY="./sshm"
    if [ ! -f "$EXTRACTED_BINARY" ]; then
        printf "${RED}Could not find extracted binary: $EXTRACTED_BINARY${NC}\n"
        exit 1
--- a/install/windows.ps1
+++ b/install/windows.ps1
@@ -80,7 +80,11 @@ if ($LocalBinary -ne "") {
    }

    # Download binary
-    $fileName = "sshm-windows-$arch.zip"
+    # Map architecture to match GoReleaser format
+    $goreleaserArch = if ($arch -eq "amd64") { "x86_64" } else { "i386" }
+    
+    # GoReleaser format: sshm_Windows_x86_64.zip
+    $fileName = "sshm_Windows_$goreleaserArch.zip"
    $downloadUrl = "https://github.com/Gu1llaum-3/sshm/releases/download/$latestVersion/$fileName"
    $tempFile = "$env:TEMP\$fileName"

@@ -101,7 +105,8 @@ if ($LocalBinary -ne "") {
    Write-Info "Extracting..."
    try {
        Expand-Archive -Path $tempFile -DestinationPath $env:TEMP -Force
-        $extractedBinary = "$env:TEMP\sshm-windows-$arch.exe"
+        # GoReleaser extracts the binary as just "sshm.exe", not with platform suffix
+        $extractedBinary = "$env:TEMP\sshm.exe"
        $targetPath = "$InstallDir\sshm.exe"
        
        Move-Item -Path $extractedBinary -Destination $targetPath -Force
--- a/internal/config/keybindings.go
+++ b/internal/config/keybindings.go
@@ -0,0 +1,146 @@
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+)
+
+// KeyBindings represents configurable key bindings for the application
+type KeyBindings struct {
+	// Quit keys - keys that will quit the application
+	QuitKeys []string `json:"quit_keys"`
+
+	// DisableEscQuit - if true, ESC key won't quit the application (useful for vim users)
+	DisableEscQuit bool `json:"disable_esc_quit"`
+}
+
+// AppConfig represents the main application configuration
+type AppConfig struct {
+	KeyBindings KeyBindings `json:"key_bindings"`
+}
+
+// GetDefaultKeyBindings returns the default key bindings configuration
+func GetDefaultKeyBindings() KeyBindings {
+	return KeyBindings{
+		QuitKeys:       []string{"q", "ctrl+c"}, // Default keeps current behavior minus ESC
+		DisableEscQuit: false,                   // Default to false for backward compatibility
+	}
+}
+
+// GetDefaultAppConfig returns the default application configuration
+func GetDefaultAppConfig() AppConfig {
+	return AppConfig{
+		KeyBindings: GetDefaultKeyBindings(),
+	}
+}
+
+// GetAppConfigPath returns the path to the application config file
+func GetAppConfigPath() (string, error) {
+	configDir, err := GetSSHMConfigDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(configDir, "config.json"), nil
+}
+
+// LoadAppConfig loads the application configuration from file
+// If the file doesn't exist, it returns the default configuration
+func LoadAppConfig() (*AppConfig, error) {
+	configPath, err := GetAppConfigPath()
+	if err != nil {
+		return nil, err
+	}
+
+	// If config file doesn't exist, return default config and create the file
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		defaultConfig := GetDefaultAppConfig()
+
+		// Create config directory if it doesn't exist
+		configDir := filepath.Dir(configPath)
+		if err := os.MkdirAll(configDir, 0755); err != nil {
+			return nil, err
+		}
+
+		// Save default config to file
+		if err := SaveAppConfig(&defaultConfig); err != nil {
+			// If we can't save, just return the default config without erroring
+			// This allows the app to work even if config file can't be created
+			return &defaultConfig, nil
+		}
+
+		return &defaultConfig, nil
+	}
+
+	// Read existing config file
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var config AppConfig
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, err
+	}
+
+	// Validate and fill in missing fields with defaults
+	config = mergeWithDefaults(config)
+
+	return &config, nil
+}
+
+// SaveAppConfig saves the application configuration to file
+func SaveAppConfig(config *AppConfig) error {
+	if config == nil {
+		return errors.New("config cannot be nil")
+	}
+
+	configPath, err := GetAppConfigPath()
+	if err != nil {
+		return err
+	}
+
+	// Create config directory if it doesn't exist
+	configDir := filepath.Dir(configPath)
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(configPath, data, 0644)
+}
+
+// mergeWithDefaults ensures all required fields are set with defaults if missing
+func mergeWithDefaults(config AppConfig) AppConfig {
+	defaults := GetDefaultAppConfig()
+
+	// If QuitKeys is empty, use defaults
+	if len(config.KeyBindings.QuitKeys) == 0 {
+		config.KeyBindings.QuitKeys = defaults.KeyBindings.QuitKeys
+	}
+
+	return config
+}
+
+// ShouldQuitOnKey checks if the given key should trigger quit based on configuration
+func (kb *KeyBindings) ShouldQuitOnKey(key string) bool {
+	// Special handling for ESC key
+	if key == "esc" {
+		return !kb.DisableEscQuit
+	}
+
+	// Check if key is in the quit keys list
+	for _, quitKey := range kb.QuitKeys {
+		if quitKey == key {
+			return true
+		}
+	}
+
+	return false
+}
--- a/internal/config/keybindings_test.go
+++ b/internal/config/keybindings_test.go
@@ -0,0 +1,181 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestDefaultKeyBindings(t *testing.T) {
+	kb := GetDefaultKeyBindings()
+
+	// Test default configuration
+	if kb.DisableEscQuit {
+		t.Error("Default configuration should allow ESC to quit (backward compatibility)")
+	}
+
+	// Test default quit keys
+	expectedQuitKeys := []string{"q", "ctrl+c"}
+	if len(kb.QuitKeys) != len(expectedQuitKeys) {
+		t.Errorf("Expected %d quit keys, got %d", len(expectedQuitKeys), len(kb.QuitKeys))
+	}
+
+	for i, expected := range expectedQuitKeys {
+		if i >= len(kb.QuitKeys) || kb.QuitKeys[i] != expected {
+			t.Errorf("Expected quit key %s, got %s", expected, kb.QuitKeys[i])
+		}
+	}
+}
+
+func TestShouldQuitOnKey(t *testing.T) {
+	tests := []struct {
+		name           string
+		keyBindings    KeyBindings
+		key            string
+		expectedResult bool
+	}{
+		{
+			name: "Default config - ESC should quit",
+			keyBindings: KeyBindings{
+				QuitKeys:       []string{"q", "ctrl+c"},
+				DisableEscQuit: false,
+			},
+			key:            "esc",
+			expectedResult: true,
+		},
+		{
+			name: "Disabled ESC quit - ESC should not quit",
+			keyBindings: KeyBindings{
+				QuitKeys:       []string{"q", "ctrl+c"},
+				DisableEscQuit: true,
+			},
+			key:            "esc",
+			expectedResult: false,
+		},
+		{
+			name: "Q key should quit",
+			keyBindings: KeyBindings{
+				QuitKeys:       []string{"q", "ctrl+c"},
+				DisableEscQuit: true,
+			},
+			key:            "q",
+			expectedResult: true,
+		},
+		{
+			name: "Ctrl+C should quit",
+			keyBindings: KeyBindings{
+				QuitKeys:       []string{"q", "ctrl+c"},
+				DisableEscQuit: true,
+			},
+			key:            "ctrl+c",
+			expectedResult: true,
+		},
+		{
+			name: "Other keys should not quit",
+			keyBindings: KeyBindings{
+				QuitKeys:       []string{"q", "ctrl+c"},
+				DisableEscQuit: true,
+			},
+			key:            "enter",
+			expectedResult: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.keyBindings.ShouldQuitOnKey(tt.key)
+			if result != tt.expectedResult {
+				t.Errorf("ShouldQuitOnKey(%q) = %v, expected %v", tt.key, result, tt.expectedResult)
+			}
+		})
+	}
+}
+
+func TestAppConfigBasics(t *testing.T) {
+	// Test default config creation
+	defaultConfig := GetDefaultAppConfig()
+
+	if defaultConfig.KeyBindings.DisableEscQuit {
+		t.Error("Default configuration should allow ESC to quit")
+	}
+
+	expectedQuitKeys := []string{"q", "ctrl+c"}
+	if len(defaultConfig.KeyBindings.QuitKeys) != len(expectedQuitKeys) {
+		t.Errorf("Expected %d quit keys, got %d", len(expectedQuitKeys), len(defaultConfig.KeyBindings.QuitKeys))
+	}
+}
+
+func TestMergeWithDefaults(t *testing.T) {
+	// Test config with missing QuitKeys
+	incompleteConfig := AppConfig{
+		KeyBindings: KeyBindings{
+			DisableEscQuit: true,
+			// QuitKeys is missing
+		},
+	}
+
+	mergedConfig := mergeWithDefaults(incompleteConfig)
+
+	// Should preserve DisableEscQuit
+	if !mergedConfig.KeyBindings.DisableEscQuit {
+		t.Error("Should preserve DisableEscQuit as true")
+	}
+
+	// Should fill in default QuitKeys
+	expectedQuitKeys := []string{"q", "ctrl+c"}
+	if len(mergedConfig.KeyBindings.QuitKeys) != len(expectedQuitKeys) {
+		t.Errorf("Expected %d quit keys, got %d", len(expectedQuitKeys), len(mergedConfig.KeyBindings.QuitKeys))
+	}
+}
+
+func TestSaveAndLoadAppConfigIntegration(t *testing.T) {
+	// Create a temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create a custom config file directly in temp directory
+	configPath := filepath.Join(tempDir, "config.json")
+
+	customConfig := AppConfig{
+		KeyBindings: KeyBindings{
+			QuitKeys:       []string{"q"},
+			DisableEscQuit: true,
+		},
+	}
+
+	// Save config directly to file
+	data, err := json.MarshalIndent(customConfig, "", "  ")
+	if err != nil {
+		t.Fatalf("Failed to marshal config: %v", err)
+	}
+
+	err = os.WriteFile(configPath, data, 0644)
+	if err != nil {
+		t.Fatalf("Failed to write config file: %v", err)
+	}
+
+	// Read and unmarshal config
+	readData, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatalf("Failed to read config file: %v", err)
+	}
+
+	var loadedConfig AppConfig
+	err = json.Unmarshal(readData, &loadedConfig)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal config: %v", err)
+	}
+
+	// Verify the loaded config matches what we saved
+	if !loadedConfig.KeyBindings.DisableEscQuit {
+		t.Error("DisableEscQuit should be true")
+	}
+
+	if len(loadedConfig.KeyBindings.QuitKeys) != 1 || loadedConfig.KeyBindings.QuitKeys[0] != "q" {
+		t.Errorf("Expected quit keys to be ['q'], got %v", loadedConfig.KeyBindings.QuitKeys)
+	}
+}
--- a/internal/config/ssh.go
+++ b/internal/config/ssh.go
@@ -40,8 +40,8 @@ func GetDefaultSSHConfigPath() (string, error) {
 	}
 }

-// GetSSHMBackupDir returns the SSHM backup directory
-func GetSSHMBackupDir() (string, error) {
+// GetSSHMConfigDir returns the SSHM config directory
+func GetSSHMConfigDir() (string, error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", err
@@ -67,6 +67,15 @@ func GetSSHMBackupDir() (string, error) {
 		}
 	}

+	return configDir, nil
+}
+
+// GetSSHMBackupDir returns the SSHM backup directory
+func GetSSHMBackupDir() (string, error) {
+	configDir, err := GetSSHMConfigDir()
+	if err != nil {
+		return "", err
+	}
 	return filepath.Join(configDir, "backups"), nil
 }

@@ -544,17 +553,40 @@ func HostExists(hostName string) (bool, error) {

 // HostExistsInFile checks if a host exists in a specific config file
 func HostExistsInFile(hostName string, configPath string) (bool, error) {
-	hosts, err := ParseSSHConfigFile(configPath)
-	if err != nil {
-		return false, err
+	// Parse only the specific file, not its includes
+	return HostExistsInSpecificFile(hostName, configPath)
 }

-	for _, host := range hosts {
-		if host.Name == hostName {
+// HostExistsInSpecificFile checks if a host exists in a specific file only (no includes)
+func HostExistsInSpecificFile(hostName string, configPath string) (bool, error) {
+	file, err := os.Open(configPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Check for Host declaration
+		if strings.HasPrefix(strings.ToLower(line), "host ") {
+			// Extract host names (can be multiple hosts on one line)
+			hostPart := strings.TrimSpace(line[5:]) // Remove "host "
+			hostNames := strings.Fields(hostPart)
+
+			for _, name := range hostNames {
+				if name == hostName {
 					return true, nil
 				}
 			}
-	return false, nil
+		}
+	}
+
+	return false, scanner.Err()
 }

 // GetSSHHost retrieves a specific host configuration by name
@@ -940,3 +972,67 @@ func GetIncludedConfigFiles() ([]string, error) {

 	return writableFiles, nil
 }
+
+// MoveHostToFile moves an SSH host from its current config file to a target config file
+func MoveHostToFile(hostName string, targetConfigFile string) error {
+	// Find the host in all configs to get its current location and data
+	host, err := FindHostInAllConfigs(hostName)
+	if err != nil {
+		return err
+	}
+
+	// Check if the target file is different from the current source file
+	if host.SourceFile == targetConfigFile {
+		return fmt.Errorf("host '%s' is already in the target config file '%s'", hostName, targetConfigFile)
+	}
+
+	// First, add the host to the target config file
+	err = AddSSHHostToFile(*host, targetConfigFile)
+	if err != nil {
+		return fmt.Errorf("failed to add host to target file: %v", err)
+	}
+
+	// Then, remove the host from its current source file
+	err = DeleteSSHHostFromFile(hostName, host.SourceFile)
+	if err != nil {
+		// If removal fails, we should try to rollback the addition, but for simplicity
+		// we'll just return the error. In a production environment, you might want
+		// to implement a proper rollback mechanism.
+		return fmt.Errorf("failed to remove host from source file: %v", err)
+	}
+
+	return nil
+}
+
+// GetConfigFilesExcludingCurrent returns all config files except the one containing the specified host
+func GetConfigFilesExcludingCurrent(hostName string, baseConfigFile string) ([]string, error) {
+	// Get all config files
+	var allFiles []string
+	var err error
+
+	if baseConfigFile != "" {
+		allFiles, err = GetAllConfigFilesFromBase(baseConfigFile)
+	} else {
+		allFiles, err = GetAllConfigFiles()
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Find the host to get its current source file
+	host, err := FindHostInAllConfigs(hostName)
+	if err != nil {
+		return nil, err
+	}
+
+	// Filter out the current source file
+	var filteredFiles []string
+	for _, file := range allFiles {
+		if file != host.SourceFile {
+			filteredFiles = append(filteredFiles, file)
+		}
+	}
+
+	return filteredFiles, nil
+}
--- a/internal/config/ssh_test.go
+++ b/internal/config/ssh_test.go
@@ -813,3 +813,177 @@ Include subdir/*.conf
 		t.Errorf("GetAllConfigFilesFromBase('') should behave like GetAllConfigFiles(). Got %d vs %d files", len(defaultFiles), len(allFiles))
 	}
 }
+
+func TestHostExistsInSpecificFile(t *testing.T) {
+	// Create temporary directory for test files
+	tempDir := t.TempDir()
+
+	// Create main config file
+	mainConfig := filepath.Join(tempDir, "config")
+	mainConfigContent := `Host main-host
+    HostName example.com
+    User mainuser
+
+Include included.conf
+
+Host another-host
+    HostName another.example.com
+    User anotheruser
+`
+
+	err := os.WriteFile(mainConfig, []byte(mainConfigContent), 0600)
+	if err != nil {
+		t.Fatalf("Failed to create main config: %v", err)
+	}
+
+	// Create included config file
+	includedConfig := filepath.Join(tempDir, "included.conf")
+	includedConfigContent := `Host included-host
+    HostName included.example.com
+    User includeduser
+`
+
+	err = os.WriteFile(includedConfig, []byte(includedConfigContent), 0600)
+	if err != nil {
+		t.Fatalf("Failed to create included config: %v", err)
+	}
+
+	// Test that host exists in main config file (should ignore includes)
+	exists, err := HostExistsInSpecificFile("main-host", mainConfig)
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() error = %v", err)
+	}
+	if !exists {
+		t.Error("main-host should exist in main config file")
+	}
+
+	// Test that host from included file does NOT exist in main config file
+	exists, err = HostExistsInSpecificFile("included-host", mainConfig)
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() error = %v", err)
+	}
+	if exists {
+		t.Error("included-host should NOT exist in main config file (should ignore includes)")
+	}
+
+	// Test that host exists in included config file
+	exists, err = HostExistsInSpecificFile("included-host", includedConfig)
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() error = %v", err)
+	}
+	if !exists {
+		t.Error("included-host should exist in included config file")
+	}
+
+	// Test non-existent host
+	exists, err = HostExistsInSpecificFile("non-existent", mainConfig)
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() error = %v", err)
+	}
+	if exists {
+		t.Error("non-existent host should not exist")
+	}
+
+	// Test with non-existent file
+	exists, err = HostExistsInSpecificFile("any-host", "/non/existent/file")
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() should not return error for non-existent file: %v", err)
+	}
+	if exists {
+		t.Error("non-existent file should not contain any hosts")
+	}
+}
+
+func TestGetConfigFilesExcludingCurrent(t *testing.T) {
+	// This test verifies the function works when SSH config is properly set up
+	// Since GetConfigFilesExcludingCurrent depends on FindHostInAllConfigs which uses the default SSH config,
+	// we'll test the function more directly by creating a temporary SSH config setup
+
+	// Skip this test if we can't access SSH config directory
+	_, err := GetSSHDirectory()
+	if err != nil {
+		t.Skipf("Skipping test: cannot get SSH directory: %v", err)
+	}
+
+	// Check if SSH config exists
+	defaultConfigPath, err := GetDefaultSSHConfigPath()
+	if err != nil {
+		t.Skipf("Skipping test: cannot get default SSH config path: %v", err)
+	}
+
+	if _, err := os.Stat(defaultConfigPath); os.IsNotExist(err) {
+		t.Skipf("Skipping test: SSH config file does not exist at %s", defaultConfigPath)
+	}
+
+	// Test that the function returns something for a hypothetical host
+	// We can't guarantee specific hosts exist, so we test the function doesn't crash
+	_, err = GetConfigFilesExcludingCurrent("test-host-that-probably-does-not-exist", defaultConfigPath)
+	if err == nil {
+		t.Log("GetConfigFilesExcludingCurrent() succeeded for non-existent host (expected)")
+	} else if strings.Contains(err.Error(), "not found") {
+		t.Log("GetConfigFilesExcludingCurrent() correctly reported host not found")
+	} else {
+		t.Fatalf("GetConfigFilesExcludingCurrent() unexpected error = %v", err)
+	}
+
+	// Test with valid SSH config directory
+	if err == nil {
+		t.Log("GetConfigFilesExcludingCurrent() function is working correctly")
+	}
+}
+
+func TestMoveHostToFile(t *testing.T) {
+	// This test verifies the MoveHostToFile function works when SSH config is properly set up
+	// Since MoveHostToFile depends on FindHostInAllConfigs which uses the default SSH config,
+	// we'll test the error handling and basic function behavior
+
+	// Check if SSH config exists
+	defaultConfigPath, err := GetDefaultSSHConfigPath()
+	if err != nil {
+		t.Skipf("Skipping test: cannot get default SSH config path: %v", err)
+	}
+
+	if _, err := os.Stat(defaultConfigPath); os.IsNotExist(err) {
+		t.Skipf("Skipping test: SSH config file does not exist at %s", defaultConfigPath)
+	}
+
+	// Create a temporary destination config file
+	tempDir := t.TempDir()
+	destConfig := filepath.Join(tempDir, "dest.conf")
+	destConfigContent := `Host dest-host
+    HostName dest.example.com
+    User destuser
+`
+
+	err = os.WriteFile(destConfig, []byte(destConfigContent), 0600)
+	if err != nil {
+		t.Fatalf("Failed to create dest config: %v", err)
+	}
+
+	// Test moving non-existent host (should return error)
+	err = MoveHostToFile("non-existent-host-12345", destConfig)
+	if err == nil {
+		t.Error("MoveHostToFile() should return error for non-existent host")
+	} else if !strings.Contains(err.Error(), "not found") {
+		t.Errorf("Expected 'not found' error, got: %v", err)
+	}
+
+	// Test moving to non-existent file (should return error)
+	err = MoveHostToFile("any-host", "/non/existent/file")
+	if err == nil {
+		t.Error("MoveHostToFile() should return error for non-existent destination file")
+	}
+
+	// Verify that the HostExistsInSpecificFile function works correctly
+	// This is a component that MoveHostToFile uses
+	exists, err := HostExistsInSpecificFile("dest-host", destConfig)
+	if err != nil {
+		t.Fatalf("HostExistsInSpecificFile() error = %v", err)
+	}
+	if !exists {
+		t.Error("dest-host should exist in destination config file")
+	}
+
+	// Test that the component functions work for the move operation
+	t.Log("MoveHostToFile() error handling works correctly")
+}
--- a/internal/history/history.go
+++ b/internal/history/history.go
@@ -15,11 +15,21 @@ type ConnectionHistory struct {
 	Connections map[string]ConnectionInfo `json:"connections"`
 }

+// PortForwardConfig stores port forwarding configuration
+type PortForwardConfig struct {
+	Type        string `json:"type"` // "local", "remote", "dynamic"
+	LocalPort   string `json:"local_port"`
+	RemoteHost  string `json:"remote_host"`
+	RemotePort  string `json:"remote_port"`
+	BindAddress string `json:"bind_address"`
+}
+
 // ConnectionInfo stores information about a specific connection
 type ConnectionInfo struct {
 	HostName       string             `json:"host_name"`
 	LastConnect    time.Time          `json:"last_connect"`
 	ConnectCount   int                `json:"connect_count"`
+	PortForwarding *PortForwardConfig `json:"port_forwarding,omitempty"`
 }

 // HistoryManager manages the connection history
@@ -30,12 +40,23 @@ type HistoryManager struct {

 // NewHistoryManager creates a new history manager
 func NewHistoryManager() (*HistoryManager, error) {
-	homeDir, err := os.UserHomeDir()
+	configDir, err := config.GetSSHMConfigDir()
 	if err != nil {
 		return nil, err
 	}

-	historyPath := filepath.Join(homeDir, ".ssh", "sshm_history.json")
+	// Ensure config dir exists
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return nil, err
+	}
+
+	historyPath := filepath.Join(configDir, "sshm_history.json")
+
+	// Migration: check if old history file exists and migrate it
+	if err := migrateOldHistoryFile(historyPath); err != nil {
+		// Don't fail if migration fails, just log it
+		// In a production environment, you might want to log this properly
+	}

 	hm := &HistoryManager{
 		historyPath: historyPath,
@@ -54,6 +75,46 @@ func NewHistoryManager() (*HistoryManager, error) {
 	return hm, nil
 }

+// migrateOldHistoryFile migrates the old history file from ~/.ssh to ~/.config/sshm
+// TODO: Remove this migration logic in v2.0.0 (introduced in v1.6.0)
+func migrateOldHistoryFile(newHistoryPath string) error {
+	// Check if new file already exists, skip migration
+	if _, err := os.Stat(newHistoryPath); err == nil {
+		return nil // New file exists, no migration needed
+	}
+
+	// Get old history file path - use same logic as SSH config location
+	sshDir, err := config.GetSSHDirectory()
+	if err != nil {
+		return err
+	}
+	oldHistoryPath := filepath.Join(sshDir, "sshm_history.json")
+
+	// Check if old file exists
+	if _, err := os.Stat(oldHistoryPath); os.IsNotExist(err) {
+		return nil // Old file doesn't exist, nothing to migrate
+	}
+
+	// Read old file
+	data, err := os.ReadFile(oldHistoryPath)
+	if err != nil {
+		return err
+	}
+
+	// Write to new location
+	if err := os.WriteFile(newHistoryPath, data, 0644); err != nil {
+		return err
+	}
+
+	// Remove old file only if write was successful
+	if err := os.Remove(oldHistoryPath); err != nil {
+		// Don't fail if we can't remove the old file
+		// The migration was successful even if cleanup failed
+	}
+
+	return nil
+}
+
 // loadHistory loads the connection history from the JSON file
 func (hm *HistoryManager) loadHistory() error {
 	data, err := os.ReadFile(hm.historyPath)
@@ -206,3 +267,42 @@ func (hm *HistoryManager) GetAllConnectionsInfo() []ConnectionInfo {

 	return connections
 }
+
+// RecordPortForwarding saves port forwarding configuration for a host
+func (hm *HistoryManager) RecordPortForwarding(hostName, forwardType, localPort, remoteHost, remotePort, bindAddress string) error {
+	now := time.Now()
+
+	portForwardConfig := &PortForwardConfig{
+		Type:        forwardType,
+		LocalPort:   localPort,
+		RemoteHost:  remoteHost,
+		RemotePort:  remotePort,
+		BindAddress: bindAddress,
+	}
+
+	if conn, exists := hm.history.Connections[hostName]; exists {
+		// Update existing connection
+		conn.LastConnect = now
+		conn.ConnectCount++
+		conn.PortForwarding = portForwardConfig
+		hm.history.Connections[hostName] = conn
+	} else {
+		// Create new connection record
+		hm.history.Connections[hostName] = ConnectionInfo{
+			HostName:       hostName,
+			LastConnect:    now,
+			ConnectCount:   1,
+			PortForwarding: portForwardConfig,
+		}
+	}
+
+	return hm.saveHistory()
+}
+
+// GetPortForwardingConfig retrieves the last used port forwarding configuration for a host
+func (hm *HistoryManager) GetPortForwardingConfig(hostName string) *PortForwardConfig {
+	if conn, exists := hm.history.Connections[hostName]; exists {
+		return conn.PortForwarding
+	}
+	return nil
+}
--- a/internal/history/history_test.go
+++ b/internal/history/history_test.go
@@ -1,6 +1,7 @@
 package history

 import (
+	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -94,3 +95,70 @@ func TestHistoryManager_GetConnectionCount(t *testing.T) {
 		t.Errorf("Expected connection count 3, got %d", count)
 	}
 }
+
+func TestMigrateOldHistoryFile(t *testing.T) {
+	// This test verifies that migration doesn't fail when called
+	// The actual migration logic will be tested in integration tests
+
+	tempDir := t.TempDir()
+	newHistoryPath := filepath.Join(tempDir, "sshm_history.json")
+
+	// Test that migration works when no old file exists (common case)
+	if err := migrateOldHistoryFile(newHistoryPath); err != nil {
+		t.Errorf("migrateOldHistoryFile() with no old file error = %v", err)
+	}
+
+	// Test that migration skips when new file already exists
+	if err := os.WriteFile(newHistoryPath, []byte(`{"connections":{}}`), 0644); err != nil {
+		t.Fatalf("Failed to write new history file: %v", err)
+	}
+
+	if err := migrateOldHistoryFile(newHistoryPath); err != nil {
+		t.Errorf("migrateOldHistoryFile() with existing new file error = %v", err)
+	}
+
+	// File should be unchanged
+	data, err := os.ReadFile(newHistoryPath)
+	if err != nil {
+		t.Errorf("Failed to read new file: %v", err)
+	}
+	if string(data) != `{"connections":{}}` {
+		t.Error("New file was modified when it shouldn't have been")
+	}
+}
+
+func TestMigrateOldHistoryFile_NoOldFile(t *testing.T) {
+	// Test migration when no old file exists
+	tempDir := t.TempDir()
+	newHistoryPath := filepath.Join(tempDir, "sshm_history.json")
+
+	// Should not return error when old file doesn't exist
+	if err := migrateOldHistoryFile(newHistoryPath); err != nil {
+		t.Errorf("migrateOldHistoryFile() with no old file error = %v", err)
+	}
+}
+
+func TestMigrateOldHistoryFile_NewFileExists(t *testing.T) {
+	// Test migration when new file already exists (should skip migration)
+	tempDir := t.TempDir()
+	newHistoryPath := filepath.Join(tempDir, "sshm_history.json")
+
+	// Create new file first
+	if err := os.WriteFile(newHistoryPath, []byte(`{"connections":{}}`), 0644); err != nil {
+		t.Fatalf("Failed to write new history file: %v", err)
+	}
+
+	// Migration should skip when new file exists
+	if err := migrateOldHistoryFile(newHistoryPath); err != nil {
+		t.Errorf("migrateOldHistoryFile() with existing new file error = %v", err)
+	}
+
+	// New file should be unchanged
+	data, err := os.ReadFile(newHistoryPath)
+	if err != nil {
+		t.Errorf("Failed to read new file: %v", err)
+	}
+	if string(data) != `{"connections":{}}` {
+		t.Error("New file was modified when it shouldn't have been")
+	}
+}
--- a/internal/history/port_forward_test.go
+++ b/internal/history/port_forward_test.go
@@ -0,0 +1,183 @@
+package history
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestPortForwardingHistory(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create history manager with temp directory
+	historyPath := filepath.Join(tempDir, "test_history.json")
+	hm := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	hostName := "test-server"
+
+	// Test recording port forwarding configuration
+	err = hm.RecordPortForwarding(hostName, "local", "8080", "localhost", "80", "127.0.0.1")
+	if err != nil {
+		t.Fatalf("Failed to record port forwarding: %v", err)
+	}
+
+	// Test retrieving port forwarding configuration
+	config := hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist")
+	}
+
+	// Verify the saved configuration
+	if config.Type != "local" {
+		t.Errorf("Expected Type 'local', got %s", config.Type)
+	}
+	if config.LocalPort != "8080" {
+		t.Errorf("Expected LocalPort '8080', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "localhost" {
+		t.Errorf("Expected RemoteHost 'localhost', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "80" {
+		t.Errorf("Expected RemotePort '80', got %s", config.RemotePort)
+	}
+	if config.BindAddress != "127.0.0.1" {
+		t.Errorf("Expected BindAddress '127.0.0.1', got %s", config.BindAddress)
+	}
+
+	// Test updating configuration with different values
+	err = hm.RecordPortForwarding(hostName, "remote", "3000", "app-server", "8000", "")
+	if err != nil {
+		t.Fatalf("Failed to record updated port forwarding: %v", err)
+	}
+
+	// Verify the updated configuration
+	config = hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist after update")
+	}
+
+	if config.Type != "remote" {
+		t.Errorf("Expected updated Type 'remote', got %s", config.Type)
+	}
+	if config.LocalPort != "3000" {
+		t.Errorf("Expected updated LocalPort '3000', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "app-server" {
+		t.Errorf("Expected updated RemoteHost 'app-server', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "8000" {
+		t.Errorf("Expected updated RemotePort '8000', got %s", config.RemotePort)
+	}
+	if config.BindAddress != "" {
+		t.Errorf("Expected updated BindAddress to be empty, got %s", config.BindAddress)
+	}
+
+	// Test dynamic forwarding
+	err = hm.RecordPortForwarding(hostName, "dynamic", "1080", "", "", "0.0.0.0")
+	if err != nil {
+		t.Fatalf("Failed to record dynamic port forwarding: %v", err)
+	}
+
+	config = hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist for dynamic forwarding")
+	}
+
+	if config.Type != "dynamic" {
+		t.Errorf("Expected Type 'dynamic', got %s", config.Type)
+	}
+	if config.LocalPort != "1080" {
+		t.Errorf("Expected LocalPort '1080', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "" {
+		t.Errorf("Expected RemoteHost to be empty for dynamic forwarding, got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "" {
+		t.Errorf("Expected RemotePort to be empty for dynamic forwarding, got %s", config.RemotePort)
+	}
+	if config.BindAddress != "0.0.0.0" {
+		t.Errorf("Expected BindAddress '0.0.0.0', got %s", config.BindAddress)
+	}
+}
+
+func TestPortForwardingHistoryPersistence(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	historyPath := filepath.Join(tempDir, "test_history.json")
+
+	// Create first history manager and record data
+	hm1 := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	hostName := "persistent-server"
+	err = hm1.RecordPortForwarding(hostName, "local", "9090", "db-server", "5432", "")
+	if err != nil {
+		t.Fatalf("Failed to record port forwarding: %v", err)
+	}
+
+	// Create second history manager and load data
+	hm2 := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	err = hm2.loadHistory()
+	if err != nil {
+		t.Fatalf("Failed to load history: %v", err)
+	}
+
+	// Verify the loaded configuration
+	config := hm2.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to be loaded from file")
+	}
+
+	if config.Type != "local" {
+		t.Errorf("Expected loaded Type 'local', got %s", config.Type)
+	}
+	if config.LocalPort != "9090" {
+		t.Errorf("Expected loaded LocalPort '9090', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "db-server" {
+		t.Errorf("Expected loaded RemoteHost 'db-server', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "5432" {
+		t.Errorf("Expected loaded RemotePort '5432', got %s", config.RemotePort)
+	}
+}
+
+func TestGetPortForwardingConfigNonExistent(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	historyPath := filepath.Join(tempDir, "test_history.json")
+	hm := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	// Test getting configuration for non-existent host
+	config := hm.GetPortForwardingConfig("non-existent-host")
+	if config != nil {
+		t.Errorf("Expected nil config for non-existent host, got %+v", config)
+	}
+}
--- a/internal/ui/add_form.go
+++ b/internal/ui/add_form.go
@@ -4,9 +4,10 @@ import (
 	"os"
 	"os/user"
 	"path/filepath"
+	"strings"
+
 	"github.com/Gu1llaum-3/sshm/internal/config"
 	"github.com/Gu1llaum-3/sshm/internal/validation"
-	"strings"

 	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
@@ -148,8 +149,8 @@ func (m *addFormModel) Update(msg tea.Msg) (*addFormModel, tea.Cmd) {
 		case "ctrl+c", "esc":
 			return m, func() tea.Msg { return addFormCancelMsg{} }

-		case "ctrl+enter":
-			// Allow submission from any field with Ctrl+Enter
+		case "ctrl+s":
+			// Allow submission from any field with Ctrl+S (Save)
 			return m, m.submitForm()

 		case "tab", "shift+tab", "enter", "up", "down":
@@ -238,7 +239,7 @@ func (m *addFormModel) View() string {
 		b.WriteString("\n\n")
 	}

-	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+Enter: submit • Ctrl+C/Esc: cancel"))
+	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+S: save • Ctrl+C/Esc: cancel"))
 	b.WriteString("\n")
 	b.WriteString(m.styles.FormHelp.Render("* Required fields"))

--- a/internal/ui/edit_form.go
+++ b/internal/ui/edit_form.go
@@ -1,9 +1,10 @@
 package ui

 import (
+	"strings"
+
 	"github.com/Gu1llaum-3/sshm/internal/config"
 	"github.com/Gu1llaum-3/sshm/internal/validation"
-	"strings"

 	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
@@ -139,8 +140,8 @@ func (m *editFormModel) Update(msg tea.Msg) (*editFormModel, tea.Cmd) {
 		case "ctrl+c", "esc":
 			return m, func() tea.Msg { return editFormCancelMsg{} }

-		case "ctrl+enter":
-			// Allow submission from any field with Ctrl+Enter
+		case "ctrl+s":
+			// Allow submission from any field with Ctrl+S (Save)
 			return m, m.submitEditForm()

 		case "tab", "shift+tab", "enter", "up", "down":
@@ -247,7 +248,7 @@ func (m *editFormModel) View() string {
 		b.WriteString("\n\n")
 	}

-	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+Enter: submit • Ctrl+C/Esc: cancel"))
+	b.WriteString(m.styles.FormHelp.Render("Tab/Shift+Tab: navigate • Enter on last field: submit • Ctrl+S: save • Ctrl+C/Esc: cancel"))
 	b.WriteString("\n")
 	b.WriteString(m.styles.FormHelp.Render("* Required fields"))

--- a/internal/ui/help_form.go
+++ b/internal/ui/help_form.go
@@ -40,64 +40,85 @@ func (m *helpModel) Update(msg tea.Msg) (*helpModel, tea.Cmd) {

 func (m *helpModel) View() string {
 	// Title
-	title := m.styles.Header.Render("📖 SSHM - Help & Commands")
+	title := m.styles.Header.Render("📖 SSHM - Commands")

-	// Create horizontal sections with compact layout
-	line1 := lipgloss.JoinHorizontal(lipgloss.Center,
-		m.styles.FocusedLabel.Render("🧭 ↑/↓/j/k"),
-		"  ",
-		m.styles.HelpText.Render("navigate"),
+	// Create two columns of commands for better visual organization
+	leftColumn := lipgloss.JoinVertical(lipgloss.Left,
+		m.styles.FocusedLabel.Render("Navigation & Connection"),
 		"",
+		lipgloss.JoinHorizontal(lipgloss.Left,
 			m.styles.FocusedLabel.Render("⏎  "),
-		"  ",
-		m.styles.HelpText.Render("connect"),
-		"    ",
-		m.styles.FocusedLabel.Render("a/e/d"),
-		"  ",
-		m.styles.HelpText.Render("add/edit/delete"),
-	)
-
-	line2 := lipgloss.JoinHorizontal(lipgloss.Center,
-		m.styles.FocusedLabel.Render("Tab"),
-		"  ",
-		m.styles.HelpText.Render("switch focus"),
-		"    ",
-		m.styles.FocusedLabel.Render("p"),
-		"  ",
-		m.styles.HelpText.Render("ping all"),
-		"    ",
-		m.styles.FocusedLabel.Render("f"),
-		"  ",
-		m.styles.HelpText.Render("port forward"),
-		"    ",
-		m.styles.FocusedLabel.Render("s/r/n"),
-		"  ",
-		m.styles.HelpText.Render("sort modes"),
-	)
-
-	line3 := lipgloss.JoinHorizontal(lipgloss.Center,
+			m.styles.HelpText.Render("connect to selected host")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("i  "),
+			m.styles.HelpText.Render("show host information")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
 			m.styles.FocusedLabel.Render("/  "),
+			m.styles.HelpText.Render("search hosts")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("Tab "),
+			m.styles.HelpText.Render("switch focus")),
 		"",
-		m.styles.HelpText.Render("search"),
+		m.styles.FocusedLabel.Render("Host Management"),
 		"",
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("a  "),
+			m.styles.HelpText.Render("add new host")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("e  "),
+			m.styles.HelpText.Render("edit selected host")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("m  "),
+			m.styles.HelpText.Render("move host to another config")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("d  "),
+			m.styles.HelpText.Render("delete selected host")),
+	)
+
+	rightColumn := lipgloss.JoinVertical(lipgloss.Left,
+		m.styles.FocusedLabel.Render("Advanced Features"),
+		"",
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("p  "),
+			m.styles.HelpText.Render("ping all hosts")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("f  "),
+			m.styles.HelpText.Render("setup port forwarding")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("s  "),
+			m.styles.HelpText.Render("cycle sort modes")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("n  "),
+			m.styles.HelpText.Render("sort by name")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("r  "),
+			m.styles.HelpText.Render("sort by recent connection")),
+		"",
+		m.styles.FocusedLabel.Render("System"),
+		"",
+		lipgloss.JoinHorizontal(lipgloss.Left,
 			m.styles.FocusedLabel.Render("h  "),
-		"  ",
-		m.styles.HelpText.Render("help"),
-		"    ",
-		m.styles.FocusedLabel.Render("q/ESC"),
-		"  ",
-		m.styles.HelpText.Render("quit"),
+			m.styles.HelpText.Render("show this help")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("q  "),
+			m.styles.HelpText.Render("quit application")),
+		lipgloss.JoinHorizontal(lipgloss.Left,
+			m.styles.FocusedLabel.Render("ESC "),
+			m.styles.HelpText.Render("exit current view")),
+	)
+
+	// Join the two columns side by side
+	columns := lipgloss.JoinHorizontal(lipgloss.Top,
+		leftColumn,
+		"    ", // spacing between columns
+		rightColumn,
 	)

 	// Create the main content
 	content := lipgloss.JoinVertical(lipgloss.Center,
 		title,
 		"",
-		line1,
-		"",
-		line2,
-		"",
-		line3,
+		columns,
 		"",
 		m.styles.HelpText.Render("Press ESC, h, q or Enter to close"),
 	)
--- a/internal/ui/model.go
+++ b/internal/ui/model.go
@@ -4,6 +4,7 @@ import (
 	"github.com/Gu1llaum-3/sshm/internal/config"
 	"github.com/Gu1llaum-3/sshm/internal/connectivity"
 	"github.com/Gu1llaum-3/sshm/internal/history"
+	"github.com/Gu1llaum-3/sshm/internal/version"

 	"github.com/charmbracelet/bubbles/table"
 	"github.com/charmbracelet/bubbles/textinput"
@@ -36,6 +37,7 @@ const (
 	ViewList ViewMode = iota
 	ViewAdd
 	ViewEdit
+	ViewMove
 	ViewInfo
 	ViewPortForward
 	ViewHelp
@@ -78,10 +80,18 @@ type Model struct {
 	sortMode       SortMode
 	configFile     string // Path to the SSH config file

+	// Application configuration
+	appConfig      *config.AppConfig
+
+	// Version update information
+	updateInfo     *version.UpdateInfo
+	currentVersion string
+
 	// View management
 	viewMode         ViewMode
 	addForm          *addFormModel
 	editForm         *editFormModel
+	moveForm         *moveFormModel
 	infoForm         *infoFormModel
 	portForwardForm  *portForwardModel
 	helpForm         *helpModel
@@ -92,6 +102,10 @@ type Model struct {
 	height int
 	styles Styles
 	ready  bool
+
+	// Error handling
+	errorMessage string
+	showingError bool
 }

 // updateTableStyles updates the table header border color based on focus state
--- a/internal/ui/move_form.go
+++ b/internal/ui/move_form.go
@@ -0,0 +1,188 @@
+package ui
+
+import (
+	"fmt"
+
+	"github.com/Gu1llaum-3/sshm/internal/config"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type moveFormModel struct {
+	fileSelector *fileSelectorModel
+	hostName     string
+	configFile   string
+	width        int
+	height       int
+	styles       Styles
+	state        moveFormState
+}
+
+type moveFormState int
+
+const (
+	moveFormSelectingFile moveFormState = iota
+	moveFormProcessing
+)
+
+type moveFormSubmitMsg struct {
+	hostName   string
+	targetFile string
+	err        error
+}
+
+type moveFormCancelMsg struct{}
+
+// NewMoveForm creates a new move form for moving a host to another config file
+func NewMoveForm(hostName string, styles Styles, width, height int, configFile string) (*moveFormModel, error) {
+	// Get all config files except the one containing the current host
+	files, err := config.GetConfigFilesExcludingCurrent(hostName, configFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get config files: %v", err)
+	}
+
+	if len(files) == 0 {
+		return nil, fmt.Errorf("no includes found in SSH config file - move operation requires multiple config files")
+	}
+
+	// Create a custom file selector for move operation
+	fileSelector, err := newFileSelectorFromFiles(
+		fmt.Sprintf("Select destination config file for host '%s':", hostName),
+		styles,
+		width,
+		height,
+		files,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create file selector: %v", err)
+	}
+
+	return &moveFormModel{
+		fileSelector: fileSelector,
+		hostName:     hostName,
+		configFile:   configFile,
+		width:        width,
+		height:       height,
+		styles:       styles,
+		state:        moveFormSelectingFile,
+	}, nil
+}
+
+func (m *moveFormModel) Init() tea.Cmd {
+	return m.fileSelector.Init()
+}
+
+func (m *moveFormModel) Update(msg tea.Msg) (*moveFormModel, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+		m.styles = NewStyles(m.width)
+		if m.fileSelector != nil {
+			m.fileSelector.width = m.width
+			m.fileSelector.height = m.height
+			m.fileSelector.styles = m.styles
+		}
+		return m, nil
+
+	case tea.KeyMsg:
+		switch m.state {
+		case moveFormSelectingFile:
+			switch msg.String() {
+			case "enter":
+				if m.fileSelector != nil && len(m.fileSelector.files) > 0 {
+					selectedFile := m.fileSelector.files[m.fileSelector.selected]
+					m.state = moveFormProcessing
+					return m, m.submitMove(selectedFile)
+				}
+			case "esc", "q":
+				return m, func() tea.Msg { return moveFormCancelMsg{} }
+			default:
+				// Forward other keys to file selector
+				if m.fileSelector != nil {
+					newFileSelector, cmd := m.fileSelector.Update(msg)
+					m.fileSelector = newFileSelector
+					return m, cmd
+				}
+			}
+		case moveFormProcessing:
+			// Dans cet état, on attend le résultat de l'opération
+			// Le résultat sera géré par le modèle principal
+			switch msg.String() {
+			case "esc", "q":
+				return m, func() tea.Msg { return moveFormCancelMsg{} }
+			}
+		}
+	}
+
+	return m, nil
+}
+
+func (m *moveFormModel) View() string {
+	switch m.state {
+	case moveFormSelectingFile:
+		if m.fileSelector != nil {
+			return m.fileSelector.View()
+		}
+		return "Loading..."
+
+	case moveFormProcessing:
+		return m.styles.FormTitle.Render("Moving host...") + "\n\n" +
+			m.styles.HelpText.Render(fmt.Sprintf("Moving host '%s' to selected config file...", m.hostName))
+
+	default:
+		return "Unknown state"
+	}
+}
+
+func (m *moveFormModel) submitMove(targetFile string) tea.Cmd {
+	return func() tea.Msg {
+		err := config.MoveHostToFile(m.hostName, targetFile)
+		return moveFormSubmitMsg{
+			hostName:   m.hostName,
+			targetFile: targetFile,
+			err:        err,
+		}
+	}
+}
+
+// Standalone move form for CLI usage
+type standaloneMoveForm struct {
+	moveFormModel *moveFormModel
+}
+
+func (m standaloneMoveForm) Init() tea.Cmd {
+	return m.moveFormModel.Init()
+}
+
+func (m standaloneMoveForm) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg.(type) {
+	case moveFormCancelMsg:
+		return m, tea.Quit
+	case moveFormSubmitMsg:
+		// En mode standalone, on quitte après le déplacement (succès ou erreur)
+		return m, tea.Quit
+	}
+
+	newForm, cmd := m.moveFormModel.Update(msg)
+	m.moveFormModel = newForm
+	return m, cmd
+}
+
+func (m standaloneMoveForm) View() string {
+	return m.moveFormModel.View()
+}
+
+// RunMoveForm provides backward compatibility for standalone move form
+func RunMoveForm(hostName string, configFile string) error {
+	styles := NewStyles(80)
+	moveForm, err := NewMoveForm(hostName, styles, 80, 24, configFile)
+	if err != nil {
+		return err
+	}
+	m := standaloneMoveForm{moveForm}
+
+	p := tea.NewProgram(m, tea.WithAltScreen())
+	_, err = p.Run()
+	return err
+}
--- a/internal/ui/port_forward_form.go
+++ b/internal/ui/port_forward_form.go
@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"

+	"github.com/Gu1llaum-3/sshm/internal/history"
 	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
@@ -29,6 +30,7 @@ type portForwardModel struct {
 	width          int
 	height         int
 	configFile     string
+	historyManager *history.HistoryManager
 }

 // portForwardSubmitMsg is sent when the port forward form is submitted
@@ -41,7 +43,7 @@ type portForwardSubmitMsg struct {
 type portForwardCancelMsg struct{}

 // NewPortForwardForm creates a new port forward form model
-func NewPortForwardForm(hostName string, styles Styles, width, height int, configFile string) *portForwardModel {
+func NewPortForwardForm(hostName string, styles Styles, width, height int, configFile string, historyManager *history.HistoryManager) *portForwardModel {
 	inputs := make([]textinput.Model, 5)

 	// Forward type input (display only, controlled by arrow keys)
@@ -49,7 +51,6 @@ func NewPortForwardForm(hostName string, styles Styles, width, height int, confi
 	inputs[pfTypeInput].Placeholder = "Use ←/→ to change forward type"
 	inputs[pfTypeInput].Focus()
 	inputs[pfTypeInput].Width = 40
-	inputs[pfTypeInput].SetValue("Local (-L)")

 	// Local port input
 	inputs[pfLocalPortInput] = textinput.New()
@@ -85,8 +86,12 @@ func NewPortForwardForm(hostName string, styles Styles, width, height int, confi
 		width:          width,
 		height:         height,
 		configFile:     configFile,
+		historyManager: historyManager,
 	}

+	// Load previous port forwarding configuration if available
+	pf.loadPreviousConfig()
+
 	// Initialize input visibility
 	pf.updateInputVisibility()

@@ -370,6 +375,11 @@ func (m *portForwardModel) submitForm() tea.Cmd {
 			return portForwardSubmitMsg{err: fmt.Errorf("invalid port number"), sshArgs: nil}
 		}

+		// Get form values for saving to history
+		remoteHost := strings.TrimSpace(m.inputs[pfRemoteHostInput].Value())
+		remotePort := strings.TrimSpace(m.inputs[pfRemotePortInput].Value())
+		bindAddress := strings.TrimSpace(m.inputs[pfBindAddressInput].Value())
+
 		// Build SSH command with port forwarding
 		var sshArgs []string

@@ -379,13 +389,10 @@ func (m *portForwardModel) submitForm() tea.Cmd {
 		}

 		// Add forwarding arguments
-		bindAddress := strings.TrimSpace(m.inputs[pfBindAddressInput].Value())
-
+		var forwardTypeStr string
 		switch m.forwardType {
 		case LocalForward:
-			remoteHost := strings.TrimSpace(m.inputs[pfRemoteHostInput].Value())
-			remotePort := strings.TrimSpace(m.inputs[pfRemotePortInput].Value())
-
+			forwardTypeStr = "local"
 			if remoteHost == "" {
 				remoteHost = "localhost"
 			}
@@ -408,31 +415,30 @@ func (m *portForwardModel) submitForm() tea.Cmd {
 			sshArgs = append(sshArgs, "-L", forwardArg)

 		case RemoteForward:
-			localHost := strings.TrimSpace(m.inputs[pfRemoteHostInput].Value())
-			localPortStr := strings.TrimSpace(m.inputs[pfRemotePortInput].Value())
-
-			if localHost == "" {
-				localHost = "localhost"
+			forwardTypeStr = "remote"
+			if remoteHost == "" {
+				remoteHost = "localhost"
 			}
-			if localPortStr == "" {
+			if remotePort == "" {
 				return portForwardSubmitMsg{err: fmt.Errorf("local port is required for remote forwarding"), sshArgs: nil}
 			}

 			// Validate local port
-			if _, err := strconv.Atoi(localPortStr); err != nil {
+			if _, err := strconv.Atoi(remotePort); err != nil {
 				return portForwardSubmitMsg{err: fmt.Errorf("invalid local port number"), sshArgs: nil}
 			}

 			// Build -R argument (note: localPort is actually the remote port in this context)
 			var forwardArg string
 			if bindAddress != "" {
-				forwardArg = fmt.Sprintf("%s:%s:%s:%s", bindAddress, localPort, localHost, localPortStr)
+				forwardArg = fmt.Sprintf("%s:%s:%s:%s", bindAddress, localPort, remoteHost, remotePort)
 			} else {
-				forwardArg = fmt.Sprintf("%s:%s:%s", localPort, localHost, localPortStr)
+				forwardArg = fmt.Sprintf("%s:%s:%s", localPort, remoteHost, remotePort)
 			}
 			sshArgs = append(sshArgs, "-R", forwardArg)

 		case DynamicForward:
+			forwardTypeStr = "dynamic"
 			// Build -D argument
 			var forwardArg string
 			if bindAddress != "" {
@@ -443,6 +449,21 @@ func (m *portForwardModel) submitForm() tea.Cmd {
 			sshArgs = append(sshArgs, "-D", forwardArg)
 		}

+		// Save port forwarding configuration to history
+		if m.historyManager != nil {
+			if err := m.historyManager.RecordPortForwarding(
+				m.hostName,
+				forwardTypeStr,
+				localPort,
+				remoteHost,
+				remotePort,
+				bindAddress,
+			); err != nil {
+				// Log the error but don't fail the connection
+				// In a production environment, you might want to handle this differently
+			}
+		}
+
 		// Add hostname
 		sshArgs = append(sshArgs, m.hostName)

@@ -488,3 +509,47 @@ func (m *portForwardModel) getPrevValidField(currentField int) int {
 	}
 	return -1
 }
+
+// loadPreviousConfig loads the previous port forwarding configuration for this host
+func (m *portForwardModel) loadPreviousConfig() {
+	if m.historyManager == nil {
+		m.inputs[pfTypeInput].SetValue("Local (-L)")
+		return
+	}
+
+	config := m.historyManager.GetPortForwardingConfig(m.hostName)
+	if config == nil {
+		m.inputs[pfTypeInput].SetValue("Local (-L)")
+		return
+	}
+
+	// Set forward type based on saved configuration
+	switch config.Type {
+	case "local":
+		m.forwardType = LocalForward
+	case "remote":
+		m.forwardType = RemoteForward
+	case "dynamic":
+		m.forwardType = DynamicForward
+	default:
+		m.forwardType = LocalForward
+	}
+	m.inputs[pfTypeInput].SetValue(m.forwardType.String())
+
+	// Set values from saved configuration
+	if config.LocalPort != "" {
+		m.inputs[pfLocalPortInput].SetValue(config.LocalPort)
+	}
+	if config.RemoteHost != "" {
+		m.inputs[pfRemoteHostInput].SetValue(config.RemoteHost)
+	} else if m.forwardType != DynamicForward {
+		// Default to localhost for local and remote forwarding if not set
+		m.inputs[pfRemoteHostInput].SetValue("localhost")
+	}
+	if config.RemotePort != "" {
+		m.inputs[pfRemotePortInput].SetValue(config.RemotePort)
+	}
+	if config.BindAddress != "" {
+		m.inputs[pfBindAddressInput].SetValue(config.BindAddress)
+	}
+}
--- a/internal/ui/table.go
+++ b/internal/ui/table.go
@@ -178,12 +178,13 @@ func (m *Model) updateTableHeight() {
 	// Calculate dynamic table height based on terminal size
 	// Layout breakdown:
 	// - ASCII title: 5 lines (1 empty + 4 text lines)
+	// - Update banner : 1 line (if present)
 	// - Search bar: 1 line
 	// - Help text: 1 line
 	// - App margins/spacing: 3 lines
 	// - Safety margin: 3 lines (to ensure UI elements are always visible)
-	// Total reserved: 13 lines minimum to preserve essential UI elements
-	reservedHeight := 13
+	// Total reserved: 14 lines minimum to preserve essential UI elements
+	reservedHeight := 14
 	availableHeight := m.height - reservedHeight
 	hostCount := len(m.table.Rows())

--- a/internal/ui/tui.go
+++ b/internal/ui/tui.go
@@ -16,7 +16,16 @@ import (
 )

 // NewModel creates a new TUI model with the given SSH hosts
-func NewModel(hosts []config.SSHHost, configFile string) Model {
+func NewModel(hosts []config.SSHHost, configFile, currentVersion string) Model {
+	// Load application configuration
+	appConfig, err := config.LoadAppConfig()
+	if err != nil {
+		// Log the error but continue with default configuration
+		fmt.Printf("Warning: Could not load application config: %v, using defaults\n", err)
+		defaultConfig := config.GetDefaultAppConfig()
+		appConfig = &defaultConfig
+	}
+
 	// Initialize the history manager
 	historyManager, err := history.NewHistoryManager()
 	if err != nil {
@@ -38,6 +47,8 @@ func NewModel(hosts []config.SSHHost, configFile string) Model {
 		pingManager:    pingManager,
 		sortMode:       SortByName,
 		configFile:     configFile,
+		currentVersion: currentVersion,
+		appConfig:      appConfig,
 		styles:         styles,
 		width:          80,
 		height:         24,
@@ -136,11 +147,17 @@ func NewModel(hosts []config.SSHHost, configFile string) Model {
 }

 // RunInteractiveMode starts the interactive TUI interface
-func RunInteractiveMode(hosts []config.SSHHost, configFile string) error {
-	m := NewModel(hosts, configFile)
+func RunInteractiveMode(hosts []config.SSHHost, configFile, currentVersion string) error {
+	m := NewModel(hosts, configFile, currentVersion)

 	// Start the application in alt screen mode for clean output
 	p := tea.NewProgram(m, tea.WithAltScreen())
+
+	// Send initial command to start auto-ping when the program starts
+	go func() {
+		p.Send(autoPingMsg{})
+	}()
+
 	_, err := p.Run()
 	if err != nil {
 		return fmt.Errorf("error running TUI: %w", err)
--- a/internal/ui/update.go
+++ b/internal/ui/update.go
@@ -8,14 +8,19 @@ import (

 	"github.com/Gu1llaum-3/sshm/internal/config"
 	"github.com/Gu1llaum-3/sshm/internal/connectivity"
+	"github.com/Gu1llaum-3/sshm/internal/version"

 	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 )

-// Messages for SSH ping functionality
+// Messages for SSH ping functionality and version checking
 type (
 	pingResultMsg   *connectivity.HostPingResult
+	versionCheckMsg *version.UpdateInfo
+	versionErrorMsg error
+	errorMsg        string
+	autoPingMsg     struct{}
 )

 // startPingAllCmd creates a command to ping all hosts concurrently
@@ -49,12 +54,33 @@ func pingSingleHostCmd(pingManager *connectivity.PingManager, host config.SSHHos
 	}
 }

+// checkVersionCmd creates a command to check for version updates
+func checkVersionCmd(currentVersion string) tea.Cmd {
+	return func() tea.Msg {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		updateInfo, err := version.CheckForUpdates(ctx, currentVersion)
+		if err != nil {
+			return versionErrorMsg(err)
+		}
+		return versionCheckMsg(updateInfo)
+	}
+}
+
 // Init initializes the model
 func (m Model) Init() tea.Cmd {
-	return tea.Batch(
-		textinput.Blink,
-		// Ping is now optional - use 'p' key to start ping
-	)
+	var cmds []tea.Cmd
+
+	// Basic initialization commands
+	cmds = append(cmds, textinput.Blink)
+
+	// Check for version updates if we have a current version
+	if m.currentVersion != "" {
+		cmds = append(cmds, checkVersionCmd(m.currentVersion))
+	}
+
+	return tea.Batch(cmds...)
 }

 // Update handles model updates
@@ -85,6 +111,11 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.editForm.height = m.height
 			m.editForm.styles = m.styles
 		}
+		if m.moveForm != nil {
+			m.moveForm.width = m.width
+			m.moveForm.height = m.height
+			m.moveForm.styles = m.styles
+		}
 		if m.infoForm != nil {
 			m.infoForm.width = m.width
 			m.infoForm.height = m.height
@@ -115,6 +146,31 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil

+	case autoPingMsg:
+		// Handle auto-ping on startup - start pinging all hosts
+		return m, m.startPingAllCmd()
+
+	case versionCheckMsg:
+		// Handle version check result
+		if msg != nil {
+			m.updateInfo = msg
+		}
+		return m, nil
+
+	case versionErrorMsg:
+		// Handle version check error (silently - not critical)
+		// We don't want to show error messages for version checks
+		// as it might disrupt the user experience
+		return m, nil
+
+	case errorMsg:
+		// Handle general error messages
+		if string(msg) == "clear" {
+			m.showingError = false
+			m.errorMessage = ""
+		}
+		return m, nil
+
 	case addFormSubmitMsg:
 		if msg.err != nil {
 			// Show error in form
@@ -203,6 +259,51 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.table.Focus()
 		return m, nil

+	case moveFormSubmitMsg:
+		if msg.err != nil {
+			// En cas d'erreur, on pourrait afficher une notification ou retourner à la liste
+			// Pour l'instant, on retourne simplement à la liste
+			m.viewMode = ViewList
+			m.moveForm = nil
+			m.table.Focus()
+			return m, nil
+		} else {
+			// Success: refresh hosts and return to list view
+			var hosts []config.SSHHost
+			var err error
+
+			if m.configFile != "" {
+				hosts, err = config.ParseSSHConfigFile(m.configFile)
+			} else {
+				hosts, err = config.ParseSSHConfig()
+			}
+
+			if err != nil {
+				return m, tea.Quit
+			}
+			m.hosts = m.sortHosts(hosts)
+
+			// Reapply search filter if there is one active
+			if m.searchInput.Value() != "" {
+				m.filteredHosts = m.filterHosts(m.searchInput.Value())
+			} else {
+				m.filteredHosts = m.hosts
+			}
+
+			m.updateTableRows()
+			m.viewMode = ViewList
+			m.moveForm = nil
+			m.table.Focus()
+			return m, nil
+		}
+
+	case moveFormCancelMsg:
+		// Cancel: return to list view
+		m.viewMode = ViewList
+		m.moveForm = nil
+		m.table.Focus()
+		return m, nil
+
 	case infoFormCancelMsg:
 		// Cancel: return to list view
 		m.viewMode = ViewList
@@ -303,6 +404,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.editForm = newForm
 				return m, cmd
 			}
+		case ViewMove:
+			if m.moveForm != nil {
+				var newForm *moveFormModel
+				newForm, cmd = m.moveForm.Update(msg)
+				m.moveForm = newForm
+				return m, cmd
+			}
 		case ViewInfo:
 			if m.infoForm != nil {
 				var newForm *infoFormModel
@@ -342,8 +450,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	var cmd tea.Cmd
+	key := msg.String()

-	switch msg.String() {
+	switch key {
 	case "esc", "ctrl+c":
 		if m.deleteMode {
 			// Exit delete mode
@@ -352,11 +461,17 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.table.Focus()
 			return m, nil
 		}
+		// Use configurable key bindings for quit
+		if m.appConfig != nil && m.appConfig.KeyBindings.ShouldQuitOnKey(key) {
 			return m, tea.Quit
+		}
 	case "q":
 		if !m.searchMode && !m.deleteMode {
+			// Use configurable key bindings for quit
+			if m.appConfig != nil && m.appConfig.KeyBindings.ShouldQuitOnKey(key) {
 				return m, tea.Quit
 			}
+		}
 	case "/", "ctrl+f":
 		if !m.searchMode && !m.deleteMode {
 			// Enter search mode
@@ -485,6 +600,27 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				return m, textinput.Blink
 			}
 		}
+	case "m":
+		if !m.searchMode && !m.deleteMode {
+			// Move the selected host to another config file
+			selected := m.table.SelectedRow()
+			if len(selected) > 0 {
+				hostName := extractHostNameFromTableRow(selected[0]) // Extract hostname from first column
+				moveForm, err := NewMoveForm(hostName, m.styles, m.width, m.height, m.configFile)
+				if err != nil {
+					// Show error message to user
+					m.errorMessage = err.Error()
+					m.showingError = true
+					return m, func() tea.Msg {
+						time.Sleep(3 * time.Second) // Show error for 3 seconds
+						return errorMsg("clear")
+					}
+				}
+				m.moveForm = moveForm
+				m.viewMode = ViewMove
+				return m, textinput.Blink
+			}
+		}
 	case "i":
 		if !m.searchMode && !m.deleteMode {
 			// Show info for the selected host
@@ -562,7 +698,7 @@ func (m Model) handleListViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			selected := m.table.SelectedRow()
 			if len(selected) > 0 {
 				hostName := extractHostNameFromTableRow(selected[0]) // Extract hostname from first column
-				m.portForwardForm = NewPortForwardForm(hostName, m.styles, m.width, m.height, m.configFile)
+				m.portForwardForm = NewPortForwardForm(hostName, m.styles, m.width, m.height, m.configFile, m.historyManager)
 				m.viewMode = ViewPortForward
 				return m, textinput.Blink
 			}
--- a/internal/ui/view.go
+++ b/internal/ui/view.go
@@ -23,6 +23,10 @@ func (m Model) View() string {
 		if m.editForm != nil {
 			return m.editForm.View()
 		}
+	case ViewMove:
+		if m.moveForm != nil {
+			return m.moveForm.View()
+		}
 	case ViewInfo:
 		if m.infoForm != nil {
 			return m.infoForm.View()
@@ -54,6 +58,34 @@ func (m Model) renderListView() string {
 	// Add the ASCII title
 	components = append(components, m.styles.Header.Render(asciiTitle))

+	// Add update notification if available (between title and search)
+	if m.updateInfo != nil && m.updateInfo.Available {
+		updateText := fmt.Sprintf("🚀 Update available: %s → %s",
+			m.updateInfo.CurrentVer,
+			m.updateInfo.LatestVer)
+
+		updateStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("10")). // Green color
+			Bold(true).
+			Align(lipgloss.Center) // Center the notification
+
+		components = append(components, updateStyle.Render(updateText))
+	}
+
+	// Add error message if there's one to show
+	if m.showingError && m.errorMessage != "" {
+		errorStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("9")). // Red color
+			Background(lipgloss.Color("1")). // Dark red background
+			Bold(true).
+			Padding(0, 1).
+			Border(lipgloss.RoundedBorder()).
+			BorderForeground(lipgloss.Color("9")).
+			Align(lipgloss.Center)
+
+		components = append(components, errorStyle.Render("❌ "+m.errorMessage))
+	}
+
 	// Add the search bar with the appropriate style based on focus
 	searchPrompt := "Search (/ to focus): "
 	if m.searchMode {
@@ -157,3 +189,30 @@ func (m Model) renderDeleteConfirmation() string {

 	return box.Render(raw)
 }
+
+// renderUpdateNotification renders the update notification banner
+func (m Model) renderUpdateNotification() string {
+	if m.updateInfo == nil || !m.updateInfo.Available {
+		return ""
+	}
+
+	// Create the notification message
+	message := fmt.Sprintf("🚀 Update available: %s → %s",
+		m.updateInfo.CurrentVer,
+		m.updateInfo.LatestVer)
+
+	// Add release URL if available
+	if m.updateInfo.ReleaseURL != "" {
+		message += fmt.Sprintf(" • View release: %s", m.updateInfo.ReleaseURL)
+	}
+
+	// Style the notification with a bright color to make it stand out
+	notificationStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#00FF00")). // Bright green
+		Bold(true).
+		Padding(0, 1).
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("#00AA00")) // Darker green border
+
+	return notificationStyle.Render(message)
+}
--- a/internal/validation/ssh_test.go
+++ b/internal/validation/ssh_test.go
@@ -128,7 +128,8 @@ func TestValidateIdentityFile(t *testing.T) {
 		{"empty path", "", true}, // Optional field
 		{"valid file", validFile, true},
 		{"non-existent file", "/path/to/nonexistent", false},
-		{"tilde path", "~/.ssh/id_rsa", true}, // Will pass if file exists
+		// 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
 	}

 	for _, tt := range tests {
@@ -138,6 +139,15 @@ func TestValidateIdentityFile(t *testing.T) {
 			}
 		})
 	}
+
+	// Test tilde path separately, but only if the file actually exists
+	t.Run("tilde path", func(t *testing.T) {
+		tildeFile := "~/.ssh/id_rsa"
+		// Just test that it doesn't crash, don't assume file exists
+		result := ValidateIdentityFile(tildeFile)
+		// Result can be true or false depending on file existence
+		_ = result // We just care that it doesn't panic
+	})
 }

 func TestValidateHost(t *testing.T) {
--- a/internal/version/version.go
+++ b/internal/version/version.go
@@ -0,0 +1,145 @@
+package version
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// GitHubRelease represents a GitHub release response
+type GitHubRelease struct {
+	TagName    string `json:"tag_name"`
+	Name       string `json:"name"`
+	HTMLURL    string `json:"html_url"`
+	Prerelease bool   `json:"prerelease"`
+	Draft      bool   `json:"draft"`
+}
+
+// UpdateInfo contains information about available updates
+type UpdateInfo struct {
+	Available   bool
+	CurrentVer  string
+	LatestVer   string
+	ReleaseURL  string
+	ReleaseName string
+}
+
+// parseVersion extracts version numbers from a version string (e.g., "v1.2.3" -> [1, 2, 3])
+func parseVersion(version string) []int {
+	// Remove 'v' prefix if present
+	version = strings.TrimPrefix(version, "v")
+
+	parts := strings.Split(version, ".")
+	nums := make([]int, len(parts))
+
+	for i, part := range parts {
+		// Remove any non-numeric suffixes (e.g., "1-beta", "2-rc1")
+		numPart := strings.FieldsFunc(part, func(r rune) bool {
+			return r == '-' || r == '+' || r == '_'
+		})[0]
+
+		if num, err := strconv.Atoi(numPart); err == nil {
+			nums[i] = num
+		}
+	}
+
+	return nums
+}
+
+// compareVersions compares two version strings
+// Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
+func compareVersions(v1, v2 string) int {
+	nums1 := parseVersion(v1)
+	nums2 := parseVersion(v2)
+
+	// Pad with zeros to make lengths equal
+	maxLen := len(nums1)
+	if len(nums2) > maxLen {
+		maxLen = len(nums2)
+	}
+
+	for len(nums1) < maxLen {
+		nums1 = append(nums1, 0)
+	}
+	for len(nums2) < maxLen {
+		nums2 = append(nums2, 0)
+	}
+
+	// Compare each part
+	for i := 0; i < maxLen; i++ {
+		if nums1[i] < nums2[i] {
+			return -1
+		}
+		if nums1[i] > nums2[i] {
+			return 1
+		}
+	}
+
+	return 0
+}
+
+// CheckForUpdates checks GitHub for the latest release of sshm
+func CheckForUpdates(ctx context.Context, currentVersion string) (*UpdateInfo, error) {
+	// Skip version check if current version is "dev"
+	if currentVersion == "dev" {
+		return &UpdateInfo{
+			Available:  false,
+			CurrentVer: currentVersion,
+		}, nil
+	}
+
+	// Create HTTP client with timeout
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	// Create request with context
+	req, err := http.NewRequestWithContext(ctx, "GET",
+		"https://api.github.com/repos/Gu1llaum-3/sshm/releases/latest", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Set user agent
+	req.Header.Set("User-Agent", "sshm/"+currentVersion)
+
+	// Make the request
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch latest release: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
+	}
+
+	// Parse the response
+	var release GitHubRelease
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	// Skip pre-releases and drafts
+	if release.Prerelease || release.Draft {
+		return &UpdateInfo{
+			Available:  false,
+			CurrentVer: currentVersion,
+		}, nil
+	}
+
+	// Compare versions
+	updateAvailable := compareVersions(currentVersion, release.TagName) < 0
+
+	return &UpdateInfo{
+		Available:   updateAvailable,
+		CurrentVer:  currentVersion,
+		LatestVer:   release.TagName,
+		ReleaseURL:  release.HTMLURL,
+		ReleaseName: release.Name,
+	}, nil
+}
--- a/internal/version/version_test.go
+++ b/internal/version/version_test.go
@@ -0,0 +1,56 @@
+package version
+
+import (
+	"testing"
+)
+
+func TestParseVersion(t *testing.T) {
+	tests := []struct {
+		version  string
+		expected []int
+	}{
+		{"v1.2.3", []int{1, 2, 3}},
+		{"1.2.3", []int{1, 2, 3}},
+		{"v2.0.0", []int{2, 0, 0}},
+		{"1.2.3-beta", []int{1, 2, 3}},
+		{"1.2.3-rc1", []int{1, 2, 3}},
+		{"dev", []int{0}},
+	}
+
+	for _, test := range tests {
+		result := parseVersion(test.version)
+		if len(result) != len(test.expected) {
+			t.Errorf("parseVersion(%q) length = %d, want %d", test.version, len(result), len(test.expected))
+			continue
+		}
+		for i, v := range result {
+			if v != test.expected[i] {
+				t.Errorf("parseVersion(%q)[%d] = %d, want %d", test.version, i, v, test.expected[i])
+				break
+			}
+		}
+	}
+}
+
+func TestCompareVersions(t *testing.T) {
+	tests := []struct {
+		v1       string
+		v2       string
+		expected int
+	}{
+		{"v1.0.0", "v1.0.1", -1},
+		{"v1.0.1", "v1.0.0", 1},
+		{"v1.0.0", "v1.0.0", 0},
+		{"1.2.3", "1.2.4", -1},
+		{"2.0.0", "1.9.9", 1},
+		{"1.2.3-beta", "1.2.3", 0}, // Should ignore suffixes
+		{"1.2.3", "1.2.3-rc1", 0},
+	}
+
+	for _, test := range tests {
+		result := compareVersions(test.v1, test.v2)
+		if result != test.expected {
+			t.Errorf("compareVersions(%q, %q) = %d, want %d", test.v1, test.v2, result, test.expected)
+		}
+	}
+}
Author	SHA1	Message	Date
cooper	8604a8f365	Merge `b43a67eb1a` into `3d746ec49a`	2025-09-30 03:32:03 +00:00
zxr	b43a67eb1a	feat: auto ping after sshm turn on.	2025-09-30 11:27:32 +08:00
zxr	120cd6c009	feat: add configurable key bindings with ESC quit disable option - Add unified application configuration system with JSON config file - Implement configurable quit keys (default: "q", "ctrl+c") - Add disable_esc_quit option for vim users to prevent accidental exits - Auto-create default config file at ~/.config/sshm/config.json - Maintain backward compatibility (ESC quit enabled by default) - Include comprehensive tests and documentation	2025-09-29 11:05:26 +08:00
Gu1llaum-3	3d746ec49a	doc: update installation instructions for Homebrew	2025-09-17 15:24:17 +02:00
Gu1llaum-3	f31fe9dacf	fix: update Windows install script for GoReleaser format - Change from sshm-windows-amd64.zip to sshm_Windows_x86_64.zip - Update architecture mapping (amd64 -> x86_64, 386 -> i386) - Fix extracted binary name (now just 'sshm.exe') - Update migration documentation	2025-09-17 14:44:50 +02:00
Gu1llaum-3	7b15db1f34	fix: update install script for GoReleaser binary format - Change from sshm-darwin-arm64.tar.gz to sshm_Darwin_arm64.tar.gz - Update architecture mapping (amd64 -> x86_64) - Update OS mapping (darwin -> Darwin) - Fix extracted binary name (now just 'sshm' instead of platform suffix)	2025-09-17 14:32:31 +02:00
Gu1llaum-3	55f3359287	fix: remove discussion_category_name (discussions not enabled)	2025-09-17 14:27:39 +02:00
Gu1llaum-3	4efec57a8a	fix: make ValidateIdentityFile test robust for CI environments - Remove assumption that ~/.ssh/id_rsa always exists - Test tilde path expansion without asserting file existence	2025-09-17 14:20:08 +02:00
Gu1llaum-3	0975ae2fe2	git commit -m "feat: add GoReleaser for automated releases and Homebrew integration - Replace manual GitHub Actions workflow - Add automated Formula updates to homebrew-sshm tap - Support pre-releases with auto-detection - Standardize cross-platform binary distribution"	2025-09-17 14:14:49 +02:00
Gu1llaum-3	ed6ea2939a	fix(ci): correct version injection in build workflow - Change -X flag from cmd.version to cmd.AppVersion - This fixes version display showing 'dev' instead of actual version - Binaries will now display correct version when built via GitHub Actions	2025-09-13 12:20:41 +02:00
Gu1llaum-3	45eccabc23	fix: replace Ctrl+Enter with Ctrl+S in forms to avoid terminal conflicts	2025-09-13 11:53:45 +02:00
Gu1llaum-3	2425695992	docs: update README	2025-09-13 11:53:45 +02:00
Gu1llaum-3	306f38e862	feat: show error when move requires includes but none found	2025-09-13 11:53:45 +02:00
Gu1llaum-3	3c627a5d21	feat: add port forwarding history persistence	2025-09-13 11:53:45 +02:00
Gu1llaum-3	71bf8ea2bb	feat: add direct host connection via `sshm <host>` with history tracking	2025-09-13 11:53:45 +02:00
Gu1llaum-3	8c6f3b01ef	feat: centralize history storage in config directory Automatically migrates existing ~/.ssh/sshm_history.json to platform-appropriate config location	2025-09-13 11:53:45 +02:00
Gu1llaum-3	aa6be1d92d	fix(cmd): export variables for test accessibility Export rootCmd->RootCmd and appVersion->AppVersion to fix test compilation errors. Update all references across cmd package and tests.	2025-09-13 11:53:45 +02:00
Gu1llaum-3	9bb44da18b	build: strip 'v' prefix from version tag for binary - Remove the 'v' prefix from the Git tag before injecting the version into the built binary - Ensures the version string in the CLI does not include a leading 'v' (e.g. '1.2.3' instead of 'v1.2.3')	2025-09-13 11:53:45 +02:00
Gu1llaum-3	77b2b8fd22	feat: add move command to relocate SSH hosts between config files - Add 'move' command with interactive file selector - Implement atomic host moving between SSH config files - Support for configs with include directives - Add comprehensive error handling and validation - Update help screen with improved two-column layout	2025-09-13 11:53:45 +02:00
Gu1llaum-3	5c832ce26f	feat: add automatic version update checking and notifications - Add internal/version module for GitHub release checking - Integrate async version check in Bubble Tea UI - Display update notification in main interface - Add version check to --version/-v command output - Include comprehensive version comparison and error handling - Add unit tests for version parsing and comparison logic	2025-09-13 11:53:45 +02:00