gssh-agent 1.0.0

package/internal/protocol/types_test.go

@@ -0,0 +1,87 @@
+package protocol
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestSessionJSON(t *testing.T) {
+	session := Session{
+		ID:     "test-id",
+		Host:   "192.168.1.1",
+		User:   "admin",
+		Port:   22,
+		Status: "connected",
+	}
+
+	data, err := json.Marshal(session)
+	if err != nil {
+		t.Fatalf("failed to marshal: %v", err)
+	}
+
+	var parsed Session
+	if err := json.Unmarshal(data, &parsed); err != nil {
+		t.Fatalf("failed to unmarshal: %v", err)
+	}
+
+	if parsed.ID != session.ID {
+		t.Errorf("expected ID %s, got %s", session.ID, parsed.ID)
+	}
+	if parsed.Host != session.Host {
+		t.Errorf("expected Host %s, got %s", session.Host, parsed.Host)
+	}
+	if parsed.User != session.User {
+		t.Errorf("expected User %s, got %s", session.User, parsed.User)
+	}
+}
+
+func TestExecResultJSON(t *testing.T) {
+	result := ExecResult{
+		Stdout:   "hello\n",
+		Stderr:   "error\n",
+		ExitCode: 0,
+	}
+
+	data, err := json.Marshal(result)
+	if err != nil {
+		t.Fatalf("failed to marshal: %v", err)
+	}
+
+	var parsed ExecResult
+	if err := json.Unmarshal(data, &parsed); err != nil {
+		t.Fatalf("failed to unmarshal: %v", err)
+	}
+
+	if parsed.Stdout != result.Stdout {
+		t.Errorf("expected stdout %s, got %s", result.Stdout, parsed.Stdout)
+	}
+	if parsed.ExitCode != result.ExitCode {
+		t.Errorf("expected exit code %d, got %d", result.ExitCode, parsed.ExitCode)
+	}
+}
+
+func TestForwardJSON(t *testing.T) {
+	forward := Forward{
+		ID:     "fwd-1",
+		Type:   "local",
+		Local:  8080,
+		Remote: 80,
+	}
+
+	data, err := json.Marshal(forward)
+	if err != nil {
+		t.Fatalf("failed to marshal: %v", err)
+	}
+
+	var parsed Forward
+	if err := json.Unmarshal(data, &parsed); err != nil {
+		t.Fatalf("failed to unmarshal: %v", err)
+	}
+
+	if parsed.Type != forward.Type {
+		t.Errorf("expected type %s, got %s", forward.Type, parsed.Type)
+	}
+	if parsed.Local != forward.Local {
+		t.Errorf("expected local port %d, got %d", forward.Local, parsed.Local)
+	}
+}

package/internal/session/manager.go

