gssh-agent 1.0.7 → 1.0.8

package/internal/session/manager.go

@@ -96,42 +96,65 @@ func needsShell(cmd string) bool {
 // 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")
+			s.mu.RLock()
+			status := s.Status
+			s.mu.RUnlock()
+
+			if status == "connected" || status == "connecting" || status == "reconnecting" {
+				m.defaultID = s.ID
+				m.mu.Unlock()
+				return toProtocolSession(s), nil
 			}
-			// Try to reconnect
+
+			// Mark as connecting to prevent concurrent connect attempts
+			s.mu.Lock()
+			s.Status = "connecting"
+			s.mu.Unlock()
+
+			// Switch default session
+			m.defaultID = s.ID
+
+			m.mu.Unlock()
+
+			// Perform network connect outside of Manager lock
 			sshClient, err := client.Connect(user, host, port, password, keyPath)
 			if err != nil {
+				s.mu.Lock()
+				s.Status = "offline"
+				s.mu.Unlock()
 				return nil, err
 			}
+
+			s.mu.Lock()
+			// Check if a disconnect was requested while we were connecting
+			if s.Status != "connecting" {
+				s.mu.Unlock()
+				sshClient.Close()
+				return nil, fmt.Errorf("session was disconnected while connecting")
+			}
 			s.SSHClient = sshClient
 			s.Status = "connected"
+			s.mu.Unlock()
+
 			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()
+	// Create new session placeholder
+	id := uuid.New().String()[:8]
 	ms := &ManagedSession{
-		ID:        id,
-		Host:      host,
-		User:      user,
-		Port:      port,
-		Status:    "connected",
-		Password:  password,
-		KeyPath:   keyPath,
-		SSHClient: sshClient,
-		Forwards:  make(map[string]*portforward.Forwarder),
+		ID:       id,
+		Host:     host,
+		User:     user,
+		Port:     port,
+		Status:   "connecting",
+		Password: password,
+		KeyPath:  keyPath,
+		Forwards: make(map[string]*portforward.Forwarder),
 	}
 
 	m.sessions[id] = ms
@@ -140,6 +163,31 @@ func (m *Manager) Connect(user, host string, port int, password, keyPath string)
 	if m.defaultID == "" {
 		m.defaultID = id
 	}
+	m.mu.Unlock()
+
+	// Perform network connect outside of Manager lock
+	sshClient, err := client.Connect(user, host, port, password, keyPath)
+	if err != nil {
+		// Clean up the placeholder since initialization failed completely
+		m.mu.Lock()
+		delete(m.sessions, id)
+		if m.defaultID == id {
+			m.defaultID = ""
+		}
+		m.mu.Unlock()
+		return nil, err
+	}
+
+	ms.mu.Lock()
+	// Check if a disconnect was requested while we were connecting
+	if ms.Status != "connecting" {
+		ms.mu.Unlock()
+		sshClient.Close()
+		return nil, fmt.Errorf("session was disconnected while connecting")
+	}
+	ms.SSHClient = sshClient
+	ms.Status = "connected"
+	ms.mu.Unlock()
 
 	// Start reconnect monitor
 	go m.monitorReconnect(ms)
@@ -149,28 +197,32 @@ func (m *Manager) Connect(user, host string, port int, password, keyPath string)
 
 // Disconnect closes a session
 func (m *Manager) Disconnect(sessionID string) error {
+	m.mu.Lock()
+
 	// Use default session if not specified
 	if sessionID == "" {
 		sessionID = m.defaultID
 	}
 
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
 	ms, ok := m.sessions[sessionID]
 	if !ok {
+		m.mu.Unlock()
 		return fmt.Errorf("session not found")
 	}
 
-	if ms.SSHClient != nil {
-		ms.SSHClient.Close()
+	// Clear default ID when disconnecting
+	if m.defaultID == sessionID {
+		m.defaultID = ""
 	}
+	m.mu.Unlock()
 
+	ms.mu.Lock()
+	sshClient := ms.SSHClient
 	ms.Status = "disconnected"
+	ms.mu.Unlock()
 
-	// Clear default ID when disconnecting
-	if m.defaultID == sessionID {
-		m.defaultID = ""
+	if sshClient != nil {
+		sshClient.Close()
 	}
 
 	return nil
@@ -191,21 +243,36 @@ func (m *Manager) Reconnect(sessionID string) (*protocol.Session, error) {
 		return nil, fmt.Errorf("session not found")
 	}
 
+	ms.mu.Lock()
+	if ms.Status == "connecting" || ms.Status == "reconnecting" {
+		ms.mu.Unlock()
+		return nil, fmt.Errorf("session is currently connecting")
+	}
+	existingClient := ms.SSHClient
+	ms.Status = "reconnecting"
+	ms.mu.Unlock()
+
 	// Close existing connection
-	if ms.SSHClient != nil {
-		ms.SSHClient.Close()
+	if existingClient != nil {
+		existingClient.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.Status = "offline"
 		ms.mu.Unlock()
 		return nil, err
 	}
 
 	ms.mu.Lock()
+	// Check if a disconnect was requested while we were reconnecting
+	if ms.Status != "reconnecting" {
+		ms.mu.Unlock()
+		sshClient.Close()
+		return nil, fmt.Errorf("session was disconnected while reconnecting")
+	}
 	ms.SSHClient = sshClient
 	ms.Status = "connected"
 	ms.mu.Unlock()
@@ -265,18 +332,24 @@ func (m *Manager) Exec(sessionID, command string, timeout int) (*protocol.ExecRe
 	var ok bool
 
 	if timeout > 0 {
-		done := make(chan struct{})
+		type result struct {
+			out []byte
+			err error
+		}
+		done := make(chan result, 1)
 		go func() {
-			output, err = session.CombinedOutput(fullCmd)
-			close(done)
+			out, err := session.CombinedOutput(fullCmd)
+			done <- result{out, err}
 		}()
 		select {
-		case <-done:
+		case res := <-done:
+			output = res.out
+			err = res.err
 			// 命令执行完成
 		case <-time.After(time.Duration(timeout) * time.Second):
 			session.Signal(ssh.SIGKILL)
 			return &protocol.ExecResult{
-				Stdout:   string(output),
+				Stdout:   "",
 				Stderr:   "",
 				ExitCode: -1,
 			}, fmt.Errorf("command timed out after %d seconds", timeout)
@@ -285,17 +358,19 @@ func (m *Manager) Exec(sessionID, command string, timeout int) (*protocol.ExecRe
 		output, err = session.CombinedOutput(fullCmd)
 	}
 
+	ms.mu.Lock()
+	ms.LastCmd = command
+	ms.mu.Unlock()
+
 	if err != nil {
 		exitErr, ok = err.(*ssh.ExitError)
 		if ok {
-			ms.LastCmd = command
 			return &protocol.ExecResult{
 				Stdout:   string(output),
 				Stderr:   "",
 				ExitCode: exitErr.ExitStatus(),
 			}, nil
 		}
-		ms.LastCmd = command
 		return &protocol.ExecResult{
 			Stdout:   string(output),
 			Stderr:   "",
@@ -303,7 +378,6 @@ func (m *Manager) Exec(sessionID, command string, timeout int) (*protocol.ExecRe
 		}, nil
 	}
 
-	ms.LastCmd = command
 	return &protocol.ExecResult{
 		Stdout:   string(output),
 		Stderr:   "",
@@ -371,7 +445,7 @@ func (m *Manager) AddForward(sessionID, forwardType string, localPort, remotePor
 		return nil, err
 	}
 
-	id := uuid.New().String()
+	id := uuid.New().String()[:8]
 	forwarder.ID = id
 
 	m.forwardMu.Lock()
@@ -598,14 +672,30 @@ func (m *Manager) monitorReconnect(ms *ManagedSession) {
 			return
 		}
 
-		if sshClient == nil || sshClient.Client == nil {
+		isAlive := false
+		if sshClient != nil && sshClient.Client != nil {
+			// Try to send a keepalive request
+			_, _, err := sshClient.Client.SendRequest("keepalive@gssh", true, nil)
+			if err == nil {
+				isAlive = true
+			}
+		}
+
+		if !isAlive {
 			ms.mu.Lock()
 			ms.Status = "reconnecting"
+			if sshClient != nil {
+				sshClient.Close()
+				ms.SSHClient = nil
+			}
 			ms.mu.Unlock()
 
 			// Try to reconnect
 			newClient, err := client.Connect(ms.User, ms.Host, ms.Port, ms.Password, ms.KeyPath)
 			if err != nil {
+				ms.mu.Lock()
+				ms.Status = "offline"
+				ms.mu.Unlock()
 				continue
 			}
 

package/internal/session/manager_test.go

@@ -1,9 +1,126 @@
 package session
 
 import (
+	"crypto/rand"
+	"crypto/rsa"
+	"net"
+	"strconv"
 	"testing"
+	"time"
+
+	"golang.org/x/crypto/ssh"
 )
 
+// generatePrivateKey generates a new RSA private key for testing
+func generatePrivateKey() (ssh.Signer, error) {
+	key, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return nil, err
+	}
+	return ssh.NewSignerFromKey(key)
+}
+
+// startDummySSHServer starts a basic SSH server for testing
+func startDummySSHServer(t *testing.T) (string, int, func()) {
+	t.Helper()
+
+	config := &ssh.ServerConfig{
+		PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
+			if c.User() == "testuser" && string(pass) == "testpass" {
+				return nil, nil
+			}
+			return nil, ssh.ErrNoAuth
+		},
+	}
+
+	signer, err := generatePrivateKey()
+	if err != nil {
+		t.Fatalf("failed to generate private key: %v", err)
+	}
+	config.AddHostKey(signer)
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("failed to listen on port: %v", err)
+	}
+
+	host, portStr, err := net.SplitHostPort(listener.Addr().String())
+	if err != nil {
+		t.Fatalf("failed to split host port: %v", err)
+	}
+
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		t.Fatalf("failed to parse port: %v", err)
+	}
+
+	go func() {
+		for {
+			nConn, err := listener.Accept()
+			if err != nil {
+				return
+			}
+
+			go func() {
+				// Perform SSH handshake
+				serverConn, chans, reqs, err := ssh.NewServerConn(nConn, config)
+				if err != nil {
+					return
+				}
+
+				go ssh.DiscardRequests(reqs)
+
+				for newChannel := range chans {
+					if newChannel.ChannelType() != "session" {
+						newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
+						continue
+					}
+
+					channel, requests, err := newChannel.Accept()
+					if err != nil {
+						continue
+					}
+
+					go func() {
+						defer channel.Close()
+						for req := range requests {
+							if req.Type == "exec" {
+								// Mock command execution
+								if req.WantReply {
+									req.Reply(true, nil)
+								}
+								// Simply write something back and exit
+								channel.Write([]byte("mock output"))
+
+								// Wait a little bit to simulate some work or timeout testing
+								cmdLen := len(req.Payload)
+								if cmdLen > 4 && string(req.Payload[4:]) == "/bin/sh -c \"sleep 2\"" {
+									time.Sleep(2 * time.Second)
+								}
+								if cmdLen > 4 && string(req.Payload[4:]) == "sleep 2" {
+									time.Sleep(2 * time.Second)
+								}
+
+								channel.SendRequest("exit-status", false, ssh.Marshal(struct{ uint32 }{0}))
+								return
+							}
+						}
+					}()
+				}
+
+				// Handle client disconnect gracefully if needed
+				_ = serverConn
+			}()
+		}
+	}()
+
+	cleanup := func() {
+		listener.Close()
+	}
+
+	return host, port, cleanup
+}
+
 func TestNewManager(t *testing.T) {
 	manager := NewManager()
 	if manager == nil {
@@ -50,3 +167,210 @@ func TestManagerListForwards(t *testing.T) {
 		t.Errorf("expected 0 forwards, got %d", len(forwards))
 	}
 }
+
+func TestNeedsShell(t *testing.T) {
+	tests := []struct {
+		cmd      string
+		expected bool
+	}{
+		{"ls -la", false},
+		{"echo hello", false},
+		{"cat file.txt | grep test", true},
+		{"echo hello > file.txt", true},
+		{"cat < file.txt", true},
+		{"cat << EOF\nhello\nEOF", true},
+		{"echo hello && echo world", true},
+		{"echo hello || echo world", true},
+		{"sleep 10 &", true},
+		{"echo $(whoami)", true},
+		{"echo `whoami`", true},
+		{"echo ${HOME}", true},
+		{"echo $HOME", true},
+		{"echo $$", false},
+		{"echo hello\nworld", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.cmd, func(t *testing.T) {
+			result := needsShell(tt.cmd)
+			if result != tt.expected {
+				t.Errorf("needsShell(%q) = %v; want %v", tt.cmd, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestManagerConnect(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	// Test successful connection
+	sess, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Fatalf("expected successful connection, got error: %v", err)
+	}
+
+	if sess.Status != "connected" {
+		t.Errorf("expected session status 'connected', got %s", sess.Status)
+	}
+
+	// Test duplicate connection (should reuse and return nil error)
+	sess2, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Errorf("expected successful reuse for duplicate connection, got error: %v", err)
+	}
+	if sess2.ID != sess.ID {
+		t.Errorf("expected reused session ID %s, got %s", sess.ID, sess2.ID)
+	}
+}
+
+func TestManagerDisconnect(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	// Connect first
+	sess, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Fatalf("expected successful connection, got error: %v", err)
+	}
+
+	// Disconnect
+	err = manager.Disconnect(sess.ID)
+	if err != nil {
+		t.Errorf("expected successful disconnect, got error: %v", err)
+	}
+
+	// Disconnect non-existent
+	err = manager.Disconnect("invalid-id")
+	if err == nil {
+		t.Errorf("expected error for non-existent session, got nil")
+	}
+}
+
+func TestManagerReconnect(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	// Connect first
+	sess, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Fatalf("expected successful connection, got error: %v", err)
+	}
+
+	// Reconnect
+	reconnectedSess, err := manager.Reconnect(sess.ID)
+	if err != nil {
+		t.Errorf("expected successful reconnect, got error: %v", err)
+	}
+
+	if reconnectedSess.Status != "connected" {
+		t.Errorf("expected reconnected session status 'connected', got %s", reconnectedSess.Status)
+	}
+}
+
+func TestManagerConcurrentStress(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	// Connect first
+	sess, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Fatalf("expected successful connection, got error: %v", err)
+	}
+
+	numGoroutines := 20
+	done := make(chan bool)
+
+	for i := 0; i < numGoroutines; i++ {
+		go func(id int) {
+			// Randomly perform operations
+			if id%3 == 0 {
+				manager.Exec(sess.ID, "echo hello", 5)
+			} else if id%3 == 1 {
+				manager.List()
+			} else {
+				manager.GetDefaultID()
+			}
+			done <- true
+		}(i)
+	}
+
+	for i := 0; i < numGoroutines; i++ {
+		<-done
+	}
+
+	// Make sure we can still disconnect
+	err = manager.Disconnect(sess.ID)
+	if err != nil {
+		t.Errorf("expected successful disconnect after stress, got error: %v", err)
+	}
+}
+
+func TestManagerConcurrentConnect(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	numGoroutines := 10
+	done := make(chan bool)
+
+	// Since they all try to connect with the same user/host/port, the first one succeeds
+	// and subsequent ones should get "session already exists".
+	// The key is that no deadlocks happen here.
+	for i := 0; i < numGoroutines; i++ {
+		go func() {
+			manager.Connect("testuser", host, port, "testpass", "")
+			done <- true
+		}()
+	}
+
+	for i := 0; i < numGoroutines; i++ {
+		<-done
+	}
+
+	sessions := manager.List()
+	if len(sessions) != 1 {
+		t.Errorf("expected exactly 1 session, got %d", len(sessions))
+	}
+}
+
+func TestManagerExecTimeout(t *testing.T) {
+	host, port, cleanup := startDummySSHServer(t)
+	defer cleanup()
+
+	manager := NewManager()
+
+	sess, err := manager.Connect("testuser", host, port, "testpass", "")
+	if err != nil {
+		t.Fatalf("expected successful connection, got error: %v", err)
+	}
+
+	// This command takes 2 seconds on our dummy server
+	// Set timeout to 1 second
+	start := time.Now()
+	res, err := manager.Exec(sess.ID, "sleep 2", 1)
+
+	elapsed := time.Since(start)
+
+	// Exec returns err != nil when it times out
+	if err == nil {
+		t.Errorf("expected timeout error, got nil")
+	}
+
+	if res != nil && res.ExitCode != -1 {
+		t.Errorf("expected exit code -1 for timeout, got %d", res.ExitCode)
+	}
+
+	if elapsed >= 2*time.Second {
+		t.Errorf("expected to timeout before 2 seconds, elapsed: %v", elapsed)
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gssh-agent",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "SSH Session Manager for Agents - Stateless SSH client with SFTP support",
   "bin": {
     "gssh": "./bin/gssh"
@@ -36,4 +36,4 @@
   "engines": {
     "node": ">=14.0.0"
   }
-}
+}

package/pkg/rpc/handler_test.go

@@ -0,0 +1,36 @@
+package rpc
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gssh/internal/protocol"
+)
+
+func TestHandle_InvalidJSON(t *testing.T) {
+	handler := NewHandler(nil)
+
+	invalidJSON := []byte(`{invalid json`)
+
+	respBytes, err := handler.Handle(invalidJSON)
+	if err != nil {
+		t.Fatalf("Handle returned unexpected error: %v", err)
+	}
+
+	var resp protocol.Response
+	if err := json.Unmarshal(respBytes, &resp); err != nil {
+		t.Fatalf("Failed to unmarshal response: %v", err)
+	}
+
+	if resp.Error == nil {
+		t.Fatal("Expected error in response, got nil")
+	}
+
+	if resp.Error.Code != -32700 {
+		t.Errorf("Expected error code -32700, got %d", resp.Error.Code)
+	}
+
+	if resp.Error.Message != "Parse error" {
+		t.Errorf("Expected error message 'Parse error', got '%s'", resp.Error.Message)
+	}
+}

package/plan.md

@@ -0,0 +1,4 @@
+1. **Create `pkg/rpc/handler_test.go`:** I will create a test file in the `pkg/rpc` directory.
+2. **Add test for invalid JSON:** I will add a test `TestHandle_InvalidJSON` that initializes a new `Handler` and calls `Handle` with an invalid JSON byte slice. It will assert that the returned error JSON structure matches the JSON-RPC error response for parse errors (`code: -32700`).
+3. **Run pre-commit steps:** Complete pre commit steps to ensure proper testing, verifications, reviews and reflections are done.
+4. **Submit change:** Once everything works and tests pass, I will submit the change.