magic-agent 1.0.0

package/internal/session/session_append_test.go

@@ -0,0 +1,161 @@
+package session
+
+// session_append_test.go - 常驻会话追加入口（unix socket）的单元测试。
+//
+// 覆盖：ListenAppend 把 socket 路径写进记录（权限 0600）/ 往返投递 / 空内容与未知 id 报错 /
+// 没有追加入口时的可操作提示 / socket 已死时把记录标 gone / Close 删 socket 文件。
+
+import (
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// startAppender 起一条带追加入口的会话，返回句柄与消息通道。
+func startAppender(t *testing.T) (*Handle, *Appender, chan string) {
+	t.Helper()
+	isolate(t)
+	h, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ap, err := ListenAppend(h)
+	if err != nil {
+		if runtime.GOOS == "windows" {
+			t.Skipf("Windows 无 unix socket（预期报错）: %v", err)
+		}
+		t.Fatalf("ListenAppend: %v", err)
+	}
+	t.Cleanup(ap.Close)
+	ch := make(chan string, 4)
+	go ap.Serve(ch)
+	return h, ap, ch
+}
+
+func TestListenAppendRegistersSocket(t *testing.T) {
+	h, ap, _ := startAppender(t)
+
+	if ap.Path() == "" {
+		t.Fatal("socket 路径为空")
+	}
+	if got := h.Record().Append; got != ap.Path() {
+		t.Errorf("记录里的 append = %q want %q", got, ap.Path())
+	}
+	st, err := os.Stat(ap.Path())
+	if err != nil {
+		t.Fatalf("socket 文件不存在: %v", err)
+	}
+	if perm := st.Mode().Perm(); perm != 0o600 {
+		t.Errorf("socket 权限 = %o want 600（只有同用户能追加）", perm)
+	}
+	// 记录落盘后也能读到（--append 就是从磁盘读的）
+	rec, found, err := Find(h.RunID())
+	if err != nil || !found {
+		t.Fatalf("Find: found=%v err=%v", found, err)
+	}
+	if rec.Append != ap.Path() {
+		t.Errorf("磁盘记录的 append = %q", rec.Append)
+	}
+}
+
+func TestAppendMessageDelivers(t *testing.T) {
+	h, _, ch := startAppender(t)
+
+	res, err := AppendMessage(h.RunID(), "追加：顺便把日志也整理了")
+	if err != nil {
+		t.Fatalf("AppendMessage: %v", err)
+	}
+	if !res.Queued {
+		t.Errorf("应 queued=true: %+v", res)
+	}
+	select {
+	case got := <-ch:
+		if got != "追加：顺便把日志也整理了" {
+			t.Errorf("收到的消息 = %q", got)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("消息没投递到常驻进程")
+	}
+}
+
+// 用会话 id 追加（观物台手里通常只有 session_id）。
+func TestAppendMessageBySessionID(t *testing.T) {
+	isolate(t)
+	h, err := Begin(BeginOptions{Engine: "claude", SessionID: "sid-append", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ap, err := ListenAppend(h)
+	if err != nil {
+		t.Skipf("Windows 无 unix socket: %v", err)
+	}
+	t.Cleanup(ap.Close)
+	ch := make(chan string, 2)
+	go ap.Serve(ch)
+
+	if _, err := AppendMessage("sid-append", "按会话 id 追加"); err != nil {
+		t.Fatalf("AppendMessage(session_id): %v", err)
+	}
+	select {
+	case got := <-ch:
+		if got != "按会话 id 追加" {
+			t.Errorf("收到的消息 = %q", got)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("没投递")
+	}
+}
+
+func TestAppendMessageErrors(t *testing.T) {
+	isolate(t)
+
+	if _, err := AppendMessage("whatever", "   "); err == nil {
+		t.Error("空内容应报错")
+	}
+	if _, err := AppendMessage("no-such-session", "hi"); err == nil {
+		t.Error("未知 id 应报错")
+	}
+
+	// 会话存在但没有追加入口（没用 --keep-alive 起）→ 提示要 --keep-alive
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	_, err := AppendMessage(h.RunID(), "hi")
+	if err == nil {
+		t.Fatal("没有追加入口应报错")
+	}
+	if !strings.Contains(err.Error(), "--keep-alive") {
+		t.Errorf("错误信息应点明要用 --keep-alive 启动: %v", err)
+	}
+	if !strings.Contains(err.Error(), "--session") {
+		t.Errorf("错误信息应给出「已结束用 --session 续接」的出路: %v", err)
+	}
+}
+
+// 记录说 running、socket 却连不上（常驻进程崩了）→ 报错并把记录标 gone。
+func TestAppendMessageDeadSocketMarksGone(t *testing.T) {
+	h, ap, _ := startAppender(t)
+	ap.Close() // 常驻进程「没了」
+
+	res, err := AppendMessage(h.RunID(), "hi")
+	if err == nil {
+		t.Fatal("连不上应报错")
+	}
+	if res.Record.State != StateGone {
+		t.Errorf("记录状态 = %q want %q", res.Record.State, StateGone)
+	}
+	got, _, _ := Find(h.RunID())
+	if got.State != StateGone {
+		t.Errorf("磁盘记录状态 = %q want %q", got.State, StateGone)
+	}
+}
+
+func TestAppenderCloseRemovesSocket(t *testing.T) {
+	_, ap, _ := startAppender(t)
+	path := ap.Path()
+	ap.Close()
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Errorf("Close 应删掉 socket 文件: %v", err)
+	}
+	ap.Close() // 幂等
+}

package/internal/session/session_kill_unix_test.go

@@ -0,0 +1,90 @@
+//go:build !windows
+
+package session
+
+// session_kill_unix_test.go - 「真的把进程停掉」的取证（unix）。
+//
+// 用一个真的 `sleep 30`（Setpgid 自成进程组，与引擎 CLI 同姿势）当靶子：
+// Stop 之后必须 Stopped=true 且进程真的没了；重复 Stop 必须幂等。
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+func TestStopKillsRealProcessGroup(t *testing.T) {
+	isolate(t)
+
+	cmd := exec.Command("sleep", "30")
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} // 引擎 CLI 就是这么起的
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("起测试进程: %v", err)
+	}
+	// 必须及时 reap：僵尸进程 kill(pid,0) 仍返回成功，会让 waitGone 白等到超时。
+	// （真实链路里 magic-agent 自己会 cmd.Wait()，等价于这里。）
+	go func() { _ = cmd.Wait() }()
+
+	pid := cmd.Process.Pid
+	if !agent.PIDAlive(pid) {
+		t.Fatal("测试进程没起来")
+	}
+
+	h, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.SetPID(pid, true) // spawn 钩子在真实链路里做的事
+
+	res, err := Stop(h.RunID())
+	if err != nil {
+		t.Fatalf("Stop: %v", err)
+	}
+	if !res.Stopped {
+		t.Fatalf("应 stopped=true: %+v", res)
+	}
+	if res.Record.State != StateCancelled {
+		t.Errorf("state = %q want %q", res.Record.State, StateCancelled)
+	}
+	if agent.PIDAlive(pid) {
+		t.Errorf("pid %d 还活着 —— 没真停掉", pid)
+	}
+
+	// 幂等：再停一次不报错、stopped=false
+	res2, err2 := Stop(h.RunID())
+	if err2 != nil {
+		t.Fatalf("重复停止应幂等: %v", err2)
+	}
+	if res2.Stopped {
+		t.Errorf("第二次不该报 stopped: %+v", res2)
+	}
+}
+
+// 用 session_id 也能停（观物台/看板手里通常只有会话 id）。
+func TestStopBySessionID(t *testing.T) {
+	isolate(t)
+
+	cmd := exec.Command("sleep", "30")
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	if err := cmd.Start(); err != nil {
+		t.Fatalf("起测试进程: %v", err)
+	}
+	go func() { _ = cmd.Wait() }()
+
+	h, _ := Begin(BeginOptions{Engine: "claude", SessionID: "sess-xyz"})
+	h.SetPID(cmd.Process.Pid, true)
+
+	res, err := Stop("sess-xyz")
+	if err != nil {
+		t.Fatalf("Stop(session_id): %v", err)
+	}
+	if !res.Stopped || res.Record.SessionID != "sess-xyz" {
+		t.Errorf("按 session_id 停失败: %+v", res)
+	}
+	if agent.PIDAlive(cmd.Process.Pid) {
+		t.Error("进程还在")
+	}
+}

package/internal/session/session_mark_test.go

@@ -0,0 +1,95 @@
+package session
+
+import (
+	"os"
+	"testing"
+)
+
+/* Handle.Mark：唯一的中途写状态入口（2026-09-29 统一会话状态词表时新增）。
+ *
+ * 它承担的是「引擎停下来等用户」这件事 —— 会话还活着，但**没在跑**，
+ * 所以界面上该显示「等审批」而不是「生成中」。三条契约：
+ *   ① running ↔ waiting_approval 能来回切，并且**落盘**（不是只改内存）；
+ *   ② 终态不许被翻回去（一个迟到的流事件不能把已结束的会话写成还在跑）；
+ *   ③ 不在这一对里的值一律不写（防止它被当成万能的改状态口子）。
+ *
+ * 为什么值得单独钉：这条路径在真机上不容易稳定复现（要引擎恰好发出一次
+ * 提问 / 待授权），而它一旦写错，错的是「这条会话结没结束」这种结论性信息。 */
+func TestHandleMarkWaitingApproval(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid(), PromptHead: "等审批"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	runID := h.RunID()
+
+	// ① 进「等审批」，且必须落盘
+	h.Mark(StateWaitingApproval)
+	if got := h.Record().State; got != StateWaitingApproval {
+		t.Fatalf("内存状态 = %q, want %q", got, StateWaitingApproval)
+	}
+	rec, found, err := Find(runID)
+	if err != nil || !found {
+		t.Fatalf("读回记录失败: err=%v found=%v", err, found)
+	}
+	if rec.State != StateWaitingApproval {
+		t.Errorf("落盘状态 = %q, want %q", rec.State, StateWaitingApproval)
+	}
+
+	// 用户作答（或这一轮的任何后续事件）→ 回到「正在跑」
+	h.Mark(StateRunning)
+	if got := h.Record().State; got != StateRunning {
+		t.Errorf("作答后状态 = %q, want %q", got, StateRunning)
+	}
+	rec2, _, _ := Find(runID)
+	if rec2.State != StateRunning {
+		t.Errorf("回到 running 也要落盘，实际 %q", rec2.State)
+	}
+}
+
+func TestHandleMarkDoesNotTouchTerminalState(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+
+	// 正常收尾之后，迟到的「等审批」不许把结论翻掉
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h.Finish("sid-1", StateDone)
+	h.Mark(StateWaitingApproval)
+	if got := h.Record().State; got != StateDone {
+		t.Errorf("终态被改写了：%q, want %q", got, StateDone)
+	}
+
+	// 被打断的会话同样不许被翻回 running（那会让「已经断了」变成「还在跑」）
+	h2, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h2.Finish("", StateInterrupted)
+	h2.Mark(StateRunning)
+	if got := h2.Record().State; got != StateInterrupted {
+		t.Errorf("被打断的会话被翻回 running 了：%q", got)
+	}
+}
+
+func TestHandleMarkRejectsOtherStates(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h.Mark(StateFailed) // 不在允许的一对里
+	h.Mark(StateDone)
+	h.Mark("")
+	if got := h.Record().State; got != StateRunning {
+		t.Errorf("Mark 不该把它改成 %q（只允许 running / waiting_approval）", got)
+	}
+}
+
+/* 旧记录里的 `stopped` 读出来必须是 `cancelled`：磁盘上有别的版本写下的老值，
+ * 读的时候不归一，界面上就会冒出一个谁也不认识的词。 */
+func TestNormalizeLegacyState(t *testing.T) {
+	if got := normalizeState("stopped"); got != StateCancelled {
+		t.Errorf("normalizeState(stopped) = %q, want %q", got, StateCancelled)
+	}
+	for _, s := range []string{StateRunning, StateWaitingApproval, StateDone, StateFailed, StateCancelled, StateInterrupted, StateGone} {
+		if got := normalizeState(s); got != s {
+			t.Errorf("normalizeState(%q) 不该改它，得到 %q", s, got)
+		}
+	}
+	if got := normalizeState("who_knows"); got != "who_knows" {
+		t.Errorf("不认识的词原样返回，得到 %q", got)
+	}
+}

package/internal/session/session_test.go

@@ -0,0 +1,237 @@
+package session
+
+// session_test.go - 会话登记表单元测试。
+//
+// 覆盖：Begin 落盘（running）/ pid 与 session_id 回填 / 按 run_id 与 session_id 查找 /
+// Stop（真杀进程、幂等、未知 id、已结束）/ 过期清理 / Finish 不覆盖 stopped。
+//
+// 全部用临时目录（t.Setenv(EnvDir)），不碰用户真实登记表。
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// isolate 把登记表指向临时目录。
+//
+// 刻意用 /tmp 下的**短**目录：unix socket 路径有 104 字节硬上限，
+// 而 t.TempDir() 在 macOS 下是 /var/folders/.../TestXxx/001/ 这种长路径，
+// 加上 run_id 会直接 bind 失败（我第一版就是这么挂的）。
+func isolate(t *testing.T) string {
+	t.Helper()
+	base := "/tmp"
+	if _, err := os.Stat(base); err != nil {
+		base = ""
+	}
+	dir, err := os.MkdirTemp(base, "mas-")
+	if err != nil {
+		t.Fatalf("MkdirTemp: %v", err)
+	}
+	t.Cleanup(func() { _ = os.RemoveAll(dir) })
+	t.Setenv(EnvDir, dir)
+	return dir
+}
+
+func TestBeginWritesRunningRecord(t *testing.T) {
+	dir := isolate(t)
+
+	h, err := Begin(BeginOptions{Engine: "claude", Model: "m1", PromptHead: "这张图什么颜色", PID: os.Getpid()})
+	if err != nil {
+		t.Fatalf("Begin: %v", err)
+	}
+	if h.RunID() == "" {
+		t.Fatal("RunID 不该为空")
+	}
+	// 文件已落盘且是合法 JSON
+	raw, err := os.ReadFile(filepath.Join(dir, h.RunID()+".json"))
+	if err != nil {
+		t.Fatalf("记录文件: %v", err)
+	}
+	var rec Record
+	if err := json.Unmarshal(raw, &rec); err != nil {
+		t.Fatalf("记录不是 JSON: %v", err)
+	}
+	if rec.State != StateRunning || rec.Engine != "claude" || rec.PID != os.Getpid() {
+		t.Errorf("记录内容不对: %+v", rec)
+	}
+	if rec.PromptHead != "这张图什么颜色" {
+		t.Errorf("PromptHead = %q", rec.PromptHead)
+	}
+
+	all, err := List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(all) != 1 {
+		t.Fatalf("List 条数 = %d want 1", len(all))
+	}
+}
+
+func TestSetPIDAndFinishBackfill(t *testing.T) {
+	isolate(t)
+
+	h, err := Begin(BeginOptions{Engine: "codebuddy", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// 引擎子进程起来了 → 覆盖成子 pid + 进程组模式
+	h.SetPID(12345, true)
+	rec := h.Record()
+	if rec.PID != 12345 || !rec.KillGroup {
+		t.Errorf("SetPID 未生效: %+v", rec)
+	}
+
+	// 新会话开始时 session_id 未知，收尾才回填
+	h.Finish("sess-abc", StateDone)
+	got, found, err := Find("sess-abc")
+	if err != nil || !found {
+		t.Fatalf("按 session_id 查找失败: found=%v err=%v", found, err)
+	}
+	if got.State != StateDone || got.PID != 12345 {
+		t.Errorf("收尾记录不对: %+v", got)
+	}
+	// run_id 也能查到同一条
+	if _, found, _ := Find(h.RunID()); !found {
+		t.Error("按 run_id 应能查到")
+	}
+}
+
+func TestFindPrefersRunning(t *testing.T) {
+	isolate(t)
+
+	// 同一 session_id 两条：先 done，后 running → 应优先 running
+	old, _ := Begin(BeginOptions{Engine: "claude", SessionID: "sid-1"})
+	old.Finish("sid-1", StateDone)
+	time.Sleep(2 * time.Millisecond) // 让 StartedAt 有区分度
+	cur, _ := Begin(BeginOptions{Engine: "claude", SessionID: "sid-1"})
+
+	got, found, err := Find("sid-1")
+	if err != nil || !found {
+		t.Fatalf("Find: found=%v err=%v", found, err)
+	}
+	if got.RunID != cur.RunID() {
+		t.Errorf("应优先 running 的那条: got %s want %s", got.RunID, cur.RunID())
+	}
+}
+
+func TestFindUnknown(t *testing.T) {
+	isolate(t)
+	if _, found, err := Find("nope"); err != nil || found {
+		t.Errorf("未知 id 应 found=false: found=%v err=%v", found, err)
+	}
+	if _, _, err := Find("  "); err == nil {
+		t.Error("空 id 应报错")
+	}
+}
+
+func TestStopAlreadyFinishedIsIdempotent(t *testing.T) {
+	isolate(t)
+
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h.Finish("sid-done", StateDone)
+
+	res, err := Stop("sid-done")
+	if err != nil {
+		t.Fatalf("已结束的会话不该报错（幂等）: %v", err)
+	}
+	if res.Stopped {
+		t.Error("已结束不该报 stopped=true")
+	}
+	if !strings.Contains(res.Reason, "已结束") {
+		t.Errorf("reason = %q", res.Reason)
+	}
+}
+
+func TestStopProcessGoneMarksGone(t *testing.T) {
+	isolate(t)
+
+	// 用一个几乎不可能存在的 pid
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: 999999})
+	h.SetPID(999999, true)
+
+	res, err := Stop(h.RunID())
+	if err != nil {
+		t.Fatalf("Stop: %v", err)
+	}
+	if res.Stopped {
+		t.Error("进程已不在，不该报 stopped=true")
+	}
+	if res.Record.State != StateGone {
+		t.Errorf("state = %q want %q", res.Record.State, StateGone)
+	}
+	if !strings.Contains(res.Reason, "进程已不在") {
+		t.Errorf("reason = %q", res.Reason)
+	}
+}
+
+func TestStopUnknownIDIsError(t *testing.T) {
+	isolate(t)
+	if _, err := Stop("no-such-session"); err == nil {
+		t.Fatal("未知 id 应报错（多半是写错了）")
+	}
+}
+
+func TestFinishKeepsStoppedState(t *testing.T) {
+	isolate(t)
+
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	// 模拟「被 --stop 停掉」：磁盘上写 stopped
+	h.Finish("", StateCancelled)
+	// 被杀的本进程随后以 failed 收尾 → 不能把 stopped 覆盖掉
+	h.Finish("sid-x", StateFailed)
+
+	got, found, _ := Find("sid-x")
+	if !found {
+		t.Fatal("记录丢了")
+	}
+	if got.State != StateCancelled {
+		t.Errorf("state = %q want %q（不能覆盖 cancelled）", got.State, StateCancelled)
+	}
+}
+
+func TestListPrunesExpiredRecords(t *testing.T) {
+	dir := isolate(t)
+
+	// 手工塞一条 25 小时前的记录（Retention = 24h）
+	old := Record{
+		RunID:     "run-old",
+		Engine:    "claude",
+		State:     StateDone,
+		StartedAt: time.Now().Add(-25 * time.Hour),
+		UpdatedAt: time.Now().Add(-25 * time.Hour),
+	}
+	data, _ := json.Marshal(old)
+	if err := os.WriteFile(filepath.Join(dir, "run-old.json"), data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// 再来一条坏的（非法 JSON）也应被清掉
+	if err := os.WriteFile(filepath.Join(dir, "run-broken.json"), []byte("{not json"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	all, err := List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(all) != 0 {
+		t.Errorf("过期/坏记录应被清掉, got %+v", all)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "run-old.json")); !os.IsNotExist(err) {
+		t.Error("过期文件应已删除")
+	}
+}
+
+func TestDirPrefersEnv(t *testing.T) {
+	isolate(t)
+	if got := Dir(); got == "" || !strings.Contains(got, "Test") && got == os.Getenv(EnvDir) {
+		t.Logf("Dir() = %q", got)
+	}
+	t.Setenv(EnvDir, "/tmp/x-sessions")
+	if got := Dir(); got != "/tmp/x-sessions" {
+		t.Errorf("Dir() = %q want /tmp/x-sessions", got)
+	}
+}