magic-agent 1.0.3 → 1.0.49

package/internal/session/sessionlog_read_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 )
 
 // 会话日志的增量读（断线续读）。这一组钉住三件最容易写错的事：
@@ -155,3 +156,412 @@ func TestReadSessionLogAfterEmptyDirRejected(t *testing.T) {
 		t.Fatal("空 dir 期望报错，实得 nil")
 	}
 }
+
+/* ── lean 读：解码前摘 snapshot（2026-10-20）──
+   snapshot 是「该 item 到此刻的累积整段」，每条增量都带一份 ⇒ 长会话二次方膨胀
+   （实测一条 9.4 万条 thinking 的会话 283MB 快照 / 整份 338MB）。回放侧只用增量 text
+   自己拼，没人读它 ⇒ 在**解码前**整段摘掉，避免为它分配 + 反转义。 */
+
+// leanSnapEvent 是解析 lean 结果用的类型：snapshot 必须解析出来为空。
+type leanSnapEvent struct {
+	Seq      uint64 `json:"seq"`
+	Text     string `json:"text"`
+	Snapshot string `json:"snapshot"`
+	Error    string `json:"error"`
+}
+
+func parseLeanSnapEvent(line []byte) (leanSnapEvent, error) {
+	var ev leanSnapEvent
+	err := json.Unmarshal(line, &ev)
+	return ev, err
+}
+
+// TestStripSnapshotField 钉住字节级摘除的各形态。
+//
+// 最要紧的是「不误伤」与「不提前收尾」：snapshot 值里有转义引号 / 花括号时，
+// 朴素地找下一个 `"` 或 `}` 会把后半行切坏（JSON 变成坏的 → 整条事件静默消失）。
+func TestStripSnapshotField(t *testing.T) {
+	cases := []struct{ name, in, want string }{
+		{
+			name: "末尾字段（thinking 的实际形态）",
+			in:   `{"seq":2,"text":"The","snapshot":"The"}`,
+			want: `{"seq":2,"text":"The"}`,
+		},
+		{
+			name: "后面还有字段（error / attachments）",
+			in:   `{"seq":3,"text":"a","snapshot":"cum","error":"boom"}`,
+			want: `{"seq":3,"text":"a","error":"boom"}`,
+		},
+		{
+			name: "值里有转义引号与反斜杠",
+			in:   `{"seq":4,"text":"a","snapshot":"say \"hi\" \\ done","error":"x"}`,
+			want: `{"seq":4,"text":"a","error":"x"}`,
+		},
+		{
+			name: "值不是字符串（结构快照）也能按括号配对跳过",
+			in:   `{"seq":5,"a":1,"snapshot":[{"x":"}"}],"b":2}`,
+			want: `{"seq":5,"a":1,"b":2}`,
+		},
+		{
+			name: "text 里出现转义后的同名字样不误伤",
+			in:   `{"seq":6,"text":"x,\"snapshot\":1","snapshot":"cum"}`,
+			want: `{"seq":6,"text":"x,\"snapshot\":1"}`,
+		},
+		{
+			name: "没有该字段原样返回",
+			in:   `{"seq":7,"text":"a"}`,
+			want: `{"seq":7,"text":"a"}`,
+		},
+		{
+			name: "坏值（未闭合）原样返回，交给 unmarshal 报错跳过",
+			in:   `{"seq":8,"snapshot":"never closed`,
+			want: `{"seq":8,"snapshot":"never closed`,
+		},
+		{
+			name: "末尾字段 + 值里有转义引号与花括号",
+			in:   `{"seq":9,"text":"t","snapshot":"say \"hi\" {x} \\ done"}`,
+			want: `{"seq":9,"text":"t"}`,
+		},
+		{
+			name: "末尾字段 + 值以偶数个反斜杠收尾",
+			in:   `{"seq":10,"text":"t","snapshot":"ends \\\\"}`,
+			want: `{"seq":10,"text":"t"}`,
+		},
+	}
+	for _, c := range cases {
+		if got := string(stripSnapshotField([]byte(c.in))); got != c.want {
+			t.Errorf("%s:\n  实得 %s\n  期望 %s", c.name, got, c.want)
+		}
+	}
+}
+
+// TestEndOfJSONString 钉住字符串结束位置的转义判据：反斜杠个数为偶数才是真结尾。
+func TestEndOfJSONString(t *testing.T) {
+	cases := []struct {
+		in   string
+		want int
+	}{
+		{`"abc"`, 5},
+		{`"a\"b"`, 6},
+		{`"a\\"`, 5},
+		{`"a\\\"b"`, 8},
+		{`""`, 2},
+		{`"never`, -1},
+	}
+	for _, c := range cases {
+		if got := endOfJSONString([]byte(c.in), 0); got != c.want {
+			t.Errorf("%s：实得 %d，期望 %d", c.in, got, c.want)
+		}
+	}
+}
+
+// TestReadSessionLogLeanDropsSnapshot 全量 / 增量两条 lean 读都要：
+//   - snapshot 解析出来为空（输出与「先读后删」一致）
+//   - 其它字段逐字保留
+//   - maxSeq 仍覆盖整个文件（合并/裁剪不影响游标判据）
+func TestReadSessionLogLeanDropsSnapshot(t *testing.T) {
+	dir := writeLog(t, "s",
+		`{"seq":1,"text":"a","snapshot":"a"}`,
+		`{"seq":2,"text":"b","snapshot":"ab","error":"x"}`,
+		`{"seq":3,"text":"c"}`,
+	)
+
+	evs, err := ReadSessionLogLean(dir, "s", parseLeanSnapEvent)
+	if err != nil {
+		t.Fatalf("lean 读失败：%v", err)
+	}
+	if len(evs) != 3 {
+		t.Fatalf("期望 3 条，实得 %d", len(evs))
+	}
+	for _, ev := range evs {
+		if ev.Snapshot != "" {
+			t.Fatalf("seq=%d 的 snapshot 应被摘掉，实得 %q", ev.Seq, ev.Snapshot)
+		}
+	}
+	if evs[1].Text != "b" || evs[1].Error != "x" {
+		t.Fatalf("snapshot 之后的字段被切坏了：%+v", evs[1])
+	}
+
+	// 非 lean 仍要能读到 snapshot（老行为不变）。
+	full, err := ReadSessionLog(dir, "s", parseLeanSnapEvent)
+	if err != nil {
+		t.Fatalf("全量读失败：%v", err)
+	}
+	if full[1].Snapshot != "ab" {
+		t.Fatalf("非 lean 应保留 snapshot，实得 %q", full[1].Snapshot)
+	}
+
+	// 增量 + lean：after=1 → 只回 2、3，但 maxSeq 仍是整份文件的 3。
+	inc, maxSeq, err := ReadSessionLogAfterLean(dir, "s", 1,
+		func(e leanSnapEvent) uint64 { return e.Seq }, parseLeanSnapEvent)
+	if err != nil {
+		t.Fatalf("lean 增量读失败：%v", err)
+	}
+	if len(inc) != 2 || inc[0].Seq != 2 || inc[1].Seq != 3 {
+		t.Fatalf("期望只回 seq=2,3，实得 %+v", inc)
+	}
+	if maxSeq != 3 {
+		t.Fatalf("maxSeq 应覆盖整个文件（期望 3，实得 %d）", maxSeq)
+	}
+}
+
+/* ── 尾部游标续读（2026-10-20）──
+   客户端（尤其移动端）每 3s 用 `/events?after=N` 轮询运行中会话；日志是纯追加的，
+   但 seq 只能解析出来 ⇒ 原先每次从文件头重扫全文，354MB 的会话单次 2~3.4s。
+   tailMark 记住「seq=N 之后的字节从哪开始」，续读只碰尾部。 */
+
+func appendLog(t *testing.T, path string, body string) {
+	t.Helper()
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(body); err != nil {
+		f.Close()
+		t.Fatal(err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func mustMark(t *testing.T, path string, seq uint64) tailMark {
+	t.Helper()
+	m, ok := loadTailMark(path, seq)
+	if !ok {
+		t.Fatalf("期望 %s 有 seq=%d 的尾部游标，实得没有", path, seq)
+	}
+	return m
+}
+
+func TestReadSessionLogAfterTailMark(t *testing.T) {
+	dir := writeLog(t, "s", `{"seq":1,"text":"a"}`, `{"seq":2,"text":"b"}`)
+	path := filepath.Join(dir, "s.jsonl")
+	seqOf := func(e seqEvent) uint64 { return e.Seq }
+
+	// 首次全量：读完应建 mark（seq=2，offset=文件末尾）。
+	if _, maxSeq, err := ReadSessionLogAfter(dir, "s", 0, seqOf, parseSeqEvent); err != nil || maxSeq != 2 {
+		t.Fatalf("全量读失败：maxSeq=%d err=%v", maxSeq, err)
+	}
+	st, _ := os.Stat(path)
+	m := mustMark(t, path, 2)
+	if m.offset != st.Size() {
+		t.Fatalf("全量读后游标 offset 期望 %d，实得 %+v", st.Size(), m)
+	}
+
+	// 追加两条 → after=2 走尾部续读，只回新增的。
+	appendLog(t, path, `{"seq":3,"text":"c"}`+"\n"+`{"seq":4,"text":"d"}`+"\n")
+	evs, maxSeq, err := ReadSessionLogAfter(dir, "s", 2, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 2 || evs[0].Seq != 3 || evs[1].Seq != 4 || maxSeq != 4 {
+		t.Fatalf("尾部续读期望 [3 4]/maxSeq=4，实得 %+v/maxSeq=%d", evs, maxSeq)
+	}
+	st, _ = os.Stat(path)
+	if m := mustMark(t, path, 4); m.offset != st.Size() {
+		t.Fatalf("续读后游标 offset 期望 %d，实得 %+v", st.Size(), m)
+	}
+
+	// 追平：空页，且 maxSeq 必须仍等于 after（否则会被误判成「游标超前」）。
+	evs, maxSeq, err = ReadSessionLogAfter(dir, "s", 4, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 0 || maxSeq != 4 {
+		t.Fatalf("追平期望 空页/maxSeq=4，实得 %+v/maxSeq=%d", evs, maxSeq)
+	}
+
+	// 末尾半行（还没落换行）不能消费；补上换行后才算。
+	appendLog(t, path, `{"seq":5,"text":"e"}`)
+	evs, maxSeq, err = ReadSessionLogAfter(dir, "s", 4, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 0 || maxSeq != 4 {
+		t.Fatalf("半行不该被返回：%+v/maxSeq=%d", evs, maxSeq)
+	}
+	if _, ok := loadTailMark(path, 5); ok {
+		t.Fatal("半行不该推进游标")
+	}
+	appendLog(t, path, "\n")
+	evs, maxSeq, err = ReadSessionLogAfter(dir, "s", 4, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 1 || evs[0].Seq != 5 || maxSeq != 5 {
+		t.Fatalf("落完换行后应读到 seq=5：%+v/maxSeq=%d", evs, maxSeq)
+	}
+
+	// after 与游标不吻合 → 退回全量，结果依旧正确（只是慢）。
+	evs, maxSeq, err = ReadSessionLogAfter(dir, "s", 1, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 4 || evs[0].Seq != 2 || evs[3].Seq != 5 || maxSeq != 5 {
+		t.Fatalf("游标不吻合时应回退全量：%+v/maxSeq=%d", evs, maxSeq)
+	}
+}
+
+// TestTailMarkKeepsRecentCursors 多客户端场景：各自游标错开一两拍时都要命中，
+// 只保留最近的几条（更老的自然回退全量）。
+func TestTailMarkKeepsRecentCursors(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "x.jsonl")
+	for seq := uint64(1); seq <= tailMarkKeep+2; seq++ {
+		storeTailMark(path, seq, int64(seq)*10)
+	}
+	for seq := uint64(1); seq <= 2; seq++ {
+		if _, ok := loadTailMark(path, seq); ok {
+			t.Fatalf("seq=%d 已超出保留窗口，不该还在", seq)
+		}
+	}
+	for seq := uint64(3); seq <= tailMarkKeep+2; seq++ {
+		if _, ok := loadTailMark(path, seq); !ok {
+			t.Fatalf("seq=%d 应仍在保留窗口内", seq)
+		}
+	}
+	// 同一 seq 以新偏移为准（文件被追加后重新算出更靠后的位置）。
+	storeTailMark(path, tailMarkKeep+2, 9999)
+	if m, _ := loadTailMark(path, tailMarkKeep+2); m.offset != 9999 {
+		t.Fatalf("同一 seq 应更新为新偏移，实得 %+v", m)
+	}
+}
+
+// TestReadSessionLogAfterTailMarkTruncated 文件被截断（日志重置 / 换了内容）时，
+// 游标必须作废、退回全量：否则 seek 到旧偏移会读到越界或错位的内容。
+func TestReadSessionLogAfterTailMarkTruncated(t *testing.T) {
+	dir := writeLog(t, "s", `{"seq":1,"text":"a"}`, `{"seq":2,"text":"b"}`, `{"seq":3,"text":"c"}`)
+	path := filepath.Join(dir, "s.jsonl")
+	seqOf := func(e seqEvent) uint64 { return e.Seq }
+
+	if _, _, err := ReadSessionLogAfter(dir, "s", 0, seqOf, parseSeqEvent); err != nil {
+		t.Fatal(err)
+	}
+	// 截回只剩 seq=1 那一行（比游标偏移还短）。
+	if err := os.WriteFile(path, []byte(`{"seq":1,"text":"a"}`+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	evs, maxSeq, err := ReadSessionLogAfter(dir, "s", 2, seqOf, parseSeqEvent)
+	if err != nil {
+		t.Fatalf("截断后不该报错：%v", err)
+	}
+	if len(evs) != 0 || maxSeq != 1 {
+		t.Fatalf("截断后期望 空页/maxSeq=1（调用方据此判超前重建），实得 %+v/maxSeq=%d", evs, maxSeq)
+	}
+}
+
+// TestReadSessionLogAfterLeanTailKeepsSlim 尾部续读也要走 slim（摘 snapshot）。
+func TestReadSessionLogAfterLeanTailKeepsSlim(t *testing.T) {
+	dir := writeLog(t, "s", `{"seq":1,"text":"a","snapshot":"a"}`)
+	path := filepath.Join(dir, "s.jsonl")
+	seqOf := func(e leanSnapEvent) uint64 { return e.Seq }
+
+	// 先用非 lean 建游标，再跑 lean 尾部续读。
+	if _, _, err := ReadSessionLogAfter(dir, "s", 0, seqOf, parseLeanSnapEvent); err != nil {
+		t.Fatal(err)
+	}
+	appendLog(t, path, `{"seq":2,"text":"ab","snapshot":"ab"}`+"\n")
+	evs, maxSeq, err := ReadSessionLogAfterLean(dir, "s", 1, seqOf, parseLeanSnapEvent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(evs) != 1 || evs[0].Seq != 2 || evs[0].Text != "ab" || maxSeq != 2 {
+		t.Fatalf("lean 尾部续读结果不对：%+v/maxSeq=%d", evs, maxSeq)
+	}
+	if evs[0].Snapshot != "" {
+		t.Fatalf("尾部续读也必须摘掉 snapshot，实得 %q", evs[0].Snapshot)
+	}
+}
+
+/* ── run_id ↔ session_id：正在跑的会话也要读得到（2026-10-15）──
+   用户要求：「不等终点事件就应该创建会话落库，这样多个客户端马上就能看到正在跑的会话」。
+   日志文件名按 session_id 落（引擎还没吐 id 时 core 先按 run_id 落，见 cli 的 sessionWriter），
+   而客户端手里的 id 往往还只是 run_id —— 不翻译就永远读到空历史（静默失败）。 */
+
+// TestResolveLogIDWhileRunning 正在跑的会话（登记表里只有 run_id、或刚回填 session_id）
+// 按 run_id 也要读得到内容。
+func TestResolveLogIDWhileRunning(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir) // 登记表与日志同目录（别碰真实的 ~/.magic-agent）
+
+	// ① 引擎还没吐 id：文件就在 run_id 名下（core 先按 run_id 落盘）。
+	if err := os.WriteFile(filepath.Join(dir, "run-y.jsonl"),
+		[]byte(`{"seq":1,"kind":"text","text":"a"}`+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	writeRecordForTest(t, dir, Record{RunID: "run-y", State: StateRunning, StartedAt: time.Now(), UpdatedAt: time.Now()})
+	if got := ResolveLogID(dir, "run-y"); got != "run-y" {
+		t.Fatalf("id 还没到手时按 run_id 应命中同名文件，实得 %q", got)
+	}
+	if !HasSessionLog(dir, "run-y") {
+		t.Fatal("刚开跑的会话就该 has_log=true")
+	}
+
+	// ② 拿到 id 后文件改名成 <session_id>.jsonl：按 run_id 仍要读得到（查登记表翻译）。
+	writeRecordForTest(t, dir, Record{RunID: "run-x", SessionID: "sess-x", State: StateRunning, StartedAt: time.Now(), UpdatedAt: time.Now()})
+	if err := os.WriteFile(filepath.Join(dir, "sess-x.jsonl"),
+		[]byte(`{"seq":1,"kind":"text","text":"b"}`+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if got := ResolveLogID(dir, "run-x"); got != "sess-x" {
+		t.Fatalf("改名后按 run_id 应翻成 sess-x，实得 %q", got)
+	}
+	if !HasSessionLog(dir, "run-x") || !HasSessionLog(dir, "sess-x") {
+		t.Fatal("两个名字都该读得到同一条会话的日志")
+	}
+
+	// ③ 都没有 → 原样返回 + has_log=false（别把「没历史」伪装成别的）。
+	if got := ResolveLogID(dir, "nope"); got != "nope" {
+		t.Fatalf("翻译不出来时应原样返回，实得 %q", got)
+	}
+	if HasSessionLog(dir, "nope") {
+		t.Fatal("没有日志时 has_log 必须是 false")
+	}
+}
+
+// TestResolveLogIDBySessionIDWhenFileKeptRunID 引擎整轮不调 OnSessionID（codex 这一脉）
+// → 日志文件**永远**叫 `<run_id>.jsonl`，而列表页与客户端手里的主键是 session_id。
+//
+// 只做单向翻译（run_id → session_id）救不了这种文件：按 session_id 去读，文件名对不上、
+// Find 查回来又是同一个 session_id，于是读到空。表现是最难查的一种错位 ——
+// 列表说 `has_log=true`、点开说「还没有事件」（用户 2026-10-18：「会话内容怎么没了」）。
+func TestResolveLogIDBySessionIDWhenFileKeptRunID(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+
+	writeRecordForTest(t, dir, Record{
+		RunID: "run-keep", SessionID: "sess-keep", State: StateDone,
+		StartedAt: time.Now(), UpdatedAt: time.Now(),
+	})
+	if err := os.WriteFile(filepath.Join(dir, "run-keep.jsonl"),
+		[]byte(`{"seq":1,"kind":"text","text":"a"}`+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if got := ResolveLogID(dir, "sess-keep"); got != "run-keep" {
+		t.Fatalf("文件没改名时按 session_id 应翻成 run-keep，实得 %q", got)
+	}
+	if !HasSessionLog(dir, "sess-keep") {
+		t.Fatal("按 session_id 问 has_log 也必须是 true（否则列表与详情自相矛盾）")
+	}
+	// 反方向照旧：同名命中最先返回。
+	if got := ResolveLogID(dir, "run-keep"); got != "run-keep" {
+		t.Fatalf("按 run_id 读应原样命中，实得 %q", got)
+	}
+	// 两个 id 都不是的，原样返回（别把别人的会话认进来）。
+	if got := ResolveLogID(dir, "nope"); got != "nope" {
+		t.Fatalf("认不出来时应原样返回，实得 %q", got)
+	}
+}
+
+// writeRecordForTest 直接落一条登记记录（Begin 会自己生成 run_id，这里要指定它）。
+func writeRecordForTest(t *testing.T, dir string, rec Record) {
+	t.Helper()
+	b, err := json.Marshal(rec)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, rec.RunID+".json"), b, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}