gssh-agent 1.0.3 → 1.0.5

package/cmd/gssh/main.go

@@ -21,58 +21,62 @@ const (
 	version          = "0.1.0"
 )
 
-var (
-	socketPath = flag.String("socket", defaultSocketPath, "Unix socket path")
-)
-
 func main() {
-	// Check for version flag before parsing
+	// Check for version flag before any parsing
 	if len(os.Args) > 1 && (os.Args[1] == "-v" || os.Args[1] == "--version") {
 		fmt.Printf("gssh version %s\n", version)
 		os.Exit(0)
 	}
 
-	// Check for help flag before parsing
-	for _, arg := range os.Args[1:] {
-		if arg == "-h" || arg == "--help" {
-			printUsage()
-			os.Exit(0)
-		}
+	// Check for help flag
+	if len(os.Args) > 1 && (os.Args[1] == "-h" || os.Args[1] == "--help") {
+		printUsage()
+		os.Exit(0)
 	}
 
-	flag.Parse()
+	// Parse global -socket flag manually
+	socketPath := defaultSocketPath
+	args := os.Args[1:]
+	for i := 0; i < len(args); i++ {
+		if args[i] == "-socket" && i+1 < len(args) {
+			socketPath = args[i+1]
+			args = append(args[:i], args[i+2:]...)
+			i--
+		}
+	}
 
-	if flag.NArg() < 1 {
+	if len(args) < 1 {
 		printUsage()
 		os.Exit(1)
 	}
 
-	cmd := flag.Arg(0)
+	cmd := args[0]
+	subArgs := args[1:]
 
 	var err error
 	switch cmd {
 	case "connect":
-		err = handleConnect()
+		err = handleConnect(subArgs, socketPath)
 	case "disconnect":
-		err = handleDisconnect()
+		err = handleDisconnect(subArgs, socketPath)
 	case "reconnect":
-		err = handleReconnect()
+		err = handleReconnect(subArgs, socketPath)
 	case "exec":
-		err = handleExec()
+		err = handleExec(subArgs, socketPath)
 	case "list", "ls":
-		err = handleList()
+		err = handleList(socketPath)
 	case "use":
-		err = handleUse()
+		err = handleUse(subArgs, socketPath)
 	case "forward":
-		err = handleForward()
+		err = handleForward(subArgs, socketPath)
 	case "forwards":
-		err = handleForwards()
+		err = handleForwards(socketPath)
 	case "forward-close":
-		err = handleForwardClose()
-	case "scp":
-		err = handleSCP()
+		err = handleForwardClose(subArgs, socketPath)
+	case "scp", "sync":
+		err = handleSCP(subArgs, socketPath)
 	case "sftp":
-		err = handleSFTP()
+		err = handleSFTP(subArgs, socketPath)
 	case "help":
 		printUsage()
 	default:
@@ -89,9 +93,7 @@ func main() {
 
 // readPassword reads password from terminal without echo
 func readPassword() (string, error) {
-	// Check if stdin is a terminal
 	if !term.IsTerminal(int(os.Stdin.Fd())) {
-		// Try to read from stdin
 		reader := bufio.NewReader(os.Stdin)
 		fmt.Print("Password: ")
 		password, err := reader.ReadString('\n')
@@ -131,8 +133,8 @@ func readPassphrase() (string, error) {
 	return string(bytePassphrase), nil
 }
 
-func sendRequest(method string, params interface{}) ([]byte, error) {
-	conn, err := net.Dial("unix", *socketPath)
+func sendRequest(socketPath, method string, params interface{}) ([]byte, error) {
+	conn, err := net.Dial("unix", socketPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to connect to daemon: %w", err)
 	}
@@ -155,7 +157,6 @@ func sendRequest(method string, params interface{}) ([]byte, error) {
 		return nil, fmt.Errorf("failed to marshal request: %w", err)
 	}
 
-	// Add newline to signal end of request
 	reqData = append(reqData, '\n')
 
 	_, err = conn.Write(reqData)
@@ -163,14 +164,12 @@ func sendRequest(method string, params interface{}) ([]byte, error) {
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
 
-	// Read line by line
 	reader := bufio.NewReader(conn)
 	line, err := reader.ReadBytes('\n')
 	if err != nil {
 		return nil, fmt.Errorf("failed to read response: %w", err)
 	}
 
-	// Remove trailing newline
 	line = line[:len(line)-1]
 
 	var resp protocol.Response
@@ -190,22 +189,24 @@ func sendRequest(method string, params interface{}) ([]byte, error) {
 	return result, nil
 }
 
-func handleConnect() error {
-	user := flag.String("u", "", "Username")
-	host := flag.String("h", "", "Host")
-	port := flag.Int("p", 22, "Port")
-	password := flag.String("P", "", "Password")
-	keyPath := flag.String("i", "", "SSH key path")
-	askPassword := flag.Bool("ask-pass", false, "Ask for password interactively")
-	askPassphrase := flag.Bool("ask-passphrase", false, "Ask for key passphrase interactively")
+func handleConnect(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("connect", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	user := fs.String("u", "", "Username")
+	host := fs.String("h", "", "Host")
+	port := fs.Int("p", 22, "Port")
+	password := fs.String("P", "", "Password")
+	keyPath := fs.String("i", "", "SSH key path")
+	askPassword := fs.Bool("ask-pass", false, "Ask for password interactively")
+	askPassphrase := fs.Bool("ask-passphrase", false, "Ask for key passphrase interactively")
 
-	flag.CommandLine.Parse(flag.Args()[1:])
+	fs.Parse(args)
 
 	if *user == "" || *host == "" {
 		return fmt.Errorf("user and host are required")
 	}
 
-	// If no password provided via flag and -ask-pass is set, read interactively
 	if *password == "" && *askPassword {
 		p, err := readPassword()
 		if err != nil {
@@ -214,14 +215,11 @@ func handleConnect() error {
 		*password = p
 	}
 
-	// If key path provided and -ask-passphrase is set, read interactively
 	if *keyPath != "" && *askPassphrase {
 		passphrase, err := readPassphrase()
 		if err != nil {
 			return fmt.Errorf("failed to read passphrase: %w", err)
 		}
-		// Note: Passphrase support would require modifying the SSH client
-		// For now, we'll just warn that it's not supported
 		if passphrase != "" {
 			fmt.Println("Note: Passphrase for keys is not yet supported, ignoring")
 		}
@@ -235,7 +233,7 @@ func handleConnect() error {
 		KeyPath:  *keyPath,
 	}
 
-	result, err := sendRequest("connect", params)
+	result, err := sendRequest(socketPath, "connect", params)
 	if err != nil {
 		return err
 	}
@@ -249,15 +247,24 @@ func handleConnect() error {
 	return nil
 }
 
-func handleDisconnect() error {
-	sessionID := flag.String("s", "", "Session ID")
-	flag.CommandLine.Parse(flag.Args()[1:])
+func handleDisconnect(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("disconnect", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	sessionID := fs.String("s", "", "Session ID")
+	fs.Parse(args)
+
+	// Support positional argument
+	sessionIDStr := *sessionID
+	if sessionIDStr == "" && fs.NArg() > 0 {
+		sessionIDStr = fs.Arg(0)
+	}
 
 	params := protocol.DisconnectParams{
-		SessionID: *sessionID,
+		SessionID: sessionIDStr,
 	}
 
-	_, err := sendRequest("disconnect", params)
+	_, err := sendRequest(socketPath, "disconnect", params)
 	if err != nil {
 		return err
 	}
@@ -266,15 +273,24 @@ func handleDisconnect() error {
 	return nil
 }
 
-func handleReconnect() error {
-	sessionID := flag.String("s", "", "Session ID")
-	flag.CommandLine.Parse(flag.Args()[1:])
+func handleReconnect(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("reconnect", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	sessionID := fs.String("s", "", "Session ID")
+	fs.Parse(args)
+
+	// Support positional argument
+	sessionIDStr := *sessionID
+	if sessionIDStr == "" && fs.NArg() > 0 {
+		sessionIDStr = fs.Arg(0)
+	}
 
 	params := protocol.ReconnectParams{
-		SessionID: *sessionID,
+		SessionID: sessionIDStr,
 	}
 
-	result, err := sendRequest("reconnect", params)
+	result, err := sendRequest(socketPath, "reconnect", params)
 	if err != nil {
 		return err
 	}
@@ -288,22 +304,22 @@ func handleReconnect() error {
 	return nil
 }
 
-func handleExec() error {
-	// Get remaining args after "exec"
-	args := flag.Args()[1:]
+func handleExec(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("exec", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
 
-	sessionID := flag.String("s", "", "Session ID")
-	sudoPassword := flag.String("S", "", "sudo password (will prompt if empty and -s flag used)")
-	askSudoPassword := flag.Bool("ask-sudo-pass", false, "Interactively ask for sudo password")
+	sessionID := fs.String("s", "", "Session ID")
+	timeout := fs.Int("t", 0, "Timeout in seconds (0 = no timeout)")
+	sudoPassword := fs.String("S", "", "sudo password")
+	askSudoPassword := fs.Bool("ask-sudo-pass", false, "Interactively ask for sudo password")
 
-	flag.CommandLine.Parse(args)
+	fs.Parse(args)
 
-	if flag.NArg() < 1 {
+	if fs.NArg() < 1 {
 		return fmt.Errorf("command required")
 	}
-	command := strings.Join(flag.Args(), " ")
+	command := strings.Join(fs.Args(), " ")
 
-	// If sudo password needed but not provided, prompt for it
 	if *askSudoPassword && *sudoPassword == "" {
 		p, err := readPassword()
 		if err != nil {
@@ -312,18 +328,17 @@ func handleExec() error {
 		*sudoPassword = p
 	}
 
-	// If command contains sudo and password provided, wrap the command
 	if *sudoPassword != "" && strings.Contains(command, "sudo") {
-		// Use printf to pipe password to sudo -S
 		command = fmt.Sprintf("printf '%%s\\n' '%s' | %s -S", *sudoPassword, command)
 	}
 
 	params := protocol.ExecParams{
 		SessionID: *sessionID,
 		Command:   command,
+		Timeout:   *timeout,
 	}
 
-	result, err := sendRequest("exec", params)
+	result, err := sendRequest(socketPath, "exec", params)
 	if err != nil {
 		return err
 	}
@@ -345,8 +360,8 @@ func handleExec() error {
 	return nil
 }
 
-func handleList() error {
-	result, err := sendRequest("list", nil)
+func handleList(socketPath string) error {
+	result, err := sendRequest(socketPath, "list", nil)
 	if err != nil {
 		return err
 	}
@@ -369,19 +384,22 @@ func handleList() error {
 	return nil
 }
 
-func handleUse() error {
-	flag.CommandLine.Parse(flag.Args()[1:])
+func handleUse(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("use", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
 
-	if flag.NArg() < 1 {
+	fs.Parse(args)
+
+	if fs.NArg() < 1 {
 		return fmt.Errorf("session ID required")
 	}
-	sessionIDStr := flag.Arg(0)
+	sessionIDStr := fs.Arg(0)
 
 	params := protocol.UseParams{
 		SessionID: sessionIDStr,
 	}
 
-	_, err := sendRequest("use", params)
+	_, err := sendRequest(socketPath, "use", params)
 	if err != nil {
 		return err
 	}
@@ -390,13 +408,16 @@ func handleUse() error {
 	return nil
 }
 
-func handleForward() error {
-	sessionID := flag.String("s", "", "Session ID")
-	local := flag.Int("l", 0, "Local port")
-	remote := flag.Int("r", 0, "Remote port")
-	isRemote := flag.Bool("R", false, "Remote port forward")
+func handleForward(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("forward", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	sessionID := fs.String("s", "", "Session ID")
+	local := fs.Int("l", 0, "Local port")
+	remote := fs.Int("r", 0, "Remote port")
+	isRemote := fs.Bool("R", false, "Remote port forward")
 
-	flag.CommandLine.Parse(flag.Args()[1:])
+	fs.Parse(args)
 
 	if *local == 0 || *remote == 0 {
 		return fmt.Errorf("local and remote ports are required")
@@ -414,7 +435,7 @@ func handleForward() error {
 		Remote:    *remote,
 	}
 
-	result, err := sendRequest("forward", params)
+	result, err := sendRequest(socketPath, "forward", params)
 	if err != nil {
 		return err
 	}
@@ -428,8 +449,8 @@ func handleForward() error {
 	return nil
 }
 
-func handleForwards() error {
-	result, err := sendRequest("forwards", nil)
+func handleForwards(socketPath string) error {
+	result, err := sendRequest(socketPath, "forwards", nil)
 	if err != nil {
 		return err
 	}
@@ -452,19 +473,22 @@ func handleForwards() error {
 	return nil
 }
 
-func handleForwardClose() error {
-	flag.CommandLine.Parse(flag.Args()[1:])
+func handleForwardClose(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("forward-close", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	fs.Parse(args)
 
-	if flag.NArg() < 1 {
+	if fs.NArg() < 1 {
 		return fmt.Errorf("forward ID required")
 	}
-	forwardID := flag.Arg(0)
+	forwardID := fs.Arg(0)
 
 	params := protocol.ForwardCloseParams{
 		ForwardID: forwardID,
 	}
 
-	_, err := sendRequest("forward_close", params)
+	_, err := sendRequest(socketPath, "forward_close", params)
 	if err != nil {
 		return err
 	}
@@ -473,19 +497,22 @@ func handleForwardClose() error {
 	return nil
 }
 
-func handleSCP() error {
-	sessionID := flag.String("s", "", "Session ID")
-	isUpload := flag.Bool("put", false, "Upload mode (local->remote)")
-	isDownload := flag.Bool("get", false, "Download mode (remote->local)")
+func handleSCP(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("scp", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
 
-	flag.CommandLine.Parse(flag.Args()[1:])
+	sessionID := fs.String("s", "", "Session ID")
+	isUpload := fs.Bool("put", false, "Upload mode (local->remote)")
+	isDownload := fs.Bool("get", false, "Download mode (remote->local)")
 
-	if flag.NArg() < 2 {
+	fs.Parse(args)
+
+	if fs.NArg() < 2 {
 		return fmt.Errorf("source and destination paths required")
 	}
 
-	source := flag.Arg(0)
-	dest := flag.Arg(1)
+	source := fs.Arg(0)
+	dest := fs.Arg(1)
 
 	if !*isUpload && !*isDownload {
 		return fmt.Errorf("must specify -put or -get")
@@ -498,7 +525,7 @@ func handleSCP() error {
 		IsUpload:  *isUpload,
 	}
 
-	result, err := sendRequest("scp", params)
+	result, err := sendRequest(socketPath, "scp", params)
 	if err != nil {
 		return err
 	}
@@ -517,12 +544,15 @@ func handleSCP() error {
 	return nil
 }
 
-func handleSFTP() error {
-	sessionID := flag.String("s", "", "Session ID")
-	command := flag.String("c", "", "SFTP command (ls, mkdir, rm)")
-	path := flag.String("p", ".", "Path")
+func handleSFTP(args []string, socketPath string) error {
+	fs := flag.NewFlagSet("sftp", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	sessionID := fs.String("s", "", "Session ID")
+	command := fs.String("c", "", "SFTP command (ls, mkdir, rm)")
+	path := fs.String("p", ".", "Path")
 
-	flag.CommandLine.Parse(flag.Args()[1:])
+	fs.Parse(args)
 
 	if *command == "" {
 		return fmt.Errorf("SFTP command required (-c ls|mkdir|rm)")
@@ -535,7 +565,7 @@ func handleSFTP() error {
 			Command:   "ls",
 			Path:      *path,
 		}
-		result, err := sendRequest("sftp_list", params)
+		result, err := sendRequest(socketPath, "sftp_list", params)
 		if err != nil {
 			return err
 		}
@@ -555,7 +585,7 @@ func handleSFTP() error {
 			Command:   "mkdir",
 			Path:      *path,
 		}
-		_, err := sendRequest("sftp_mkdir", params)
+		_, err := sendRequest(socketPath, "sftp_mkdir", params)
 		if err != nil {
 			return err
 		}
@@ -567,7 +597,7 @@ func handleSFTP() error {
 			Command:   "rm",
 			Path:      *path,
 		}
-		_, err := sendRequest("sftp_remove", params)
+		_, err := sendRequest(socketPath, "sftp_remove", params)
 		if err != nil {
 			return err
 		}
@@ -585,8 +615,8 @@ func printUsage() {
 
 Usage:
   gssh connect -u user -h host [-p port] [-i key_path] [-P password] [--ask-pass]
-  gssh disconnect [-s session_id]
-  gssh reconnect [-s session_id]
+  gssh disconnect [session_id]
+  gssh reconnect [session_id]
   gssh exec [-s session_id] [-S password | --ask-sudo-pass] "command"
   gssh list
   gssh use <session_id>
@@ -595,6 +625,8 @@ Usage:
   gssh forward-close <forward_id>
   gssh scp [-s session_id] -put <local> <remote>
   gssh scp [-s session_id] -get <remote> <local>
+  gssh sync [-s session_id] -put <local> <remote>
+  gssh sync [-s session_id] -get <remote> <local>
   gssh sftp [-s session_id] -c <ls|mkdir|rm> -p <path>
   gssh -v, --version
 
@@ -621,16 +653,15 @@ Options:
 Examples:
   gssh connect -u admin -h 192.168.1.1 -P password
   gssh exec "ls -la"
+  gssh reconnect 549b6eff-f62c-4dae-a7e9-298815233cf4
   gssh forward -l 8080 -r 80
-  gssh forward -l 9000 -r 3000 -R
   gssh scp -put local.txt /home/user/remote.txt
-  gssh sftp -c ls -p /home/user
+  gssh sync -put local_dir /home/user/remote_dir
 `, version)
 }
 
 // Restore terminal on exit
 func init() {
-	// Setup cleanup to restore terminal state on unexpected exit
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
 	go func() {

package/fix_manager.patch

@@ -0,0 +1,79 @@
+--- internal/session/manager.go
++++ internal/session/manager.go
+@@ -100,16 +100,24 @@
+	// Check if session already exists
+	for _, s := range m.sessions {
+		if s.Host == host && s.User == user && s.Port == port {
+-			if s.Status == "connected" {
++			s.mu.RLock()
++			status := s.Status
++			s.mu.RUnlock()
++
++			if 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.mu.Lock()
+			s.SSHClient = sshClient
+			s.Status = "connected"
++			s.mu.Unlock()
++
+			return toProtocolSession(s), nil
+		}
+	}
+@@ -159,10 +167,12 @@
+		return fmt.Errorf("session not found")
+	}
+
++	ms.mu.Lock()
+	if ms.SSHClient != nil {
+		ms.SSHClient.Close()
+	}
+-
+	ms.Status = "disconnected"
++	ms.mu.Unlock()
+
+	// Clear default ID when disconnecting
+	if m.defaultID == sessionID {
+@@ -188,10 +198,14 @@
+		return nil, fmt.Errorf("session not found")
+	}
+
++	ms.mu.RLock()
++	existingClient := ms.SSHClient
++	ms.mu.RUnlock()
++
+	// 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)
+@@ -239,15 +253,16 @@
+	}
+
+	ms.mu.RLock()
+-	if ms.SSHClient == nil {
++	sshClient := ms.SSHClient
++	ms.mu.RUnlock()
++
++	if sshClient == nil {
+-		ms.mu.RUnlock()
+		return nil, fmt.Errorf("session not connected")
+	}
+-	ms.mu.RUnlock()
+
+	// 复用 SSH 连接，创建新的 session 执行命令
+-	session, err := ms.SSHClient.Client.NewSession()
++	session, err := sshClient.Client.NewSession()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create session: %w", err)
+	}