gssh-agent 1.0.0

package/README.md

@@ -0,0 +1,175 @@
+# gssh - SSH Session Manager for Agents
+
+gssh 是一个供 Agent 使用的 SSH Session 管理工具。通过 Go 语言实现，支持多个 SSH 会话管理、命令执行、端口转发和自动重连。
+
+## 特性
+
+- 多个 SSH Session 并发管理
+- 命令执行与结果透传（stdout/stderr/exit code）
+- TCP 端口转发（本地/远程）
+- 断线自动重连
+- 支持密码认证和 SSH 密钥认证
+- 被连接机器零配置（普通 SSH 即可）
+
+## 安装
+
+### 方式一：Homebrew（推荐）
+
+```bash
+# 添加 tap（未来会支持）
+# brew tap forechoandlook/gssh
+# brew install gssh
+
+# 暂时使用手动安装方式
+git clone https://github.com/forechoandlook/gssh.git
+cd gssh
+go build -o bin/daemon cmd/daemon/main.go
+go build -o bin/gssh cmd/gssh/main.go
+./homebrew/install.sh
+```
+
+### 方式二：直接安装
+
+```bash
+# 克隆项目
+git clone https://github.com/forechoandlook/gssh.git
+cd gssh
+
+# 构建
+go build -o bin/daemon cmd/daemon/main.go
+go build -o bin/gssh cmd/gssh/main.go
+
+# 复制到系统路径
+cp bin/daemon /usr/local/bin/gssh-daemon
+cp bin/gssh /usr/local/bin/gssh
+```
+
+## 服务管理（macOS）
+
+### 使用 launchctl
+
+```bash
+# 启动服务
+launchctl start com.gssh.daemon
+
+# 停止服务
+launchctl stop com.gssh.daemon
+
+# 查看状态
+launchctl list | grep gssh
+
+# 卸载服务
+launchctl unload ~/Library/LaunchAgents/gssh.plist
+rm ~/Library/LaunchAgents/gssh.plist
+```
+
+### 使用 Homebrew services
+
+```bash
+# 启动（首次安装后自动启动）
+brew services start gssh
+
+# 停止
+brew services stop gssh
+
+# 查看状态
+brew services list
+
+# 重启
+brew services restart gssh
+```
+
+### 使用 PM2（跨平台）
+
+```bash
+# 安装 PM2
+npm install -g pm2
+
+# 启动 daemon
+pm2 start gssh-daemon.sh --name gssh
+
+# 保存并设置开机自启
+pm2 save
+pm2 startup
+```
+
+## 使用方法
+
+### 连接 SSH（密码认证）
+
+```bash
+gssh connect -u admin1 -h 139.196.175.163 -p 7080 -P 1234
+```
+
+### 连接 SSH（密钥认证）
+
+```bash
+gssh connect -u admin1 -h example.com -i ~/.ssh/id_rsa
+```
+
+### 执行命令
+
+```bash
+# 使用默认 session
+gssh exec "ls -la"
+
+# 指定 session
+gssh exec -s <session_id> "pwd"
+```
+
+### 端口转发
+
+```bash
+# 本地端口转发：本地 8080 -> 远程 80
+gssh forward -l 8080 -r 80
+```
+
+### Session 管理
+
+```bash
+# 列出所有 session
+gssh list
+
+# 切换默认 session
+gssh use <session_id>
+
+# 断开 session
+gssh disconnect -s <session_id>
+
+# 重连 session
+gssh reconnect -s <session_id>
+```
+
+## 命令行选项
+
+| 选项 | 说明 |
+|------|------|
+| `-socket path` | Unix socket 路径（默认：/tmp/gssh.sock） |
+| `-s session_id` | Session ID |
+| `-u user` | 用户名 |
+| `-h host` | 主机地址 |
+| `-p port` | 端口（默认：22） |
+| `-P password` | 密码 |
+| `-i key_path` | SSH 密钥路径 |
+| `-l local` | 本地端口 |
+| `-r remote` | 远程端口 |
+| `-R` | 远程端口转发 |
+
+## 开发
+
+### 运行测试
+
+```bash
+go test ./...
+```
+
+### 代码结构
+
+- `cmd/daemon/` - daemon 主程序
+- `cmd/gssh/` - CLI 主程序
+- `internal/client/` - SSH 客户端封装
+- `internal/session/` - Session 管理器
+- `internal/portforward/` - 端口转发
+- `internal/protocol/` - 协议类型定义
+- `pkg/rpc/` - RPC 处理器
+- `homebrew/` - Homebrew 安装文件

