gssh-agent 1.0.0 → 1.0.2

package/internal/client/ssh.go

@@ -2,11 +2,14 @@ package client
 
 import (
 	"fmt"
+	"io"
 	"net"
 	"os"
 	"os/user"
 	"path/filepath"
+	"time"
 
+	"github.com/pkg/sftp"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -100,7 +103,7 @@ func Connect(user, host string, port int, password, keyPath string) (*SSHClient,
 	return NewSSHClient(user, host, port, authMethods...)
 }
 
-// Exec executes a command on the remote host
+// Exec executes a command on the remote host using an interactive login shell
 func (c *SSHClient) Exec(cmd string) (string, string, int, error) {
 	session, err := c.Client.NewSession()
 	if err != nil {
@@ -108,7 +111,29 @@ func (c *SSHClient) Exec(cmd string) (string, string, int, error) {
 	}
 	defer session.Close()
 
-	output, err := session.CombinedOutput(cmd)
+	// Get terminal info for PTY
+	// Use default term if not available
+	termEnv := os.Getenv("TERM")
+	if termEnv == "" {
+		termEnv = "xterm-256color"
+	}
+
+	// Request PTY for interactive shell
+	termWidth := 80
+	termHeight := 24
+	if err := session.RequestPty(termEnv, termWidth, termHeight, ssh.TerminalModes{
+		ssh.ECHO:          1,
+		ssh.TTY_OP_ISPEED: 14400,
+		ssh.TTY_OP_OSPEED: 14400,
+	}); err != nil {
+		return "", "", 0, fmt.Errorf("failed to request PTY: %w", err)
+	}
+
+	// Execute command using login shell to load user config files (.zprofile, .bash_profile, etc.)
+	// Using -l for login shell, -c to execute command
+	fullCmd := fmt.Sprintf("/bin/zsh -l -c %q", cmd)
+
+	output, err := session.CombinedOutput(fullCmd)
 	if err != nil {
 		exitErr, ok := err.(*ssh.ExitError)
 		if ok {
@@ -130,6 +155,231 @@ func (c *SSHClient) LocalForward(localPort, remotePort int) (net.Listener, error
 	return c.Client.Listen("tcp", fmt.Sprintf("localhost:%d", localPort))
 }
 
+// SFTPClient wraps SFTP client for file transfers
+type SFTPClient struct {
+	Client *sftp.Client
+}
+
+// NewSFTPClient creates a new SFTP client from SSH client
+func (c *SSHClient) NewSFTPClient() (*SFTPClient, error) {
+	sftpClient, err := sftp.NewClient(c.Client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create SFTP client: %w", err)
+	}
+	return &SFTPClient{Client: sftpClient}, nil
+}
+
+// Upload uploads a local file to remote
+func (s *SFTPClient) Upload(localPath, remotePath string) (int64, error) {
+	localFile, err := os.Open(localPath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to open local file: %w", err)
+	}
+	defer localFile.Close()
+
+	localInfo, err := localFile.Stat()
+	if err != nil {
+		return 0, fmt.Errorf("failed to stat local file: %w", err)
+	}
+
+	remoteFile, err := s.Client.Create(remotePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	written, err := io.Copy(remoteFile, localFile)
+	if err != nil {
+		return 0, fmt.Errorf("failed to upload file: %w", err)
+	}
+
+	// Set file permissions
+	s.Client.Chmod(remotePath, localInfo.Mode())
+
+	return written, nil
+}
+
+// Download downloads a remote file to local
+func (s *SFTPClient) Download(remotePath, localPath string) (int64, error) {
+	remoteFile, err := s.Client.Open(remotePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to open remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	localFile, err := os.Create(localPath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create local file: %w", err)
+	}
+	defer localFile.Close()
+
+	written, err := io.Copy(localFile, remoteFile)
+	if err != nil {
+		return 0, fmt.Errorf("failed to download file: %w", err)
+	}
+
+	// Get remote file info to set local permissions
+	remoteInfo, err := s.Client.Stat(remotePath)
+	if err == nil {
+		os.Chmod(localPath, remoteInfo.Mode())
+	}
+
+	return written, nil
+}
+
+// List lists files in a remote directory
+func (s *SFTPClient) List(path string) ([]string, error) {
+	entries, err := s.Client.ReadDir(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory: %w", err)
+	}
+
+	names := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		names = append(names, entry.Name())
+	}
+	return names, nil
+}
+
+// Mkdir creates a remote directory
+func (s *SFTPClient) Mkdir(path string) error {
+	return s.Client.Mkdir(path)
+}
+
+// Remove removes a remote file
+func (s *SFTPClient) Remove(path string) error {
+	return s.Client.Remove(path)
+}
+
+// Stat gets remote file info
+func (s *SFTPClient) Stat(path string) (os.FileInfo, error) {
+	return s.Client.Stat(path)
+}
+
+// Close closes the SFTP client
+func (s *SFTPClient) Close() error {
+	return s.Client.Close()
+}
+
+// TransferResult represents the result of a file transfer
+type TransferResult struct {
+	Bytes    int64
+	Duration time.Duration
+}
+
+// TransferWithProgress uploads or downloads a file with progress callback
+func (s *SFTPClient) TransferWithProgress(isUpload bool, src, dst string, progress func(int64)) (*TransferResult, error) {
+	start := time.Now()
+
+	if isUpload {
+		result, err := s.uploadWithProgress(src, dst, progress)
+		if err != nil {
+			return nil, err
+		}
+		return &TransferResult{
+			Bytes:    result,
+			Duration: time.Since(start),
+		}, nil
+	} else {
+		result, err := s.downloadWithProgress(src, dst, progress)
+		if err != nil {
+			return nil, err
+		}
+		return &TransferResult{
+			Bytes:    result,
+			Duration: time.Since(start),
+		}, nil
+	}
+}
+
+func (s *SFTPClient) uploadWithProgress(localPath, remotePath string, progress func(int64)) (int64, error) {
+	localFile, err := os.Open(localPath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to open local file: %w", err)
+	}
+	defer localFile.Close()
+
+	localInfo, err := localFile.Stat()
+	if err != nil {
+		return 0, fmt.Errorf("failed to stat local file: %w", err)
+	}
+
+	remoteFile, err := s.Client.Create(remotePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	// Create a writer with progress tracking
+	writer := &progressWriter{
+		w:        remoteFile,
+		progress: progress,
+		total:    localInfo.Size(),
+	}
+
+	written, err := io.Copy(writer, localFile)
+	if err != nil {
+		return 0, fmt.Errorf("failed to upload file: %w", err)
+	}
+
+	// Set file permissions
+	s.Client.Chmod(remotePath, localInfo.Mode())
+
+	return written, nil
+}
+
+func (s *SFTPClient) downloadWithProgress(remotePath, localPath string, progress func(int64)) (int64, error) {
+	remoteFile, err := s.Client.Open(remotePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to open remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	remoteInfo, err := s.Client.Stat(remotePath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to stat remote file: %w", err)
+	}
+
+	localFile, err := os.Create(localPath)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create local file: %w", err)
+	}
+	defer localFile.Close()
+
+	// Create a writer with progress tracking
+	writer := &progressWriter{
+		w:        localFile,
+		progress: progress,
+		total:    remoteInfo.Size(),
+	}
+
+	written, err := io.Copy(writer, remoteFile)
+	if err != nil {
+		return 0, fmt.Errorf("failed to download file: %w", err)
+	}
+
+	// Set local file permissions
+	os.Chmod(localPath, remoteInfo.Mode())
+
+	return written, nil
+}
+
+type progressWriter struct {
+	w        io.Writer
+	progress func(int64)
+	total    int64
+	written  int64
+}
+
+func (pw *progressWriter) Write(p []byte) (n int, err error) {
+	n, err = pw.w.Write(p)
+	pw.written += int64(n)
+	if pw.progress != nil {
+		pw.progress(pw.written)
+	}
+	return
+}
+
 // expandPath expands ~ to home directory
 func expandPath(path string) string {
 	if len(path) > 0 && path[0] == '~' {

package/internal/portforward/forwarder.go

@@ -3,6 +3,7 @@ package portforward
 import (
 	"fmt"
 	"io"
+	"log"
 	"net"
 	"sync"
 
@@ -16,12 +17,12 @@ type Forwarder struct {
 	LocalPort  int
 	RemotePort int
 
-	sshClient  *ssh.Client
-	listener   net.Listener
-	conns      map[net.Conn]bool
-	mu         sync.RWMutex
-	closed     bool
-	wg         sync.WaitGroup
+	sshClient *ssh.Client
+	listener  net.Listener
+	conns     map[net.Conn]bool
+	mu        sync.RWMutex
+	closed    bool
+	wg        sync.WaitGroup
 }
 
 // NewForwarder creates a new port forwarder
@@ -42,6 +43,10 @@ func NewForwarder(sshClient *ssh.Client, forwardType string, localPort, remotePo
 			return nil, fmt.Errorf("failed to listen on %s: %w", addr, err)
 		}
 		f.listener = listener
+		log.Printf("[portforward] Local forward: localhost:%d -> remote:%d", localPort, remotePort)
+	} else if forwardType == "remote" {
+		// Remote port forward: remote:remotePort -> localhost:localPort
+		log.Printf("[portforward] Remote forward: remote:%d -> localhost:%d", remotePort, localPort)
 	}
 
 	return f, nil
@@ -51,7 +56,7 @@ func NewForwarder(sshClient *ssh.Client, forwardType string, localPort, remotePo
 func (f *Forwarder) Start() {
 	if f.Type == "local" {
 		f.startLocalForward()
-	} else {
+	} else if f.Type == "remote" {
 		f.startRemoteForward()
 	}
 }
@@ -98,13 +103,18 @@ func (f *Forwarder) handleLocalConnection(localConn net.Conn) {
 		f.mu.Unlock()
 	}()
 
+	log.Printf("[portforward] Connection accepted from %s", localConn.RemoteAddr())
+
 	remoteAddr := fmt.Sprintf("localhost:%d", f.RemotePort)
 	remoteConn, err := f.sshClient.Dial("tcp", remoteAddr)
 	if err != nil {
+		log.Printf("[portforward] Failed to connect to remote %s: %v", remoteAddr, err)
 		return
 	}
 	defer remoteConn.Close()
 
+	log.Printf("[portforward] Tunnel established to remote %s", remoteAddr)
+
 	// Bidirectional copy
 	done := make(chan struct{})
 	go func() {
@@ -119,14 +129,34 @@ func (f *Forwarder) handleLocalConnection(localConn net.Conn) {
 }
 
 // startRemoteForward handles remote port forwarding
+// Remote port forward: remote:remotePort -> localhost:localPort
 func (f *Forwarder) startRemoteForward() {
-	// Remote port forwarding: remote:remotePort -> localhost:localPort
 	f.wg.Add(1)
 	go func() {
 		defer f.wg.Done()
 
-		// Request the server to forward remote port
-		// This is a simplified implementation
+		// Request the SSH server to listen on remote:remotePort and forward connections to us
+		// Payload format: string (address) + uint32 (port)
+		addr := fmt.Sprintf(":%d", f.RemotePort)
+		payload := ssh.Marshal(struct {
+			Addr string
+			Port uint32
+		}{Addr: addr, Port: uint32(f.RemotePort)})
+
+		ok, _, err := f.sshClient.SendRequest("tcpip-forward", true, payload)
+		if err != nil {
+			log.Printf("[portforward] Failed to send tcpip-forward request: %v", err)
+			return
+		}
+		if !ok {
+			log.Printf("[portforward] SSH server rejected tcpip-forward request for port %d", f.RemotePort)
+			return
+		}
+
+		log.Printf("[portforward] Remote forward: SSH server listening on port %d", f.RemotePort)
+
+		// Now we need to accept forwarded connections from the SSH server
+		// The SSH server will open a "forwarded-tcpip" channel for each connection
 		for {
 			f.mu.RLock()
 			if f.closed {
@@ -135,9 +165,46 @@ func (f *Forwarder) startRemoteForward() {
 			}
 			f.mu.RUnlock()
 
-			// Wait for connections on remote side
-			// In practice, SSH server handles this
-			// This would need SSH channel forwarding
+			// Wait for a forwarded connection
+			ch, reqs, err := f.sshClient.OpenChannel("forwarded-tcpip", nil)
+			if err != nil {
+				f.mu.RLock()
+				closed := f.closed
+				f.mu.RUnlock()
+				if closed {
+					return
+				}
+				log.Printf("[portforward] Error accepting forwarded connection: %v", err)
+				continue
+			}
+
+			// Discard any requests
+			go ssh.DiscardRequests(reqs)
+
+			// Connect to local port
+			localAddr := fmt.Sprintf("localhost:%d", f.LocalPort)
+			localConn, err := net.Dial("tcp", localAddr)
+			if err != nil {
+				log.Printf("[portforward] Failed to connect to local port %d: %v", f.LocalPort, err)
+				ch.Close()
+				continue
+			}
+
+			f.mu.Lock()
+			f.conns[localConn] = true
+			f.mu.Unlock()
+
+			log.Printf("[portforward] Remote connection forwarded to localhost:%d", f.LocalPort)
+
+			// Bidirectional copy
+			go func() {
+				io.Copy(ch, localConn)
+				ch.Close()
+				localConn.Close()
+			}()
+			go func() {
+				io.Copy(localConn, ch)
+			}()
 		}
 	}()
 }
@@ -175,13 +242,15 @@ func (f *Forwarder) Restart(sshClient *ssh.Client) {
 		f.listener.Close()
 	}
 
-	// Create new listener
-	addr := fmt.Sprintf("localhost:%d", f.LocalPort)
-	listener, err := net.Listen("tcp", addr)
-	if err != nil {
-		return
+	if f.Type == "local" {
+		// Create new listener
+		addr := fmt.Sprintf("localhost:%d", f.LocalPort)
+		listener, err := net.Listen("tcp", addr)
+		if err != nil {
+			return
+		}
+		f.listener = listener
 	}
-	f.listener = listener
 
 	f.Start()
 }

package/internal/protocol/types.go

@@ -88,3 +88,26 @@ type ForwardCloseParams struct {
 type UseParams struct {
 	SessionID string `json:"session_id"`
 }
+
+// SCPParams represents SCP transfer parameters
+type SCPParams struct {
+	SessionID string `json:"session_id,omitempty"`
+	Source    string `json:"source"`
+	Dest      string `json:"dest"`
+	IsUpload  bool   `json:"is_upload"` // true = upload (local->remote), false = download (remote->local)
+}
+
+// SCPResult represents SCP transfer result
+type SCPResult struct {
+	Success  bool   `json:"success"`
+	Message  string `json:"message"`
+	Bytes    int64  `json:"bytes"`
+	Duration int64  `json:"duration_ms"`
+}
+
+// SFTPParams represents SFTP command parameters
+type SFTPParams struct {
+	SessionID string `json:"session_id,omitempty"`
+	Command   string `json:"command"` // "ls", "cd", "pwd", "mkdir", "rm", "rmdir"
+	Path      string `json:"path"`
+}