minimal ssh

internal/adapters/data/file/server_file_repo.go

@@ -0,0 +1,365 @@
+// 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"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.uber.org/zap"
+
+	"github.com/Adembc/lazyssh/internal/core/domain"
+)
+
+const (
+	ManagedByComment = "# Managed by lazyssh"
+	DefaultPort      = 22
+)
+
+type ServerMetadata struct {
+	Tags     []string `json:"tags,omitempty"`
+	LastSeen string   `json:"last_seen,omitempty"`
+	Favorite bool     `json:"favorite,omitempty"`
+	Notes    string   `json:"notes,omitempty"`
+}
+
+type serverRepo struct {
+	sshConfigFilePath string
+	metaDataFilePath  string
+	logger            *zap.SugaredLogger
+}
+
+func NewServerRepo(logger *zap.SugaredLogger, sshPath, metaDataPath string) *serverRepo {
+	return &serverRepo{logger: logger, sshConfigFilePath: sshPath, metaDataFilePath: metaDataPath}
+}
+
+func (s serverRepo) ListServers(query string) ([]domain.Server, error) {
+	servers, err := s.parseSSHConfig()
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse SSH config: %w", err)
+	}
+
+	metadata, err := s.loadMetadata()
+	if err != nil {
+		// Log error but continue without metadata
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	// Merge metadata with servers
+	for i, server := range servers {
+		servers[i].Status = "online"
+		servers[i].LastSeen = time.Time{}
+
+		if meta, exists := metadata[server.Alias]; exists {
+			servers[i].Tags = meta.Tags
+			if meta.LastSeen != "" {
+				if lastSeen, err := time.Parse(time.RFC3339, meta.LastSeen); err == nil {
+					servers[i].LastSeen = lastSeen
+				}
+			}
+		}
+	}
+
+	// Filter by query if provided
+	if query != "" {
+		filtered := make([]domain.Server, 0)
+		queryLower := strings.ToLower(query)
+		for _, server := range servers {
+			if strings.Contains(strings.ToLower(server.Alias), queryLower) ||
+				strings.Contains(strings.ToLower(server.Host), queryLower) ||
+				strings.Contains(strings.ToLower(server.User), queryLower) {
+				filtered = append(filtered, server)
+			}
+		}
+		return filtered, nil
+	}
+
+	return servers, nil
+}
+
+func (s serverRepo) UpdateServer(server domain.Server, newServer domain.Server) error {
+	servers, err := s.parseSSHConfig()
+	if err != nil {
+		return fmt.Errorf("failed to parse SSH config: %w", err)
+	}
+
+	// Find and update the server
+	found := false
+	for i, srv := range servers {
+		if srv.Alias == server.Alias {
+			servers[i] = newServer
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("server with alias '%s' not found", server.Alias)
+	}
+
+	// Write back to SSH config
+	if err := s.writeSSHConfig(servers); err != nil {
+		return fmt.Errorf("failed to write SSH config: %w", err)
+	}
+
+	// Update metadata
+	return s.updateMetadata(newServer)
+}
+
+func (s serverRepo) AddServer(server domain.Server) error {
+	servers, err := s.parseSSHConfig()
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to parse SSH config: %w", err)
+	}
+
+	// Check if server already exists
+	for _, srv := range servers {
+		if srv.Alias == server.Alias {
+			return fmt.Errorf("server with alias '%s' already exists", server.Alias)
+		}
+	}
+
+	// Add new server
+	servers = append(servers, server)
+
+	// Write to SSH config
+	if err := s.writeSSHConfig(servers); err != nil {
+		return fmt.Errorf("failed to write SSH config: %w", err)
+	}
+
+	// Update metadata
+	return s.updateMetadata(server)
+}
+
+func (s serverRepo) DeleteServer(server domain.Server) error {
+	servers, err := s.parseSSHConfig()
+	if err != nil {
+		return fmt.Errorf("failed to parse SSH config: %w", err)
+	}
+
+	// Find and remove the server
+	found := false
+	newServers := make([]domain.Server, 0, len(servers))
+	for _, srv := range servers {
+		if srv.Alias != server.Alias {
+			newServers = append(newServers, srv)
+		} else {
+			found = true
+		}
+	}
+
+	if !found {
+		return fmt.Errorf("server with alias '%s' not found", server.Alias)
+	}
+
+	// Write back to SSH config
+	if err := s.writeSSHConfig(newServers); err != nil {
+		return fmt.Errorf("failed to write SSH config: %w", err)
+	}
+
+	// Remove from metadata
+	return s.removeFromMetadata(server.Alias)
+}
+
+func (s serverRepo) parseSSHConfig() ([]domain.Server, error) {
+	file, err := os.Open(s.sshConfigFilePath)
+	if err != nil {
+
+		if os.IsNotExist(err) {
+			return []domain.Server{}, nil
+		}
+		return nil, err
+	}
+	defer file.Close()
+
+	var servers []domain.Server
+	var currentServer *domain.Server
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		// Skip empty lines and comments
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Split key-value pairs
+		parts := strings.Fields(line)
+		if len(parts) < 2 {
+			continue
+		}
+
+		key := strings.ToLower(parts[0])
+		value := strings.Join(parts[1:], " ")
+
+		switch key {
+		case "host":
+			// Save previous server if exists
+			if currentServer != nil {
+				servers = append(servers, *currentServer)
+			}
+			// Start new server
+			currentServer = &domain.Server{
+				Alias: value,
+				Port:  DefaultPort, // Default SSH port
+			}
+		case "hostname":
+			if currentServer != nil {
+				currentServer.Host = value
+			}
+		case "user":
+			if currentServer != nil {
+				currentServer.User = value
+			}
+		case "port":
+			if currentServer != nil {
+				if port, err := strconv.Atoi(value); err == nil {
+					currentServer.Port = port
+				}
+			}
+		case "identityfile":
+			if currentServer != nil {
+				// Expand ~ to home directory
+				if strings.HasPrefix(value, "~/") {
+					if home, err := os.UserHomeDir(); err == nil {
+						value = filepath.Join(home, value[2:])
+					}
+				}
+				currentServer.Key = value
+			}
+		}
+	}
+
+	if currentServer != nil {
+
+		servers = append(servers, *currentServer)
+	}
+
+	return servers, scanner.Err()
+}
+
+func (s serverRepo) writeSSHConfig(servers []domain.Server) error {
+	// Create directory if it doesn't exist
+	dir := filepath.Dir(s.sshConfigFilePath)
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return err
+	}
+
+	file, err := os.Create(s.sshConfigFilePath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	writer := bufio.NewWriter(file)
+	defer writer.Flush()
+
+	for i, server := range servers {
+		if i > 0 {
+			writer.WriteString("\n")
+		}
+
+		fmt.Fprintf(writer, "%s\n", ManagedByComment)
+		fmt.Fprintf(writer, "Host %s\n", server.Alias)
+
+		if server.Host != "" {
+			fmt.Fprintf(writer, "    HostName %s\n", server.Host)
+		}
+
+		if server.User != "" {
+			fmt.Fprintf(writer, "    User %s\n", server.User)
+		}
+
+		if server.Port != 0 && server.Port != DefaultPort {
+			fmt.Fprintf(writer, "    Port %d\n", server.Port)
+		}
+
+		if server.Key != "" {
+			fmt.Fprintf(writer, "    IdentityFile %s\n", server.Key)
+		}
+	}
+
+	return nil
+}
+
+func (s serverRepo) loadMetadata() (map[string]ServerMetadata, error) {
+	metadata := make(map[string]ServerMetadata)
+
+	if _, err := os.Stat(s.metaDataFilePath); os.IsNotExist(err) {
+		return metadata, nil
+	}
+
+	data, err := os.ReadFile(s.metaDataFilePath)
+	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 (s serverRepo) updateMetadata(server domain.Server) error {
+	metadata, err := s.loadMetadata()
+	if err != nil {
+		metadata = make(map[string]ServerMetadata)
+	}
+
+	serverMeta := ServerMetadata{
+		Tags:     server.Tags,
+		LastSeen: server.LastSeen.Format(time.RFC3339),
+	}
+
+	metadata[server.Alias] = serverMeta
+
+	return s.saveMetadata(metadata)
+}
+
+func (s serverRepo) removeFromMetadata(alias string) error {
+	metadata, err := s.loadMetadata()
+	if err != nil {
+		return nil // If we can't load metadata, there's nothing to remove
+	}
+
+	delete(metadata, alias)
+	return s.saveMetadata(metadata)
+}
+
+func (s serverRepo) saveMetadata(metadata map[string]ServerMetadata) error {
+	// Create directory if it doesn't exist
+	dir := filepath.Dir(s.metaDataFilePath)
+	if err := os.MkdirAll(dir, 0o750); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(metadata, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(s.metaDataFilePath, data, 0o600)
+}

internal/adapters/data/memory/server_in_memory_repo.go

@@ -19,10 +19,14 @@ 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)},
@@ -36,8 +40,10 @@ var servers = []domain.Server{
 }
 
 // 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.

