gssh-agent 1.0.1 → 1.0.2

package/internal/client/ssh.go

@@ -103,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 {
@@ -111,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 {

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/session/manager.go

@@ -10,6 +10,7 @@ import (
 	"gssh/internal/protocol"
 
 	"github.com/google/uuid"
+	"golang.org/x/crypto/ssh"
 )
 
 // Manager manages SSH sessions
@@ -23,17 +24,17 @@ type Manager struct {
 
 // 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
+	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
@@ -180,23 +181,47 @@ func (m *Manager) Exec(sessionID, command string) (*protocol.ExecResult, error)
 	}
 
 	ms.mu.RLock()
-	defer ms.mu.RUnlock()
-
 	if ms.SSHClient == nil {
+		ms.mu.RUnlock()
 		return nil, fmt.Errorf("session not connected")
 	}
+	ms.mu.RUnlock()
 
-	stdout, stderr, exitCode, err := ms.SSHClient.Exec(command)
-	if err != nil && exitCode == 0 {
-		return nil, err
+	// 复用 SSH 连接，创建新的 session 执行命令
+	session, err := ms.SSHClient.Client.NewSession()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create session: %w", err)
 	}
+	defer session.Close()
 
-	ms.LastCmd = command
+	// 直接执行命令，不通过 shell
+	
+	fullCmd := command
 
+	output, err := session.CombinedOutput(fullCmd)
+	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:   "",
+			ExitCode: 0,
+		}, nil
+	}
+
+	ms.LastCmd = command
 	return &protocol.ExecResult{
-		Stdout:   stdout,
-		Stderr:   stderr,
-		ExitCode: exitCode,
+		Stdout:   string(output),
+		Stderr:   "",
+		ExitCode: 0,
 	}, nil
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gssh-agent",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "SSH Session Manager for Agents - Stateless SSH client with SFTP support",
   "bin": {
     "gssh": "./bin/gssh",

package/skill.md

@@ -7,19 +7,18 @@ triggers:
   - ssh session
   - ssh 连接
   - ssh 管理
+  - sftp
+  - scp 文件传输
 ---
 
-## 快速开始
+## 连接认证
 
 ```bash
-# 连接 SSH（交互式输入密码）
-gssh connect -u admin -h 192.168.1.100 --ask-pass
+# 使用密码
+gssh connect -u user -h host -p password
 
-# 执行命令
-gssh exec "ls -la"
-
-# 断开连接
-gssh disconnect
+# SSH 密钥
+gssh connect -u user -h host -i ~/.ssh/id_rsa
 ```
 
 ## 核心命令
@@ -28,33 +27,70 @@ gssh disconnect
 |------|------|
 | `connect` | 建立 SSH 连接 |
 | `exec` | 执行命令 |
-| `scp` | 文件传输（上/下载） |
+| `scp` | 文件传输 |
 | `sftp` | SFTP 操作 |
 | `forward` | 端口转发 |
 | `list` | 列出 session |
+| `use` | 切换默认 session |
 
-## 认证
+## 执行命令
 
 ```bash
-# 交互式密码（推荐）
-gssh connect -u user -h host --ask-pass
+# 普通命令
+gssh exec "ls -la"
 
-# SSH 密钥
-gssh connect -u user -h host -i ~/.ssh/id_rsa
+# sudo 命令
+gssh exec -S password "sudo systemctl restart nginx"
 ```
 
-## sudo 命令
+## 文件传输
 
 ```bash
-gssh exec --ask-sudo-pass "sudo apt update"
+# 上传本地 -> 远程
+gssh scp -put local.txt /remote/path/
+
+# 下载远程 -> 本地
+gssh scp -get /remote/file.txt ./
+
+# SFTP 目录操作
+gssh sftp -c ls -p /home/user
+gssh sftp -c mkdir -p /home/user/newdir
+gssh sftp -c rm -p /home/user/file.txt
 ```
 
-## 文件传输
+## 端口转发
 
 ```bash
-# 上传
-gssh scp -put local.txt /remote/path/
+# 本地转发: localhost:8080 -> remote:80
+gssh forward -l 8080 -r 80
 
-# 下载
-gssh scp -get /remote/file.txt ./
+# 远程转发: remote:9000 -> localhost:3000
+gssh forward -R -l 9000 -r 3000
 ```
+
+## Session 管理
+
+```bash
+gssh list                    # 列出所有 session
+gssh use <session-id>        # 切换默认 session
+gssh disconnect             # 断开
+gssh reconnect -s <id>     # 重连
+```
+
+## 选项汇总
+
+| 选项 | 说明 |
+|------|------|
+| `-s` | session ID |
+| `-u` | 用户名 |
+| `-h` | 主机地址 |
+| `-p` | 端口（默认 22） |
+| `-P` | SSH 密码 |
+| `-i` | SSH 密钥 |
+| `-l` | 本地端口 |
+| `-r` | 远程端口 |
+| `-R` | 远程端口转发 |
+| `-put/-get` | 上传/下载 |
+| `-S` | sudo 密码 |
+| `--ask-pass` | 交互输入 SSH 密码 |
+| `--ask-sudo-pass` | 交互输入 sudo 密码 |