magic-agent 2.6.0 → 2.6.3

package/internal/client/coreexe.go

@@ -0,0 +1,196 @@
+package client
+
+// coreexe.go - core 可执行文件的路径解析。
+//
+// 2026-10-26 真机事故（「每条任务都 failed，但错误跟引擎无关」的根因）：
+//
+//	客户端的 opts.MagicAgent 缺省是相对名 "magic-agent"，exec 时走 PATH，
+//	命中的是 npm 全局 bin 里那份**转发脚本**（`#!/usr/bin/env node`）。
+//	如果客户端本身是从宿主 IDE（WorkBuddy）的终端起的，环境里带着
+//
+//	    NODE_OPTIONS=--require=".../app.asar.unpacked/.../node-language-shim.cjs"
+//	    ELECTRON_RUN_AS_NODE=1
+//	    PATH=<...>/shim/brokered-bin:<...>     ← 假 cat/cp/dd，require 时去连宿主 broker
+//
+//	那么 `env node` 解析到的就是宿主那份 node，转发脚本**在 require 阶段就崩**：
+//	`connect failed: Connection refused`。core 一个字节都没跑起来 ——
+//	所以现象是「日志里 core 路径看着对、任务全 failed、连 core 进程都抓不到」。
+//
+// 修法：core 与 client 永远同目录发布（npm/build.js 两个产物都落 dist/<plat>/，
+// 仓库 bin/ 同理），优先取同目录那份**真二进制**，绕开 PATH 上的 node 转发层。
+// 这一步与环境清理（internal/agent/env.go）互补：那个保证 core 起的引擎干净，
+// 这个保证 core 自己能起来。
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// coreBinaryName 允许调用方只给命令名。
+const coreBinaryName = "magic-agent"
+
+// resolveCoreExe 把 core 的命令名解析成可执行路径，优先「与本进程同目录」。
+//
+//	name    —— 配置值（空 / "magic-agent" / 绝对路径 / 带目录的相对路径）
+//	selfExe —— 本进程可执行文件路径（生产传 os.Executable() 的结果；测试可注入）
+func resolveCoreExe(name, selfExe string) string {
+	n := strings.TrimSpace(name)
+	if n == "" {
+		n = coreBinaryName
+	}
+	/* 带目录的写法同样可能是 npm 转发脚本（`--magic-agent /…/npm/bin/magic-agent.js`，
+	   或者 daemon 状态文件里存下来的那条路径）—— 2026-10-26 实测：`magic-client start`
+	   把它记成绝对路径后，上面「带目录就原样返回」直接把转发脚本放行了。见 npmShimBinary。 */
+	if strings.ContainsAny(n, `/\`) {
+		if bin, ok := npmShimBinary(n); ok {
+			return bin
+		}
+		return n
+	}
+	if bin, ok := siblingCore(n, selfExe); ok {
+		return bin
+	}
+	if p, err := exec.LookPath(n); err == nil {
+		/* PATH 上命中的是 npm 全局 bin 里的转发脚本（`#!/usr/bin/env node`）。
+		   真身在同包 npm/dist/<plat>/ 下 —— 解析到它，别每次调用都白起一个 Node。
+		   解析不出来才退回脚本本身（环境干净时它本来也能工作）。 */
+		if bin, ok := npmShimBinary(p); ok {
+			return bin
+		}
+		return p
+	}
+	return n
+}
+
+/*
+	npmShimBinary 把 npm 包里的 node 转发脚本（npm/bin/magic-agent.js）换成它要 spawn 的
+	  真二进制（npm/dist/<plat>/magic-agent）。解析不出来就返回 false，调用方保留原路径。
+
+为什么必须做（2026-10-26 真机实测，用户报「会话列表现在显示很慢」）：
+
+	`magic-client start` 把 core 路径记成绝对路径时落的是 npm/bin/magic-agent.js ——
+	那是 `#!/usr/bin/env node` 的转发层。于是**每一次** `--sessions` / `--contract` /
+	`--engines` 都要先起一个 Node 解释器（约 40ms，Host 环境更贵），再 spawnSync 到 Go。
+	同一个 core 直连只要 18ms，经客户端却要 200~900ms（机器负载 9~11 时放大到接近 1s）。
+	转发层本身没有一行业务逻辑，纯属白烧 —— 这里一次性解析掉。
+
+布局依据 npm/lib/platform.js：dist/<goos>-<nodearch>/<exe>，node 的 x64 对应 goarch amd64。
+
+	…/node_modules/magic-agent/npm/bin/magic-agent.js
+	                                   └── dist/darwin-arm64/magic-agent
+*/
+func npmShimBinary(path string) (string, bool) {
+	/* 先穿透符号链接（2026-10-26 补）：/opt/homebrew/bin/magic-agent 是指向
+	   ../lib/node_modules/magic-agent/npm/bin/magic-agent.js 的 symlink，**没有 .js 后缀**。
+	   只看扩展名的老实现把它当普通二进制原样返回 → 仍然每次白起一个 Node。
+	   实测差 3 倍（直跑 dist 10ms / 经 symlink 30ms），所以这一步不能省。
+
+	   注意用 derefLink 而不是 filepath.EvalSymlinks：后者会把路径里所有组件都解掉，
+	   macOS 上 `/var/folders/...` 会变成 `/private/var/folders/...`。路径字符串一变，
+	   日志、状态文件比对、测试期望全跟着漂 —— 只解最后那段链接就够了。 */
+	if direct := derefLink(path, 8); direct != path {
+		if bin, ok := npmShimBinary(direct); ok {
+			return bin, true
+		}
+		// 解出来的不是转发脚本（可能指向真二进制）→ 用解出来的路径继续判。
+		path = direct
+	}
+	ext := strings.ToLower(filepath.Ext(path))
+	if ext != ".js" && ext != ".cjs" {
+		return "", false
+	}
+	base := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	// 只认本仓的两个转发脚本，别的 .js 一律不碰（调用方可能真的想跑一个脚本）。
+	if base != coreBinaryName && base != "magic-client" {
+		return "", false
+	}
+	binDir := filepath.Dir(path)
+	if filepath.Base(binDir) != "bin" {
+		return "", false
+	}
+	pkgRoot := filepath.Dir(binDir) // npm/
+	distDir := filepath.Join(pkgRoot, "dist")
+	// 包根判定：npm/ 下同时有 bin/ 与 dist/。不满足就不是本仓的包结构，别乱猜。
+	if st, err := os.Stat(distDir); err != nil || !st.IsDir() {
+		return "", false
+	}
+	cand := filepath.Join(distDir, npmPlatformDir(), exeNameFor(base))
+	st, err := os.Stat(cand)
+	if err != nil || st.IsDir() {
+		return "", false
+	}
+	if runtime.GOOS != "windows" && st.Mode()&0o111 == 0 {
+		return "", false
+	}
+	return cand, true
+}
+
+// derefLink 只解「路径最后一段是不是符号链接」，逐层跟到底（相对链接按所在目录解）。
+//
+// 不用 filepath.EvalSymlinks 的原因：它会解掉**路径里每一级**组件。macOS 上
+// /var/folders/... 实际是 /private/var/folders/... 的链接，于是同一个文件会返回
+// 两个不同的字符串 —— 调用方拿去比对状态文件、写日志、做相等断言就会全乱。
+//
+// 解不动（循环 / 层级过深 / 读不到）就原样返回，交给调用方按普通路径处理。
+func derefLink(path string, maxDepth int) string {
+	cur := path
+	for i := 0; i < maxDepth; i++ {
+		fi, err := os.Lstat(cur)
+		if err != nil || fi.Mode()&os.ModeSymlink == 0 {
+			return cur
+		}
+		target, err := os.Readlink(cur)
+		if err != nil {
+			return cur
+		}
+		if !filepath.IsAbs(target) {
+			target = filepath.Join(filepath.Dir(cur), target)
+		}
+		cur = filepath.Clean(target)
+	}
+	return cur
+}
+
+// npmPlatformDir npm 产物目录名（与 npm/lib/platform.js 的 currentTarget().dir 逐字一致）。
+func npmPlatformDir() string {
+	goos := runtime.GOOS
+	if goos == "windows" {
+		goos = "win32"
+	}
+	arch := runtime.GOARCH
+	if arch == "amd64" {
+		arch = "x64"
+	}
+	return goos + "-" + arch
+}
+
+// exeNameFor 平台可执行文件名（Windows 带 .exe）。
+func exeNameFor(base string) string {
+	if runtime.GOOS == "windows" {
+		return base + ".exe"
+	}
+	return base
+}
+
+// siblingCore 在 selfExe 同目录找同名可执行文件。
+func siblingCore(name, selfExe string) (string, bool) {
+	if strings.TrimSpace(selfExe) == "" {
+		return "", false
+	}
+	dir := filepath.Dir(selfExe)
+	cand := filepath.Join(dir, name)
+	if runtime.GOOS == "windows" && !strings.HasSuffix(strings.ToLower(cand), ".exe") {
+		cand += ".exe"
+	}
+	st, err := os.Stat(cand)
+	if err != nil || st.IsDir() {
+		return "", false
+	}
+	if runtime.GOOS != "windows" && st.Mode()&0o111 == 0 {
+		return "", false
+	}
+	return cand, true
+}

