feat: add IP address validation and duplicate alias checking

- Add IsIPAddress public function for shared IP validation
- Add GetFieldValidatorsWithContext for context-aware validation
- Implement duplicate alias validation with support for edit mode
- Share IP validation logic between alias generation and validation
- Add comprehensive test coverage for IPv4 and IPv6 addresses
- Add tests for duplicate alias validation scenarios

Author: tan9

internal/adapters/ui/validation.go

@@ -131,12 +131,20 @@ const invalidAddressChars = "@#$%^&()=+{}|\\;:'\"<>,?/"
 
 // GetFieldValidators returns validation rules for SSH configuration fields
 func GetFieldValidators() map[string]fieldValidator {
+	return GetFieldValidatorsWithContext("", nil)
+}
+
+// GetFieldValidatorsWithContext returns validation rules with context-aware validators
+// originalAlias is used to exclude the current alias when editing
+// existingAliases is used to check for duplicates
+func GetFieldValidatorsWithContext(originalAlias string, existingAliases []string) map[string]fieldValidator {
 	validators := make(map[string]fieldValidator)
 
 	// Basic fields
 	validators["Alias"] = fieldValidator{
 		Required: true,
 		Pattern:  regexp.MustCompile(`^[a-zA-Z0-9._-]+$`),
+		Validate: createAliasValidator(originalAlias, existingAliases),
 		Message:  "Alias is required and can only contain letters, numbers, dots, hyphens, and underscores",
 	}
 	validators["Host"] = fieldValidator{
@@ -447,6 +455,35 @@ func validateKnownHostsFiles(files string) error {
 	return validateFilePaths(files, " ")
 }
 
+// createAliasValidator creates a validator for alias uniqueness
+func createAliasValidator(originalAlias string, existingAliases []string) func(string) error {
+	return func(alias string) error {
+		// Skip duplicate check if no existing aliases provided
+		if len(existingAliases) == 0 {
+			return nil
+		}
+
+		// Skip check if alias hasn't changed (edit mode)
+		if originalAlias != "" && alias == originalAlias {
+			return nil
+		}
+
+		// Check for duplicates
+		for _, existing := range existingAliases {
+			if existing == alias {
+				return fmt.Errorf("alias '%s' already exists", alias)
+			}
+		}
+
+		return nil
+	}
+}
+
+// IsIPAddress checks if the given string is a valid IP address (IPv4 or IPv6)
+func IsIPAddress(host string) bool {
+	return net.ParseIP(host) != nil
+}
+
 // validateHost validates a hostname or IP address
 func validateHost(host string) error {
 	if host == "" {
@@ -459,7 +496,7 @@ func validateHost(host string) error {
 	}
 
 	// Try to parse as IP address first
-	if net.ParseIP(host) != nil {
+	if IsIPAddress(host) {
 		return nil
 	}
 

internal/adapters/ui/validation_ip_test.go

@@ -0,0 +1,123 @@
+// Copyright 2025.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ui
+
+import "testing"
+
+func TestIsIPAddress(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  bool
+	}{
+		// Valid IPv4 addresses
+		{
+			name:  "valid IPv4",
+			input: "192.168.1.1",
+			want:  true,
+		},
+		{
+			name:  "valid IPv4 - localhost",
+			input: "127.0.0.1",
+			want:  true,
+		},
+		{
+			name:  "valid IPv4 - zeros",
+			input: "0.0.0.0",
+			want:  true,
+		},
+		{
+			name:  "valid IPv4 - max",
+			input: "255.255.255.255",
+			want:  true,
+		},
+		// Valid IPv6 addresses
+		{
+			name:  "valid IPv6 - full",
+			input: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+			want:  true,
+		},
+		{
+			name:  "valid IPv6 - compressed",
+			input: "2001:db8:85a3::8a2e:370:7334",
+			want:  true,
+		},
+		{
+			name:  "valid IPv6 - localhost",
+			input: "::1",
+			want:  true,
+		},
+		{
+			name:  "valid IPv6 - all zeros",
+			input: "::",
+			want:  true,
+		},
+		// Invalid addresses
+		{
+			name:  "invalid - hostname",
+			input: "example.com",
+			want:  false,
+		},
+		{
+			name:  "invalid - hostname with subdomain",
+			input: "api.example.com",
+			want:  false,
+		},
+		{
+			name:  "invalid - IPv4 out of range",
+			input: "256.256.256.256",
+			want:  false,
+		},
+		{
+			name:  "invalid - IPv4 with letters",
+			input: "192.168.1.a",
+			want:  false,
+		},
+		{
+			name:  "invalid - too many octets",
+			input: "192.168.1.1.1",
+			want:  false,
+		},
+		{
+			name:  "invalid - too few octets",
+			input: "192.168.1",
+			want:  false,
+		},
+		{
+			name:  "invalid - empty string",
+			input: "",
+			want:  false,
+		},
+		{
+			name:  "invalid - just dots",
+			input: "...",
+			want:  false,
+		},
+		{
+			name:  "invalid - localhost name",
+			input: "localhost",
+			want:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := IsIPAddress(tt.input)
+			if got != tt.want {
+				t.Errorf("IsIPAddress(%q) = %v, want %v", tt.input, got, tt.want)
+			}
+		})
+	}
+}

internal/adapters/ui/validation_test.go

@@ -17,6 +17,7 @@ package ui
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -327,3 +328,82 @@ func TestValidationState_Clear(t *testing.T) {
 		t.Errorf("Expected error count to be 0, got %d", state.GetErrorCount())
 	}
 }
+
+func TestAliasValidation(t *testing.T) {
+	tests := []struct {
+		name            string
+		alias           string
+		originalAlias   string
+		existingAliases []string
+		wantErr         bool
+		errContains     string
+	}{
+		{
+			name:            "valid new alias",
+			alias:           "newserver",
+			originalAlias:   "",
+			existingAliases: []string{"server1", "server2"},
+			wantErr:         false,
+		},
+		{
+			name:            "duplicate alias",
+			alias:           "server1",
+			originalAlias:   "",
+			existingAliases: []string{"server1", "server2"},
+			wantErr:         true,
+			errContains:     "already exists",
+		},
+		{
+			name:            "edit mode - same alias allowed",
+			alias:           "server1",
+			originalAlias:   "server1",
+			existingAliases: []string{"server1", "server2"},
+			wantErr:         false,
+		},
+		{
+			name:            "edit mode - changed to duplicate",
+			alias:           "server2",
+			originalAlias:   "server1",
+			existingAliases: []string{"server1", "server2"},
+			wantErr:         true,
+			errContains:     "already exists",
+		},
+		{
+			name:            "no existing aliases",
+			alias:           "anyserver",
+			originalAlias:   "",
+			existingAliases: nil,
+			wantErr:         false,
+		},
+		{
+			name:            "empty existing aliases",
+			alias:           "anyserver",
+			originalAlias:   "",
+			existingAliases: []string{},
+			wantErr:         false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			validators := GetFieldValidatorsWithContext(tt.originalAlias, tt.existingAliases)
+			aliasValidator := validators["Alias"]
+
+			var err error
+			if aliasValidator.Validate != nil {
+				err = aliasValidator.Validate(tt.alias)
+			}
+
+			if (err != nil) != tt.wantErr {
+				t.Errorf("alias validation error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if err != nil && tt.errContains != "" {
+				if !strings.Contains(err.Error(), tt.errContains) {
+					t.Errorf("error message = %v, want to contain %v", err.Error(), tt.errContains)
+				}
+			}
+		})
+	}
+}