magic-agent 2.4.3 → 2.6.3

package/internal/client/scripts_decode_implausible.go

@@ -0,0 +1,38 @@
+package client
+
+// scripts_decode_implausible.go - 「解码结果像不像乱码」的判定，**全平台共用一份**。
+//
+// 只保留 !windows 时会怎样：scripts_decode_windows.go 里调用了它却没定义，
+// Windows 目标直接编译不过（`undefined: hasImplausibleRune`）——
+// 2026-10-26 打 2.6.1 时 win32-x64 就是这个错误挂掉的（另外 4 个目标照常出包，
+// 很容易被「完成 4/5」这句糊过去）。
+//
+// 非 Windows 的解码路径本身不走它（UTF-8 解不出就原样保留字节，见
+// scripts_decode_other.go），但 scripts_decode_test.go 不分平台编译、要引用它，
+// 所以两个平台都得有这个符号。判定逻辑只有这一份，不要再往平台文件里抄第二份。
+
+import "unicode/utf8"
+
+// hasImplausibleRune 报告文本里有没有「控制台输出里不会出现」的字符。
+//
+// 这些字符是「字节编码猜错」的典型产物：GBK 字节被当 UTF-8 解会冒出
+// 西里尔文（һ）、希伯来文、中文全角标点残留等。
+func hasImplausibleRune(s string) bool {
+	for _, r := range s {
+		switch {
+		case r == utf8.RuneError: // 替换符：解码失败过
+			return true
+		case r < 0x20 && r != '\t' && r != '\n' && r != '\r':
+			return true // 控制符
+		case r >= 0x80 && r <= 0x9F:
+			return true // C1 控制区
+		case r >= 0xE000 && r <= 0xF8FF:
+			return true // 私用区
+		case r >= 0x0370 && r <= 0x04FF:
+			return true // 希腊文 + 西里尔文
+		case r >= 0x0590 && r <= 0x08FF:
+			return true // 希伯来文 / 阿拉伯文 / 叙利亚文 / 塔安文
+		}
+	}
+	return false
+}

package/internal/client/scripts_decode_other.go

@@ -0,0 +1,31 @@
+//go:build !windows
+
+package client
+
+// scripts_decode_other.go - 非 Windows 平台脚本输出的解码。
+//
+// unix 上没有「控制台代码页」这回事：脚本往管道写的就是**原始字节**，
+// 绝大多数工具写 UTF-8，少量老工具写 Latin-1。按 UTF-8 解是唯一合理口径；
+// 解不出就按字节保留（不猜别的编码 —— 猜错比乱码更难查）。
+
+import "unicode/utf8"
+
+// decodeScriptBytes 把脚本输出的一行字节解成文本。
+func decodeScriptBytes(b []byte) string {
+	if len(b) == 0 {
+		return ""
+	}
+	if utf8.Valid(b) {
+		return string(b)
+	}
+	return string(b)
+}
+
+// encodeACP 非 Windows 平台不需要按代码页编码（unix 上就是原始字节）。
+func encodeACP(s string, cp uint32) ([]byte, bool) {
+	return []byte(s), true
+}
+
+// scriptCodePage 非 Windows 平台没有「控制台代码页」：UTF-8（65001）就是它。
+// 单独存在的理由是 scripts_decode_test.go 会引用它（测试文件不分平台编译）。
+func scriptCodePage() uint32 { return 65001 }

package/internal/client/scripts_decode_test.go

