magic-agent 1.0.3 → 1.0.49

package/internal/client/plugins_test.go

@@ -0,0 +1,223 @@
+package client
+
+import (
+	"bufio"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+/* 插件目录（发现页的「插件」）：
+ *  ① 清单只从服务端那张表里来，客户端传什么都在表里找；
+ *  ② 安装动作只跑表里写死的 argv，**不接受客户端传命令**；
+ *  ③ 状态如实：没装就说没装，失败把退出码与 stderr 一起回。 */
+
+// fakePluginRepo 造一个「源码目录 + 两个假 CLI」的临时环境。
+// 假 CLI 是 shell 脚本：安装那一刻才被 `go test` 之外的东西创建出来 —— 这里由 npm/git 桩创建。
+func fakePluginRepo(t *testing.T) (repo string, binDir string) {
+	t.Helper()
+	root := t.TempDir()
+	repo = filepath.Join(root, "magic-shorts")
+	binDir = filepath.Join(root, "bin")
+	for _, d := range []string{repo, binDir} {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(filepath.Join(repo, "package.json"), []byte(`{"name":"magic-shorts","version":"9.9.9"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("MAGIC_CLIENT_SHORTS_DIR", repo)
+	t.Setenv("MAGIC_CLIENT_VIDEO_DIR", filepath.Join(root, "magic-video"))
+	t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	return repo, binDir
+}
+
+func pluginService() *Service { return &Service{opts: Options{}} }
+
+func TestPluginsListsCatalog(t *testing.T) {
+	fakePluginRepo(t)
+	rec := httptest.NewRecorder()
+	pluginService().handlePlugins(rec, httptest.NewRequest(http.MethodGet, "/desk/plugins", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("状态码 = %d，期望 200", rec.Code)
+	}
+	var body struct {
+		Plugins []pluginInfo `json:"plugins"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("响应不是合法 JSON：%v（%s）", err, rec.Body.String())
+	}
+	if len(body.Plugins) != 2 {
+		t.Fatalf("插件数 = %d，期望 2（magic-shorts / magic-video）", len(body.Plugins))
+	}
+	byID := map[string]pluginInfo{}
+	for _, p := range body.Plugins {
+		byID[p.ID] = p
+	}
+	shorts, ok := byID["magic-shorts"]
+	if !ok {
+		t.Fatal("清单里没有 magic-shorts")
+	}
+	// 路径上还没有那个 CLI → 必须如实说没装，而不是给一个看起来成功的空壳
+	if shorts.Installed {
+		t.Fatal("PATH 上没有 magic-shorts 时 Installed 应为 false")
+	}
+	if !shorts.SourceExists {
+		t.Fatal("源码目录存在时 SourceExists 应为 true")
+	}
+	if !strings.Contains(shorts.Install, "npm install -g") {
+		t.Fatalf("安装命令缺失或形状不对：%q", shorts.Install)
+	}
+	if shorts.Tagline == "" || shorts.Description == "" || len(shorts.Examples) == 0 {
+		t.Fatal("介绍三件套（一句话简介 / 详细说明 / 示例）不能空 —— 发现页要展示它们")
+	}
+	if !strings.Contains(shorts.UsePrompt, "magic-shorts") {
+		t.Fatal("让它干活的预填提示里要点名 CLI，否则 Agent 不知道用哪个")
+	}
+	video := byID["magic-video"]
+	if !strings.Contains(video.Install, "@magicstock/magic-cli") {
+		t.Fatalf("magic-video 的安装命令应装 npm 包 @magicstock/magic-cli：%q", video.Install)
+	}
+}
+
+// 版本号从可执行文件所属 npm 包的 package.json 读（不跑 --version：magic-video 不认这个 flag）。
+func TestPluginVersionFromPackageJSON(t *testing.T) {
+	_, binDir := fakePluginRepo(t)
+	pkgDir := filepath.Join(filepath.Dir(binDir), "lib", "node_modules", "magic-shorts")
+	if err := os.MkdirAll(pkgDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(pkgDir, "package.json"), []byte(`{"name":"magic-shorts","version":"1.2.3"}`), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	bin := filepath.Join(pkgDir, "bin", "magic-shorts.js")
+	if err := os.MkdirAll(filepath.Dir(bin), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(bin, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if got := versionNearBin(bin); got != "1.2.3" {
+		t.Fatalf("版本 = %q，期望 1.2.3", got)
+	}
+	if err := os.WriteFile(filepath.Join(pkgDir, "package.json"), []byte("not json"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if got := versionNearBin(bin); got != "" {
+		t.Fatalf("坏 package.json 应回空串，实际 %q", got)
+	}
+}
+
+// 安装动作：只跑表里那几条 argv（这里用桩 npm 顶替），并把输出按行流回去。
+func TestPluginInstallStreamsAndRefreshes(t *testing.T) {
+	repo, binDir := fakePluginRepo(t)
+	// 桩 npm：把自己收到的参数写成一行输出，并在「成功」时把假 CLI 放进 PATH ——
+	// 于是「跑完重新探测」这条链真的会翻成 installed=true，而不是靠测试自己断言。
+	npm := filepath.Join(binDir, "npm")
+	script := `#!/bin/sh
+echo "npm $*"
+case "$*" in
+  *install*) printf '#!/bin/sh\nexit 0\n' > ` + filepath.Join(binDir, "magic-shorts") + `; chmod +x ` + filepath.Join(binDir, "magic-shorts") + ` ;;
+esac
+exit 0
+`
+	if err := os.WriteFile(npm, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	// python3 桩：pip 那一步不该真的装东西
+	py := filepath.Join(binDir, "python3")
+	if err := os.WriteFile(py, []byte("#!/bin/sh\necho \"pip $*\"\nexit 0\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	rec := httptest.NewRecorder()
+	pluginService().handlePluginAction(rec,
+		httptest.NewRequest(http.MethodPost, "/desk/plugins/magic-shorts/install", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("状态码 = %d，期望 200（SSE）：%s", rec.Code, rec.Body.String())
+	}
+	if ct := rec.Header().Get("Content-Type"); !strings.Contains(ct, "text/event-stream") {
+		t.Fatalf("Content-Type = %q，期望 SSE", ct)
+	}
+
+	// 解析 SSE：按 event 名归集 data
+	events := map[string][]string{}
+	var cur string
+	sc := bufio.NewScanner(strings.NewReader(rec.Body.String()))
+	for sc.Scan() {
+		line := sc.Text()
+		switch {
+		case strings.HasPrefix(line, "event: "):
+			cur = strings.TrimPrefix(line, "event: ")
+		case strings.HasPrefix(line, "data: "):
+			events[cur] = append(events[cur], strings.TrimPrefix(line, "data: "))
+		}
+	}
+	if len(events["open"]) != 1 {
+		t.Fatalf("应先发一条 open（告诉客户端要跑什么），实际 %v", events)
+	}
+	var open struct {
+		Commands []string `json:"commands"`
+	}
+	_ = json.Unmarshal([]byte(events["open"][0]), &open)
+	if len(open.Commands) != 2 || !strings.Contains(open.Commands[0], "npm") {
+		t.Fatalf("open.commands = %v，期望两条（npm 安装 + pip -e）", open.Commands)
+	}
+	if !strings.Contains(strings.Join(events["line"], "\n"), "npm install -g "+repo) {
+		t.Fatalf("安装输出没有流回客户端：%v", events["line"])
+	}
+	if len(events["end"]) != 1 {
+		t.Fatalf("必须恰好一条 end 收尾，实际 %d", len(events["end"]))
+	}
+	var end struct {
+		OK     bool       `json:"ok"`
+		Plugin pluginInfo `json:"plugin"`
+	}
+	_ = json.Unmarshal([]byte(events["end"][0]), &end)
+	if !end.OK {
+		t.Fatalf("安装成功却回了 ok=false：%s", events["end"][0])
+	}
+	if !end.Plugin.Installed {
+		t.Fatalf("跑完应重新探测到已安装（end.plugin.installed 仍为 false）：%s", events["end"][0])
+	}
+}
+
+// 未知 id / 未知动作一律 404，且**没有任何命令被执行** —— 这条接口不能变成任意命令执行器。
+func TestPluginActionRejectsUnknown(t *testing.T) {
+	fakePluginRepo(t)
+	for _, target := range []string{
+		"/desk/plugins/rm-rf/install",
+		"/desk/plugins/magic-shorts/run",
+		"/desk/plugins/magic-shorts",
+	} {
+		rec := httptest.NewRecorder()
+		pluginService().handlePluginAction(rec, httptest.NewRequest(http.MethodPost, target, nil))
+		if rec.Code != http.StatusNotFound {
+			t.Fatalf("%s 状态码 = %d，期望 404", target, rec.Code)
+		}
+	}
+}
+
+// 失败的安装：退出码 + 错误要回给客户端，end.ok=false（不能静默当成功）。
+func TestPluginInstallFailureReported(t *testing.T) {
+	_, binDir := fakePluginRepo(t)
+	npm := filepath.Join(binDir, "npm")
+	if err := os.WriteFile(npm, []byte("#!/bin/sh\necho 'EACCES: permission denied' >&2\nexit 3\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	rec := httptest.NewRecorder()
+	pluginService().handlePluginAction(rec,
+		httptest.NewRequest(http.MethodPost, "/desk/plugins/magic-shorts/install", nil))
+	body := rec.Body.String()
+	if !strings.Contains(body, "EACCES: permission denied") {
+		t.Fatalf("stderr 没有流回客户端：%s", body)
+	}
+	if !strings.Contains(body, `"ok":false`) {
+		t.Fatalf("失败应以 ok=false 收尾：%s", body)
+	}
+}

package/internal/client/proxy.go

@@ -0,0 +1,374 @@
+package client
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"time"
+)
+
+/* 极简 SOCKS5 服务：给移动端 VPN 隧道核心（TUN → SOCKS5）做**出口**。
+ *
+ * ── 为什么是 SOCKS5 ──
+ * 主流隧道内核（hev-socks5-tunnel / tun2socks 等）说的都是 SOCKS5，且都支持
+ * RFC 1929 用户名口令认证 —— 令牌正好塞在这里，不用自己发明协议。
+ *
+ * ── 范围 ──
+ * 只实现 CONNECT（TCP）+ 用户名口令认证。浏览器绝大多数请求走 TCP；
+ * UDP ASSOCIATE（QUIC/HTTP3）暂不支持，缺了它浏览器会自动退回 TCP(H2)，不影响可用性。
+ * 需要时再补 UDP，别一上来就把复杂度拉满。
+ *
+ * ── 安全 ──
+ * 这是个**开放出口**：能连到它的人就能借这台机器上网。所以必须绑在受控网络上，
+ * 且口令（= 服务令牌）是唯一门锁；没配令牌时只允许回环，绝不对局域网裸奔。
+ */
+
+const (
+	socksVersion     = 0x05
+	socksAuthNone    = 0x00
+	socksAuthUserPw  = 0x02
+	socksAuthNoOK    = 0x01
+	socksCmdConnect  = 0x01
+	socksCmdUDPAssoc = 0x03
+	socksATYPIPv4    = 0x01
+	socksATYPDomain  = 0x03
+	socksATYPIPv6    = 0x04
+)
+
+// ServeProxy 在 ln 上跑 SOCKS5 服务，阻塞直到监听器出错。
+func (s *Service) ServeProxy(ln net.Listener) error {
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			return err
+		}
+		go func() {
+			defer conn.Close()
+			if err := s.serveSOCKS5(conn); err != nil {
+				s.log.Printf("socks5: %v", err)
+			}
+		}()
+	}
+}
+
+func (s *Service) serveSOCKS5(conn net.Conn) error {
+	_ = conn.SetDeadline(time.Now().Add(30 * time.Second))
+
+	// ── 协商：必须有「用户名口令」这一项；一个方法都不能给的客户端直接拒。 ──
+	head := make([]byte, 2)
+	if _, err := io.ReadFull(conn, head); err != nil {
+		return err
+	}
+	if head[0] != socksVersion {
+		return fmt.Errorf("非 SOCKS5 版本：%d", head[0])
+	}
+	methods := make([]byte, int(head[1]))
+	if _, err := io.ReadFull(conn, methods); err != nil {
+		return err
+	}
+	if !hasByte(methods, socksAuthUserPw) {
+		_, _ = conn.Write([]byte{socksVersion, 0xFF})
+		return fmt.Errorf("客户端不支持用户名口令认证")
+	}
+	if _, err := conn.Write([]byte{socksVersion, socksAuthUserPw}); err != nil {
+		return err
+	}
+
+	// ── 认证（RFC 1929）：口令即服务令牌。 ──
+	if err := s.socksAuth(conn); err != nil {
+		return err
+	}
+
+	// ── 请求：CONNECT（TCP）或 UDP ASSOCIATE（DNS / QUIC 等 UDP 流量）。 ──
+	req := make([]byte, 4)
+	if _, err := io.ReadFull(conn, req); err != nil {
+		return err
+	}
+	if req[0] != socksVersion {
+		return fmt.Errorf("版本不对：%d", req[0])
+	}
+	host, err := readSOCKSAddr(conn, req[3])
+	if err != nil {
+		return err
+	}
+	portBuf := make([]byte, 2)
+	if _, err := io.ReadFull(conn, portBuf); err != nil {
+		return err
+	}
+	target := net.JoinHostPort(host, fmt.Sprint(binary.BigEndian.Uint16(portBuf)))
+
+	switch req[1] {
+	case socksCmdConnect:
+		return s.serveConnect(conn, target)
+	case socksCmdUDPAssoc:
+		return s.serveUDPAssociate(conn)
+	default:
+		_, _ = conn.Write([]byte{socksVersion, 0x07, 0x00, socksATYPIPv4, 0, 0, 0, 0, 0, 0})
+		return fmt.Errorf("不支持的命令：%d", req[1])
+	}
+}
+
+// serveConnect 处理 CONNECT：连目标并双向搬运字节。
+func (s *Service) serveConnect(conn net.Conn, target string) error {
+	upstream, err := net.DialTimeout("tcp", target, 20*time.Second)
+	if err != nil {
+		_, _ = conn.Write([]byte{socksVersion, 0x05, 0x00, socksATYPIPv4, 0, 0, 0, 0, 0, 0})
+		return fmt.Errorf("连 %s 失败：%w", target, err)
+	}
+	defer upstream.Close()
+
+	if _, err := conn.Write([]byte{socksVersion, 0x00, 0x00, socksATYPIPv4, 0, 0, 0, 0, 0, 0}); err != nil {
+		return err
+	}
+
+	// 握手完成，此后是纯字节搬运（隧道里可能是 TLS，我们不看不碰）。
+	_ = conn.SetDeadline(time.Time{})
+	done := make(chan struct{}, 2)
+	go func() { _, _ = io.Copy(upstream, conn); done <- struct{}{} }()
+	go func() { _, _ = io.Copy(conn, upstream); done <- struct{}{} }()
+	<-done
+	return nil
+}
+
+/* serveUDPAssociate 处理 UDP ASSOCIATE。
+ *
+ * 这条不能省：VPN 一旦接管默认路由，**DNS 查询（UDP 53）也进了隧道**。
+ * 没有 UDP，手机上任何域名都解析不了 —— 表现是「网页打不开、但 ping IP 通」。
+ *
+ * 协议：TCP 控制连接先回一个「UDP 中继端点」，此后客户端把每个数据报按
+ * RSV(2) FRAG(1) ATYP ADDR PORT DATA 的格式发到这个端点，我们解包后转发，
+ * 收到回包再按同样格式包回去。控制连接断开即撤销。
+ */
+func (s *Service) serveUDPAssociate(conn net.Conn) error {
+	udp, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
+	if err != nil {
+		return err
+	}
+	defer udp.Close()
+
+	// 把中继端点告诉客户端（用它自己命中的那个本机地址，别报 0.0.0.0）。
+	tcpLocal, _ := conn.LocalAddr().(*net.TCPAddr)
+	ip4 := net.IPv4zero
+	if tcpLocal != nil && tcpLocal.IP.To4() != nil {
+		ip4 = tcpLocal.IP.To4()
+	}
+	port := uint16(udp.LocalAddr().(*net.UDPAddr).Port)
+	reply := []byte{socksVersion, 0x00, 0x00, socksATYPIPv4}
+	reply = append(reply, ip4...)
+	reply = append(reply, byte(port>>8), byte(port))
+	if _, err := conn.Write(reply); err != nil {
+		return err
+	}
+
+	// 控制连接断开 = 撤销这个 UDP 关联。
+	go func() {
+		_, _ = io.Copy(io.Discard, conn)
+		_ = udp.Close()
+	}()
+	_ = conn.SetDeadline(time.Time{})
+
+	var client *net.UDPAddr
+	flows := map[string]*net.UDPConn{} // 目标 → 出站 UDP 连接（复用，别每个包都新建）
+	defer func() {
+		for _, c := range flows {
+			_ = c.Close()
+		}
+	}()
+
+	buf := make([]byte, 65535)
+	for {
+		n, from, err := udp.ReadFromUDP(buf)
+		if err != nil {
+			return err
+		}
+		// 只服务控制连接对端发来的包，避免本机其它进程蹭这条出口。
+		if client == nil {
+			client = from
+		}
+		if !from.IP.Equal(client.IP) {
+			continue
+		}
+
+		dstAddr, payload, ok := parseSocksUDP(buf[:n])
+		if !ok {
+			continue
+		}
+		key := dstAddr.String()
+		out, ok := flows[key]
+		if !ok {
+			out, err = net.DialUDP("udp", nil, dstAddr)
+			if err != nil {
+				continue
+			}
+			flows[key] = out
+			go func(out *net.UDPConn, dst *net.UDPAddr) {
+				rb := make([]byte, 65535)
+				for {
+					_ = out.SetReadDeadline(time.Now().Add(120 * time.Second))
+					rn, rerr := out.Read(rb)
+					if rerr != nil {
+						return
+					}
+					pkt := buildSocksUDP(dst, rb[:rn])
+					if client != nil {
+						_, _ = udp.WriteToUDP(pkt, client)
+					}
+				}
+			}(out, dstAddr)
+		}
+		_, _ = out.Write(payload)
+	}
+}
+
+// parseSocksUDP 解 SOCKS5 UDP 请求头：RSV(2) FRAG(1) ATYP ADDR PORT DATA。
+func parseSocksUDP(pkt []byte) (*net.UDPAddr, []byte, bool) {
+	if len(pkt) < 4 {
+		return nil, nil, false
+	}
+	if pkt[2] != 0x00 { // 不支持分片
+		return nil, nil, false
+	}
+	atyp := pkt[3]
+	i := 4
+	var host string
+	switch atyp {
+	case socksATYPIPv4:
+		if len(pkt) < i+4 {
+			return nil, nil, false
+		}
+		host = net.IP(pkt[i : i+4]).String()
+		i += 4
+	case socksATYPIPv6:
+		if len(pkt) < i+16 {
+			return nil, nil, false
+		}
+		host = net.IP(pkt[i : i+16]).String()
+		i += 16
+	case socksATYPDomain:
+		if len(pkt) < i+1 {
+			return nil, nil, false
+		}
+		l := int(pkt[i])
+		i++
+		if len(pkt) < i+l {
+			return nil, nil, false
+		}
+		host = string(pkt[i : i+l])
+		i += l
+	default:
+		return nil, nil, false
+	}
+	if len(pkt) < i+2 {
+		return nil, nil, false
+	}
+	port := binary.BigEndian.Uint16(pkt[i : i+2])
+	i += 2
+	addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(host, fmt.Sprint(port)))
+	if err != nil {
+		return nil, nil, false
+	}
+	return addr, pkt[i:], true
+}
+
+// buildSocksUDP 把回包按 SOCKS5 UDP 格式包好（源地址即回包来源）。
+func buildSocksUDP(from *net.UDPAddr, payload []byte) []byte {
+	out := []byte{0x00, 0x00, 0x00}
+	if ip4 := from.IP.To4(); ip4 != nil {
+		out = append(out, socksATYPIPv4)
+		out = append(out, ip4...)
+	} else {
+		out = append(out, socksATYPIPv6)
+		out = append(out, from.IP.To16()...)
+	}
+	out = append(out, byte(from.Port>>8), byte(from.Port))
+	return append(out, payload...)
+}
+
+func (s *Service) socksAuth(conn net.Conn) error {
+	// RFC 1929：ver(1) 后跟「用户名(len+data)」，再跟「口令(len+data)」。
+	// ⚠️ 这里只能读 1 个字节 —— 把版本和用户名长度一起读会整体错位一个字节，
+	// 表现为握手挂死到超时。
+	ver := make([]byte, 1)
+	if _, err := io.ReadFull(conn, ver); err != nil {
+		return err
+	}
+	if ver[0] != 0x01 {
+		return fmt.Errorf("认证版本不对：%d", ver[0])
+	}
+	user, err := readLenPrefixed(conn)
+	if err != nil {
+		return err
+	}
+	pass, err := readLenPrefixed(conn)
+	if err != nil {
+		return err
+	}
+	want := s.opts.Token
+	if want == "" {
+		// 没配令牌只允许回环 —— 绝不把开放出口暴露到局域网。
+		if !isLoopback(conn.RemoteAddr()) {
+			_, _ = conn.Write([]byte{0x01, socksAuthNoOK})
+			return fmt.Errorf("未配置令牌，且来源非回环：%s", conn.RemoteAddr())
+		}
+	} else if pass != want {
+		_, _ = conn.Write([]byte{0x01, socksAuthNoOK})
+		return fmt.Errorf("口令错误（user=%q）", user)
+	}
+	_, err = conn.Write([]byte{0x01, 0x00})
+	return err
+}
+
+func readSOCKSAddr(conn net.Conn, atyp byte) (string, error) {
+	switch atyp {
+	case socksATYPIPv4:
+		b := make([]byte, 4)
+		if _, err := io.ReadFull(conn, b); err != nil {
+			return "", err
+		}
+		return net.IP(b).String(), nil
+	case socksATYPIPv6:
+		b := make([]byte, 16)
+		if _, err := io.ReadFull(conn, b); err != nil {
+			return "", err
+		}
+		return net.IP(b).String(), nil
+	case socksATYPDomain:
+		return readLenPrefixed(conn)
+	default:
+		return "", fmt.Errorf("未知地址类型：%d", atyp)
+	}
+}
+
+func readLenPrefixed(r io.Reader) (string, error) {
+	n := make([]byte, 1)
+	if _, err := io.ReadFull(r, n); err != nil {
+		return "", err
+	}
+	b := make([]byte, int(n[0]))
+	if _, err := io.ReadFull(r, b); err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+func hasByte(b []byte, want byte) bool {
+	for _, x := range b {
+		if x == want {
+			return true
+		}
+	}
+	return false
+}
+
+func isLoopback(addr net.Addr) bool {
+	if addr == nil {
+		return false
+	}
+	host, _, err := net.SplitHostPort(addr.String())
+	if err != nil {
+		return false
+	}
+	ip := net.ParseIP(host)
+	return ip != nil && ip.IsLoopback()
+}