magic-agent 1.0.2 → 1.0.46

package/internal/session/title_test.go

@@ -0,0 +1,298 @@
+package session
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// withTitleHome 把标题表指到临时目录（测试期间不碰用户真实的 ~/.magic-agent）。
+func withTitleHome(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	t.Setenv(EnvDir, filepath.Join(dir, "sessions"))
+	// 进程内缓存是包级变量：换目录后必须失效，否则会读到上一个用例的表。
+	titleMu.Lock()
+	titleCache, titleLoaded = nil, false
+	titleMu.Unlock()
+	return dir
+}
+
+func TestSetTitleRoundTrip(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("sess-1", "设置界面版本号"); err != nil {
+		t.Fatalf("SetTitle: %v", err)
+	}
+	if got := TitleFor("sess-1"); got != "设置界面版本号" {
+		t.Fatalf("TitleFor = %q", got)
+	}
+	if got := Titles()["sess-1"]; got != "设置界面版本号" {
+		t.Fatalf("Titles()[sess-1] = %q", got)
+	}
+	// 落盘形状：路径不变（插件时代就是它），所以已有的重命名结果不丢。
+	p, err := TitleStorePath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if filepath.Base(p) != "session-titles.json" {
+		t.Fatalf("标题表文件名变了：%s", p)
+	}
+	if b, err := os.ReadFile(p); err != nil || len(b) == 0 {
+		t.Fatalf("标题表没落盘：%v", err)
+	}
+	// 空标题 = 清除覆盖（界面「恢复默认标题」用这条）。
+	if err := SetTitle("sess-1", "  "); err != nil {
+		t.Fatal(err)
+	}
+	if got := TitleFor("sess-1"); got != "" {
+		t.Fatalf("空标题应清除覆盖，实际 %q", got)
+	}
+}
+
+func TestSetTitleEmptyIDRejected(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("  ", "x"); err == nil {
+		t.Fatal("空 id 应被拒（否则会写出一条认不出来的覆盖）")
+	}
+}
+
+// TestSetTitleKeepsOtherEntries 回归：整表覆盖曾把别的条目抹掉。
+// 两条覆盖先后写入，先写的那条必须还在。
+func TestSetTitleKeepsOtherEntries(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("a", "标题甲"); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetTitle("b", "标题乙"); err != nil {
+		t.Fatal(err)
+	}
+	m := Titles()
+	if m["a"] != "标题甲" || m["b"] != "标题乙" {
+		t.Fatalf("后写的一条把先写的抹了：%+v", m)
+	}
+}
+
+func TestNormalizeTitle(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"设置界面版本号", "设置界面版本号"},
+		{"标题：设置界面版本号", "设置界面版本号"},
+		{"标题: 设置界面版本号", "设置界面版本号"},
+		{"【标题】设置界面版本号", "设置界面版本号"},
+		{"1. 设置界面版本号", "设置界面版本号"},
+		{"1、设置界面版本号", "设置界面版本号"},
+		{"- 设置界面版本号", "设置界面版本号"},
+		{"## 设置界面版本号", "设置界面版本号"},
+		{"“设置界面版本号”", "设置界面版本号"},
+		{"「设置界面版本号」", "设置界面版本号"},
+		{"（设置界面版本号）", "设置界面版本号"},
+		{"设置界面版本号。", "设置界面版本号"},
+		{"设置界面版本号。\n", "设置界面版本号"},
+		{"```\n设置界面版本号\n```", "设置界面版本号"},
+		{"设置界面版本号\n这是解释，不该进标题", "设置界面版本号"},
+		{"", ""},
+		{"\n\n", ""},
+	}
+	for _, c := range cases {
+		if got := normalizeTitle(c.in, TitleMaxChars); got != c.want {
+			t.Errorf("normalizeTitle(%q) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+// TestNormalizeTitleKeepsTitlePrefix 回归：剥前缀不能误伤**本身就以「标题」开头**的正常标题。
+func TestNormalizeTitleKeepsTitlePrefix(t *testing.T) {
+	// 「标题设计评审」里「标题」后面不是冒号/破折号 → 不该被当成前缀剥掉。
+	if got := normalizeTitle("标题设计评审", TitleMaxChars); got != "标题设计评审" {
+		t.Fatalf("正常标题被误剥前缀：%q", got)
+	}
+}
+
+func TestNormalizeTitleTruncates(t *testing.T) {
+	// 超长按 rune 截断（不是字节）：中文不能被切坏。
+	long := "一二三四五六七八九十一二三四五六七八九十"
+	got := normalizeTitle(long, TitleMaxChars)
+	if n := len([]rune(got)); n != TitleMaxChars {
+		t.Fatalf("截断后 %d 字，期望 %d（%q）", n, TitleMaxChars, got)
+	}
+	for _, r := range got {
+		if r == '�' {
+			t.Fatalf("按字节截了中文：%q", got)
+		}
+	}
+}
+
+func TestFirstUserTextPrefersLog(t *testing.T) {
+	withTitleHome(t)
+	dir := t.TempDir()
+	log := `{"seq":0,"kind":"user","text":"要在设置界面显示版本号"}
+{"seq":1,"kind":"text","text":"好的"}`
+	if err := os.WriteFile(filepath.Join(dir, "sess-1.jsonl"), []byte(log), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// 日志优先：prompt_head 只有前 80 字，长首问靠它才归纳得出要点。
+	if got := FirstUserText(dir, "sess-1", "截断的首问"); got != "要在设置界面显示版本号" {
+		t.Fatalf("FirstUserText = %q", got)
+	}
+	// 没日志 → 回落 prompt_head（归纳仍能工作）。
+	if got := FirstUserText(dir, "sess-none", "回落用的首问"); got != "回落用的首问" {
+		t.Fatalf("无日志时未回落 prompt_head：%q", got)
+	}
+	// 空 sid + 空 head → 空（调用方据此报错，不硬编一个标题）。
+	if got := FirstUserText(dir, "", ""); got != "" {
+		t.Fatalf("应为空，实际 %q", got)
+	}
+}
+
+func TestSummarizeRequiresText(t *testing.T) {
+	withTitleHome(t)
+	if _, err := Summarize(context.Background(), SummarizeOptions{SessionID: "s"}); err == nil {
+		t.Fatal("没有可归纳的原文时应报错，而不是返回一个空标题")
+	}
+	if _, err := Summarize(context.Background(), SummarizeOptions{}); err == nil {
+		t.Fatal("空 id 应被拒")
+	}
+}
+
+// TestSummarizeUsesCache 幂等：已有覆盖就直接回，不该再调一次 LLM。
+func TestSummarizeUsesCache(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("sess-1", "设置界面版本号"); err != nil {
+		t.Fatal(err)
+	}
+	res, err := Summarize(context.Background(), SummarizeOptions{SessionID: "sess-1", Text: "任意"})
+	if err != nil {
+		t.Fatalf("命中缓存不该报错：%v", err)
+	}
+	if !res.Cached || res.Title != "设置界面版本号" {
+		t.Fatalf("应命中缓存并回现有标题，实际 %+v", res)
+	}
+}
+
+/* ── 标题的键必须稳定（2026-10-15，用户：「标题只在第一次创建时生成」）──
+   首轮归纳时引擎可能还没吐 session_id，键就落在 run_id 上；而 run_id **每轮追问都换一个**
+   → 下一轮按 session_id 查不到 → 客户端以为「还没归纳」→ 再归纳一次（输入还会回落成
+   最新那条追问）→ 标题每轮都在变。两个键都认 + 迁移到 session_id 就是为了堵这个洞。 */
+
+// TestTitleForAnyAdoptsRunIDKey 存量「键在 run_id 上」的标题，按 session_id 也要读得到，
+// 且能被迁到 session_id 上。
+func TestTitleForAnyAdoptsRunIDKey(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("run-old", "补全学校场景功能"); err != nil {
+		t.Fatal(err)
+	}
+	if got := TitleFor("sess-1"); got != "" {
+		t.Fatalf("前置条件：session_id 键上本该没有标题，实得 %q", got)
+	}
+	// ① 两键都认。
+	if got := TitleForAny("sess-1", "run-old"); got != "补全学校场景功能" {
+		t.Fatalf("TitleForAny = %q，want 补全学校场景功能", got)
+	}
+	// ② 迁移之后按 session_id 直接命中（此后 run_id 再换也不影响）；
+	//    旧键要**删掉** —— 留着就成了「同一会话两个键、两个值」。
+	AdoptTitle("sess-1", "run-old")
+	if got := TitleFor("sess-1"); got != "补全学校场景功能" {
+		t.Fatalf("迁移后 TitleFor(sess-1) = %q", got)
+	}
+	if got := TitleFor("run-old"); got != "" {
+		t.Fatalf("迁移后旧键该被清掉，实得 %q", got)
+	}
+	// ③ 幂等；且**不覆盖**人工重命名（新键有值就不搬）。
+	AdoptTitle("sess-1", "run-old")
+	if err := SetTitle("sess-1", "我自己改的名字"); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetTitle("run-old", "旧键上的名字"); err != nil {
+		t.Fatal(err)
+	}
+	AdoptTitle("sess-1", "run-old")
+	if got := TitleFor("sess-1"); got != "我自己改的名字" {
+		t.Fatalf("人工重命名不能被旧键覆盖，实得 %q", got)
+	}
+}
+
+// TestConsolidateTitleDropsRunKeys 归纳出新标题时，该会话**各轮 run_id** 上的旧键都要清掉，
+// 只留 session_id 一个 —— 否则按不同 id 读会看到不同标题。
+func TestConsolidateTitleDropsRunKeys(t *testing.T) {
+	dir := withTitleHome(t)
+	if err := SetTitle("run-1", "旧标题一"); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetTitle("run-2", "旧标题二"); err != nil {
+		t.Fatal(err)
+	}
+	// 登记表里这两轮都属于同一条会话（免得依赖真实 home 目录）。
+	regDir := filepath.Join(dir, "sessions")
+	if err := os.MkdirAll(regDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	for _, rid := range []string{"run-1", "run-2"} {
+		writeRecordForTest(t, regDir,
+			Record{RunID: rid, SessionID: "sess-c", State: StateDone,
+				StartedAt: time.Now(), UpdatedAt: time.Now()})
+	}
+	if err := ConsolidateTitle("sess-c", "run-2", "归纳出来的标题"); err != nil {
+		t.Fatal(err)
+	}
+	if got := TitleFor("sess-c"); got != "归纳出来的标题" {
+		t.Fatalf("TitleFor(sess-c) = %q", got)
+	}
+	for _, rid := range []string{"run-1", "run-2"} {
+		if got := TitleFor(rid); got != "" {
+			t.Fatalf("该会话的 run 键 %s 应被清掉，实得 %q", rid, got)
+		}
+	}
+	// 按 run_id 读也要得到同一个标题（先查登记表翻到 session_id）。
+	if got := TitleForAny("sess-c", "run-2"); got != "归纳出来的标题" {
+		t.Fatalf("TitleForAny = %q", got)
+	}
+}
+
+// TestTitleForSessionRuns 标题挂在**其他轮**的 run_id 上时（首轮归纳时还没有 session_id），
+// 按 session_id 也要认到；取最早那一轮的值。
+func TestTitleForSessionRuns(t *testing.T) {
+	dir := withTitleHome(t)
+	regDir := filepath.Join(dir, "sessions")
+	if err := os.MkdirAll(regDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	now := time.Now()
+	writeRecordForTest(t, regDir, Record{RunID: "run-new", SessionID: "sess-r", State: StateDone,
+		StartedAt: now, UpdatedAt: now})
+	writeRecordForTest(t, regDir, Record{RunID: "run-old", SessionID: "sess-r", State: StateDone,
+		StartedAt: now.Add(-time.Hour), UpdatedAt: now.Add(-time.Hour)})
+	writeRecordForTest(t, regDir, Record{RunID: "run-other", SessionID: "sess-other", State: StateDone,
+		StartedAt: now.Add(-2 * time.Hour), UpdatedAt: now.Add(-2 * time.Hour)})
+	if err := SetTitle("run-old", "第一次生成的标题"); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetTitle("run-other", "别的会话的标题"); err != nil {
+		t.Fatal(err)
+	}
+	if got := TitleForSessionRuns("sess-r"); got != "第一次生成的标题" {
+		t.Fatalf("TitleForSessionRuns(sess-r) = %q", got)
+	}
+	if got := TitleForSessionRuns("nope"); got != "" {
+		t.Fatalf("没有记录的会话应为空，实得 %q", got)
+	}
+}
+
+// TestSummarizeCachedAcrossKeys 按 run_id 建的标题，在按 session_id 归纳时也算命中
+// （不调 LLM），并把键迁到 session_id。
+func TestSummarizeCachedAcrossKeys(t *testing.T) {
+	withTitleHome(t)
+	if err := SetTitle("run-old", "设置页展示版本号"); err != nil {
+		t.Fatal(err)
+	}
+	res, err := Summarize(context.Background(), SummarizeOptions{SessionID: "sess-1", RunID: "run-old", Text: "任意"})
+	if err != nil {
+		t.Fatalf("跨键命中不该报错：%v", err)
+	}
+	if !res.Cached || res.Title != "设置页展示版本号" {
+		t.Fatalf("应按 run_id 键命中缓存，实际 %+v", res)
+	}
+	if TitleFor("sess-1") == "" {
+		t.Fatal("命中时应把标题迁到 session_id（否则下一轮又要重算）")
+	}
+}

package/npm/bin/magic-agent.js

@@ -7,24 +7,89 @@
 // 之所以用 spawnSync + stdio:inherit 而不是直接 exec：
 //   - 保持真实 fd 0/1/2，Go 侧 process.stdin.isTTY 判定不受影响（管道读 prompt 依赖它）
 //   - 退出码、Ctrl-C 信号行为与直接运行二进制一致
+//
+// 定位顺序（逐级兜底，尽量不让用户卡在「装上了但跑不了」）：
+//   1) MAGIC_AGENT_BIN            环境变量显式指定
+//   2) npm/dist/<plat>/          预编译产物（npm 包正常路径）
+//   3) bin/                      本地开发产物（go build -o bin/...）
+//   4) 本机 go 现场编译            与 npm/install.js 的兜底策略保持一致
+// 全都落空才报错退出，错误信息里带上「已打包了哪些平台」便于自查。
 
-const { spawnSync } = require("child_process");
+const { execFileSync, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 
-const { binaryPath, distDir, currentTarget, exeName } = require("../lib/platform");
+const { binaryPath, distDir, currentTarget, exeName, findGo, pkgRoot } = require("../lib/platform");
 
 const target = currentTarget();
-const bin = binaryPath(target);
+const exe = exeName(target.goos);
+const isWin = process.platform === "win32";
+
+function fromDist() {
+  const p = binaryPath(target);
+  return fs.existsSync(p) ? p : null;
+}
+
+function fromLocalBin() {
+  const p = path.join(pkgRoot, "bin", exe);
+  return fs.existsSync(p) ? p : null;
+}
+
+/** 最后兜底：本机装了 Go 就现场编译一份。 */
+function buildFromSource() {
+  const go = findGo();
+  if (!go) return null;
+  const out = fromLocalBin() || path.join(pkgRoot, "bin", exe);
+  process.stderr.write(`magic-agent: 未找到 ${target.dir} 预编译产物，用 go 现场编译 ...\n`);
+  try {
+    // 版本号从 package.json 注入，与 npm/build.js 保持一致 ——
+    // 否则兜底编译出来的产物会报 0.1.0（Go 侧默认值），和正式包对不上。
+    let version = "";
+    try {
+      version = require(path.join(pkgRoot, "package.json")).version || "";
+    } catch (_) {
+      /* 读不到就不注入，Go 侧会用默认值 */
+    }
+    const ldflags = version
+      ? `-s -w -X github.com/darren/magic-agent/internal/cli.Version=${version}`
+      : "-s -w";
+
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    execFileSync(go, ["build", "-trimpath", "-ldflags", ldflags, "-o", out, "./cmd/magic-agent"], {
+      cwd: pkgRoot,
+      stdio: ["ignore", "ignore", "pipe"],
+      env: { ...process.env, CGO_ENABLED: "0", GOOS: target.goos, GOARCH: target.goarch },
+    });
+    return fs.existsSync(out) ? out : null;
+  } catch (err) {
+    process.stderr.write(`magic-agent: 现场编译失败: ${String(err.message).split("\n")[0]}\n`);
+    return null;
+  }
+}
+
+function resolve() {
+  if (process.env.MAGIC_AGENT_BIN && fs.existsSync(process.env.MAGIC_AGENT_BIN)) {
+    return process.env.MAGIC_AGENT_BIN;
+  }
+  return fromDist() || fromLocalBin() || buildFromSource();
+}
+
+const bin = resolve();
 
-if (!fs.existsSync(bin)) {
-  const found = fs.existsSync(distDir)
-    ? fs.readdirSync(distDir).filter((d) => fs.existsSync(path.join(distDir, d, exeName(d.startsWith("win32") ? "windows" : "linux"))))
+if (!bin) {
+  // 列出包里实际带了哪些平台，方便判断是「平台没打」还是「包不完整」。
+  const packed = fs.existsSync(distDir)
+    ? fs
+        .readdirSync(distDir)
+        .filter((d) => fs.existsSync(path.join(distDir, d, exeName(d.startsWith("win32") ? "windows" : "linux"))))
     : [];
   process.stderr.write(
-    `magic-agent: 当前平台 ${target.dir} 没有可用二进制（期望 ${bin}）\n` +
-      `已打包的平台：${found.length ? found.join(", ") : "（无）"}\n` +
-      `解决办法：在有 Go 的环境执行 \`npm run build\`，或用 \`go build -o bin/magic-agent ./cmd/magic-agent\` 自行编译后直接调用。\n`
+    `magic-agent: 当前平台 ${target.dir} 没有可用二进制（期望 ${binaryPath(target)}）\n` +
+      `已打包的平台：${packed.length ? packed.join(", ") : "（无）"}\n` +
+      `解决办法：装 Go 后重跑本命令（会自动现场编译），或手工执行\n` +
+      `  npm run build\n` +
+      `  go build -o bin/${exe} ./cmd/magic-agent\n` +
+      `或用 MAGIC_AGENT_BIN 指向已有的可执行文件。\n`
   );
   process.exit(1);
 }
@@ -36,7 +101,10 @@ if (res.error) {
   process.exit(1);
 }
 if (res.signal) {
-  // 让父进程以相同信号退出，保持 shell 语义（如超时/中断）
+  // 让父进程以相同信号退出，保持 shell 语义（如超时/中断）。
+  // Windows 上没有真正的信号投递，process.kill 自杀会丢掉退出码语义，
+  // 这种情况退回 1（通用失败），不要假装成功。
+  if (isWin) process.exit(1);
   process.kill(process.pid, res.signal);
   process.exit(1);
 }

package/npm/bin/magic-client.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+"use strict";
+
+// magic-client 的 npm bin 转发层：与 magic-agent.js 同一套定位顺序，
+// 只是把目标二进制换成同目录的 magic-client。
+//
+// 为什么需要独立的 bin：`magic-agent client start` 已经能管它，但直接跑
+// `magic-client serve --lan`（前台、看日志）仍然是最常用的排障姿势 —— 没有这个转发，
+// 用户得自己去 node_modules/magic-agent/npm/dist/<plat>/ 里翻路径。
+//
+// 定位顺序：MAGIC_CLIENT_BIN > npm/dist/<plat>/magic-client > bin/ > 本机 go 现场编译。
+
+const { execFileSync, spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const { clientBinaryPath, distDir, currentTarget, exeName, findGo, pkgRoot } = require("../lib/platform");
+
+const target = currentTarget();
+const exe = exeName(target.goos, "magic-client");
+const isWin = process.platform === "win32";
+
+function fromDist() {
+  const p = clientBinaryPath(target);
+  return fs.existsSync(p) ? p : null;
+}
+
+function fromLocalBin() {
+  const p = path.join(pkgRoot, "bin", exe);
+  return fs.existsSync(p) ? p : null;
+}
+
+function buildFromSource() {
+  const go = findGo();
+  if (!go) return null;
+  const out = fromLocalBin() || path.join(pkgRoot, "bin", exe);
+  process.stderr.write(`magic-client: 未找到 ${target.dir} 预编译产物，用 go 现场编译 ...\n`);
+  try {
+    let version = "";
+    try {
+      version = require(path.join(pkgRoot, "package.json")).version || "";
+    } catch (_) {
+      /* 读不到就不注入 */
+    }
+    const ldflags = version
+      ? `-s -w -X github.com/darren/magic-agent/internal/cli.Version=${version}`
+      : "-s -w";
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    execFileSync(go, ["build", "-trimpath", "-ldflags", ldflags, "-o", out, "./cmd/magic-client"], {
+      cwd: pkgRoot,
+      stdio: ["ignore", "ignore", "pipe"],
+      env: { ...process.env, CGO_ENABLED: "0", GOOS: target.goos, GOARCH: target.goarch },
+    });
+    return fs.existsSync(out) ? out : null;
+  } catch (err) {
+    process.stderr.write(`magic-client: 现场编译失败: ${String(err.message).split("\n")[0]}\n`);
+    return null;
+  }
+}
+
+const bin =
+  process.env.MAGIC_CLIENT_BIN && fs.existsSync(process.env.MAGIC_CLIENT_BIN)
+    ? process.env.MAGIC_CLIENT_BIN
+    : fromDist() || fromLocalBin() || buildFromSource();
+
+if (!bin) {
+  const packed = fs.existsSync(distDir) ? fs.readdirSync(distDir) : [];
+  process.stderr.write(
+    `magic-client: 当前平台 ${target.dir} 没有可用二进制（期望 ${clientBinaryPath(target)}）\n` +
+      `已打包的平台：${packed.length ? packed.join(", ") : "（无）"}\n` +
+      `解决办法：装 Go 后重跑本命令（会自动现场编译），或 npm run build 重新打包。\n`
+  );
+  process.exit(1);
+}
+
+const res = spawnSync(bin, process.argv.slice(2), { stdio: "inherit", env: clientEnv(bin) });
+
+// clientEnv 让插件用**同目录的** core 校验契约。
+//
+// 为什么不能靠 PATH：npm 包里两个二进制并排（npm/dist/<plat>/），而 PATH 里那份
+// 可能是别处装的旧版本 —— 契约版本一比对不过，插件就直接拒绝启动，
+// 用户看到的却是「刚装的这个坏了」。已经显式设了 MAGIC_AGENT_BIN 就尊重它。
+function clientEnv(self) {
+  const env = { ...process.env };
+  if (env.MAGIC_AGENT_BIN) return env;
+  const sibling = path.join(path.dirname(self), exeName(currentTarget().goos));
+  if (fs.existsSync(sibling)) env.MAGIC_AGENT_BIN = sibling;
+  return env;
+}
+
+if (res.error) {
+  process.stderr.write(`magic-client: 启动失败: ${res.error.message}\n`);
+  process.exit(1);
+}
+if (res.signal) {
+  if (isWin) process.exit(1);
+  process.kill(process.pid, res.signal);
+  process.exit(1);
+}
+process.exit(res.status === null ? 1 : res.status);

package/npm/install.js

@@ -20,46 +20,69 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
-const { currentTarget, binaryPath, pkgRoot, findGo } = require("./lib/platform");
+const { currentTarget, binaryPath, clientBinaryPath, pkgRoot, findGo } = require("./lib/platform");
 
-// ── 1) magic-agent 二进制 ──────────────────────────────────────
+// ── 1) magic-agent / magic-client 二进制 ───────────────────────
+//
+// 两个入口一起兜底：client 缺了，`magic-agent client start` 会报「找不到 magic-client」，
+// 而手机连接完全依赖它 —— 装上了却连不上，比装不上更难查。
 
 const target = currentTarget();
-const out = binaryPath(target);
+const BINARIES = [
+  { name: "magic-agent", out: binaryPath(target), entry: "./cmd/magic-agent" },
+  { name: "magic-client", out: clientBinaryPath(target), entry: "./cmd/magic-client" },
+];
 
-if (!fs.existsSync(out)) {
+for (const b of BINARIES) {
+  if (fs.existsSync(b.out)) continue;
   const go = findGo();
   if (go) {
     const pkg = require(path.join(pkgRoot, "package.json"));
-    process.stdout.write(`magic-agent: 当前平台 ${target.dir} 无预编译产物，尝试用 go 现场编译 ... `);
+    process.stdout.write(`magic-agent: 当前平台 ${target.dir} 无 ${b.name} 预编译产物，尝试用 go 现场编译 ... `);
     try {
       execFileSync(
         go,
-        ["build", "-trimpath", "-ldflags", `-s -w -X github.com/darren/magic-agent/internal/cli.Version=${pkg.version}`, "-o", out, "./cmd/magic-agent"],
+        ["build", "-trimpath", "-ldflags", `-s -w -X github.com/darren/magic-agent/internal/cli.Version=${pkg.version}`, "-o", b.out, b.entry],
         {
           cwd: pkgRoot,
           stdio: ["ignore", "ignore", "pipe"],
           env: { ...process.env, CGO_ENABLED: "0", GOOS: target.goos, GOARCH: target.goarch },
         }
       );
-      fs.chmodSync(out, 0o755);
+      // Windows 上没有 POSIX 权限位，chmodSync 会抛 EPERM/EINVAL，别碰。
+      if (target.goos !== "windows") fs.chmodSync(b.out, 0o755);
       console.log("ok");
     } catch (err) {
       console.log(`失败: ${err.message}`);
     }
   } else {
     process.stderr.write(
-      `magic-agent: 警告 - 当前平台 ${target.dir} 缺少预编译二进制，且本机未找到 go，命令可能无法运行。\n`
+      `magic-agent: 警告 - 当前平台 ${target.dir} 缺少 ${b.name} 预编译二进制，且本机未找到 go，命令可能无法运行。\n`
     );
   }
 }
 
 // ── 2) llm CLI（simonw/LLM）────────────────────────────────────
 
+// venv 的可执行目录：POSIX 是 <venv>/bin，Windows 是 <venv>/Scripts。
+// （Windows 的 venv 从来就是 Scripts；bin 只出现在 Unix。）
+function venvDir(home) {
+  return path.join(home, ".llm-venv", process.platform === "win32" ? "Scripts" : "bin");
+}
+
+/** llm 在 venv 里的可能文件名（Windows 上是 llm.exe）。 */
+function venvExeCandidates(home) {
+  const dir = venvDir(home);
+  return process.platform === "win32"
+    ? [path.join(dir, "llm.exe"), path.join(dir, "llm")]
+    : [path.join(dir, "llm")];
+}
+
 function haveLlm() {
   if (process.env.MAGIC_AGENT_LLM_BIN) return process.env.MAGIC_AGENT_LLM_BIN;
-  const venv = path.join(os.homedir(), ".llm-venv", "bin", "llm");
-  if (fs.existsSync(venv)) return venv;
+  for (const c of venvExeCandidates(os.homedir())) {
+    if (fs.existsSync(c)) return c;
+  }
   try {
     return execFileSync("llm", ["--version"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim() && "llm";
   } catch (_) {
@@ -70,7 +93,6 @@ function haveLlm() {
 
 function installLlm() {
   const home = os.homedir();
-  const venvBin = path.join(home, ".llm-venv", "bin");
 
   // 找一个能用的 python3（python3 > python；都不行时放弃）。
   let py = null;
@@ -91,10 +113,11 @@ function installLlm() {
     // Homebrew Python pip 可能因 PIP_BREAK_SYSTEM_PACKAGES / truststore 报错，
     // venv 内不需要这些；静音升级提示。
     delete env.PIP_BREAK_SYSTEM_PACKAGES;
+    // Windows 的 venv 自带 pip 一般已装好，但 -m pip 走解释器更稳。
     execFileSync(py, ["-m", "venv", path.join(home, ".llm-venv")], { stdio: ["ignore", "ignore", "pipe"] });
     execFileSync(
-      path.join(venvBin, "pip"),
-      ["install", "--quiet", "--disable-pip-version-check", "llm"],
+      py,
+      ["-m", "pip", "install", "--quiet", "--disable-pip-version-check", "llm"],
       { stdio: ["ignore", "ignore", "pipe"], env }
     );
     console.log("ok");