@@ -0,0 +1,130 @@
+package client
+
+import (
+	"runtime"
+	"testing"
+	"unicode/utf8"
+)
+
+/* 脚本输出的解码（Windows 上是**控制台代码页**，不是 UTF-8 —— 见
+ * scripts_decode_windows.go 的说明）。
+ *
+ * 这一组测试钉住三件事：
+ *   ① UTF-8 输出原样通过（node / python / go 写的 stdout）；
+ *   ② 代码页输出能正确还原（中文 Windows 上 .cmd/.bat 的常态）；
+ *   ③ **GBK 字节碰巧是合法 UTF-8** 时不能误判（这是纯 utf8.Valid 判不出的
+ *      情况 —— 「第一行」的 GBK 字节解成 UTF-8 是「һһࠀ」，看着像乱码但
+ *      utf8.Valid 返回 true）。 */
+
+func TestDecodeScriptBytesKeepsUTF8(t *testing.T) {
+	in := "hello 世界 · 正常输出"
+	if got := decodeScriptBytes([]byte(in)); got != in {
+		t.Fatalf("UTF-8 输出被改动了：%q != %q", got, in)
+	}
+}
+
+func TestDecodeScriptBytesRoundTripCodePage(t *testing.T) {
+	for _, in := range []string{"第一行", "中文", "hello", "混合 mixed 内容 123"} {
+		in := in
+		t.Run(in, func(t *testing.T) {
+			// 「代码页」只存在于 Windows；unix 上 encodeACP 就是原始字节，往返没有意义。
+			// 按用例跳过而不是整函数跳过：非 Windows 编译时才算这个函数（否则 vet 报未定义）。
+			if runtime.GOOS != "windows" {
+				t.Skip("只有 Windows 才有控制台代码页这回事")
+			}
+			enc, ok := encodeACP(in, scriptCodePage())
+			if !ok {
+				t.Fatalf("按代码页编码 %q 失败", in)
+			}
+			got := decodeScriptBytes(enc)
+			if got != in {
+				t.Fatalf("代码页往返不对：%q != %q（字节 % x）", got, in, enc)
+			}
+		})
+	}
+}
+
+// TestDecodeScriptBytesDetectsGBKAsUTF8 钉住那个「判别不出来」的坑：
+//
+// 单个汉字的 GBK 字节**常常**是合法 UTF-8 ——
+// 「一」的 GBK 字节是 d2 bb，按 UTF-8 解是西里尔文「һ」（U+04BB）。
+// utf8.Valid 返回 true，所以**只靠 utf8.Valid 判不出编码**，
+// 必须同时看「解出来的文本里有没有不像话字符」。
+//
+// （实测：本机代码页 936 下，「一」「专」「业」「丫」等都是这种。）
+func TestDecodeScriptBytesDetectsGBKAsUTF8(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("只有 Windows 才有控制台代码页这回事")
+	}
+	// 「一」在这个代码页下的 GBK 字节恰好是合法 UTF-8（前提）。
+	enc, ok := encodeACP("一", scriptCodePage())
+	if !ok {
+		t.Fatal("编码失败")
+	}
+	if !utf8.Valid(enc) {
+		t.Skip("当前系统的代码页下这个字节恰好不是合法 UTF-8，本用例的前提不成立")
+	}
+	// 但按 UTF-8 解出来的文本里应该有「不像话字符」——
+	// 这正是解码器据以下判断的依据。
+	if !hasImplausibleRune(string(enc)) {
+		t.Skip("这串字节按 UTF-8 解出来没有异常字符，本用例的前提不成立")
+	}
+	// 解码器必须绕过 UTF-8 那条路，落到代码页上。
+	if got := decodeScriptBytes(enc); got != "一" {
+		t.Fatalf("解码结果 = %q，期望 %q", got, "一")
+	}
+}
+
+// TestDecodeScriptBytesCodePageLine 钉住整行的情形：
+// 中文 Windows 上 .cmd 的一整行输出，多半是「ASCII + 若干双字节字符」，
+// 整串通常不是合法 UTF-8 —— 但**不能只靠这一条**（上一条用例证明了
+// 单个汉字就能是合法的）。两件事都要成立才算对。
+func TestDecodeScriptBytesCodePageLine(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("只有 Windows 才有控制台代码页这回事")
+	}
+	for _, in := range []string{
+		"第一行",
+		"INFO 启动完成",
+		"总计 3 项",
+		"路径 D:\\work\\x",
+	} {
+		enc, ok := encodeACP(in, scriptCodePage())
+		if !ok {
+			t.Fatalf("编码 %q 失败", in)
+		}
+		if got := decodeScriptBytes(enc); got != in {
+			t.Fatalf("解码结果 = %q，期望 %q", got, in)
+		}
+	}
+}
+
+func TestHasImplausibleRune(t *testing.T) {
+	// 正常输出不该被判成乱码。
+	for _, s := range []string{
+		"hello world",
+		"第一行",
+		"路径 D:\\workspace\\magic-agent",
+		"2026-10-24 12:00:00 INFO 启动完成",
+		"总计 3 项，耗时 1.2s",
+	} {
+		if hasImplausibleRune(s) {
+			t.Errorf("正常文本被误判成乱码：%q", s)
+		}
+	}
+	// 这些是「编码猜错」的典型产物，必须被判出来。
+	for _, s := range []string{
+		"\uFFFD", // 替换符
+		"\u04BB", // 西里尔文（GBK 字节被当 UTF-8 解的产物）
+		"\u0400", // 西里尔文
+		"\u05D0", // 希伯来文
+		"\u0600", // 阿拉伯文
+		"\uE000", // 私用区
+		"\u0007", // 控制符（BEL）
+		"\u0085", // C1 控制区
+	} {
+		if !hasImplausibleRune(s) {
+			t.Errorf("乱码字符没被识别：%q", s)
+		}
+	}
+}