@@ -0,0 +1,380 @@
+package session
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"gssh/internal/client"
+	"gssh/internal/portforward"
+	"gssh/internal/protocol"
+
+	"github.com/google/uuid"
+)
+
+// Manager manages SSH sessions
+type Manager struct {
+	sessions  map[string]*ManagedSession
+	defaultID string
+	mu         sync.RWMutex
+	forwards   map[string]*portforward.Forwarder
+	forwardMu  sync.RWMutex
+}
+
+// ManagedSession wraps a session with additional state
+type ManagedSession struct {
+	ID        string
+	Host      string
+	User      string
+	Port      int
+	Status    string
+	Password  string
+	KeyPath   string
+	SSHClient *client.SSHClient
+	LastCmd   string
+	Forwards  map[string]*portforward.Forwarder
+	mu        sync.RWMutex
+}
+
+// NewManager creates a new session manager
+func NewManager() *Manager {
+	return &Manager{
+		sessions: make(map[string]*ManagedSession),
+		forwards: make(map[string]*portforward.Forwarder),
+	}
+}
+
+// Connect creates a new SSH session
+func (m *Manager) Connect(user, host string, port int, password, keyPath string) (*protocol.Session, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Check if session already exists
+	for _, s := range m.sessions {
+		if s.Host == host && s.User == user && s.Port == port {
+			if s.Status == "connected" {
+				return toProtocolSession(s), fmt.Errorf("session already exists")
+			}
+			// Try to reconnect
+			sshClient, err := client.Connect(user, host, port, password, keyPath)
+			if err != nil {
+				return nil, err
+			}
+			s.SSHClient = sshClient
+			s.Status = "connected"
+			return toProtocolSession(s), nil
+		}
+	}
+
+	// Create new session
+	sshClient, err := client.Connect(user, host, port, password, keyPath)
+	if err != nil {
+		return nil, err
+	}
+
+	id := uuid.New().String()
+	ms := &ManagedSession{
+		ID:        id,
+		Host:      host,
+		User:      user,
+		Port:      port,
+		Status:    "connected",
+		Password:  password,
+		KeyPath:   keyPath,
+		SSHClient: sshClient,
+		Forwards:  make(map[string]*portforward.Forwarder),
+	}
+
+	m.sessions[id] = ms
+
+	// Set as default if first session
+	if m.defaultID == "" {
+		m.defaultID = id
+	}
+
+	// Start reconnect monitor
+	go m.monitorReconnect(ms)
+
+	return toProtocolSession(ms), nil
+}
+
+// Disconnect closes a session
+func (m *Manager) Disconnect(sessionID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	ms, ok := m.sessions[sessionID]
+	if !ok {
+		return fmt.Errorf("session not found")
+	}
+
+	if ms.SSHClient != nil {
+		ms.SSHClient.Close()
+	}
+
+	ms.Status = "disconnected"
+
+	// Clear default ID when disconnecting
+	if m.defaultID == sessionID {
+		m.defaultID = ""
+	}
+
+	return nil
+}
+
+// Reconnect reconnects a session
+func (m *Manager) Reconnect(sessionID string) (*protocol.Session, error) {
+	m.mu.Lock()
+	ms, ok := m.sessions[sessionID]
+	m.mu.Unlock()
+
+	if !ok {
+		return nil, fmt.Errorf("session not found")
+	}
+
+	// Close existing connection
+	if ms.SSHClient != nil {
+		ms.SSHClient.Close()
+	}
+
+	// Create new connection
+	sshClient, err := client.Connect(ms.User, ms.Host, ms.Port, ms.Password, ms.KeyPath)
+	if err != nil {
+		ms.mu.Lock()
+		ms.Status = "disconnected"
+		ms.mu.Unlock()
+		return nil, err
+	}
+
+	ms.mu.Lock()
+	ms.SSHClient = sshClient
+	ms.Status = "connected"
+	ms.mu.Unlock()
+
+	// Restore default ID if it was cleared
+	m.mu.Lock()
+	if m.defaultID == "" {
+		m.defaultID = sessionID
+	}
+	m.mu.Unlock()
+
+	// Restore forwards
+	m.restoreForwards(ms)
+
+	return toProtocolSession(ms), nil
+}
+
+// Exec executes a command on a session
+func (m *Manager) Exec(sessionID, command string) (*protocol.ExecResult, error) {
+	m.mu.RLock()
+	var ms *ManagedSession
+	if sessionID != "" {
+		ms = m.sessions[sessionID]
+	} else if m.defaultID != "" {
+		ms = m.sessions[m.defaultID]
+	}
+	m.mu.RUnlock()
+
+	if ms == nil {
+		return nil, fmt.Errorf("session not found")
+	}
+
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	if ms.SSHClient == nil {
+		return nil, fmt.Errorf("session not connected")
+	}
+
+	stdout, stderr, exitCode, err := ms.SSHClient.Exec(command)
+	if err != nil && exitCode == 0 {
+		return nil, err
+	}
+
+	ms.LastCmd = command
+
+	return &protocol.ExecResult{
+		Stdout:   stdout,
+		Stderr:   stderr,
+		ExitCode: exitCode,
+	}, nil
+}
+
+// List returns all sessions
+func (m *Manager) List() []*protocol.Session {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	result := make([]*protocol.Session, 0, len(m.sessions))
+	for _, s := range m.sessions {
+		result = append(result, toProtocolSession(s))
+	}
+	return result
+}
+
+// Use sets the default session
+func (m *Manager) Use(sessionID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if _, ok := m.sessions[sessionID]; !ok {
+		return fmt.Errorf("session not found")
+	}
+
+	m.defaultID = sessionID
+	return nil
+}
+
+// GetDefaultID returns the default session ID
+func (m *Manager) GetDefaultID() string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.defaultID
+}
+
+// AddForward adds a port forward
+func (m *Manager) AddForward(sessionID, forwardType string, localPort, remotePort int) (*protocol.Forward, error) {
+	m.mu.RLock()
+	var ms *ManagedSession
+	if sessionID != "" {
+		ms = m.sessions[sessionID]
+	} else if m.defaultID != "" {
+		ms = m.sessions[m.defaultID]
+	}
+	m.mu.RUnlock()
+
+	if ms == nil {
+		return nil, fmt.Errorf("session not found")
+	}
+
+	ms.mu.RLock()
+	sshClient := ms.SSHClient
+	ms.mu.RUnlock()
+
+	if sshClient == nil {
+		return nil, fmt.Errorf("session not connected")
+	}
+
+	forwarder, err := portforward.NewForwarder(sshClient.Client, forwardType, localPort, remotePort)
+	if err != nil {
+		return nil, err
+	}
+
+	id := uuid.New().String()
+	forwarder.ID = id
+
+	m.forwardMu.Lock()
+	m.forwards[id] = forwarder
+
+	ms.mu.Lock()
+	ms.Forwards[id] = forwarder
+	ms.mu.Unlock()
+	m.forwardMu.Unlock()
+
+	go forwarder.Start()
+
+	return &protocol.Forward{
+		ID:     id,
+		Type:   forwardType,
+		Local:  localPort,
+		Remote: remotePort,
+	}, nil
+}
+
+// ListForwards lists all forwards
+func (m *Manager) ListForwards() []*protocol.Forward {
+	m.forwardMu.RLock()
+	defer m.forwardMu.RUnlock()
+
+	result := make([]*protocol.Forward, 0, len(m.forwards))
+	for _, f := range m.forwards {
+		result = append(result, &protocol.Forward{
+			ID:     f.ID,
+			Type:   f.Type,
+			Local:  f.LocalPort,
+			Remote: f.RemotePort,
+		})
+	}
+	return result
+}
+
+// CloseForward closes a forward
+func (m *Manager) CloseForward(forwardID string) error {
+	m.forwardMu.Lock()
+	defer m.forwardMu.Unlock()
+
+	forwarder, ok := m.forwards[forwardID]
+	if !ok {
+		return fmt.Errorf("forward not found")
+	}
+
+	forwarder.Close()
+	delete(m.forwards, forwardID)
+
+	return nil
+}
+
+// monitorReconnect monitors connection and auto-reconnects
+func (m *Manager) monitorReconnect(ms *ManagedSession) {
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		ms.mu.RLock()
+		status := ms.Status
+		sshClient := ms.SSHClient
+		ms.mu.RUnlock()
+
+		if status == "disconnected" {
+			return
+		}
+
+		if sshClient == nil || sshClient.Client == nil {
+			ms.mu.Lock()
+			ms.Status = "reconnecting"
+			ms.mu.Unlock()
+
+			// Try to reconnect
+			newClient, err := client.Connect(ms.User, ms.Host, ms.Port, ms.Password, ms.KeyPath)
+			if err != nil {
+				continue
+			}
+
+			ms.mu.Lock()
+			ms.SSHClient = newClient
+			ms.Status = "connected"
+			ms.mu.Unlock()
+
+			// Restore forwards
+			m.restoreForwards(ms)
+		}
+	}
+}
+
+// restoreForwards restores all forwards after reconnection
+func (m *Manager) restoreForwards(ms *ManagedSession) {
+	ms.mu.RLock()
+	forwards := make(map[string]*portforward.Forwarder)
+	for k, v := range ms.Forwards {
+		forwards[k] = v
+	}
+	ms.mu.RUnlock()
+
+	for _, f := range forwards {
+		f.Restart(ms.SSHClient.Client)
+	}
+}
+
+func toProtocolSession(ms *ManagedSession) *protocol.Session {
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	return &protocol.Session{
+		ID:      ms.ID,
+		Host:    ms.Host,
+		User:    ms.User,
+		Port:    ms.Port,
+		Status:  ms.Status,
+		KeyPath: ms.KeyPath,
+	}
+}

