magic-agent 2.4.3 → 2.6.3

package/internal/client/sessions_fold.go

@@ -0,0 +1,165 @@
+package client
+
+// sessions_fold.go - 会话清单按**会话**折叠（同一会话的多轮记录合并成一行）。
+//
+// 2026-10-26，用户报「会话列表现在显示很慢」的收尾一项。同一份登记表的实测：
+//
+//	全量 411 行  221.6KB
+//	去重 109 行   58.1KB   降幅 73.8%
+//
+// 也就是说列表里**四分之三的行是同一个会话的不同轮次**。它们对列表页毫无用处：
+// 左栏一屏最多画 60 行（QA_RAIL_MAX），407 行意味着用户要求的最新会话可能压根排不进
+// 那 60 行；移动端更是为此写了一段 40 行的并查集（client-ui-mobile/index.html 的 UF /
+// GROUP_KEY），就为了把「同一会话的两轮」藏掉。列表是**会话**视图，轮次是详情页的事。
+//
+// 为什么折在插件这一层而不是 core 的 `--sessions`：
+//   - `--sessions` 是**登记表**（run 级）的对外契约，掌天瓶桌面壳与手工 CLI 都在直接
+//     exec 它；改成会话级会动到别人的读法，收益却集中在「HTTP 列表接口每 5 秒传 211KB」
+//     这一条路上 —— 折在这里收益全拿、影响面最小。
+//   - core 那边真要改，应该另开一条会话级命令，而不是把登记表本身改掉。
+//
+// ⚠️ 折叠必须**保守**，三条硬约束：
+//  ① 没有 session_id 的行不动（引擎还没报 id 的首轮 / 旧记录）—— 它们本来就是独立一行，
+//     而且互相之间无从判断是不是同一会话。
+//  ② 被别的行当父指针引用的行**必须保留**。客户端认亲靠 `parent_run_id` 反查同一份清单
+//     （移动端 KEY2SID[parent_run_id]），折掉父行会让团队子任务变成一条孤儿顶层会话。
+//  ③ 组里有一行活着就显示那一行 —— 否则「正在跑」的那轮被折掉，列表上这条会话就
+//     变回「已完成」，用户点了会发现还在跑（停下按钮也没了）。
+//
+// 折叠后 has_log / title_summarized 取**组内或**：这两个字段回答的是「这条会话有没有
+// 历史可回看」「标题是不是真归纳过」，属于会话级属性，不该因为挑中了某一轮就变成 false
+// （踩过：挑中最早那轮 → 明明有历史却标成「无历史」，点开看不出坏在哪）。
+
+import (
+	"strings"
+
+	"github.com/darren/magic-agent/internal/session"
+)
+
+// foldSessionRuns 把同一会话的多轮记录折成一行，保持原有顺序。
+//
+// rows 是 core `--sessions` 解出来的原始行（新的在前）。返回新切片，不修改入参 ——
+// 入参是缓存里的原始输出解出来的，改它会污染后面的请求（缓存存的是字节，每次请求
+// 各自 Unmarshal，但保持函数无副作用更容易推理）。
+func foldSessionRuns(rows []map[string]any) []map[string]any {
+	if len(rows) < 2 {
+		return rows
+	}
+	/* 被引用的父 id：既要认 run_id 也要认 session_id（团队主会话每轮的 session_id 会换，
+	   子任务的两根父指针分别指向不同轮，见 client-ui-mobile 的 UF 注释）。 */
+	referenced := make(map[string]bool, len(rows))
+	for _, r := range rows {
+		if v := idField(r, "parent_run_id"); v != "" {
+			referenced[v] = true
+		}
+		if v := idField(r, "parent_session_id"); v != "" {
+			referenced[v] = true
+		}
+	}
+	/* 每组挑一条显示（组按 session_id 分）。 */
+	type pick struct {
+		idx  int
+		live bool
+	}
+	best := make(map[string]pick, len(rows))
+	keep := make([]bool, len(rows))
+	for i, r := range rows {
+		sid := idField(r, "session_id")
+		if sid == "" {
+			keep[i] = true // 约束 ①：没有会话 id 的行各自独立
+			continue
+		}
+		live := isLiveRow(r)
+		cur, ok := best[sid]
+		switch {
+		case !ok:
+			best[sid] = pick{idx: i, live: live}
+		case live && !cur.live:
+			// 约束 ③：活着的轮一定显示（哪怕它比别的轮旧 —— 活着就是当前状态）。
+			best[sid] = pick{idx: i, live: live}
+		case live == cur.live:
+			// 同档取更新的那轮。core 已按 started_at 倒序，所以「先遇到的」就是新的；
+			// 这里仍显式比较一次，免得将来 core 改了排序就静默挑了旧的。
+			if idField(r, "started_at") > idField(rows[cur.idx], "started_at") {
+				best[sid] = pick{idx: i, live: live}
+			}
+		}
+	}
+	for _, p := range best {
+		keep[p.idx] = true
+	}
+	/* 约束 ②：父行必须留 —— 与上面的挑法独立，可能额外多留几行。 */
+	for i, r := range rows {
+		if keep[i] {
+			continue
+		}
+		if referenced[idField(r, "run_id")] || referenced[idField(r, "session_id")] {
+			keep[i] = true
+		}
+	}
+	/* 组内或：会话级属性不该因为挑中某一轮而丢失（见文件头）。 */
+	logged := make(map[string]bool, len(best))
+	summarized := make(map[string]bool, len(best))
+	for _, r := range rows {
+		sid := idField(r, "session_id")
+		if sid == "" {
+			continue
+		}
+		if b, _ := r["has_log"].(bool); b {
+			logged[sid] = true
+		}
+		if b, _ := r["title_summarized"].(bool); b {
+			summarized[sid] = true
+		}
+	}
+	out := make([]map[string]any, 0, len(best)+2)
+	for i, r := range rows {
+		if !keep[i] {
+			continue
+		}
+		if sid := idField(r, "session_id"); sid != "" {
+			r = cloneRow(r)
+			if logged[sid] {
+				r["has_log"] = true
+			}
+			if summarized[sid] {
+				r["title_summarized"] = true
+			}
+		}
+		out = append(out, r)
+	}
+	return out
+}
+
+// cloneRow 浅拷贝一行，供折叠时改字段用（不改缓存解出来的原对象）。
+func cloneRow(r map[string]any) map[string]any {
+	cp := make(map[string]any, len(r))
+	for k, v := range r {
+		cp[k] = v
+	}
+	return cp
+}
+
+// isLiveRow 这一行是不是「还活着」的会话。
+//
+// 判据与核心始终一致：status（会话级统一状态）优先，缺失回落 state（这一轮的状态）。
+// 用 alive 字段不够 —— 它是 core 按 status==running 算出来的，而 idle / waiting_approval
+// 同样是活着的进程（常驻会话、等审批），也要优先显示。
+func isLiveRow(r map[string]any) bool {
+	if b, ok := r["alive"].(bool); ok && b {
+		return true
+	}
+	if session.IsLiveState(idField(r, "status")) {
+		return true
+	}
+	return session.IsLiveState(idField(r, "state"))
+}
+
+// idField 取一个**标识类**字段：缺失 / 类型不对都当空串，并去掉首尾空白。
+//
+// 为什么不直接用 strField（jobs_auto.go）：那个是「把任意值 JSON 化」的通用取值，
+// 不去空白；这里取的是 session_id / run_id / parent_* 这些要拿来做等值比较的键，
+// 带个尾随空格就会被当成另一个会话（分组错乱、认亲认不到，且完全看不出来）。
+func idField(r map[string]any, key string) string {
+	return strings.TrimSpace(strField(r, key))
+}