package/internal/client/coreexe_test.go

@@ -0,0 +1,161 @@
+package client
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// 同目录有真二进制时必须优先用它 —— 这就是 2026-10-26 真机事故的修法：
+// 别让 exec 走 PATH 撞上 npm 的 node 转发脚本。
+func TestResolveCoreExePrefersSibling(t *testing.T) {
+	dir := t.TempDir()
+	core := filepath.Join(dir, "magic-agent")
+	if err := os.WriteFile(core, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	self := filepath.Join(dir, "magic-client")
+	got := resolveCoreExe("magic-agent", self)
+	if got != core {
+		t.Fatalf("应取同目录 core %s，实际 %s", core, got)
+	}
+}
+
+// 显式给了路径就照用，不猜。
+func TestResolveCoreExeKeepsExplicitPath(t *testing.T) {
+	if got := resolveCoreExe("/opt/x/magic-agent", "/tmp/magic-client"); got != "/opt/x/magic-agent" {
+		t.Fatalf("显式路径被改写：%s", got)
+	}
+}
+
+// 同目录没有就退回命令名/PATH 解析，不制造不存在的路径。
+func TestResolveCoreExeFallsBack(t *testing.T) {
+	dir := t.TempDir()
+	got := resolveCoreExe("", filepath.Join(dir, "magic-client"))
+	if filepath.Dir(got) == dir {
+		t.Fatalf("同目录没有 core 却编出一个：%s", got)
+	}
+}
+
+// npm 包布局：npmShimBinary 把 bin/magic-agent.js 换成 dist/<plat>/magic-agent。
+//
+// 这就是「会话列表慢」的根因修法：转发脚本零业务逻辑，却让每次列表请求多起一个 Node
+// 解释器（实测 40ms → 800ms 量级，机器负载高时接近 1 秒）。
+func TestNpmShimBinaryResolvesDistBinary(t *testing.T) {
+	pkg := filepath.Join(t.TempDir(), "node_modules", "magic-agent", "npm")
+	binScript := filepath.Join(pkg, "bin", "magic-agent.js")
+	real := filepath.Join(pkg, "dist", npmPlatformDir(), exeNameFor("magic-agent"))
+	for _, p := range []string{binScript, real} {
+		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(binScript, []byte("#!/usr/bin/env node\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(real, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	got, ok := npmShimBinary(binScript)
+	if !ok || got != real {
+		t.Fatalf("应解析到真二进制 %s，实际 ok=%v got=%s", real, ok, got)
+	}
+	// 绝对路径同样要走这条解析（daemon 状态文件记下的就是绝对路径）。
+	if viaResolve := resolveCoreExe(binScript, ""); viaResolve != real {
+		t.Fatalf("resolveCoreExe 没解析转发脚本：%s", viaResolve)
+	}
+}
+
+// dist 下没有该平台产物时不许编路径 —— 宁可原样返回脚本，让调用方看到真实错误。
+func TestNpmShimBinaryNoDistKeepsScript(t *testing.T) {
+	pkg := filepath.Join(t.TempDir(), "node_modules", "magic-agent", "npm")
+	binScript := filepath.Join(pkg, "bin", "magic-agent.js")
+	if err := os.MkdirAll(filepath.Dir(binScript), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(binScript, []byte("#!/usr/bin/env node\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := npmShimBinary(binScript); ok {
+		t.Fatal("没有 dist 产物却解析成功了")
+	}
+	if got := resolveCoreExe(binScript, ""); got != binScript {
+		t.Fatalf("应原样保留脚本路径，实际 %s", got)
+	}
+}
+
+// 非本仓的脚本（名字对不上）不碰 —— 调用方可能真的想跑一个 .js。
+func TestNpmShimBinaryIgnoresForeignScript(t *testing.T) {
+	pkg := filepath.Join(t.TempDir(), "npm")
+	other := filepath.Join(pkg, "bin", "something-else.js")
+	if err := os.MkdirAll(filepath.Dir(other), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(other, []byte("#!/usr/bin/env node\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := npmShimBinary(other); ok {
+		t.Fatal("不相干的 .js 被当成转发层了")
+	}
+}
+
+// symlink 形式的全局 bin 必须穿透（2026-10-26 真机发现的漏洞）：
+// /opt/homebrew/bin/magic-agent -> ../lib/node_modules/magic-agent/npm/bin/magic-agent.js
+// 它**没有 .js 后缀**，只看扩展名的实现会原样放行，于是每次请求照样白起一个 Node。
+// 实测直跑 dist 10ms / 经 symlink 30ms，3 倍差。
+func TestNpmShimBinaryResolvesThroughSymlink(t *testing.T) {
+	pkg := filepath.Join(t.TempDir(), "node_modules", "magic-agent", "npm")
+	binScript := filepath.Join(pkg, "bin", "magic-agent.js")
+	real := filepath.Join(pkg, "dist", npmPlatformDir(), exeNameFor("magic-agent"))
+	for _, p := range []string{binScript, real} {
+		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(binScript, []byte("#!/usr/bin/env node\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(real, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	// 模拟 Homebrew / npm prefix 的 bin：同一层级放一个无后缀的 symlink。
+	linkDir := filepath.Join(t.TempDir(), "homebrew", "bin")
+	if err := os.MkdirAll(linkDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(linkDir, "magic-agent")
+	if err := os.Symlink(binScript, link); err != nil {
+		t.Skipf("本平台不支持 symlink：%v", err)
+	}
+
+	got, ok := npmShimBinary(link)
+	if !ok || got != real {
+		t.Fatalf("symlink 没穿透到真二进制：ok=%v got=%s（期望 %s）", ok, got, real)
+	}
+	if viaResolve := resolveCoreExe(link, ""); viaResolve != real {
+		t.Fatalf("resolveCoreExe 没穿透 symlink：%s", viaResolve)
+	}
+}
+
+// 反过来：symlink 指向**真二进制**时必须原样可用（别把它当成转发脚本拦下来）。
+func TestNpmShimBinarySymlinkToRealBinaryPassesThrough(t *testing.T) {
+	real := filepath.Join(t.TempDir(), "dist", "magic-agent")
+	if err := os.MkdirAll(filepath.Dir(real), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(real, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(t.TempDir(), "magic-agent")
+	if err := os.Symlink(real, link); err != nil {
+		t.Skipf("本平台不支持 symlink：%v", err)
+	}
+	// 不 panic、不误判；返回值就是链接本身或它解出来的路径，两者都指向真二进制。
+	got, ok := npmShimBinary(link)
+	if ok && got != real && got != link {
+		t.Fatalf("symlink 指向真二进制时解析出了怪路径：%s", got)
+	}
+	if viaResolve := resolveCoreExe(link, ""); viaResolve == "" {
+		t.Fatal("resolveCoreExe 返回空")
+	}
+}