package/cmd/daemon/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"gssh/internal/session"
+	"gssh/pkg/rpc"
+)
+
+const (
+	defaultSocketPath = "/tmp/gssh.sock"
+)
+
+func main() {
+	socketPath := flag.String("socket", defaultSocketPath, "Unix socket path")
+	flag.Parse()
+
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	log.SetOutput(os.Stderr)
+
+	log.Printf("Starting gssh daemon on %s", *socketPath)
+
+	// Create session manager
+	manager := session.NewManager()
+
+	// Start RPC server
+	go func() {
+		if err := rpc.ServeUnixSocket(manager, *socketPath); err != nil {
+			log.Printf("RPC server error: %v", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Wait for interrupt signal
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	<-sigCh
+
+	log.Println("Shutting down...")
+	os.Remove(*socketPath)
+}

package/cmd/gssh/main.go

@@ -0,0 +1,394 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+
+	"gssh/internal/protocol"
+)
+
+const (
+	defaultSocketPath = "/tmp/gssh.sock"
+)
+
+var (
+	socketPath = flag.String("socket", defaultSocketPath, "Unix socket path")
+)
+
+func main() {
+	flag.Parse()
+
+	if flag.NArg() < 1 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	cmd := flag.Arg(0)
+
+	var err error
+	switch cmd {
+	case "connect":
+		err = handleConnect()
+	case "disconnect":
+		err = handleDisconnect()
+	case "reconnect":
+		err = handleReconnect()
+	case "exec":
+		err = handleExec()
+	case "list", "ls":
+		err = handleList()
+	case "use":
+		err = handleUse()
+	case "forward":
+		err = handleForward()
+	case "forwards":
+		err = handleForwards()
+	case "forward-close":
+		err = handleForwardClose()
+	case "help", "-h", "--help":
+		printUsage()
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown command: %s\n", cmd)
+		printUsage()
+		os.Exit(1)
+	}
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func sendRequest(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)
+	}
+	defer conn.Close()
+
+	paramsJSON, err := json.Marshal(params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal params: %w", err)
+	}
+
+	req := protocol.Request{
+		JSONRPC: "2.0",
+		Method:  method,
+		Params:  paramsJSON,
+		ID:      1,
+	}
+
+	reqData, err := json.Marshal(req)
+	if err != nil {
+		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)
+	if err != nil {
+		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
+	if err := json.Unmarshal(line, &resp); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if resp.Error != nil {
+		return nil, fmt.Errorf("RPC error: %s", resp.Error.Message)
+	}
+
+	result, err := json.Marshal(resp.Result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal result: %w", err)
+	}
+
+	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")
+
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	if *user == "" || *host == "" {
+		return fmt.Errorf("user and host are required")
+	}
+
+	params := protocol.ConnectParams{
+		User:     *user,
+		Host:     *host,
+		Port:     *port,
+		Password: *password,
+		KeyPath:  *keyPath,
+	}
+
+	result, err := sendRequest("connect", params)
+	if err != nil {
+		return err
+	}
+
+	var session protocol.Session
+	if err := json.Unmarshal(result, &session); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	fmt.Printf("Connected: %s@%s (ID: %s)\n", session.User, session.Host, session.ID)
+	return nil
+}
+
+func handleDisconnect() error {
+	sessionID := flag.String("s", "", "Session ID")
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	params := protocol.DisconnectParams{
+		SessionID: *sessionID,
+	}
+
+	_, err := sendRequest("disconnect", params)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Disconnected")
+	return nil
+}
+
+func handleReconnect() error {
+	sessionID := flag.String("s", "", "Session ID")
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	params := protocol.ReconnectParams{
+		SessionID: *sessionID,
+	}
+
+	result, err := sendRequest("reconnect", params)
+	if err != nil {
+		return err
+	}
+
+	var session protocol.Session
+	if err := json.Unmarshal(result, &session); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	fmt.Printf("Reconnected: %s@%s (ID: %s)\n", session.User, session.Host, session.ID)
+	return nil
+}
+
+func handleExec() error {
+	// Get remaining args after "exec"
+	args := flag.Args()[1:]
+
+	sessionID := flag.String("s", "", "Session ID")
+	flag.CommandLine.Parse(args)
+
+	if flag.NArg() < 1 {
+		return fmt.Errorf("command required")
+	}
+	command := strings.Join(flag.Args(), " ")
+
+	params := protocol.ExecParams{
+		SessionID: *sessionID,
+		Command:   command,
+	}
+
+	result, err := sendRequest("exec", params)
+	if err != nil {
+		return err
+	}
+
+	var execResult protocol.ExecResult
+	if err := json.Unmarshal(result, &execResult); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	fmt.Print(execResult.Stdout)
+	if execResult.Stderr != "" {
+		fmt.Fprintf(os.Stderr, "%s", execResult.Stderr)
+	}
+
+	if execResult.ExitCode != 0 {
+		os.Exit(execResult.ExitCode)
+	}
+
+	return nil
+}
+
+func handleList() error {
+	result, err := sendRequest("list", nil)
+	if err != nil {
+		return err
+	}
+
+	var sessions []*protocol.Session
+	if err := json.Unmarshal(result, &sessions); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	if len(sessions) == 0 {
+		fmt.Println("No sessions")
+		return nil
+	}
+
+	fmt.Println("ID                                      HOST              USER    STATUS")
+	for _, s := range sessions {
+		fmt.Printf("%-38s %-17s %-7s %s\n", s.ID, s.Host, s.User, s.Status)
+	}
+
+	return nil
+}
+
+func handleUse() error {
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	if flag.NArg() < 1 {
+		return fmt.Errorf("session ID required")
+	}
+	sessionIDStr := flag.Arg(0)
+
+	params := protocol.UseParams{
+		SessionID: sessionIDStr,
+	}
+
+	_, err := sendRequest("use", params)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Using session: %s\n", sessionIDStr)
+	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")
+
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	if *local == 0 || *remote == 0 {
+		return fmt.Errorf("local and remote ports are required")
+	}
+
+	forwardType := "local"
+	if *isRemote {
+		forwardType = "remote"
+	}
+
+	params := protocol.ForwardParams{
+		SessionID: *sessionID,
+		Type:      forwardType,
+		Local:     *local,
+		Remote:    *remote,
+	}
+
+	result, err := sendRequest("forward", params)
+	if err != nil {
+		return err
+	}
+
+	var forward protocol.Forward
+	if err := json.Unmarshal(result, &forward); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	fmt.Printf("Forward started: %s %d:%d (ID: %s)\n", forward.Type, forward.Local, forward.Remote, forward.ID)
+	return nil
+}
+
+func handleForwards() error {
+	result, err := sendRequest("forwards", nil)
+	if err != nil {
+		return err
+	}
+
+	var forwards []*protocol.Forward
+	if err := json.Unmarshal(result, &forwards); err != nil {
+		return fmt.Errorf("failed to parse result: %w", err)
+	}
+
+	if len(forwards) == 0 {
+		fmt.Println("No forwards")
+		return nil
+	}
+
+	fmt.Println("ID    LOCAL    REMOTE    TYPE")
+	for _, f := range forwards {
+		fmt.Printf("%-5s %-7d %-8d %s\n", f.ID[:8], f.Local, f.Remote, f.Type)
+	}
+
+	return nil
+}
+
+func handleForwardClose() error {
+	flag.CommandLine.Parse(flag.Args()[1:])
+
+	if flag.NArg() < 1 {
+		return fmt.Errorf("forward ID required")
+	}
+	forwardID := flag.Arg(0)
+
+	params := protocol.ForwardCloseParams{
+		ForwardID: forwardID,
+	}
+
+	_, err := sendRequest("forward_close", params)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Forward %s closed\n", forwardID)
+	return nil
+}
+
+func printUsage() {
+	fmt.Println(`gssh - SSH Session Manager for Agents (Stateless)
+
+Usage:
+  gssh connect -u user -h host [-p port] [-i key_path] [-P password]
+  gssh disconnect [-s session_id]
+  gssh reconnect [-s session_id]
+  gssh exec [-s session_id] "command"
+  gssh list
+  gssh use <session_id>
+  gssh forward [-s session_id] -l local_port -r remote_port
+  gssh forwards
+  gssh forward-close <forward_id>
+
+Note: For sudo commands, use key-based authentication or configure passwordless sudo.
+
+Options:
+  -socket path    Unix socket path (default: /tmp/gssh.sock)
+  -s session_id   Session ID
+  -u user         Username
+  -h host         Host
+  -p port         Port (default: 22)
+  -P password     Password
+  -i key_path     SSH key path
+  -l local        Local port
+  -r remote       Remote port
+  -R              Remote port forward`)
+}

package/go.mod

@@ -0,0 +1,10 @@
+module gssh
+
+go 1.21
+
+require (
+	github.com/google/uuid v1.5.0
+	golang.org/x/crypto v0.18.0
+)
+
+require golang.org/x/sys v0.16.0 // indirect

package/go.sum

@@ -0,0 +1,8 @@
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=

package/homebrew/gssh.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.gssh.daemon</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/gssh-daemon</string>
+        <string>-socket</string>
+        <string>/tmp/gssh.sock</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>/var/log/gssh.log</string>
+    <key>StandardErrorPath</key>
+    <string>/var/log/gssh.error.log</string>
+</dict>
+</plist>

package/homebrew/install.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# gssh service installation script
+
+set -e
+
+# Detect architecture
+ARCH=$(uname -m)
+if [ "$ARCH" = "arm64" ]; then
+    PREFIX="/opt/homebrew"
+else
+    PREFIX="/usr/local"
+fi
+
+DAEMON_BIN="$PREFIX/bin/gssh-daemon"
+CLI_BIN="$PREFIX/bin/gssh"
+
+echo "Installing gssh to $PREFIX/bin/..."
+
+# Copy binaries
+cp bin/daemon "$DAEMON_BIN"
+cp bin/gssh "$CLI_BIN"
+
+chmod +x "$DAEMON_BIN" "$CLI_BIN"
+
+# Install launchd plist
+PLIST_DIR="$HOME/Library/LaunchAgents"
+mkdir -p "$PLIST_DIR"
+cp homebrew/gssh.plist "$PLIST_DIR/"
+
+echo "Loading gssh service..."
+launchctl load "$PLIST_DIR/gssh.plist"
+
+echo "gssh installed successfully!"
+echo ""
+echo "Usage:"
+echo "  Start:   launchctl start com.gssh.daemon"
+echo "  Stop:    launchctl stop com.gssh.daemon"
+echo "  Status:  launchctl list | grep gssh"
+echo ""
+echo "Or use Homebrew services:"
+echo "  brew services start gssh"
+echo "  brew services stop gssh"
+echo "  brew services list"