package/internal/client/scripts_decode_windows.go

@@ -0,0 +1,182 @@
+//go:build windows
+
+package client
+
+// scripts_decode_windows.go - Windows 上脚本输出的**字节 → 文本**解码。
+//
+// ## 为什么需要这一层（实测，2026-10-24）
+//
+// Windows 的控制台有**代码页**（codepage）概念，中文系统默认 936（GBK）。
+// cmd.exe / PowerShell 往管道写文本时，编码的是**代码页**，不是 UTF-8：
+//
+//	GBK 编码的 .cmd 里 echo 中文 → 管道里是 d6 d0 ce c4（4 字节）
+//	UTF-8 编码的 .cmd 里 echo 中文 → 管道里是 e4 b8 ad e6 96 87（6 字节）
+//
+// 服务端若一律按 UTF-8 解，日志区就是一串乱码 —— 用户看到一堆看不懂的字符，
+// 还以为脚本坏了。
+//
+// ## 为什么不能一律按代码页解
+//
+// 现在越来越多的工具（node / python / go）**直接写 UTF-8 字节**到 stdout，
+// 不经过控制台编码。那种脚本按 GBK 解就反过来会坏（经典 mojibake：
+// 「中文」解成「涓」）。
+//
+// ## 判据：UTF-8 自校验 + 「不像话字符」排查
+//
+// UTF-8 是自校验的，合法字节序列解出来的文本一定是可信的 —— **但反过来不成立**：
+// GBK 字节常常**碰巧**是合法 UTF-8。实测「第一行」的 GBK 字节
+// （b5 da d2 bb d0 d0）解成 UTF-8 是「һһࠀ」—— 看着像乱码，但 utf8.Valid
+// 返回 true。**只靠 utf8.Valid 判不出编码**，这是本文件的核心难点。
+//
+// 所以判据是两条一起看：
+//
+//  1. 字节是合法 UTF-8；**且**
+//  2. 解出来的文本里**没有「不像话字符」**（见 implausibleRune）。
+//
+// 「不像话字符」= 控制符 / 替换符 / 私用区 / 希腊文 / 西里尔文 / 希伯来文 /
+// 阿拉伯文 —— 这些字符**不会出现在控制台输出里**，但**恰好**是 GBK 字节被
+// 当 UTF-8 解时的典型产物（上面那个「һ」就是西里尔文 U+04BB）。
+//
+// 两条都满足 → 按 UTF-8；否则 → 按控制台代码页解。
+//
+// ## 诚实边界
+//
+// 这仍是**启发式**，不是万能检测：
+//
+//   - 脚本输出真的含希腊文/西里尔文时，会被误判成代码页（少见，可接受）。
+//   - 同一行里 UTF-8 与 GBK 混排（几乎不可能出现）不处理。
+//
+// 但它覆盖了真实场景的两个大头（中文 Windows 上的 .cmd/.bat/.ps1 走代码页；
+// node/python 工具走 UTF-8），而且**不会崩、不会丢内容** —— 解不出来时保留
+// 原始字节，好过乱码或空串。
+
+import (
+	"errors"
+	"syscall"
+	"unicode/utf8"
+	"unsafe"
+)
+
+var (
+	kernel32                = syscall.NewLazyDLL("kernel32.dll")
+	procGetACP              = kernel32.NewProc("GetACP")
+	procMultiByteToWideChar = kernel32.NewProc("MultiByteToWideChar")
+	procWideCharToMultiByte = kernel32.NewProc("WideCharToMultiByte")
+)
+
+// scriptCodePage 当前系统的 ANSI 代码页（936=GBK / 1252=西欧 / 65001=UTF-8）。
+func scriptCodePage() uint32 {
+	r, _, _ := procGetACP.Call()
+	cp := uint32(r)
+	if cp == 0 {
+		cp = 1252 // 兜底：拿不到就用西欧，宁可显示成问号也别崩
+	}
+	return cp
+}
+
+// decodeScriptBytes 把脚本输出的一行字节解成文本。
+func decodeScriptBytes(b []byte) string {
+	if len(b) == 0 {
+		return ""
+	}
+	// 先试 UTF-8：合法 + 解出来不像乱码 → 直接用。
+	if utf8.Valid(b) {
+		if s := string(b); !hasImplausibleRune(s) {
+			return s
+		}
+	}
+	// 再试控制台代码页。
+	if s, ok := decodeACP(b, scriptCodePage()); ok && !hasImplausibleRune(s) {
+		return s
+	}
+	// 都不理想 → 保留原始字节（宁可显示成乱码，也不要静默丢内容）。
+	return string(b)
+}
+
+// errnoIsZero 判断 syscall 调用的错误码是否为 0（成功）。
+//
+// ⚠️ **不要直接比 err != nil**：Proc.Call 返回的 error **成功时也是非 nil**
+// （它是 syscall.Errno(0) 装箱出来的接口值，接口本身不为 nil）。
+// 直接比 err != nil 会把每次成功都判成失败 —— 这是本文件第一个版本的实际 bug。
+//
+// 正确口径：把 error 拆成 syscall.Errno 再比值。
+func errnoIsZero(err error) bool {
+	if err == nil {
+		return true
+	}
+	var errno syscall.Errno
+	if errors.As(err, &errno) {
+		return errno == 0
+	}
+	// 不是 Errno（例如某些平台包装过）→ 保守当作失败。
+	return false
+}
+
+// decodeACP 用指定代码页解码（MultiByteToWideChar）。
+func decodeACP(b []byte, cp uint32) (string, bool) {
+	if len(b) == 0 {
+		return "", true
+	}
+	// 第一次调用问长度（cbMultiByte = 0）。
+	n, _, errno := procMultiByteToWideChar.Call(
+		uintptr(cp), 0,
+		uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)),
+		0, 0,
+	)
+	/* ⚠️ errno 是 syscall.Errno，**成功时也是非 nil 的接口值**（值是 0）——
+	   必须比 errno != 0，不能比 err != nil，否则每次都判成失败。 */
+	if n == 0 || !errnoIsZero(errno) {
+		return "", false
+	}
+	wide := make([]uint16, n)
+	n2, _, errno := procMultiByteToWideChar.Call(
+		uintptr(cp), 0,
+		uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)),
+		uintptr(unsafe.Pointer(&wide[0])), uintptr(len(wide)),
+	)
+	if n2 == 0 || !errnoIsZero(errno) {
+		return "", false
+	}
+	return syscall.UTF16ToString(wide[:n2]), true
+}
+
+/* encodeACP 用指定代码页编码（WideCharToMultiByte）。
+ *
+ * 给测试桩用：Windows 上 cmd.exe 按代码页解释脚本文件里的字节，
+ * 测试桩必须按同样的编码存，否则「echo 中文」会变成乱码命令。
+ */
+func encodeACP(s string, cp uint32) ([]byte, bool) {
+	if s == "" {
+		return nil, true
+	}
+	wide, err := syscall.UTF16FromString(s)
+	if err != nil {
+		return nil, false
+	}
+	// UTF16FromString 末尾带一个 NUL，编码时不要它。
+	if len(wide) > 0 && wide[len(wide)-1] == 0 {
+		wide = wide[:len(wide)-1]
+	}
+	if len(wide) == 0 {
+		return nil, true
+	}
+	n, _, errno := procWideCharToMultiByte.Call(
+		uintptr(cp), 0,
+		uintptr(unsafe.Pointer(&wide[0])), uintptr(len(wide)),
+		0, 0, 0, 0,
+	)
+	if n == 0 || !errnoIsZero(errno) {
+		return nil, false
+	}
+	out := make([]byte, n)
+	n2, _, errno := procWideCharToMultiByte.Call(
+		uintptr(cp), 0,
+		uintptr(unsafe.Pointer(&wide[0])), uintptr(len(wide)),
+		uintptr(unsafe.Pointer(&out[0])), uintptr(len(out)),
+		0, 0,
+	)
+	if n2 == 0 || !errnoIsZero(errno) {
+		return nil, false
+	}
+	return out[:n2], true
+}