implement core logic (#3)

internal/adapters/data/file/metadata_manager.go

@@ -0,0 +1,151 @@
+// 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 file
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+type ServerMetadata struct {
+	Tags     []string `json:"tags,omitempty"`
+	LastSeen string   `json:"last_seen,omitempty"`
+	PinnedAt string   `json:"pinned_at,omitempty"`
+	SSHCount int      `json:"ssh_count,omitempty"`
+}
+
+type metadataManager struct {
+	filePath string
+}
+
+func newMetadataManager(filePath string) *metadataManager {
+	return &metadataManager{filePath: filePath}
+}
+
+func (m *metadataManager) loadAll() (map[string]ServerMetadata, error) {
+	metadata := make(map[string]ServerMetadata)
+
+	if _, err := os.Stat(m.filePath); os.IsNotExist(err) {
+		return metadata, nil
+	}
+
+	data, err := os.ReadFile(m.filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(data) == 0 {
+		return metadata, nil
+	}
+
+	if err := json.Unmarshal(data, &metadata); err != nil {
+		return nil, fmt.Errorf("failed to parse metadata JSON: %w", err)
+	}
+
+	return metadata, nil
+}
+
+func (m *metadataManager) saveAll(metadata map[string]ServerMetadata) error {
+	if err := m.ensureDirectory(); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(metadata, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(m.filePath, data, 0o600)
+}
+
+func (m *metadataManager) updateServer(server domain.Server) error {
+	metadata, err := m.loadAll()
+	if err != nil {
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	existing := metadata[server.Alias]
+	merged := existing
+
+	if server.Tags != nil {
+		merged.Tags = server.Tags
+	}
+
+	if !server.LastSeen.IsZero() {
+		merged.LastSeen = server.LastSeen.Format(time.RFC3339)
+	}
+
+	if !server.PinnedAt.IsZero() {
+		merged.PinnedAt = server.PinnedAt.Format(time.RFC3339)
+	}
+
+	if server.SSHCount > 0 {
+		merged.SSHCount = server.SSHCount
+	}
+
+	metadata[server.Alias] = merged
+	return m.saveAll(metadata)
+}
+
+func (m *metadataManager) deleteServer(alias string) error {
+	metadata, err := m.loadAll()
+	if err != nil {
+		return nil
+	}
+
+	delete(metadata, alias)
+	return m.saveAll(metadata)
+}
+
+func (m *metadataManager) setPinned(alias string, pinned bool) error {
+	metadata, err := m.loadAll()
+	if err != nil {
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	meta := metadata[alias]
+	if pinned {
+		meta.PinnedAt = time.Now().Format(time.RFC3339)
+	} else {
+		meta.PinnedAt = ""
+	}
+
+	metadata[alias] = meta
+	return m.saveAll(metadata)
+}
+
+func (m *metadataManager) recordSSH(alias string) error {
+	metadata, err := m.loadAll()
+	if err != nil {
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	meta := metadata[alias]
+	meta.LastSeen = time.Now().Format(time.RFC3339)
+	meta.SSHCount++
+
+	metadata[alias] = meta
+	return m.saveAll(metadata)
+}
+
+func (m *metadataManager) ensureDirectory() error {
+	dir := filepath.Dir(m.filePath)
+	return os.MkdirAll(dir, 0o750)
+}

internal/adapters/data/file/parser.go

@@ -0,0 +1,119 @@
+// 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 file
+
+import (
+	"bufio"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+const (
+	sshConfigAliasField = "host"
+	sshConfigIPField    = "hostname"
+	sshConfigUserField  = "user"
+	sshConfigPortField  = "port"
+	sshConfigKeyField   = "identityfile"
+)
+
+type SSHConfigParser struct{}
+
+func (p *SSHConfigParser) Parse(reader io.Reader) ([]domain.Server, error) {
+	servers := make([]domain.Server, 0)
+	var currentServer *domain.Server
+
+	scanner := bufio.NewScanner(reader)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		if p.shouldSkipLine(line) {
+			continue
+		}
+
+		key, value := p.parseKeyValue(line)
+		if key == "" {
+			continue
+		}
+
+		switch key {
+		case sshConfigAliasField:
+			if currentServer != nil {
+				servers = append(servers, *currentServer)
+			}
+			currentServer = &domain.Server{
+				Alias: value,
+				Port:  DefaultPort,
+			}
+		case sshConfigIPField:
+			if currentServer != nil {
+				currentServer.Host = value
+			}
+		case sshConfigUserField:
+			if currentServer != nil {
+				currentServer.User = value
+			}
+		case sshConfigPortField:
+			if currentServer != nil {
+				currentServer.Port = p.parsePort(value)
+			}
+		case sshConfigKeyField:
+			if currentServer != nil {
+				currentServer.Key = p.expandPath(value)
+			}
+		}
+	}
+
+	if currentServer != nil {
+		servers = append(servers, *currentServer)
+	}
+
+	return servers, scanner.Err()
+}
+
+func (p *SSHConfigParser) shouldSkipLine(line string) bool {
+	return line == "" || strings.HasPrefix(line, "#")
+}
+
+func (p *SSHConfigParser) parseKeyValue(line string) (string, string) {
+	parts := strings.Fields(line)
+	if len(parts) < 2 {
+		return "", ""
+	}
+
+	key := strings.ToLower(parts[0])
+	value := strings.Join(parts[1:], " ")
+	return key, value
+}
+
+func (p *SSHConfigParser) parsePort(value string) int {
+	if port, err := strconv.Atoi(value); err == nil {
+		return port
+	}
+	return DefaultPort
+}
+
+func (p *SSHConfigParser) expandPath(path string) string {
+	if strings.HasPrefix(path, "~/") {
+		if home, err := os.UserHomeDir(); err == nil {
+			return filepath.Join(home, path[2:])
+		}
+	}
+	return path
+}

internal/adapters/data/file/server_repo.go

@@ -0,0 +1,144 @@
+// 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 file
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+	"go.uber.org/zap"
+)
+
+type serverRepo struct {
+	sshConfigManager *sshConfigManager
+	metadataManager  *metadataManager
+	logger           *zap.SugaredLogger
+}
+
+func NewServerRepo(logger *zap.SugaredLogger, sshPath, metaDataPath string) *serverRepo {
+	return &serverRepo{
+		sshConfigManager: newSSHConfigManager(sshPath),
+		metadataManager:  newMetadataManager(metaDataPath),
+		logger:           logger,
+	}
+}
+
+func (s *serverRepo) ListServers(query string) ([]domain.Server, error) {
+	servers, err := s.sshConfigManager.parseServers()
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse SSH config: %w", err)
+	}
+
+	metadata, err := s.metadataManager.loadAll()
+	if err != nil {
+		s.logger.Warnf("Failed to load metadata: %v", err)
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	servers = s.mergeMetadata(servers, metadata)
+
+	if query != "" {
+		servers = s.filterServers(servers, query)
+	}
+
+	return servers, nil
+}
+
+func (s *serverRepo) UpdateServer(server domain.Server, newServer domain.Server) error {
+	if err := s.sshConfigManager.updateServer(server.Alias, newServer); err != nil {
+		return fmt.Errorf("failed to update SSH config: %w", err)
+	}
+
+	return s.metadataManager.updateServer(newServer)
+}
+
+func (s *serverRepo) AddServer(server domain.Server) error {
+	if err := s.sshConfigManager.addServer(server); err != nil {
+		return fmt.Errorf("failed to add to SSH config: %w", err)
+	}
+
+	return s.metadataManager.updateServer(server)
+}
+
+func (s *serverRepo) DeleteServer(server domain.Server) error {
+	if err := s.sshConfigManager.deleteServer(server.Alias); err != nil {
+		return fmt.Errorf("failed to delete from SSH config: %w", err)
+	}
+
+	return s.metadataManager.deleteServer(server.Alias)
+}
+
+func (s *serverRepo) SetPinned(alias string, pinned bool) error {
+	return s.metadataManager.setPinned(alias, pinned)
+}
+
+func (s *serverRepo) RecordSSH(alias string) error {
+	return s.metadataManager.recordSSH(alias)
+}
+
+func (s *serverRepo) mergeMetadata(servers []domain.Server, metadata map[string]ServerMetadata) []domain.Server {
+	for i, server := range servers {
+		servers[i].LastSeen = time.Time{}
+
+		if meta, exists := metadata[server.Alias]; exists {
+			servers[i].Tags = meta.Tags
+			servers[i].SSHCount = meta.SSHCount
+
+			if meta.LastSeen != "" {
+				if lastSeen, err := time.Parse(time.RFC3339, meta.LastSeen); err == nil {
+					servers[i].LastSeen = lastSeen
+				}
+			}
+
+			if meta.PinnedAt != "" {
+				if pinnedAt, err := time.Parse(time.RFC3339, meta.PinnedAt); err == nil {
+					servers[i].PinnedAt = pinnedAt
+				}
+			}
+		}
+	}
+	return servers
+}
+
+func (s *serverRepo) filterServers(servers []domain.Server, query string) []domain.Server {
+	queryLower := strings.ToLower(query)
+	filtered := make([]domain.Server, 0)
+
+	for _, server := range servers {
+		if s.matchesQuery(server, queryLower) {
+			filtered = append(filtered, server)
+		}
+	}
+
+	return filtered
+}
+
+func (s *serverRepo) matchesQuery(server domain.Server, queryLower string) bool {
+	if strings.Contains(strings.ToLower(server.Alias), queryLower) ||
+		strings.Contains(strings.ToLower(server.Host), queryLower) ||
+		strings.Contains(strings.ToLower(server.User), queryLower) {
+		return true
+	}
+
+	for _, tag := range server.Tags {
+		if strings.Contains(strings.ToLower(tag), queryLower) {
+			return true
+		}
+	}
+
+	return false
+}

internal/adapters/data/file/ssh_config_manager.go

@@ -0,0 +1,137 @@
+// 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 file
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+const (
+	ManagedByComment = "# Managed by lazyssh"
+	DefaultPort      = 22
+)
+
+type sshConfigManager struct {
+	filePath string
+}
+
+func newSSHConfigManager(filePath string) *sshConfigManager {
+	return &sshConfigManager{filePath: filePath}
+}
+
+func (m *sshConfigManager) parseServers() ([]domain.Server, error) {
+	file, err := os.Open(m.filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []domain.Server{}, nil
+		}
+		return nil, err
+	}
+	defer func() {
+		_ = file.Close()
+	}()
+
+	parser := &SSHConfigParser{}
+	return parser.Parse(file)
+}
+
+func (m *sshConfigManager) writeServers(servers []domain.Server) error {
+	if err := m.ensureDirectory(); err != nil {
+		return err
+	}
+
+	file, err := os.Create(m.filePath)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = file.Close()
+	}()
+
+	writer := &SSHConfigWriter{}
+	return writer.Write(file, servers)
+}
+
+func (m *sshConfigManager) addServer(server domain.Server) error {
+	servers, err := m.parseServers()
+	if err != nil {
+		return err
+	}
+
+	// Check for duplicates
+	for _, srv := range servers {
+		if srv.Alias == server.Alias {
+			return fmt.Errorf("server with alias '%s' already exists", server.Alias)
+		}
+	}
+
+	servers = append(servers, server)
+	return m.writeServers(servers)
+}
+
+func (m *sshConfigManager) updateServer(alias string, newServer domain.Server) error {
+	servers, err := m.parseServers()
+	if err != nil {
+		return err
+	}
+
+	found := false
+	for i, srv := range servers {
+		if srv.Alias == alias {
+			servers[i] = newServer
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("server with alias '%s' not found", alias)
+	}
+
+	return m.writeServers(servers)
+}
+
+func (m *sshConfigManager) deleteServer(alias string) error {
+	servers, err := m.parseServers()
+	if err != nil {
+		return err
+	}
+
+	newServers := make([]domain.Server, 0, len(servers))
+	found := false
+
+	for _, srv := range servers {
+		if srv.Alias != alias {
+			newServers = append(newServers, srv)
+		} else {
+			found = true
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("server with alias '%s' not found", alias)
+	}
+
+	return m.writeServers(newServers)
+}
+
+func (m *sshConfigManager) ensureDirectory() error {
+	dir := filepath.Dir(m.filePath)
+	return os.MkdirAll(dir, 0o700)
+}

internal/adapters/data/file/writer.go

@@ -0,0 +1,80 @@
+// 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 file
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+type SSHConfigWriter struct{}
+
+func (w *SSHConfigWriter) Write(writer io.Writer, servers []domain.Server) error {
+	bufWriter := bufio.NewWriter(writer)
+	defer func() {
+		_ = bufWriter.Flush()
+	}()
+
+	if _, err := fmt.Fprintf(bufWriter, "%s\n\n", ManagedByComment); err != nil {
+		return err
+	}
+
+	for i, server := range servers {
+		if i > 0 {
+			if _, err := bufWriter.WriteString("\n"); err != nil {
+				return err
+			}
+		}
+		if err := w.writeServer(bufWriter, server); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (w *SSHConfigWriter) writeServer(writer *bufio.Writer, server domain.Server) error {
+	if _, err := fmt.Fprintf(writer, "Host %s\n", server.Alias); err != nil {
+		return err
+	}
+
+	if server.Host != "" {
+		if _, err := fmt.Fprintf(writer, "    HostName %s\n", server.Host); err != nil {
+			return err
+		}
+	}
+
+	if server.User != "" {
+		if _, err := fmt.Fprintf(writer, "    User %s\n", server.User); err != nil {
+			return err
+		}
+	}
+
+	if server.Port != 0 && server.Port != DefaultPort {
+		if _, err := fmt.Fprintf(writer, "    Port %d\n", server.Port); err != nil {
+			return err
+		}
+	}
+
+	if server.Key != "" {
+		if _, err := fmt.Fprintf(writer, "    IdentityFile %s\n", server.Key); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/adapters/data/memory/server_in_memory_repo.go

@@ -19,25 +19,31 @@ import (
 	"strings"
 	"time"
 
+	"go.uber.org/zap"
+
 	"github.com/Adembc/lazyssh/internal/core/domain"
 )
 
-type serverRepository struct{}
+type serverRepository struct {
+	logger *zap.SugaredLogger
+}
 
 var servers = []domain.Server{
-	{Alias: "web-01", Host: "192.168.1.10", User: "root", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "web"}, Status: "online", LastSeen: time.Now().Add(-2 * time.Hour)},
-	{Alias: "web-02", Host: "192.168.1.11", User: "ubuntu", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"prod", "web"}, Status: "warn", LastSeen: time.Now().Add(-30 * time.Minute)},
-	{Alias: "db-01", Host: "192.168.1.20", User: "postgres", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "db"}, Status: "offline", LastSeen: time.Now().Add(-26 * time.Hour)},
-	{Alias: "api-01", Host: "192.168.1.30", User: "deploy", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"prod", "api"}, Status: "online", LastSeen: time.Now().Add(-10 * time.Minute)},
-	{Alias: "cache-01", Host: "192.168.1.40", User: "redis", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "cache"}, Status: "online", LastSeen: time.Now().Add(-1 * time.Hour)},
-	{Alias: "dev-web", Host: "10.0.1.10", User: "dev", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"dev", "web"}, Status: "online", LastSeen: time.Now().Add(-5 * time.Minute)},
-	{Alias: "dev-db", Host: "10.0.1.20", User: "dev", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"dev", "db"}, Status: "online", LastSeen: time.Now().Add(-15 * time.Minute)},
-	{Alias: "staging", Host: "staging.example.com", User: "ubuntu", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"test"}, Status: "warn", LastSeen: time.Now().Add(-45 * time.Minute)},
+	{Alias: "web-01", Host: "192.168.1.10", User: "root", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "web"}, LastSeen: time.Now().Add(-2 * time.Hour)},
+	{Alias: "web-02", Host: "192.168.1.11", User: "ubuntu", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"prod", "web"}, LastSeen: time.Now().Add(-30 * time.Minute)},
+	{Alias: "db-01", Host: "192.168.1.20", User: "postgres", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "db"}, LastSeen: time.Now().Add(-26 * time.Hour)},
+	{Alias: "api-01", Host: "192.168.1.30", User: "deploy", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"prod", "api"}, LastSeen: time.Now().Add(-10 * time.Minute)},
+	{Alias: "cache-01", Host: "192.168.1.40", User: "redis", Port: 22, Key: "~/.ssh/id_rsa", Tags: []string{"prod", "cache"}, LastSeen: time.Now().Add(-1 * time.Hour)},
+	{Alias: "dev-web", Host: "10.0.1.10", User: "dev", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"dev", "web"}, LastSeen: time.Now().Add(-5 * time.Minute)},
+	{Alias: "dev-db", Host: "10.0.1.20", User: "dev", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"dev", "db"}, LastSeen: time.Now().Add(-15 * time.Minute)},
+	{Alias: "staging", Host: "staging.example.com", User: "ubuntu", Port: 22, Key: "~/.ssh/id_ed25519", Tags: []string{"test"}, LastSeen: time.Now().Add(-45 * time.Minute)},
 }
 
 // NewServerRepository creates a new server repository with the given file path.
