magic-agent 1.0.2 → 1.0.46

package/internal/cli/keepalive_test.go

@@ -92,7 +92,7 @@ func shortSessionsDir(t *testing.T) string {
 
 func TestKeepAliveRequiresStream(t *testing.T) {
 	kaEngineForTest(t)
-	_, _, err := runAskCmd(t, "", "-e", "codebuddy", "--keep-alive", "-p", "hi")
+	_, _, err := runAskCmd(t, "", "--save-registry", "-e", "codebuddy", "--keep-alive", "-p", "hi")
 	if err == nil {
 		t.Fatal("--keep-alive 不配 --stream 应报错")
 	}
@@ -143,7 +143,7 @@ func TestKeepAliveIsDefaultForStreaming(t *testing.T) {
 
 	done := make(chan error, 1)
 	go func() {
-		_, _, err := runAskCmd(t, "", "-e", "codebuddy", "--stream", "--idle", "1s", "-p", "首轮")
+		_, _, err := runAskCmd(t, "", "--save-registry", "-e", "codebuddy", "--stream", "--idle", "1s", "-p", "首轮")
 		done <- err
 	}()
 
@@ -183,7 +183,7 @@ func TestKeepAliveCanBeDisabled(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&streamingEngine{name: "fake-ka-off", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-ka-off", "--stream", "--keep-alive=false", "hi"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-ka-off", "--stream", "--keep-alive=false", "hi"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 	recs := mustListSessions(t, dir)
@@ -201,7 +201,7 @@ func TestKeepAliveNotAppliedToNonStream(t *testing.T) {
 	t.Setenv(session.EnvDir, dir)
 	registerFake(&stringEngine{name: "fake-ka-nostream", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-ka-nostream", "hi"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-ka-nostream", "hi"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 	recs := mustListSessions(t, dir)
@@ -255,7 +255,7 @@ func TestAppendToNonKeepAliveSession(t *testing.T) {
 	t.Setenv(session.EnvDir, shortSessionsDir(t))
 	registerFake(&stringEngine{name: "fake-ka-none", text: "ok"})
 
-	if _, _, err := runAskCmd(t, "", "-e", "fake-ka-none", "普通调用"); err != nil {
+	if _, _, err := runAskCmd(t, "", "--save-registry", "-e", "fake-ka-none", "普通调用"); err != nil {
 		t.Fatalf("ask: %v", err)
 	}
 	rows := parseSessions(t, mustSessions(t))
@@ -283,7 +283,7 @@ func TestKeepAliveAppendEndToEnd(t *testing.T) {
 	// ① 起常驻会话（后台跑，空闲 1s 自动收工）
 	done := make(chan error, 1)
 	go func() {
-		_, _, err := runAskCmd(t, "", "-e", "codebuddy", "--stream", "--keep-alive",
+		_, _, err := runAskCmd(t, "", "--save-registry", "-e", "codebuddy", "--stream", "--keep-alive",
 			"--idle", "1s", "-p", "首轮任务")
 		done <- err
 	}()
@@ -350,6 +350,101 @@ func TestKeepAliveAppendEndToEnd(t *testing.T) {
 	}
 }
 
+// TestKeepAliveAppendWithoutRegistry 默认不留档（不开 --save-registry）时，
+// --append 仍要能用 —— 走的是「按约定找 socket」那条路（session.AppendSocketPath）。
+//
+// 为什么这一条重要：常驻会话对 claude/codebuddy 是**默认开**的，而登记表默认不落。
+// 若 --append 只认登记表，用户会撞上「默认能常驻、却追加不了」这个自相矛盾的行为。
+// 代价是这条路径只认 run_id（session_id 要靠记录映射，没有记录就无从查起）。
+func TestKeepAliveAppendWithoutRegistry(t *testing.T) {
+	dir := shortSessionsDir(t)
+	t.Setenv(session.EnvDir, dir)
+
+	eng := kaEngineForTest(t)
+
+	// ① 起常驻会话（**不开** --save-registry）
+	done := make(chan error, 1)
+	go func() {
+		_, _, err := runAskCmd(t, "", "-e", "codebuddy", "--stream", "--keep-alive",
+			"--idle", "5s", "-p", "首轮任务")
+		done <- err
+	}()
+
+	// ② 登记表里什么都没有（这正是前提），只能等 socket 文件出现
+	if recs := mustListSessions(t, dir); len(recs) != 0 {
+		t.Fatalf("默认不该有登记记录，实际 %+v", recs)
+	}
+	var runID string
+	deadline := time.Now().Add(10 * time.Second)
+	for time.Now().Before(deadline) && runID == "" {
+		ents, _ := os.ReadDir(dir)
+		for _, e := range ents {
+			if strings.HasSuffix(e.Name(), ".sock") {
+				runID = strings.TrimSuffix(e.Name(), ".sock")
+			}
+		}
+		if runID == "" {
+			time.Sleep(50 * time.Millisecond)
+		}
+	}
+	if runID == "" {
+		t.Fatal("常驻会话没开出追加入口 socket")
+	}
+	// 按约定推出来的路径必须与实际建出来的同一个（两端算法唯一的交叉点）
+	if got, want := session.AppendSocketPath(runID), filepath.Join(dir, runID+".sock"); got != want {
+		t.Fatalf("AppendSocketPath = %q want %q", got, want)
+	}
+
+	// ③ 按 run_id 追加（记录不存在的路径）
+	stdout, _, err := runAskCmd(t, "", "--append", runID, "-p", "不留档也能追加")
+	if err != nil {
+		t.Fatalf("--append（无登记记录）: %v", err)
+	}
+	var out struct {
+		Type   string `json:"type"`
+		Queued bool   `json:"queued"`
+	}
+	if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &out); err != nil {
+		t.Fatalf("--append 输出不是 JSON: %v (%s)", err, stdout)
+	}
+	if out.Type != "append" || !out.Queued {
+		t.Errorf("--append 结果不对: %+v", out)
+	}
+
+	// ④ 引擎确实收到了；收工后 socket 照旧清掉
+	if got := waitAppend(t, eng, "不留档也能追加", 10*time.Second); got != "不留档也能追加" {
+		t.Errorf("引擎收到的追加 = %q", got)
+	}
+	// ⑤ --stop 依赖登记表（pid 只存在那里），所以不留档的会话**停不掉** ——
+	// 这是「默认不留痕」的已知代价，明写出来免得当成 bug 报回来。
+	if _, _, err := runAskCmd(t, "", "--stop", runID); err == nil {
+		t.Error("--stop 对不留档的会话应当报「找不到」（它靠登记表寻址）")
+	}
+	select {
+	case err := <-done:
+		if err != nil {
+			t.Fatalf("常驻会话收尾报错: %v", err)
+		}
+	case <-time.After(20 * time.Second):
+		t.Fatal("常驻会话没收工")
+	}
+}
+
+// waitAppend 等引擎收到追加内容（追加是异步投递的，socket 收到 ≠ 引擎已读）。
+func waitAppend(t *testing.T, eng *kaEngine, want string, d time.Duration) string {
+	t.Helper()
+	deadline := time.Now().Add(d)
+	for time.Now().Before(deadline) {
+		for _, got := range eng.received() {
+			if got == want {
+				return got
+			}
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	return ""
+}
+
 // mustListSessions 直接读登记表（比 --sessions 的 JSON 更直接，且能看到 append 字段）。
 func mustListSessions(t *testing.T, dir string) []session.Record {
 	t.Helper()

package/internal/cli/login.go

@@ -14,6 +14,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"sync"
 
 	"github.com/darren/magic-agent/internal/agent"
 	"github.com/spf13/cobra"
@@ -40,7 +41,11 @@ func runLogin(cmd *cobra.Command, opts *askOptions) error {
 		return err
 	}
 
-	// stdio 直通：交互式界面必须拿到真的 TTY。
+	/* stdio 直通：交互式界面必须拿到真的 TTY。
+	   ⚠️ 这里**刻意不设进程组**（普通引擎调用走 configureProcAttr 自成一组）：
+	   交互式 TUI 必须在**前台进程组**里，否则它从 tty 读输入会被 SIGTTIN 停住 ——
+	   表现就是「一进登录界面就卡住」。代之以「登记子进程 + 退出前带走」的清理
+	   （见 loginChild / stopLoginChild），保证它不会变成占着账号的孤儿。 */
 	c := exec.Command(bin, args...)
 	c.Stdin, c.Stdout, c.Stderr = os.Stdin, os.Stdout, os.Stderr
 	c.Env = agent.ChildEnvWith(extraEnv)
@@ -49,20 +54,72 @@ func runLogin(cmd *cobra.Command, opts *askOptions) error {
 	}
 
 	// 提示走 stderr：stdout 留给子进程的交互界面，不被污染。
+	// 第三行是给「上一次登录没成功」的情形：残留的登录态得先清掉，否则会一直登不上。
 	fmt.Fprintf(cmd.ErrOrStderr(),
 		"magic-agent: 已按 %s 的账号环境启动 %s\n"+
-			"            在里面执行 /login 完成登录（退出后本命令结束）\n", eng.Name(), bin)
+			"            在里面执行 /login 完成登录（退出后本命令结束）\n"+
+			"            若上一次登录没成功、这次进去仍登不上：先执行 /logout 清掉残留登录态，再执行 /login\n",
+		eng.Name(), bin)
 
-	if runErr := c.Run(); runErr != nil {
+	if startErr := c.Start(); startErr != nil {
+		return fmt.Errorf("启动 %s 失败: %w", bin, startErr)
+	}
+	setLoginChild(c)
+	defer clearLoginChild()
+
+	if runErr := c.Wait(); runErr != nil {
 		var ee *exec.ExitError
 		if errors.As(runErr, &ee) {
 			return fmt.Errorf("%s 会话退出码 %d", eng.Name(), ee.ExitCode())
 		}
-		return fmt.Errorf("启动 %s 失败: %w", bin, runErr)
+		return fmt.Errorf("%s 会话异常: %w", eng.Name(), runErr)
 	}
 	return nil
 }
 
+/* ── 交互式登录子进程的清理登记 ──────────────────────────────
+ *
+ * 为什么单独记一笔：登录是**唯一**不走进程组管理的子进程（理由见上面 runLogin 的
+ * 注释 —— 交互式 TUI 必须留在前台组里）。因此它既不在会话登记表（--stop 管不到），
+ * 也不会被 installSignalStop 的「杀会话」路径带走。一旦 magic-agent 被 SIGTERM
+ * （桌面壳的「停止」按钮、`kill <pid>`）终止，这个 CLI 就成孤儿，继续占着该账号的
+ * 配置目录 / 端口，下一次 --login 起来会撞上残留状态 —— 用户看到的就是
+ * 「登录失败后再也登不上」。所以退出前必须补一刀。
+ */
+var (
+	loginMu    sync.Mutex
+	loginChild *exec.Cmd
+)
+
+// setLoginChild 登记正在跑的登录子进程。
+func setLoginChild(c *exec.Cmd) {
+	loginMu.Lock()
+	loginChild = c
+	loginMu.Unlock()
+}
+
+// clearLoginChild 注销（登录会话正常结束 / 启动失败时调用）。
+func clearLoginChild() {
+	setLoginChild(nil)
+}
+
+/* stopLoginChild 杀掉正在跑的登录子进程（若在），返回是否真的动了手。
+ *
+ * 用**单进程**信号（group=false）：它本来就与 magic-agent 同组，负 pid 会把
+ * magic-agent 自己一起杀掉。
+ */
+func stopLoginChild() bool {
+	loginMu.Lock()
+	c := loginChild
+	loginChild = nil
+	loginMu.Unlock()
+	if c == nil || c.Process == nil {
+		return false
+	}
+	_ = agent.KillPID(c.Process.Pid, false)
+	return true
+}
+
 // loginCapableEngines 列出实现了 LoginRunner 的引擎名（报错提示用）。
 func loginCapableEngines() string {
 	var names []string

package/internal/cli/login_test.go

@@ -0,0 +1,99 @@
+package cli
+
+// login_test.go - `--login` 的参数校验与「退出前带走登录子进程」的清理契约。
+//
+// 这两件事都是「登录失败后再也登不上」那个用户问题的直接成因：
+//   - 参数写错时给一句看得懂的中文（而不是 cobra 的英文裸报错，且退出码要对）；
+//   - 登录 TUI 必须留在前台进程组里（否则读 tty 被 SIGTTIN 停住），代价是
+//     magic-agent 被 SIGTERM / 关终端时必须主动把它带走，不能留成占着账号的孤儿。
+
+import (
+	"errors"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// `--login` 后面没跟引擎名：必须给出中文 usage（点名可用引擎），且算参数错（exit 2）。
+// cobra 在解析阶段就报错（走不到 runLogin），所以这条靠 SetFlagErrorFunc 兜住。
+func TestLoginWithoutEngineNameIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login")
+	if err == nil {
+		t.Fatal("--login 缺引擎名应报错")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "需要引擎名") {
+		t.Errorf("应是中文用法提示，实际 %q", msg)
+	}
+	/* ⚠️ 不断言「提示里点名了 codebuddy」：包内用例会在 Engines() 首次调用前
+	   agent.Register 假引擎，触发 registry 的已知脆弱点（内置引擎整体不注册，
+	   见 agent/engine.go 的守卫注释），那时可用引擎列表本来就是空的。
+	   这里只锚定稳定契约：中文提示 + usage（exit 2）。 */
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 未知引擎名：usage 错误 + 列出可用引擎，不静默启一个空 bin。
+func TestLoginUnknownEngine(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login", "no-such-engine")
+	if err == nil {
+		t.Fatal("未知引擎应报错")
+	}
+	if !strings.Contains(err.Error(), "未知引擎") {
+		t.Errorf("错误应点名未知引擎，实际 %q", err.Error())
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 不支持交互式登录的引擎：明确说不必用 --login，而不是硬造一条命令。
+func TestLoginEngineWithoutLoginRunner(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--login", "claude")
+	if err == nil {
+		t.Fatal("claude 不支持 --login，应报错")
+	}
+	if !strings.Contains(err.Error(), "不需要 --login") {
+		t.Errorf("错误应说明该引擎不需要 --login，实际 %q", err.Error())
+	}
+}
+
+// 登录子进程必须能被 stopLoginChild 收掉（进程真死）。
+// 为什么值得测：登录是唯一不进进程组的子进程，孤儿化正是「登录失败后再也登不上」的成因。
+//
+// 判据用 c.Wait()（真回收）而不是 PIDAlive —— 被 SIGKILL 的子进程在没人 Wait 之前
+// 是僵尸，仍然会被 kill(pid, 0) 判成「活着」，拿它当判据会假红。
+func TestStopLoginChildKillsProcess(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("用 sleep 当靶子，Windows 另论")
+	}
+	c := exec.Command("sleep", "60")
+	if err := c.Start(); err != nil {
+		t.Fatalf("起靶子进程失败: %v", err)
+	}
+	setLoginChild(c)
+
+	if !stopLoginChild() {
+		t.Fatal("stopLoginChild 应报告动了手")
+	}
+
+	done := make(chan error, 1)
+	go func() { done <- c.Wait() }()
+	select {
+	case werr := <-done:
+		var ee *exec.ExitError
+		if !errors.As(werr, &ee) {
+			t.Fatalf("靶子应被信号杀掉，实际 err=%v", werr)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("登录子进程未被收掉（5s 内没退出）")
+	}
+
+	// 已经清空：再调一次不应再动手（幂等，避免误杀复用的 pid）。
+	if stopLoginChild() {
+		t.Error("注销后再调 stopLoginChild 不应再动手")
+	}
+}

package/internal/cli/permission_test.go

@@ -139,7 +139,11 @@ func TestEnginesReportsPermission(t *testing.T) {
 	if seen["codebuddy-ai"] != "flag:--permission-mode" {
 		t.Errorf("codebuddy-ai 的 permission 字段 = %q, want flag:--permission-mode", seen["codebuddy-ai"])
 	}
-	for _, e := range []string{"trae", "llm", "codex", "openclaw", "dsh", "arkclaw"} {
+	// dsh 的档位不走 flag，走子进程环境变量 —— 能力串是 env:<VAR>，客户端据此放行。
+	if seen["dsh"] != "env:DSH_PERMISSION_MODE" {
+		t.Errorf("dsh 的 permission 字段 = %q, want env:DSH_PERMISSION_MODE", seen["dsh"])
+	}
+	for _, e := range []string{"trae", "llm", "codex", "openclaw", "arkclaw"} {
 		if v, ok := seen[e]; !ok {
 			t.Errorf("--engines 缺 %s 行", e)
 		} else if v != "none" {

package/internal/cli/repair.go

@@ -0,0 +1,60 @@
+package cli
+
+// repair.go - `--repair-models <engine>`：还原被反向同步写坏的桌面端 models.json。
+//
+// 为什么要有它：2026-09-30 的 Windows 事故里，magic-agent 把桌面端（WorkBuddy）那份
+// **数组格式**的 models.json 覆盖成了 `{availableModels, models}` 对象格式，桌面端
+// 解析不了 → 模型清单整个为空。同步那一侧已经加了「陌生形状一律不动」的硬约束，
+// 但**已经坏掉的现场**需要一条能自己走回来的路 —— 否则用户只能手抄 apiKey。
+//
+// 还原逻辑在 agent.RepairDesktopModels（见 custom_models.go 的事故还原一节）：
+// 只认明确的坏形状才动手，动手前先留 .broken.bak。
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/darren/magic-agent/internal/agent"
+	"github.com/spf13/cobra"
+)
+
+// runRepairModels 处理 `--repair-models <engine>`。
+func runRepairModels(cmd *cobra.Command, opts *askOptions) error {
+	name := strings.TrimSpace(opts.repairModels)
+	if name == "" {
+		return &usageError{fmt.Errorf(
+			"--repair-models 需要引擎名：magic-agent --repair-models <engine>（可用：%s）",
+			strings.Join(agent.DesktopEngines(), " / "))}
+	}
+
+	// 引擎名先在这里校验：这是**参数错**（exit 2），而不是运行期失败（exit 1）。
+	// agent 层还会再兜一次，但那属于「不该发生」的安全网。
+	if agent.DesktopAppHomeOf(name) == "" {
+		return &usageError{fmt.Errorf("引擎 %q 没有对应的桌面端数据目录，没有可修的 models.json（可用：%s）",
+			name, strings.Join(agent.DesktopEngines(), " / "))}
+	}
+
+	repaired, note, err := agent.RepairDesktopModels(name)
+	if err != nil {
+		return err
+	}
+
+	// 机器可读的一行结果走 stdout（与 --sessions / --stop 同一族）；人看的说明走 stderr。
+	if eerr := json.NewEncoder(cmd.OutOrStdout()).Encode(map[string]any{
+		"engine":   name,
+		"repaired": repaired,
+		"note":     note,
+	}); eerr != nil {
+		return eerr
+	}
+	out := cmd.ErrOrStderr()
+	fmt.Fprintf(out, "magic-agent: %s\n", note)
+	if !repaired {
+		// 没改动不是失败，但必须说清「没动」，不静默（本项目铁律）。
+		fmt.Fprintf(out, "magic-agent: 未改动任何文件。形状对不上就不动，避免二次破坏。\n")
+		return nil
+	}
+	fmt.Fprintf(out, "magic-agent: 已还原。请重开桌面端确认模型清单；官方模型由桌面端自己拉取，不在这个文件里。\n")
+	return nil
+}

package/internal/cli/repair_test.go

@@ -0,0 +1,51 @@
+package cli
+
+// repair_test.go - `--repair-models` 的参数校验。
+//
+// 落地逻辑（形状识别 / 还原 / 备份 / 幂等）在 internal/agent/repair_models_test.go，
+// 这里只锁 CLI 层的契约：引擎名缺失或不支持桌面端时是**参数错**（exit 2），
+// 而不是被当成 prompt 发给引擎。
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestRepairModelsWithoutEngineNameIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models")
+	if err == nil {
+		t.Fatal("--repair-models 缺引擎名应报错")
+	}
+	if !strings.Contains(err.Error(), "需要引擎名") {
+		t.Errorf("应是中文用法提示，实际 %q", err.Error())
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 显式给空串同样走校验（与 --login 同一取舍：用「传过没有」而不是「值非空」判断）。
+func TestRepairModelsEmptyEngineIsUsageError(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models", "")
+	if err == nil {
+		t.Fatal("空引擎名应报错")
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}
+
+// 没有桌面端数据目录的引擎：参数错，并点名可用值。
+func TestRepairModelsUnsupportedEngine(t *testing.T) {
+	_, _, err := runAskCmd(t, "", "--repair-models", "claude")
+	if err == nil {
+		t.Fatal("claude 没有桌面端 models.json，应报错")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "没有对应的桌面端数据目录") {
+		t.Errorf("错误应说明该引擎没有桌面端目录，实际 %q", msg)
+	}
+	if _, ok := err.(*usageError); !ok {
+		t.Errorf("应是 usageError（exit 2），实际 %T", err)
+	}
+}