package/internal/client/sessions_fold_test.go

@@ -0,0 +1,204 @@
+package client
+
+// sessions_fold_test.go - 会话清单折叠（sessions_fold.go）的边界测试。
+//
+// 重点钉三件事：① 同会话多轮只留一行；② 被当父指针引用的行不能折掉；
+// ③ 活着的轮优先（否则列表上「正在跑」退回「已完成」，停止按钮也跟着消失）。
+// 另外钉住 has_log / title_summarized 的「组内或」—— 挑中哪一轮不该改变这两个会话级属性。
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// foldRow 造一行 core `--sessions` 形状的数据（只给折叠用到的字段）。
+func foldRow(sid, run string, started string, extra map[string]any) map[string]any {
+	r := map[string]any{
+		"session_id": sid,
+		"run_id":     run,
+		"started_at": started,
+		"state":      "done",
+		"status":     "done",
+		"has_log":    false,
+	}
+	for k, v := range extra {
+		r[k] = v
+	}
+	return r
+}
+
+func foldRunIDs(rows []map[string]any) []string {
+	out := make([]string, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, idField(r, "run_id"))
+	}
+	return out
+}
+
+func foldHas(rows []map[string]any, run string) map[string]any {
+	for _, r := range rows {
+		if idField(r, "run_id") == run {
+			return r
+		}
+	}
+	return nil
+}
+
+// 同一会话多轮 → 只留一行（新的那轮），顺序不变。
+func TestFoldSessionRunsKeepsNewestPerSession(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r3", "2026-10-26 12:00:00", nil),
+		foldRow("s1", "r2", "2026-10-26 11:00:00", nil),
+		foldRow("s1", "r1", "2026-10-26 10:00:00", nil),
+		foldRow("s2", "r9", "2026-10-26 09:00:00", nil),
+	}
+	got := foldSessionRuns(rows)
+	if want := []string{"r3", "r9"}; !equalStrings(foldRunIDs(got), want) {
+		t.Fatalf("折叠结果 = %v，want %v", foldRunIDs(got), want)
+	}
+	if got[0]["session_id"] != "s1" {
+		t.Errorf("留下的那条应该是新一轮: %v", got[0])
+	}
+}
+
+// 没有 session_id 的行**不折**：引擎还没报 id 的首轮、旧记录，各自独立一行。
+func TestFoldSessionRunsKeepsRowsWithoutSessionID(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("", "r2", "2026-10-26 12:00:00", nil),
+		foldRow("", "r1", "2026-10-26 11:00:00", nil),
+		foldRow("s1", "r0", "2026-10-26 10:00:00", nil),
+	}
+	got := foldSessionRuns(rows)
+	if want := []string{"r2", "r1", "r0"}; !equalStrings(foldRunIDs(got), want) {
+		t.Fatalf("无 session_id 的行被折掉了: %v，want %v", foldRunIDs(got), want)
+	}
+}
+
+// 活着的轮一定显示，哪怕它不是最新的一轮。
+//
+// 场景：新一轮已经起了行（但还在排队 / 尚未开始计时），旧一轮还在 idle（常驻会话）——
+// 按「取最新」会挑到排队那条，列表上这条会话就显示成「已完成」。
+func TestFoldSessionRunsPrefersLiveRun(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r-new", "2026-10-26 12:00:00", map[string]any{"state": "queued", "status": "queued"}),
+		foldRow("s1", "r-live", "2026-10-26 11:00:00", map[string]any{"state": "idle", "status": "idle"}),
+	}
+	got := foldSessionRuns(rows)
+	if len(got) != 1 {
+		t.Fatalf("应折成 1 行，实得 %d: %v", len(got), foldRunIDs(got))
+	}
+	if idField(got[0], "run_id") != "r-live" {
+		t.Errorf("活着的轮 (idle) 应优先于更新的排队轮，实得 %s", idField(got[0], "run_id"))
+	}
+}
+
+// alive 字段单独也能表达「活着」（core 按 status==running 算的）。
+func TestFoldSessionRunsHonoursAliveFlag(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r-new", "2026-10-26 12:00:00", nil),
+		foldRow("s1", "r-alive", "2026-10-26 11:00:00", map[string]any{"alive": true}),
+	}
+	got := foldSessionRuns(rows)
+	if len(got) != 1 || idField(got[0], "run_id") != "r-alive" {
+		t.Fatalf("alive 的轮应优先，实得 %v", foldRunIDs(got))
+	}
+}
+
+// 被父指针引用的行必须保留 —— 客户端认亲靠同一份清单里的 parent_run_id 反查，
+// 折掉父行会让团队子任务变成一条孤儿顶层会话（移动端 KEY2SID 查不到就自己当顶层）。
+func TestFoldSessionRunsKeepsReferencedParents(t *testing.T) {
+	rows := []map[string]any{
+		// 主会话 s1 两轮：r-parent 是子任务认的父，r-newest 是最新那轮。
+		foldRow("s1", "r-newest", "2026-10-26 12:00:00", nil),
+		foldRow("s1", "r-parent", "2026-10-26 11:00:00", nil),
+		foldRow("c1", "r-kid", "2026-10-26 11:30:00", map[string]any{
+			"parent_run_id": "r-parent",
+		}),
+	}
+	got := foldSessionRuns(rows)
+	ids := foldRunIDs(got)
+	if foldHas(got, "r-parent") == nil {
+		t.Fatalf("被引用的父行被折掉了，子会话会变孤儿: %v", ids)
+	}
+	if foldHas(got, "r-newest") == nil {
+		t.Errorf("组内显示的那行也该在: %v", ids)
+	}
+	if foldHas(got, "r-kid") == nil {
+		t.Errorf("子会话自己不能被折: %v", ids)
+	}
+}
+
+// parent_session_id 同样算引用（团队主会话每轮换 session_id，子任务两种指针都可能有）。
+func TestFoldSessionRunsKeepsParentSessionRefs(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r-newest", "2026-10-26 12:00:00", nil),
+		foldRow("s1", "r-parent", "2026-10-26 11:00:00", nil),
+		foldRow("c1", "r-kid", "2026-10-26 11:30:00", map[string]any{
+			"parent_session_id": "s1",
+			"parent_run_id":     "r-parent",
+		}),
+	}
+	got := foldSessionRuns(rows)
+	if foldHas(got, "r-parent") == nil {
+		t.Fatalf("按 parent_session_id 认亲时父行同样要留: %v", foldRunIDs(got))
+	}
+}
+
+// has_log / title_summarized 取组内或：挑中哪一轮不该让「有历史」「标题归纳过」变假。
+func TestFoldSessionRunsMergesSessionLevelFlags(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r-new", "2026-10-26 12:00:00", map[string]any{
+			"has_log": false, "title_summarized": false,
+		}),
+		foldRow("s1", "r-old", "2026-10-26 11:00:00", map[string]any{
+			"has_log": true, "title_summarized": true,
+		}),
+	}
+	got := foldSessionRuns(rows)
+	if len(got) != 1 {
+		t.Fatalf("应折成 1 行，实得 %d", len(got))
+	}
+	if b, _ := got[0]["has_log"].(bool); !b {
+		t.Error("组里有一轮留下了历史 → 这行必须 has_log=true（否则界面上标成「无历史」）")
+	}
+	if b, _ := got[0]["title_summarized"].(bool); !b {
+		t.Error("组里有一轮归纳过标题 → 这行必须 title_summarized=true（否则客户端每轮重打归纳）")
+	}
+}
+
+// 折叠不许改到缓存解出来的原对象（缓存存的是字节，这里保持「无副作用」更好推理）。
+func TestFoldSessionRunsDoesNotMutateInput(t *testing.T) {
+	rows := []map[string]any{
+		foldRow("s1", "r-new", "2026-10-26 12:00:00", map[string]any{"has_log": false}),
+		foldRow("s1", "r-old", "2026-10-26 11:00:00", map[string]any{"has_log": true}),
+	}
+	before, _ := json.Marshal(rows)
+	_ = foldSessionRuns(rows)
+	after, _ := json.Marshal(rows)
+	if string(before) != string(after) {
+		t.Fatalf("入参被改了:\n before=%s\n after =%s", before, after)
+	}
+}
+
+// 空 / 单行不该出错，也不该额外分配（走短路）。
+func TestFoldSessionRunsShortCircuits(t *testing.T) {
+	if got := foldSessionRuns(nil); got != nil {
+		t.Errorf("nil 应原样返回，实得 %v", got)
+	}
+	one := []map[string]any{foldRow("s1", "r1", "2026-10-26 12:00:00", nil)}
+	if got := foldSessionRuns(one); len(got) != 1 || idField(got[0], "run_id") != "r1" {
+		t.Errorf("单行应原样返回，实得 %v", foldRunIDs(got))
+	}
+}
+
+func equalStrings(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}