-func NewServerRepository() *serverRepository {
-	return &serverRepository{}
+func NewServerRepository(logger *zap.SugaredLogger) *serverRepository {
+	return &serverRepository{
+		logger: logger,
+	}
 }
 
 // ListServers returns a list of servers from the repository.
@@ -52,11 +58,10 @@ func (r *serverRepository) ListServers(query string) ([]domain.Server, error) {
 		alias := strings.ToLower(server.Alias)
 		host := strings.ToLower(server.Host)
 		user := strings.ToLower(server.User)
-		status := strings.ToLower(server.Status)
 		port := strconv.Itoa(server.Port)
 
 		match := false
-		if strings.Contains(alias, q) || strings.Contains(host, q) || strings.Contains(user, q) || strings.Contains(status, q) || strings.Contains(port, q) {
+		if strings.Contains(alias, q) || strings.Contains(host, q) || strings.Contains(user, q) || strings.Contains(port, q) {
 			match = true
 		}
 		if !match {
@@ -101,3 +106,27 @@ func (r *serverRepository) DeleteServer(server domain.Server) error {
 	}
 	return nil
 }
+
+func (r *serverRepository) SetPinned(alias string, pinned bool) error {
+	for i, s := range servers {
+		if s.Alias == alias {
+			if pinned {
+				servers[i].PinnedAt = time.Now()
+			} else {
+				servers[i].PinnedAt = time.Time{}
+			}
+			return nil
+		}
+	}
+	return nil
+}
+
+func (r *serverRepository) RecordSSH(alias string) error {
+	for i, s := range servers {
+		if s.Alias == alias {
+			servers[i].LastSeen = time.Now()
+			return nil
+		}
+	}
+	return nil
+}

internal/adapters/ui/handlers.go

@@ -16,8 +16,11 @@ package ui
 
 import (
 	"fmt"
+	"strings"
+	"time"
 
 	"github.com/Adembc/lazyssh/internal/core/domain"
+	"github.com/atotto/clipboard"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
@@ -34,7 +37,7 @@ func (t *tui) handleGlobalKeys(event *tcell.EventKey) *tcell.EventKey {
 
 	switch event.Rune() {
 	case 'q':
-		t.app.Stop()
+		t.handleQuit()
 		return nil
 	case '/':
 		t.handleSearchToggle()
@@ -48,8 +51,26 @@ func (t *tui) handleGlobalKeys(event *tcell.EventKey) *tcell.EventKey {
 	case 'd':
 		t.handleServerDelete()
 		return nil
-	case '?':
-		t.handleHelpShow()
+	case 'p':
+		t.handleServerPin()
+		return nil
+	case 's':
+		t.handleSortToggle()
+		return nil
+	case 'S':
+		t.handleSortReverse()
+		return nil
+	case 'c':
+		t.handleCopyCommand()
+		return nil
+	case 'g':
+		t.handlePingSelected()
+		return nil
+	case 'r':
+		t.handleRefreshBackground()
+		return nil
+	case 't':
+		t.handleTagsEdit()
 		return nil
 	}
 
@@ -61,8 +82,52 @@ func (t *tui) handleGlobalKeys(event *tcell.EventKey) *tcell.EventKey {
 	return event
 }
 
+func (t *tui) handleQuit() {
+	t.app.Stop()
+}
+
+func (t *tui) handleServerPin() {
+	if server, ok := t.serverList.GetSelectedServer(); ok {
+		pinned := server.PinnedAt.IsZero()
+		_ = t.serverService.SetPinned(server.Alias, pinned)
+		t.refreshServerList()
+	}
+}
+
+func (t *tui) handleSortToggle() {
+	t.sortMode = t.sortMode.ToggleField()
+	t.showStatusTemp("Sort: " + t.sortMode.String())
+	t.updateListTitle()
+	t.refreshServerList()
+}
+
+func (t *tui) handleSortReverse() {
+	t.sortMode = t.sortMode.Reverse()
+	t.showStatusTemp("Sort: " + t.sortMode.String())
+	t.updateListTitle()
+	t.refreshServerList()
+}
+
+func (t *tui) handleCopyCommand() {
+	if server, ok := t.serverList.GetSelectedServer(); ok {
+		cmd := BuildSSHCommand(server)
+		if err := clipboard.WriteAll(cmd); err == nil {
+			t.showStatusTemp("Copied: " + cmd)
+		} else {
+			t.showStatusTemp("Failed to copy to clipboard")
+		}
+	}
+}
+
+func (t *tui) handleTagsEdit() {
+	if server, ok := t.serverList.GetSelectedServer(); ok {
+		t.showEditTagsForm(server)
+	}
+}
+
 func (t *tui) handleSearchInput(query string) {
 	filtered, _ := t.serverService.ListServers(query)
+	sortServersForUI(filtered, t.sortMode)
 	t.serverList.UpdateServers(filtered)
 	if len(filtered) == 0 {
 		t.details.ShowEmpty()
@@ -100,12 +165,22 @@ func (t *tui) handleServerEdit() {
 }
 
 func (t *tui) handleServerSave(server domain.Server, original *domain.Server) {
+	var err error
 	if original != nil {
 		// Edit mode
-		_ = t.serverService.UpdateServer(*original, server)
+		err = t.serverService.UpdateServer(*original, server)
 	} else {
 		// Add mode
-		_ = t.serverService.AddServer(server)
+		err = t.serverService.AddServer(server)
+	}
+	if err != nil {
+		// Stay on form; show a small modal with the error
+		modal := tview.NewModal().
+			SetText(fmt.Sprintf("Save failed: %v", err)).
+			AddButtons([]string{"Close"}).
+			SetDoneFunc(func(buttonIndex int, buttonLabel string) { t.handleModalClose() })
+		t.app.SetRoot(modal, true)
+		return
 	}
 
 	t.refreshServerList()
@@ -114,8 +189,7 @@ func (t *tui) handleServerSave(server domain.Server, original *domain.Server) {
 
 func (t *tui) handleServerDelete() {
 	if server, ok := t.serverList.GetSelectedServer(); ok {
-		_ = t.serverService.DeleteServer(server)
-		t.refreshServerList()
+		t.showDeleteConfirmModal(server)
 	}
 }
 
@@ -123,14 +197,66 @@ func (t *tui) handleFormCancel() {
 	t.returnToMain()
 }
 
-func (t *tui) handleHelpShow() {
-	t.showHelpModal()
+func (t *tui) handlePingSelected() {
+	if server, ok := t.serverList.GetSelectedServer(); ok {
+		alias := server.Alias
+
+		t.showStatusTemp(fmt.Sprintf("Pinging %s…", alias))
+		go func() {
+			up, dur, err := t.serverService.Ping(server)
+			t.app.QueueUpdateDraw(func() {
+				if err != nil {
+					t.showStatusTempColor(fmt.Sprintf("Ping %s: DOWN (%v)", alias, err), "#FF6B6B")
+					return
+				}
+				if up {
+					t.showStatusTempColor(fmt.Sprintf("Ping %s: UP (%s)", alias, dur), "#A0FFA0")
+				} else {
+					t.showStatusTempColor(fmt.Sprintf("Ping %s: DOWN", alias), "#FF6B6B")
+				}
+			})
+		}()
+	}
 }
 
 func (t *tui) handleModalClose() {
 	t.returnToMain()
 }
 
+// handleRefreshBackground refreshes the server list in the background without leaving the current screen.
+// It preserves the current search query and selection, shows transient status, and avoids concurrent runs.
+func (t *tui) handleRefreshBackground() {
+	currentIdx := t.serverList.GetCurrentItem()
+	query := ""
+	if t.searchVisible {
+		query = t.searchBar.InputField.GetText()
+	}
+
+	t.showStatusTemp("Refreshing…")
+
+	go func(prevIdx int, q string) {
+		servers, err := t.serverService.ListServers(q)
+		if err != nil {
+			t.app.QueueUpdateDraw(func() {
+				t.showStatusTempColor(fmt.Sprintf("Refresh failed: %v", err), "#FF6B6B")
+			})
+			return
+		}
+		sortServersForUI(servers, t.sortMode)
+		t.app.QueueUpdateDraw(func() {
+			t.serverList.UpdateServers(servers)
+			// Try to restore selection if still valid
+			if prevIdx >= 0 && prevIdx < t.serverList.List.GetItemCount() {
+				t.serverList.SetCurrentItem(prevIdx)
+				if srv, ok := t.serverList.GetSelectedServer(); ok {
+					t.details.UpdateServer(srv)
+				}
+			}
+			t.showStatusTemp(fmt.Sprintf("Refreshed %d servers", len(servers)))
+		})
+	}(currentIdx, query)
+}
+
 // =============================================================================
 // UI Display Functions (show UI elements/modals)
 // =============================================================================
@@ -144,40 +270,89 @@ func (t *tui) showSearchBar() {
 }
 
 func (t *tui) showConnectModal(server domain.Server) {
-	msg := fmt.Sprintf("SSH to %s (%s@%s:%d)\n\nThis is a mock action.",
+	msg := fmt.Sprintf("SSH to %s (%s@%s:%d)\n\nConfirm to start an SSH session .",
 		server.Alias, server.User, server.Host, server.Port)
 
 	modal := tview.NewModal().
 		SetText(msg).
-		AddButtons([]string{"OK"}).
+		AddButtons([]string{"Confirm", "Cancel"}).
 		SetDoneFunc(func(buttonIndex int, buttonLabel string) {
+			if buttonIndex == 0 {
+				// Suspend the TUI while running the external ssh command.
+				t.app.Suspend(func() {
+					err := t.serverService.SSH(server.Alias)
+					if err != nil {
+						// Show a brief status after we resume
+						t.app.QueueUpdateDraw(func() {
+							if strings.Contains(strings.ToLower(err.Error()), "timeout") {
+								t.showStatusTempColor("SSH timeout, returning to list", "#FF6B6B")
+							} else {
+								t.showStatusTempColor("SSH failed: "+err.Error(), "#FF6B6B")
+							}
+						})
+					}
+				})
+				// Refresh to reflect updated last seen and ssh count
+				t.refreshServerList()
+			}
 			t.handleModalClose()
 		})
 
 	t.app.SetRoot(modal, true)
 }
 
-func (t *tui) showHelpModal() {
-	text := "Keyboard shortcuts:\n\n" +
-		"  ↑/↓          Navigate\n" +
-		"  Enter        SSH connect (mock)\n" +
-		"  a            Add server (mock)\n" +
-		"  e            Edit server (mock)\n" +
-		"  d            Delete entry (mock)\n" +
-		"  /            Focus search\n" +
-		"  q            Quit\n" +
-		"  ?            Help\n"
+func (t *tui) showDeleteConfirmModal(server domain.Server) {
+	msg := fmt.Sprintf("Delete server %s (%s@%s:%d)?\n\nThis action cannot be undone.",
+		server.Alias, server.User, server.Host, server.Port)
 
 	modal := tview.NewModal().
-		SetText(text).
-		AddButtons([]string{"Close"}).
+		SetText(msg).
+		AddButtons([]string{"Cancel", "Confirm"}).
 		SetDoneFunc(func(buttonIndex int, buttonLabel string) {
+			if buttonIndex == 1 {
+				_ = t.serverService.DeleteServer(server)
+				t.refreshServerList()
+			}
 			t.handleModalClose()
 		})
 
 	t.app.SetRoot(modal, true)
 }
 
+func (t *tui) showEditTagsForm(server domain.Server) {
+	form := tview.NewForm()
+	form.SetBorder(true).
+		SetTitle(fmt.Sprintf("Edit Tags: %s", server.Alias)).
+		SetTitleAlign(tview.AlignLeft)
+
+	defaultTags := strings.Join(server.Tags, ", ")
+	form.AddInputField("Tags (comma):", defaultTags, 40, nil, nil)
+
+	form.AddButton("Save", func() {
+		text := strings.TrimSpace(form.GetFormItem(0).(*tview.InputField).GetText())
+		var tags []string
+		if text != "" {
+			for _, part := range strings.Split(text, ",") {
+				if s := strings.TrimSpace(part); s != "" {
+					tags = append(tags, s)
+				}
+			}
+		}
+		newServer := server
+		newServer.Tags = tags
+		_ = t.serverService.UpdateServer(server, newServer)
+		// Refresh UI and go back
+		t.refreshServerList()
+		t.returnToMain()
+		t.showStatusTemp("Tags updated")
+	})
+	form.AddButton("Cancel", func() { t.returnToMain() })
+	form.SetCancelFunc(func() { t.returnToMain() })
+
+	t.app.SetRoot(form, true)
+	t.app.SetFocus(form)
+}
+
 // =============================================================================
 // UI State Management (hide UI elements)
 // =============================================================================
@@ -200,9 +375,35 @@ func (t *tui) refreshServerList() {
 		query = t.searchBar.InputField.GetText()
 	}
 	filtered, _ := t.serverService.ListServers(query)
+	sortServersForUI(filtered, t.sortMode)
 	t.serverList.UpdateServers(filtered)
 }
 
 func (t *tui) returnToMain() {
 	t.app.SetRoot(t.root, true)
 }
+
+// showStatusTemp displays a temporary message in the status bar (default green) and then restores the default text.
+func (t *tui) showStatusTemp(msg string) {
+	if t.statusBar == nil {
+		return
+	}
+	t.showStatusTempColor(msg, "#A0FFA0")
+}
+
+// showStatusTempColor displays a temporary colored message in the status bar and restores default text after 2s.
+func (t *tui) showStatusTempColor(msg string, color string) {
+	if t.statusBar == nil {
+		return
+	}
+	t.statusBar.SetText("[" + color + "]" + msg + "[-]")
+	time.AfterFunc(2*time.Second, func() {
+		if t.app != nil {
+			t.app.QueueUpdateDraw(func() {
+				if t.statusBar != nil {
+					t.statusBar.SetText(DefaultStatusText())
+				}
+			})
+		}
+	})
+}

internal/adapters/ui/hint_bar.go

@@ -22,6 +22,6 @@ import (
 func NewHintBar() *tview.TextView {
 	hint := tview.NewTextView().SetDynamicColors(true)
 	hint.SetBackgroundColor(tcell.Color233)
-	hint.SetText("[#BBBBBB]Press [::b]/[-:-:b] to search…  •  ↑↓ Navigate  •  Enter SSH  •  a Add  •  e Edit  •  d Delete  •  ? Help[-]")
+	hint.SetText("[#BBBBBB]Press [::b]/[-:-:b] to search…  •  ↑↓ Navigate  •  Enter SSH  •  c Copy SSH  •  g Ping  •  r Refresh  •  a Add  •  e Edit  •  t Tags  •  d Delete  •  p Pin/Unpin  •  s Sort[-]")
 	return hint
 }

internal/adapters/ui/server_details.go

@@ -16,6 +16,7 @@ package ui
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/gdamore/tcell/v2"
@@ -43,12 +44,37 @@ func (sd *ServerDetails) build() {
 		SetTitleColor(tcell.Color250)
 }
 
+// renderTagChips builds colored tag chips for details view.
+func renderTagChips(tags []string) string {
+	if len(tags) == 0 {
+		return "-"
+	}
+	chips := make([]string, 0, len(tags))
+	for _, t := range tags {
+		chips = append(chips, fmt.Sprintf("[black:#5FAFFF] %s [-:-:-]", t))
+	}
+	return strings.Join(chips, " ")
+}
+
 func (sd *ServerDetails) UpdateServer(server domain.Server) {
+	lastSeen := server.LastSeen.Format("2006-01-02 15:04:05")
+	if server.LastSeen.IsZero() {
+		lastSeen = "Never"
+	}
+	serverKey := server.Key
+	if serverKey == "" {
+		serverKey = "(default: ~/.ssh/id_{rsa,ed25519,ecdsa})"
+	}
+	pinnedStr := "true"
+	if server.PinnedAt.IsZero() {
+		pinnedStr = "false"
+	}
+	tagsText := renderTagChips(server.Tags)
 	text := fmt.Sprintf(
-		"[::b]%s[-]\n\nHost: [white]%s[-]\nUser: [white]%s[-]\nPort: [white]%d[-]\nKey:  [white]%s[-]\nTags: [white]%s[-]\nStatus: %s\nLast: %s\n\n[::b]Commands:[-]\n  Enter: SSH connect\n  a: Add new server\n  e: Edit entry\n  d: Delete entry",
+		"[::b]%s[-]\n\nHost: [white]%s[-]\nUser: [white]%s[-]\nPort: [white]%d[-]\nKey:  [white]%s[-]\nTags: %s\nPinned: [white]%s[-]\nLast SSH: %s\nSSH Count: [white]%d[-]\n\n[::b]Commands:[-]\n  Enter: SSH connect\n  c: Copy SSH command\n  g: Ping server\n  r: Refresh list\n  a: Add new server\n  e: Edit entry\n  t: Edit tags\n  d: Delete entry\n  p: Pin/Unpin",
 		server.Alias, server.Host, server.User, server.Port,
-		server.Key, joinTags(server.Tags), statusIcon(server.Status),
-		server.LastSeen.Format("2006-01-02 15:04"))
+		serverKey, tagsText, pinnedStr,
+		lastSeen, server.SSHCount)
 	sd.TextView.SetText(text)
 }
 

internal/adapters/ui/server_form.go

@@ -16,9 +16,10 @@ package ui
 
 import (
 	"fmt"
+	"net"
+	"regexp"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/gdamore/tcell/v2"
@@ -51,10 +52,7 @@ func NewServerForm(mode ServerFormMode, original *domain.Server) *ServerForm {
 }
 
 func (sf *ServerForm) build() {
-	title := "Add Server"
-	if sf.mode == ServerFormEdit {
-		title = "Edit Server"
-	}
+	title := sf.titleForMode()
 
 	sf.Form.SetBorder(true).
 		SetTitle(title).
@@ -69,24 +67,29 @@ func (sf *ServerForm) build() {
 	sf.Form.SetCancelFunc(sf.handleCancel)
 }
 
+func (sf *ServerForm) titleForMode() string {
+	if sf.mode == ServerFormEdit {
+		return "Edit Server"
+	}
+	return "Add Server"
+}
+
 func (sf *ServerForm) addFormFields() {
 	var defaultValues ServerFormData
 	if sf.mode == ServerFormEdit && sf.original != nil {
 		defaultValues = ServerFormData{
-			Alias:  sf.original.Alias,
-			Host:   sf.original.Host,
-			User:   sf.original.User,
-			Port:   fmt.Sprint(sf.original.Port),
-			Key:    sf.original.Key,
-			Tags:   strings.Join(sf.original.Tags, ", "),
-			Status: sf.original.Status,
+			Alias: sf.original.Alias,
+			Host:  sf.original.Host,
+			User:  sf.original.User,
+			Port:  fmt.Sprint(sf.original.Port),
+			Key:   sf.original.Key,
+			Tags:  strings.Join(sf.original.Tags, ", "),
 		}
 	} else {
 		defaultValues = ServerFormData{
-			User:   "root",
-			Port:   "22",
-			Key:    "~/.ssh/id_ed25519",
-			Status: "online",
+			User: "root",
+			Port: "22",
+			Key:  "~/.ssh/id_ed25519",
 		}
 	}
 
@@ -96,28 +99,15 @@ func (sf *ServerForm) addFormFields() {
 	sf.Form.AddInputField("Port:", defaultValues.Port, 20, nil, nil)
 	sf.Form.AddInputField("Key:", defaultValues.Key, 40, nil, nil)
 	sf.Form.AddInputField("Tags (comma):", defaultValues.Tags, 30, nil, nil)
-
-	statusDD := tview.NewDropDown().SetLabel("Status: ")
-	statusOptions := []string{"online", "warn", "offline"}
-	statusDD.SetOptions(statusOptions, nil)
-
-	for i, opt := range statusOptions {
-		if opt == defaultValues.Status {
-			statusDD.SetCurrentOption(i)
-			break
-		}
-	}
-	sf.Form.AddFormItem(statusDD)
 }
 
 type ServerFormData struct {
-	Alias  string
-	Host   string
-	User   string
-	Port   string
-	Key    string
-	Tags   string
-	Status string
+	Alias string
+	Host  string
+	User  string
+	Port  string
+	Key   string
+	Tags  string
 }
 
 func (sf *ServerForm) getFormData() ServerFormData {
@@ -133,14 +123,18 @@ func (sf *ServerForm) getFormData() ServerFormData {
 
 func (sf *ServerForm) handleSave() {
 	data := sf.getFormData()
-	if data.Alias == "" || data.Host == "" {
+
+	if errMsg := validateServerForm(data); errMsg != "" {
+
+		sf.Form.SetTitle(fmt.Sprintf("%s — [red::b]%s[-]", sf.titleForMode(), errMsg))
+		sf.Form.SetBorderColor(tcell.ColorRed)
 		return
 	}
 
+	sf.Form.SetTitle(sf.titleForMode())
+	sf.Form.SetBorderColor(tcell.Color238)
+
 	server := sf.dataToServer(data)
-	if sf.original == nil {
-		server.LastSeen = time.Now()
-	}
 	if sf.onSave != nil {
 		sf.onSave(server, sf.original)
 	}
@@ -169,18 +163,61 @@ func (sf *ServerForm) dataToServer(data ServerFormData) domain.Server {
 		}
 	}
 
-	_, status := sf.Form.GetFormItem(6).(*tview.DropDown).GetCurrentOption()
 	return domain.Server{
-		Alias:  data.Alias,
-		Host:   data.Host,
-		User:   data.User,
-		Port:   port,
-		Key:    data.Key,
-		Tags:   tags,
-		Status: status,
+		Alias: data.Alias,
+		Host:  data.Host,
+		User:  data.User,
+		Port:  port,
+		Key:   data.Key,
+		Tags:  tags,
 	}
 }
 
+// validateServerForm returns an error message string if validation fails; empty string means valid.
+func validateServerForm(data ServerFormData) string {
+	alias := data.Alias
+	if alias == "" {
+		return "Alias is required"
+	}
+	if !regexp.MustCompile(`^[A-Za-z0-9_.-]+$`).MatchString(alias) {
+		return "Alias may contain letters, digits, dot, dash, underscore"
+	}
+
+	host := data.Host
+	if host == "" {
+		return "Host/IP is required"
+	}
+	if ip := net.ParseIP(host); ip == nil {
+
+		if strings.Contains(host, " ") {
+			return "Host must not contain spaces"
+		}
+		if !regexp.MustCompile(`^[A-Za-z0-9.-]+$`).MatchString(host) {
+			return "Host contains invalid characters"
+		}
+		if strings.HasPrefix(host, ".") || strings.HasSuffix(host, ".") {
+			return "Host must not start or end with a dot"
+		}
+		for _, lbl := range strings.Split(host, ".") {
+			if lbl == "" {
+				return "Host must not contain empty labels"
+			}
+			if strings.HasPrefix(lbl, "-") || strings.HasSuffix(lbl, "-") {
+				return "Hostname labels must not start or end with a hyphen"
+			}
+		}
+	}
+
+	if data.Port != "" {
+		p, err := strconv.Atoi(data.Port)
+		if err != nil || p < 1 || p > 65535 {
+			return "Port must be a number between 1 and 65535"
+		}
+	}
+
+	return ""
+}
+
 func (sf *ServerForm) OnSave(fn func(domain.Server, *domain.Server)) *ServerForm {
 	sf.onSave = fn
 	return sf

internal/adapters/ui/sort.go

@@ -0,0 +1,130 @@
+// 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 (
+	"sort"
+	"strings"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+// SortMode controls how unpinned servers are ordered in the UI.
+type SortMode int
+
+const (
+	SortByAliasAsc SortMode = iota
+	SortByAliasDesc
+	SortByLastSeenDesc
+	SortByLastSeenAsc
+)
+
+func (m SortMode) String() string {
+	switch m {
+	case SortByAliasAsc:
+		return "Alias ↑"
+	case SortByAliasDesc:
+		return "Alias ↓"
+	case SortByLastSeenAsc:
+		return "Last SSH ↑"
+	case SortByLastSeenDesc:
+		return "Last SSH ↓"
+	default:
+		return "Alias ↑"
+	}
+}
+
+// ToggleField switches between Alias and LastSeen while preserving direction.
+func (m SortMode) ToggleField() SortMode {
+	switch m {
+	case SortByAliasAsc:
+		return SortByLastSeenAsc
+	case SortByAliasDesc:
+		return SortByLastSeenDesc
+	case SortByLastSeenAsc:
+		return SortByAliasAsc
+	case SortByLastSeenDesc:
+		return SortByAliasDesc
+	default:
+		return SortByAliasAsc
+	}
+}
+
+// Reverse flips the direction within the current field.
+func (m SortMode) Reverse() SortMode {
+	switch m {
+	case SortByAliasAsc:
+		return SortByAliasDesc
+	case SortByAliasDesc:
+		return SortByAliasAsc
+	case SortByLastSeenAsc:
+		return SortByLastSeenDesc
+	case SortByLastSeenDesc:
+		return SortByLastSeenAsc
+	default:
+		return SortByAliasAsc
+	}
+}
+
+// sortServersForUI sorts servers according to the rules required by the UI.
+// Pinned servers are always at the top, ordered by pinned date (newest first).
+// Unpinned servers are sorted by the selected mode. "Never" (zero time) goes to
+// the bottom when sorting by last seen asc/desc accordingly. Ties break by Alias asc.
+func sortServersForUI(servers []domain.Server, mode SortMode) {
+	sort.SliceStable(servers, func(i, j int) bool {
+		si, sj := servers[i], servers[j]
+
+		pi, pj := !si.PinnedAt.IsZero(), !sj.PinnedAt.IsZero()
+		if pi != pj {
+			return pi
+		}
+		if pi && pj { // both pinned: newer pinned first, tie-break alias
+			if !si.PinnedAt.Equal(sj.PinnedAt) {
+				return si.PinnedAt.After(sj.PinnedAt)
+			}
+			return strings.ToLower(si.Alias) < strings.ToLower(sj.Alias)
+		}
+
+		// both unpinned
+		switch mode {
+		case SortByLastSeenDesc, SortByLastSeenAsc:
+			zi := si.LastSeen.IsZero()
+			zj := sj.LastSeen.IsZero()
+			if zi != zj {
+				// when sorting by last seen, entries with zero (never) should be bottom in either direction
+				return !zi // non-zero first
+			}
+			if !zi && !zj && !si.LastSeen.Equal(sj.LastSeen) {
+				if mode == SortByLastSeenDesc {
+					return si.LastSeen.After(sj.LastSeen)
+				}
+				return si.LastSeen.Before(sj.LastSeen)
+			}
+			// tie-break by alias asc
+			return strings.ToLower(si.Alias) < strings.ToLower(sj.Alias)
+		case SortByAliasAsc:
+			return strings.ToLower(si.Alias) < strings.ToLower(sj.Alias)
+		case SortByAliasDesc:
+			ai := strings.ToLower(si.Alias)
+			aj := strings.ToLower(sj.Alias)
+			if ai != aj {
+				return ai > aj
+			}
+			return false
+		default:
+			return strings.ToLower(si.Alias) < strings.ToLower(sj.Alias)
+		}
+	})
+}

internal/adapters/ui/status_bar.go

@@ -19,10 +19,14 @@ import (
 	"github.com/rivo/tview"
 )
 
+func DefaultStatusText() string {
+	return "[white]↑↓[-] Navigate  • [white]Enter[-] SSH  • [white]c[-] Copy SSH  • [white]a[-] Add  • [white]e[-] Edit  • [white]g[-] Ping  • [white]d[-] Delete  • [white]p[-] Pin/Unpin  • [white]/[-] Search  • [white]q[-] Quit"
+}
+
 func NewStatusBar() *tview.TextView {
 	status := tview.NewTextView().SetDynamicColors(true)
 	status.SetBackgroundColor(tcell.Color235)
 	status.SetTextAlign(tview.AlignCenter)
-	status.SetText("[white]↑↓[-] Navigate  • [white]Enter[-] SSH  • [white]a[-] Add  • [white]e[-] Edit  • [white]d[-] Delete  • [white]/[-] Search  • [white]q[-] Quit  • [white]?[-] Help")
+	status.SetText(DefaultStatusText())
 	return status
 }

internal/adapters/ui/tui.go

@@ -17,12 +17,16 @@ package ui
 import (
 	"time"
 
-	"github.com/Adembc/lazyssh/internal/core/ports"
 	"github.com/gdamore/tcell/v2"
+	"go.uber.org/zap"
+
+	"github.com/Adembc/lazyssh/internal/core/ports"
 	"github.com/rivo/tview"
 )
 
 type tui struct {
+	logger *zap.SugaredLogger
+
 	version   string
 	commit    string
 	buildDate string
@@ -41,11 +45,13 @@ type tui struct {
 	left    *tview.Flex
 	content *tview.Flex
 
+	sortMode      SortMode
 	searchVisible bool
 }
 
-func NewTUI(ss ports.ServerService, version, commit, buildDate string) *tui {
+func NewTUI(logger *zap.SugaredLogger, ss ports.ServerService, version, commit, buildDate string) *tui {
 	return &tui{
+		logger:        logger,
 		app:           tview.NewApplication(),
 		serverService: ss,
 		version:       version,
@@ -55,10 +61,19 @@ func NewTUI(ss ports.ServerService, version, commit, buildDate string) *tui {
 }
 
 func (t *tui) Run() error {
+	defer func() {
+		if r := recover(); r != nil {
+			t.logger.Errorw("panic recovered", "error", r)
+		}
+	}()
 	t.app.EnableMouse(true)
 	t.initializeTheme().buildComponents().buildLayout().bindEvents().loadInitialData().loadSplashScreen()
-
-	return t.app.Run()
+	t.logger.Infow("starting TUI application", "version", t.version, "commit", t.commit, "buildDate", t.buildDate)
+	if err := t.app.Run(); err != nil {
+		t.logger.Errorw("application run error", "error", err)
+		return err
+	}
+	return nil
 }
 
 func (t *tui) initializeTheme() *tui {
@@ -83,6 +98,10 @@ func (t *tui) buildComponents() *tui {
 		OnSelectionChange(t.handleServerSelectionChange)
 	t.details = NewServerDetails()
 	t.statusBar = NewStatusBar()
+
+	// default sort mode
+	t.sortMode = SortByAliasAsc
+
 	return t
 }
 
@@ -112,11 +131,19 @@ func (t *tui) bindEvents() *tui {
 
 func (t *tui) loadInitialData() *tui {
 	servers, _ := t.serverService.ListServers("")
+	sortServersForUI(servers, t.sortMode)
+	t.updateListTitle()
 	t.serverList.UpdateServers(servers)
 
 	return t
 }
 
+func (t *tui) updateListTitle() {
+	if t.serverList != nil {
+		t.serverList.SetTitle("Servers — Sort: " + t.sortMode.String())
+	}
+}
+
 func (t *tui) loadSplashScreen() *tui {
 	splash, stop := buildSplash(t.app)
 	t.app.SetRoot(splash, true)

internal/adapters/ui/utils.go

@@ -20,53 +20,120 @@ import (
 	"time"
 
 	"github.com/Adembc/lazyssh/internal/core/domain"
+	"github.com/mattn/go-runewidth"
 )
 
-func statusIcon(s string) string {
-	switch s {
-	case "online":
-		return "🟢"
-	case "warn":
-		return "🟡"
-	case "offline":
-		return "🔴"
-	default:
-		return "⚪"
+// renderTagBadgesForList renders up to two colored tag chips for the server list.
+// If there are more tags, it appends a subtle gray "+N" badge. Returns an empty
+// string when there are no tags to avoid cluttering the list.
+func renderTagBadgesForList(tags []string) string {
+	if len(tags) == 0 {
+		return ""
 	}
+	maxTags := 2
+	shown := tags
+	if len(tags) > maxTags {
+		shown = tags[:maxTags]
+	}
+	parts := make([]string, 0, len(shown)+1)
+	for _, t := range shown {
+		// Light blue background chip, similar to details view.
+		parts = append(parts, fmt.Sprintf("[black:#5FAFFF] %s [-:-:-]", t))
+	}
+	if extra := len(tags) - len(shown); extra > 0 {
+		parts = append(parts, fmt.Sprintf("[#8A8A8A]+%d[-]", extra))
+	}
+	return strings.Join(parts, " ")
 }
 
-func joinTags(tags []string) string {
-	if len(tags) == 0 {
-		return "-"
+// cellPad pads a string with spaces so its display width is at least `width` cells.
+// This keeps emoji-based icons from breaking alignment in tview.
+func cellPad(s string, width int) string {
+	w := runewidth.StringWidth(s)
+	if w >= width {
+		return s
 	}
-	return strings.Join(tags, ",")
+	return s + strings.Repeat(" ", width-w)
+}
+
+func pinnedIcon(pinnedAt time.Time) string {
+	// Use emojis for a nicer UI; combined with cellPad to keep widths consistent in tview.
+	if pinnedAt.IsZero() {
+		return "📡" // not pinned
+	}
+	return "📌" // pinned
 }
 
 func formatServerLine(s domain.Server) (primary, secondary string) {
-	icon := statusIcon(s.Status)
-	// Choose a color per status for the alias and a subtle gray for host/time
-	statusColor := "white"
-	switch s.Status {
-	case "online":
-		statusColor = "green"
-	case "warn":
-		statusColor = "yellow"
-	case "offline":
-		statusColor = "red"
-	}
-	primary = fmt.Sprintf("%s [%s::b]%-12s[-] [#AAAAAA]%-18s[-] [#888888]Last:%s[-]", icon, statusColor, s.Alias, s.Host, humanizeDuration(time.Since(s.LastSeen)))
+	icon := cellPad(pinnedIcon(s.PinnedAt), 2)
+	// Use a consistent color for alias; the icon reflects pinning
+	primary = fmt.Sprintf("%s [white::b]%-12s[-] [#AAAAAA]%-18s[-] [#888888]Last SSH: %s[-]  %s", icon, s.Alias, s.Host, humanizeDuration(s.LastSeen), renderTagBadgesForList(s.Tags))
 	secondary = ""
 	return
 }
 
-func humanizeDuration(d time.Duration) string {
+func humanizeDuration(t time.Time) string {
+	if t.IsZero() {
+		return "never"
+	}
+	d := time.Since(t)
 	if d < time.Minute {
 		return "just now"
 	}
-	h := int(d.Hours())
-	m := int(d.Minutes()) % 60
-	if h > 0 {
-		return fmt.Sprintf("%dh%dm ago", h, m)
+	if d < time.Hour {
+		m := int(d.Minutes())
+		return fmt.Sprintf("%dm ago", m)
 	}
-	return fmt.Sprintf("%dm ago", m)
+	if d < 48*time.Hour {
+		h := int(d.Hours())
+		return fmt.Sprintf("%dh ago", h)
+	}
+	if d < 60*24*time.Hour {
+		days := int(d.Hours()) / 24
+		return fmt.Sprintf("%dd ago", days)
+	}
+	if d < 365*24*time.Hour {
+		months := int(d.Hours()) / (24 * 30)
+		if months < 1 {
+			months = 1
+		}
+		return fmt.Sprintf("%dmo ago", months)
+	}
+	years := int(d.Hours()) / (24 * 365)
+	if years < 1 {
+		years = 1
+	}
+	return fmt.Sprintf("%dy ago", years)
+}
+
+// BuildSSHCommand constructs a ready-to-run ssh command for the given server.
+// Format: ssh [user@]host [-p PORT if not 22] [-i KEY if provided]
+func BuildSSHCommand(s domain.Server) string {
+	parts := []string{"ssh"}
+	userHost := ""
+	switch {
+	case s.User != "" && s.Host != "":
+		userHost = fmt.Sprintf("%s@%s", s.User, s.Host)
+	case s.Host != "":
+		userHost = s.Host
+	default:
+		userHost = s.Alias
+	}
+	parts = append(parts, userHost)
+
+	if s.Port != 0 && s.Port != 22 {
+		parts = append(parts, "-p", fmt.Sprintf("%d", s.Port))
+	}
+	if s.Key != "" {
+		parts = append(parts, "-i", quoteIfNeeded(s.Key))
+	}
+	return strings.Join(parts, " ")
+}
+
+// quoteIfNeeded returns the value quoted if it contains spaces.
+func quoteIfNeeded(val string) string {
+	if strings.ContainsAny(val, " \t") {
+		return fmt.Sprintf("%q", val)
+	}
+	return val
 }

internal/core/domain/server.go

@@ -23,6 +23,7 @@ type Server struct {
 	Port     int
 	Key      string
 	Tags     []string
-	Status   string
 	LastSeen time.Time
+	PinnedAt time.Time
+	SSHCount int
 }

internal/core/ports/repositories.go

@@ -21,4 +21,6 @@ type ServerRepository interface {
 	UpdateServer(server domain.Server, newServer domain.Server) error
 	AddServer(server domain.Server) error
 	DeleteServer(server domain.Server) error
+	SetPinned(alias string, pinned bool) error
+	RecordSSH(alias string) error
 }

internal/core/ports/services.go

@@ -14,11 +14,18 @@
 
 package ports
 
-import "github.com/Adembc/lazyssh/internal/core/domain"
+import (
+	"time"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
 
 type ServerService interface {
 	ListServers(query string) ([]domain.Server, error)
 	UpdateServer(server domain.Server, newServer domain.Server) error
 	AddServer(server domain.Server) error
 	DeleteServer(server domain.Server) error
+	SetPinned(alias string, pinned bool) error
+	SSH(alias string) error
+	Ping(server domain.Server) (bool, time.Duration, error)
 }

internal/core/services/server_service.go

@@ -15,42 +15,224 @@
 package services
 
 import (
+	"bufio"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
 	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/Adembc/lazyssh/internal/core/ports"
+	"go.uber.org/zap"
 )
 
 type serverService struct {
 	serverRepository ports.ServerRepository
+	logger           *zap.SugaredLogger
 }
 
 // NewServerService creates a new instance of serverService.
-func NewServerService(sr ports.ServerRepository) *serverService {
+func NewServerService(logger *zap.SugaredLogger, sr ports.ServerRepository) *serverService {
 	return &serverService{
+		logger:           logger,
 		serverRepository: sr,
 	}
 }
 
-// ListServers returns a list of servers.
+// ListServers returns a list of servers sorted with pinned on top.
 func (s *serverService) ListServers(query string) ([]domain.Server, error) {
-	// do any relevant business logic here if needed
 	servers, err := s.serverRepository.ListServers(query)
 	if err != nil {
+		s.logger.Errorw("failed to list servers", "error", err)
 		return nil, err
 	}
+
+	// Sort: pinned first (PinnedAt non-zero), then by PinnedAt desc, then by Alias asc.
+	sort.SliceStable(servers, func(i, j int) bool {
+		pi := !servers[i].PinnedAt.IsZero()
+		pj := !servers[j].PinnedAt.IsZero()
+		if pi != pj {
+			return pi
+		}
+		if pi && pj {
+			return servers[i].PinnedAt.After(servers[j].PinnedAt)
+		}
+		return servers[i].Alias < servers[j].Alias
+	})
+
 	return servers, nil
 }
 
+// validateServer performs core validation of server fields.
+func validateServer(srv domain.Server) error {
+	if strings.TrimSpace(srv.Alias) == "" {
+		return fmt.Errorf("alias is required")
+	}
+	if ok, _ := regexp.MatchString(`^[A-Za-z0-9_.-]+$`, srv.Alias); !ok {
+		return fmt.Errorf("alias may contain letters, digits, dot, dash, underscore")
+	}
+	if strings.TrimSpace(srv.Host) == "" {
+		return fmt.Errorf("Host/IP is required")
+	}
+	if ip := net.ParseIP(srv.Host); ip == nil {
+		if strings.Contains(srv.Host, " ") {
+			return fmt.Errorf("host must not contain spaces")
+		}
+		if ok, _ := regexp.MatchString(`^[A-Za-z0-9.-]+$`, srv.Host); !ok {
+			return fmt.Errorf("host contains invalid characters")
+		}
+		if strings.HasPrefix(srv.Host, ".") || strings.HasSuffix(srv.Host, ".") {
+			return fmt.Errorf("host must not start or end with a dot")
+		}
+		for _, lbl := range strings.Split(srv.Host, ".") {
+			if lbl == "" {
+				return fmt.Errorf("host must not contain empty labels")
+			}
+			if strings.HasPrefix(lbl, "-") || strings.HasSuffix(lbl, "-") {
+				return fmt.Errorf("hostname labels must not start or end with a hyphen")
+			}
+		}
+	}
+	if srv.Port != 0 && (srv.Port < 1 || srv.Port > 65535) {
+		return fmt.Errorf("port must be a number between 1 and 65535")
+	}
+	return nil
+}
+
 // UpdateServer updates an existing server with new details.
 func (s *serverService) UpdateServer(server domain.Server, newServer domain.Server) error {
-	return s.serverRepository.UpdateServer(server, newServer)
+	if err := validateServer(newServer); err != nil {
+		s.logger.Warnw("validation failed on update", "error", err, "server", newServer)
+		return err
+	}
+	err := s.serverRepository.UpdateServer(server, newServer)
+	if err != nil {
+		s.logger.Errorw("failed to update server", "error", err, "server", server)
+	}
+	return err
 }
 
 // AddServer adds a new server to the repository.
 func (s *serverService) AddServer(server domain.Server) error {
-	return s.serverRepository.AddServer(server)
+	if err := validateServer(server); err != nil {
+		s.logger.Warnw("validation failed on add", "error", err, "server", server)
+		return err
+	}
+	err := s.serverRepository.AddServer(server)
+	if err != nil {
+		s.logger.Errorw("failed to add server", "error", err, "server", server)
+	}
+	return err
 }
 
 // DeleteServer removes a server from the repository.
 func (s *serverService) DeleteServer(server domain.Server) error {
-	return s.serverRepository.DeleteServer(server)
+	err := s.serverRepository.DeleteServer(server)
+	if err != nil {
+		s.logger.Errorw("failed to delete server", "error", err, "server", server)
+	}
+	return err
+}
+
+// SetPinned sets or clears a pin timestamp for the server alias.
+func (s *serverService) SetPinned(alias string, pinned bool) error {
+	err := s.serverRepository.SetPinned(alias, pinned)
+	if err != nil {
+		s.logger.Errorw("failed to set pin state", "error", err, "alias", alias, "pinned", pinned)
+	}
+	return err
+}
+
+// SSH starts an interactive SSH session to the given alias using the system's ssh client.
+func (s *serverService) SSH(alias string) error {
+	s.logger.Infow("ssh start", "alias", alias)
+	cmd := exec.Command("ssh", alias)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		s.logger.Errorw("ssh command failed", "alias", alias, "error", err)
+		return err
+	}
+
+	if err := s.serverRepository.RecordSSH(alias); err != nil {
+		s.logger.Errorw("failed to record ssh metadata", "alias", alias, "error", err)
+	}
+
+	s.logger.Infow("ssh end", "alias", alias)
+	return nil
+}
+
+// Ping checks if the server is reachable on its SSH port.
+func (s *serverService) Ping(server domain.Server) (bool, time.Duration, error) {
+	start := time.Now()
+
+	host, port, ok := resolveSSHDestination(server.Alias)
+	if !ok {
+
+		host = strings.TrimSpace(server.Host)
+		if host == "" {
+			host = server.Alias
+		}
+		if server.Port > 0 {
+			port = server.Port
+		} else {
+			port = 22
+		}
+	}
+	addr := net.JoinHostPort(host, fmt.Sprintf("%d", port))
+
+	dialer := net.Dialer{Timeout: 3 * time.Second}
+	conn, err := dialer.Dial("tcp", addr)
+	if err != nil {
+		return false, time.Since(start), err
+	}
+	_ = conn.Close()
+	return true, time.Since(start), nil
+}
+
+// resolveSSHDestination uses `ssh -G <alias>` to extract HostName and Port from the user's SSH config.
+// Returns host, port, ok where ok=false if resolution failed.
+func resolveSSHDestination(alias string) (string, int, bool) {
+	alias = strings.TrimSpace(alias)
+	if alias == "" {
+		return "", 0, false
+	}
+	cmd := exec.Command("ssh", "-G", alias)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", 0, false
+	}
+	host := ""
+	port := 0
+	scanner := bufio.NewScanner(strings.NewReader(string(out)))
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "hostname ") {
+			parts := strings.Fields(line)
+			if len(parts) >= 2 {
+				host = parts[1]
+			}
+		}
+		if strings.HasPrefix(line, "port ") {
+			parts := strings.Fields(line)
+			if len(parts) >= 2 {
+				if p, err := strconv.Atoi(parts[1]); err == nil {
+					port = p
+				}
+			}
+		}
+	}
+	if host == "" {
+		host = alias
+	}
+	if port == 0 {
+		port = 22
+	}
+	return host, port, true
 }

internal/logger/logger.go

@@ -0,0 +1,58 @@
+// 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 logger
+
+import (
+	"os"
+	"path/filepath"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// New constructs a Sugared Logger that writes to a file and
+// provides human-readable timestamps.
+func New(service string, outputPaths ...string) (*zap.SugaredLogger, error) {
+	config := zap.NewProductionConfig()
+
+	config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	config.Level = zap.NewAtomicLevelAt(zap.DebugLevel)
+
+	config.DisableStacktrace = true
+	config.InitialFields = map[string]any{
+		"service": service,
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil, err
+	}
+	logDir := filepath.Join(home, ".lazyssh")
+	if err := os.MkdirAll(logDir, 0o750); err != nil {
+		return nil, err
+	}
+	config.OutputPaths = []string{filepath.Join(logDir, "lazyssh.log")}
+
+	if outputPaths != nil {
+		config.OutputPaths = outputPaths
+	}
+
+	log, err := config.Build(zap.WithCaller(true))
+	if err != nil {
+		return nil, err
+	}
+
+	return log.Sugar(), nil
+}