package/internal/session/manager_test.go

@@ -0,0 +1,52 @@
+package session
+
+import (
+	"testing"
+)
+
+func TestNewManager(t *testing.T) {
+	manager := NewManager()
+	if manager == nil {
+		t.Error("NewManager returned nil")
+	}
+	if manager.sessions == nil {
+		t.Error("sessions map is nil")
+	}
+	if manager.forwards == nil {
+		t.Error("forwards map is nil")
+	}
+}
+
+func TestManagerList(t *testing.T) {
+	manager := NewManager()
+	sessions := manager.List()
+	if len(sessions) != 0 {
+		t.Errorf("expected 0 sessions, got %d", len(sessions))
+	}
+}
+
+func TestManagerUse(t *testing.T) {
+	manager := NewManager()
+
+	// Test using non-existent session
+	err := manager.Use("non-existent")
+	if err == nil {
+		t.Error("expected error for non-existent session")
+	}
+}
+
+func TestManagerGetDefaultID(t *testing.T) {
+	manager := NewManager()
+	id := manager.GetDefaultID()
+	if id != "" {
+		t.Errorf("expected empty default ID, got %s", id)
+	}
+}
+
+func TestManagerListForwards(t *testing.T) {
+	manager := NewManager()
+	forwards := manager.ListForwards()
+	if len(forwards) != 0 {
+		t.Errorf("expected 0 forwards, got %d", len(forwards))
+	}
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "gssh-agent",
+  "version": "1.0.0",
+  "description": "SSH Session Manager for Agents",
+  "bin": {
+    "gssh": "bin/gssh",
+    "gssh-daemon": "bin/gssh-daemon"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forechoandlook/gssh.git"
+  },
+  "keywords": [
+    "ssh",
+    "agent",
+    "session-manager",
+    "port-forwarding"
+  ],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/forechoandlook/gssh/issues"
+  },
+  "homepage": "https://github.com/forechoandlook/gssh#readme"
+}