internal/adapters/ui/handlers.go

@@ -16,7 +16,6 @@ package ui
 
 import (
 	"fmt"
-
 	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
@@ -76,6 +75,7 @@ func (t *tui) handleSearchToggle() {
 func (t *tui) handleServerConnect() {
 	if server, ok := t.serverList.GetSelectedServer(); ok {
 		t.showConnectModal(server)
+
 	}
 }
 
@@ -114,8 +114,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)
 	}
 }
 
@@ -144,13 +143,37 @@ 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{"Cancel", "Confirm"}).
 		SetDoneFunc(func(buttonIndex int, buttonLabel string) {
+			if buttonIndex == 1 {
+				// Suspend the TUI while running the external ssh command.
+				t.app.Suspend(func() {
+					_ = t.serverService.SSH(server.Alias)
+				})
+			}
+			t.handleModalClose()
+		})
+
+	t.app.SetRoot(modal, true)
+}
+
+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(msg).
+		AddButtons([]string{"Cancel", "Confirm"}).
+		SetDoneFunc(func(buttonIndex int, buttonLabel string) {
+			if buttonIndex == 1 {
+				_ = t.serverService.DeleteServer(server)
+				t.refreshServerList()
+			}
 			t.handleModalClose()
 		})
 
@@ -159,14 +182,14 @@ func (t *tui) showConnectModal(server domain.Server) {
 
 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"
+		"  ↑/↓            Navigate\n" +
+		"    Enter          SSH connect \n" +
+		"    a              Add server \n" +
+		"    e              Edit server \n" +
+		"      d              Delete entry \n" +
+		"    /              Focus search\n" +
+		"q              Quit\n" +
+		"?              Help\n"
 
 	modal := tview.NewModal().
 		SetText(text).

internal/adapters/ui/server_details.go

@@ -16,7 +16,6 @@ package ui
 
 import (
 	"fmt"
-
 	"github.com/Adembc/lazyssh/internal/core/domain"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
@@ -44,11 +43,20 @@ func (sd *ServerDetails) build() {
 }
 
 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})"
