magic-agent 2.4.2 → 2.6.0

package/internal/client/knowledge_test.go

@@ -0,0 +1,510 @@
+package client
+
+/* knowledge_test.go — 「发现 → 知识库」（OpenViking）的行为钉住：
+ *  ① 清单只从服务端那张表里来，客户端传什么都在表里找；
+ *  ② 安装动作只跑服务端构造好的 argv，**不接受客户端传命令**；
+ *  ③ 状态如实：没装就说没装，版本读不到就留空（不编），查不到最新版本也不报错卡住；
+ *  ④ 可升级的判定要真的比较版本号，且预发布版不提示升级。
+
+ * ⚠️ 这些用例**不打外网、不真装 openviking**：PyPI 查询与 python 探测都换成桩。 */
+
+import (
+	"bufio"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// fakeKnowledgeEnv 造一个「家目录 + 干净的 PATH」的临时环境。
+//
+// ⚠️ PATH 必须**只留临时 binDir**、不能追加原 PATH：本机真的装了 OpenViking
+// （`C:\Python313\Scripts\ov.exe` 在 PATH 上），追加原 PATH 会让「PATH 上没有 ov」
+// 这条断言永远不成立 —— 而且那不是代码的问题，是本机的真实状态。
+func fakeKnowledgeEnv(t *testing.T) (home string, binDir string) {
+	t.Helper()
+	root := t.TempDir()
+	home = filepath.Join(root, "home")
+	binDir = filepath.Join(root, "bin")
+	for _, d := range []string{home, binDir} {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("PATH", binDir)
+	t.Setenv(ovEnvBin, "")
+	t.Setenv(ovEnvPython, "")
+
+	oldHome := ovHomeDir
+	oldProbe := ovPythonProbe
+	oldPyPI := pypiLatest
+	t.Cleanup(func() {
+		ovHomeDir = oldHome
+		ovPythonProbe = oldProbe
+		pypiLatest = oldPyPI
+	})
+	ovHomeDir = func() (string, error) { return home, nil }
+	// python 探测打桩：假装系统里有 3.13（够 ≥3.10 就行），但**不真的建 venv**。
+	ovPythonProbe = func() ([]string, string) { return []string{"python3"}, "3.13.3" }
+	pypiLatest = func(pkg string) (string, error) { return "", nil }
+	return home, binDir
+}
+
+// writeFakeOV 在 PATH 上放一个假 `ov`。
+//
+// ⚠️ Windows 上必须带 .exe 后缀：Go 的 LookPath 对无扩展名的文件会按 PATHEXT
+// 逐个加后缀去找，不会直接用裸名 —— 裸名文件在 Windows 上永远找不到。
+func writeFakeOV(t *testing.T, binDir, name, content string) string {
+	t.Helper()
+	if runtime.GOOS == "windows" && filepath.Ext(name) == "" {
+		name += ".exe"
+	}
+	p := filepath.Join(binDir, name)
+	if err := os.WriteFile(p, []byte(content), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func knowledgeService() *Service { return &Service{opts: Options{}} }
+
+/* ── 清单 ── */
+
+func TestKnowledgeListsCatalog(t *testing.T) {
+	fakeKnowledgeEnv(t)
+	rec := httptest.NewRecorder()
+	knowledgeService().handleKnowledge(rec, httptest.NewRequest(http.MethodGet, "/desk/knowledge", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("状态码 = %d，期望 200", rec.Code)
+	}
+	var body struct {
+		Knowledge []knowledgeInfo `json:"knowledge"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("响应不是合法 JSON：%v（%s）", err, rec.Body.String())
+	}
+	if len(body.Knowledge) != 1 {
+		t.Fatalf("知识库数 = %d，期望 1（openviking）", len(body.Knowledge))
+	}
+	k := body.Knowledge[0]
+	if k.ID != "openviking" {
+		t.Fatalf("id = %q，期望 openviking", k.ID)
+	}
+	// PATH 上没有 → 必须如实说没装，而不是给一个看起来成功的空壳
+	if k.Installed {
+		t.Fatal("PATH 上没有 ov 时 Installed 应为 false")
+	}
+	if k.Tagline == "" || k.Description == "" || len(k.Examples) == 0 {
+		t.Fatal("介绍三件套（一句话简介 / 详细说明 / 示例）不能空 —— 发现页要展示它们")
+	}
+	if !strings.Contains(k.UsePrompt, "知识库") {
+		t.Fatal("让它干活的预填提示里要点明用途")
+	}
+	if k.Note == "" {
+		t.Fatal("必须有一句 note 讲清「为什么是现在这个状态」")
+	}
+}
+
+/* ── 探测：环境变量 / venv / PATH 三档 ── */
+
+// 环境变量指定的命令优先级最高（用户显式指定）。
+func TestKnowledgeDetectsEnvOverride(t *testing.T) {
+	home, binDir := fakeKnowledgeEnv(t)
+	custom := writeFakeOV(t, binDir, "my-ov", "#!/bin/sh\n")
+	t.Setenv(ovEnvBin, custom)
+
+	d := detectOpenViking()
+	if d.Bin != custom {
+		t.Fatalf("bin = %q，期望 %q", d.Bin, custom)
+	}
+	if d.Source != "env" {
+		t.Fatalf("source = %q，期望 env", d.Source)
+	}
+	_ = home
+}
+
+// 自建 venv 里的命令**不在 PATH 上** —— 一键安装装进 venv 后 `ov` 就不在 PATH，
+// 所以 venv 这档必须排在 PATH 之前，否则「刚装好」会被误报成「未安装」。
+func TestKnowledgeDetectsVenvBeforePath(t *testing.T) {
+	home, binDir := fakeKnowledgeEnv(t)
+	// PATH 上放一个同名命令：它应该被 venv 里那个**盖掉**（venv 优先）。
+	writeFakeOV(t, binDir, "ov", "#!/bin/sh\n")
+
+	venvBin := filepath.Join(ovVenvBinDir(filepath.Join(home, ovVenvName)), "ov")
+	if runtime.GOOS == "windows" {
+		venvBin += ".exe"
+	}
+	if err := os.MkdirAll(filepath.Dir(venvBin), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(venvBin, []byte("#!/bin/sh\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	d := detectOpenViking()
+	if d.Source != "venv" {
+		t.Fatalf("source = %q，期望 venv（venv 里的命令不在 PATH 上，必须先认它）", d.Source)
+	}
+	if d.Bin != venvBin {
+		t.Fatalf("bin = %q，期望 %q", d.Bin, venvBin)
+	}
+}
+
+// 两个命令名都认：0.5.2 的文档给 `ov`，0.4.15 的文档给 `openviking`。
+// 认错的后果是「明明装了却说没装」。
+func TestKnowledgeAcceptsBothCLINames(t *testing.T) {
+	_, binDir := fakeKnowledgeEnv(t)
+	for _, name := range ovCLINames {
+		t.Run(name, func(t *testing.T) {
+			_, binDir := fakeKnowledgeEnv(t)
+			p := writeFakeOV(t, binDir, name, "#!/bin/sh\n")
+			d := detectOpenViking()
+			if d.Bin != p {
+				t.Fatalf("bin = %q，期望 %q（命令名 %s 应当被认）", d.Bin, p, name)
+			}
+		})
+	}
+	_ = binDir
+}
+
+/* ── 版本号：分层兜底 ── */
+
+// L1：CLI 自己说（`--version`）。
+func TestKnowledgeVersionFromCLI(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("本用例用 shell 脚本桩，Windows 上跑不了")
+	}
+	_, binDir := fakeKnowledgeEnv(t)
+	bin := writeFakeOV(t, binDir, "ov", "#!/bin/sh\necho 'ov 0.5.2'\n")
+	if got := versionFromCLI(bin); got != "0.5.2" {
+		t.Fatalf("版本 = %q，期望 0.5.2", got)
+	}
+}
+
+// L2：从 dist-info 目录名读（纯文件系统，不依赖解释器）。
+// 这层是「CLI 没有 --version」时的主路径 —— `ov --version` 是否被支持并未确认。
+func TestKnowledgeVersionFromDistInfo(t *testing.T) {
+	home, _ := fakeKnowledgeEnv(t)
+	venv := filepath.Join(home, ovVenvName)
+	site := filepath.Join(venv, "Lib", "site-packages")
+	if runtime.GOOS != "windows" {
+		site = filepath.Join(venv, "lib", "python3.12", "site-packages")
+	}
+	dist := filepath.Join(site, "openviking-0.4.15.dist-info")
+	if err := os.MkdirAll(dist, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dist, "METADATA"), []byte("Name: openviking\nVersion: 0.4.15\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	// 放一个空的 bin（不传 bin 也行，但传了更贴近真实形态）
+	bin := filepath.Join(ovVenvBinDir(venv), "ov")
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+	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)
+	}
+
+	got := versionFromDistInfo(bin, venv)
+	if got != "0.4.15" {
+		t.Fatalf("版本 = %q，期望 0.4.15", got)
+	}
+}
+
+// 读不到版本就留空 —— 绝不编一个看起来对的版本号。
+func TestKnowledgeVersionEmptyWhenUnreadable(t *testing.T) {
+	home, _ := fakeKnowledgeEnv(t)
+	if got := readOpenVikingVersion("", home); got != "" {
+		t.Fatalf("没有命令时版本应为空串，实际 %q", got)
+	}
+}
+
+/* ── 版本比较 ── */
+
+func TestKnowledgeVersionCompare(t *testing.T) {
+	cases := []struct {
+		cur, latest string
+		less        bool
+	}{
+		{"0.4.15", "0.5.2", true},
+		{"0.5.2", "0.5.2", false},
+		{"0.6.0", "0.5.2", false},
+		{"0.5.2", "0.5.10", true},
+		{"1.0.0", "0.9.9", false},
+		{"", "0.5.2", false},
+		{"0.5.2", "", false},
+	}
+	for _, c := range cases {
+		if got := ovVersionLess(c.cur, c.latest); got != c.less {
+			t.Fatalf("ovVersionLess(%q, %q) = %v，期望 %v", c.cur, c.latest, got, c.less)
+		}
+	}
+}
+
+// 预发布版**不**提示升级 —— 那不是「有新版」，是「有测试版」。
+//
+// ⚠️ 判据不是「有没有 '-'」：PEP 440 的预发布形态**不一定用连字符分隔**
+// （实测本机 `ov --version` 吐 `0.4.16.dev0`，PyPI 上还有 `0.6.0rc1` 这种连字符都没有的）。
+func TestKnowledgePreReleaseNotOffered(t *testing.T) {
+	for _, v := range []string{
+		"0.6.0rc1", "0.6.0-rc1", "1.0.0a2", "1.0.0-alpha2", "0.7.0.dev3",
+		"0.4.16.dev0", "1.0.0b1", "1.0.0pre1",
+	} {
+		if !ovIsPreRelease(v) {
+			t.Fatalf("%q 应判为预发布", v)
+		}
+	}
+	for _, v := range []string{"0.5.2", "1.0.0", "0.4.16", "2.0.0+local"} {
+		if ovIsPreRelease(v) {
+			t.Fatalf("%q 不应判为预发布", v)
+		}
+	}
+}
+
+// 版本号提取要连后缀一起拿：`ov --version` 吐的是 `openviking 0.4.16.dev0`，
+// 只取数字段会把这个 dev 版说成正式版 0.4.16（然后界面就误判「已是最新」）。
+func TestKnowledgeVersionTokenKeepsSuffix(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"openviking 0.4.16.dev0", "0.4.16.dev0"},
+		{"OpenViking v0.5.2", "0.5.2"},
+		{"0.6.0rc1", "0.6.0rc1"},
+		{"0.5.2+local", "0.5.2+local"},
+		{"no version here", ""},
+	}
+	for _, c := range cases {
+		if got := ovVersionToken(c.in); got != c.want {
+			t.Fatalf("ovVersionToken(%q) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+/* ── 最新版本：查不到不报错 ── */
+
+func TestKnowledgeLatestVersionUnavailable(t *testing.T) {
+	fakeKnowledgeEnv(t)
+	pypiLatest = func(pkg string) (string, error) { return "", os.ErrNotExist }
+	s := knowledgeService()
+	v, ok := s.ovLatestVersion(ovPyPackage)
+	if ok {
+		t.Fatalf("查不到时 ok 应为 false，实际 %q", v)
+	}
+	if v != "" {
+		t.Fatalf("查不到时版本应为空串，实际 %q", v)
+	}
+}
+
+// 缓存：连续两次查询只打一次外网。
+func TestKnowledgeLatestVersionCached(t *testing.T) {
+	fakeKnowledgeEnv(t)
+	calls := 0
+	pypiLatest = func(pkg string) (string, error) {
+		calls++
+		return "0.5.2", nil
+	}
+	s := knowledgeService()
+	for i := 0; i < 3; i++ {
+		v, ok := s.ovLatestVersion(ovPyPackage)
+		if !ok || v != "0.5.2" {
+			t.Fatalf("第 %d 次查询 = (%q, %v)", i+1, v, ok)
+		}
+	}
+	if calls != 1 {
+		t.Fatalf("外网查询次数 = %d，期望 1（要有缓存）", calls)
+	}
+}
+
+/* ── 可升级判定 ── */
+
+func TestKnowledgeUpgradeAvailable(t *testing.T) {
+	home, binDir := fakeKnowledgeEnv(t)
+	// 造一个「装着 0.4.15」的 venv：dist-info 目录名就是版本来源
+	venv := filepath.Join(home, ovVenvName)
+	site := filepath.Join(venv, "Lib", "site-packages")
+	if runtime.GOOS != "windows" {
+		site = filepath.Join(venv, "lib", "python3.12", "site-packages")
+	}
+	if err := os.MkdirAll(filepath.Join(site, "openviking-0.4.15.dist-info"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	bin := filepath.Join(ovVenvBinDir(venv), "ov")
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+	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)
+	}
+	writeFakeOV(t, binDir, "other", "#!/bin/sh\n") // PATH 上有个无关命令，别被认成 ov
+
+	pypiLatest = func(pkg string) (string, error) { return "0.5.2", nil }
+	s := knowledgeService()
+	info := s.knowledgeInfoOf(knowledgeSpecs()[0])
+	if !info.Installed {
+		t.Fatal("venv 里有命令时 Installed 应为 true")
+	}
+	if info.Version != "0.4.15" {
+		t.Fatalf("版本 = %q，期望 0.4.15", info.Version)
+	}
+	if !info.UpgradeAvailable {
+		t.Fatal("本机 0.4.15 < 最新 0.5.2，UpgradeAvailable 应为 true")
+	}
+	if info.LatestVersion != "0.5.2" {
+		t.Fatalf("最新版本 = %q，期望 0.5.2", info.LatestVersion)
+	}
+}
+
+/* ── 安装 / 升级 ── */
+
+// 安装动作：只跑服务端构造好的 argv，输出按行流回。
+func TestKnowledgeInstallStreams(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("本用例用 shell 脚本桩，Windows 上跑不了")
+	}
+	home, binDir := fakeKnowledgeEnv(t)
+	// 桩 python：建 venv 那步把「假 ov」放进 venv 的 bin 目录 ——
+	// 于是「跑完重新探测」这条链真的会翻成 installed=true，而不是靠测试自己断言。
+	venv := filepath.Join(home, ovVenvName)
+	py := filepath.Join(binDir, "python3")
+	script := "#!/bin/sh\necho \"python $*\"\n" +
+		"if [ \"$2\" = \"venv\" ]; then\n" +
+		"  mkdir -p \"" + filepath.Join(venv, "bin") + "\"\n" +
+		"  printf '#!/bin/sh\\necho \"ov 0.5.2\"\\n' > \"" + filepath.Join(venv, "bin", "ov") + "\"\n" +
+		"  chmod +x \"" + filepath.Join(venv, "bin", "ov") + "\"\n" +
+		"fi\n" +
+		"exit 0\n"
+	if err := os.WriteFile(py, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	rec := httptest.NewRecorder()
+	knowledgeService().handleKnowledgeAction(rec,
+		httptest.NewRequest(http.MethodPost, "/desk/knowledge/openviking/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)
+	}
+
+	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) != 3 {
+		t.Fatalf("open.commands = %v，期望三条（建 venv / pip install / pip show）", open.Commands)
+	}
+	if !strings.Contains(strings.Join(open.Commands, " "), "pip") {
+		t.Fatalf("命令里应有 pip：%v", open.Commands)
+	}
+	if !strings.Contains(strings.Join(events["line"], "\n"), "python") {
+		t.Fatalf("安装输出没有流回客户端：%v", events["line"])
+	}
+	if len(events["end"]) != 1 {
+		t.Fatalf("必须恰好一条 end 收尾，实际 %d", len(events["end"]))
+	}
+	var end struct {
+		OK        bool          `json:"ok"`
+		Knowledge knowledgeInfo `json:"knowledge"`
+	}
+	_ = json.Unmarshal([]byte(events["end"][0]), &end)
+	if !end.OK {
+		t.Fatalf("安装成功却回了 ok=false：%s", events["end"][0])
+	}
+	if !end.Knowledge.Installed {
+		t.Fatalf("跑完应重新探测到已安装（end.knowledge.installed 仍为 false）：%s", events["end"][0])
+	}
+}
+
+// 未知 id / 未知动作一律 404，且**没有任何命令被执行** —— 这条接口不能变成任意命令执行器。
+func TestKnowledgeActionRejectsUnknown(t *testing.T) {
+	fakeKnowledgeEnv(t)
+	for _, target := range []string{
+		"/desk/knowledge/rm-rf/install",
+		"/desk/knowledge/openviking/run",
+		"/desk/knowledge/openviking",
+	} {
+		rec := httptest.NewRecorder()
+		knowledgeService().handleKnowledgeAction(rec, httptest.NewRequest(http.MethodPost, target, nil))
+		if rec.Code != http.StatusNotFound {
+			t.Fatalf("%s 状态码 = %d，期望 404", target, rec.Code)
+		}
+	}
+}
+
+// 失败的安装：退出码 + 错误要回给客户端，end.ok=false（不能静默当成功）。
+func TestKnowledgeInstallFailureReported(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("本用例用 shell 脚本桩，Windows 上跑不了")
+	}
+	_, binDir := fakeKnowledgeEnv(t)
+	py := filepath.Join(binDir, "python3")
+	if err := os.WriteFile(py, []byte("#!/bin/sh\necho 'EACCES: permission denied' >&2\nexit 3\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	rec := httptest.NewRecorder()
+	knowledgeService().handleKnowledgeAction(rec,
+		httptest.NewRequest(http.MethodPost, "/desk/knowledge/openviking/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)
+	}
+}
+
+/* ── python 探测 ── */
+
+// 找不到 ≥3.10 的 python → 就没有安装命令（界面要如实说「装不了」，而不是给一条跑不通的命令）。
+func TestKnowledgeNoPythonNoSteps(t *testing.T) {
+	fakeKnowledgeEnv(t)
+	ovPythonProbe = func() ([]string, string) { return nil, "" }
+	isteps, usteps := ovSteps()
+	if len(isteps) != 0 || len(usteps) != 0 {
+		t.Fatalf("没有 python 时不该有步骤，实际 %v / %v", isteps, usteps)
+	}
+	rec := httptest.NewRecorder()
+	knowledgeService().handleKnowledgeAction(rec,
+		httptest.NewRequest(http.MethodPost, "/desk/knowledge/openviking/install", nil))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("状态码 = %d，期望 400（没有 python 就装不了）", rec.Code)
+	}
+}
+
+// 3.9 不满足 OpenViking 的要求（需要 ≥3.10）。
+func TestKnowledgePythonVersionGate(t *testing.T) {
+	if ovPythonVersionOK("3.9.7") {
+		t.Fatal("3.9.7 不该通过（OpenViking 需要 ≥3.10）")
+	}
+	if !ovPythonVersionOK("3.10.0") {
+		t.Fatal("3.10.0 应通过")
+	}
+	if !ovPythonVersionOK("3.13.3") {
+		t.Fatal("3.13.3 应通过")
+	}
+}