+	}
 	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: [white]%s[-]\nStatus: %s\nLast SSH: %s\n\n[::b]Commands:[-]\n  Enter: SSH connect\n  a: Add new server\n  e: Edit entry\n  d: Delete entry",
 		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, joinTags(server.Tags), statusIcon(server.Status),
+		lastSeen)
 	sd.TextView.SetText(text)
 }
 

internal/adapters/ui/tui.go

@@ -17,12 +17,16 @@ package ui
 import (
 	"time"
 
+	"go.uber.org/zap"
+
 	"github.com/Adembc/lazyssh/internal/core/ports"
 	"github.com/gdamore/tcell/v2"
 	"github.com/rivo/tview"
 )
 
 type tui struct {
+	logger *zap.SugaredLogger
+
 	version   string
 	commit    string
 	buildDate string
@@ -44,8 +48,9 @@ type tui struct {
 	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 +60,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 {

internal/adapters/ui/utils.go

@@ -54,12 +54,16 @@ func formatServerLine(s domain.Server) (primary, secondary string) {
 	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)))
+	primary = fmt.Sprintf("%s [%s::b]%-12s[-] [#AAAAAA]%-18s[-] [#888888]Last SSH: %s[-]", icon, statusColor, s.Alias, s.Host, humanizeDuration(s.LastSeen))
 	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"
 	}

internal/core/ports/services.go

@@ -21,4 +21,5 @@ type ServerService interface {
 	UpdateServer(server domain.Server, newServer domain.Server) error
 	AddServer(server domain.Server) error
 	DeleteServer(server domain.Server) error
+	SSH(alias string) error
 }

internal/core/services/server_service.go

@@ -15,17 +15,23 @@
 package services
 
 import (
+	"os"
+	"os/exec"
+
 	"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,
 	}
 }
@@ -35,22 +41,51 @@ 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
 	}
+
 	return servers, 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)
+	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)
+	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
+}
+
+// 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
+	}
+	s.logger.Infow("ssh end", "alias", alias)
+	return nil
 }

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, 0o755); 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
+}