pi-web-ui 0.90.1 → 0.92.0

package/dist/server/compaction-markers.js

@@ -0,0 +1,287 @@
+/**
+ * Compaction transcript markers + transcript repair (issue #235).
+ *
+ * 背景：pi-web-ui 在 compaction_start 时往会话 JSONL 尾追加一行自有的 custom
+ * 标记（crash-safe 的"正在压缩"记录），compaction_end 时原地改写为完成标记。
+ * 0.90.x 用硬编码 id（pi-web-ui-compaction-pending / -done），多次压缩后文件
+ * 里出现多个同名 entry；SDK 的 byId 索引是 last-wins，leaf 又是文件最后一行，
+ * 若标记恰为末行则新消息的 parentId 记成共享 id，下次 open 回溯 parent 链成环，
+ * getBranch 死循环 push 直到 V8 抛 RangeError: Invalid array length，整个会话
+ * 打不开（"Failed to initialize session"）。
+ *
+ * 本模块：
+ * - makeCompactionMarkerId：每次压缩唯一 id，根除新坏文件；
+ * - repairSessionTranscript：纯函数，移除残留 pending（其子节点旁路到 pending
+ *   的 parent，marker 对 LLM 上下文零贡献）＋ 重复 id 改名 ＋ 重复 id 引用改指
+ *   最近的前序同名 ＋ 环路截断。只改坏行，其余字节不动；
+ * - repairSessionFile：落盘版，改前写 <原名>.bak（已存在则保留最早那份）；
+ * - looksLikeChainCorruption：识别链损坏报错，供 open 重试分支用。
+ */
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+export const COMPACTION_PENDING_TYPE = "pi-web-ui/compaction-pending";
+export const COMPACTION_DONE_TYPE = "pi-web-ui/compaction-done";
+/** 0.90.x 写死的 id——repair 用来识别存量坏标记。 */
+const LEGACY_PENDING_ID = "pi-web-ui-compaction-pending";
+const LEGACY_DONE_ID = "pi-web-ui-compaction-done";
+/** 每次压缩唯一 id：Date.now 保证先后可辨，random 保证同毫秒不撞。 */
+export function makeCompactionMarkerId(kind) {
+    return `pi-web-ui-compaction-${kind}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+function markerKindOf(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return null;
+    const e = entry;
+    if (e.type !== "custom" || typeof e.id !== "string")
+        return null;
+    if (e.customType === COMPACTION_PENDING_TYPE)
+        return "pending";
+    if (e.customType === COMPACTION_DONE_TYPE)
+        return "done";
+    // 兜底：customType 丢失的手工改坏文件，按 id 前缀认（SDK 自生成的 id 不带此前缀）。
+    if (e.id === LEGACY_PENDING_ID || e.id.startsWith(`${LEGACY_PENDING_ID}-`))
+        return "pending";
+    if (e.id === LEGACY_DONE_ID || e.id.startsWith(`${LEGACY_DONE_ID}-`))
+        return "done";
+    return null;
+}
+function parentIdOf(entry) {
+    const p = entry.parentId;
+    return typeof p === "string" ? p : null;
+}
+/**
+ * 修复会话转录文本。健康文件原样返回（changed=false，text === raw）。
+ * 有坏必修：pending 残留→删（子节点旁路）；重复 id→首个保留、其余改名，
+ * 引用改指最近前序同名；残余环→截断。调用方负责落盘＋备份（见 repairSessionFile）。
+ */
+export function repairSessionTranscript(raw) {
+    const result = {
+        text: raw,
+        changed: false,
+        removedPending: 0,
+        renamedIds: 0,
+        rewiredParents: 0,
+        cyclesBroken: 0,
+        interrupted: false,
+    };
+    const lines = raw.split("\n");
+    const slots = lines.map((line) => {
+        if (!line.trim())
+            return { raw: line, entry: null, removed: false, dirty: false, finalId: null };
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed === "object" && parsed !== null) {
+                const id = parsed.id;
+                return {
+                    raw: line,
+                    entry: parsed,
+                    removed: false,
+                    dirty: false,
+                    finalId: typeof id === "string" ? id : null,
+                };
+            }
+        }
+        catch {
+            // 脏行：SDK 加载时同样跳过，这里原样保留。
+        }
+        return { raw: line, entry: null, removed: false, dirty: false, finalId: null };
+    });
+    // 第 1 步：移除残留 pending，记录 id→parent 供子节点旁路。
+    const pendingParent = new Map();
+    for (const s of slots) {
+        if (!s.entry || markerKindOf(s.entry) !== "pending")
+            continue;
+        const id = typeof s.entry.id === "string" ? s.entry.id : null;
+        if (!id)
+            continue;
+        s.removed = true;
+        result.removedPending += 1;
+        if (!pendingParent.has(id))
+            pendingParent.set(id, parentIdOf(s.entry));
+    }
+    if (pendingParent.size > 0) {
+        const resolveBypass = (id) => {
+            // pending 套 pending 理论上不存在，visited 防万一。
+            const seen = new Set();
+            let cur = id;
+            while (cur !== null && pendingParent.has(cur) && !seen.has(cur)) {
+                seen.add(cur);
+                cur = pendingParent.get(cur) ?? null;
+            }
+            return cur;
+        };
+        for (const s of slots) {
+            if (s.removed || !s.entry)
+                continue;
+            const p = parentIdOf(s.entry);
+            if (p === null || !pendingParent.has(p))
+                continue;
+            const next = resolveBypass(p);
+            if (next === p)
+                continue;
+            if (next === null) {
+                // pending 本就没有 parent（首行标记）——子节点提升为根。
+                s.entry.parentId = null;
+            }
+            else {
+                s.entry.parentId = next;
+            }
+            s.dirty = true;
+            result.rewiredParents += 1;
+        }
+    }
+    // 第 2 步：重复 id 改名（首个保留），引用改指"最近的前序同名"。
+    // 先算每行的最终 id，再统一改引用，避免先改后认错。
+    const live = slots.filter((s) => !s.removed && s.entry && s.finalId !== null);
+    const seenIds = new Set();
+    const takenIds = new Set();
+    for (const s of live)
+        takenIds.add(s.finalId);
+    const dupSeq = new Map();
+    for (const s of live) {
+        const id = s.finalId;
+        if (!seenIds.has(id)) {
+            seenIds.add(id);
+            continue;
+        }
+        let k = (dupSeq.get(id) ?? 0) + 1;
+        let candidate = `${id}--dup-${k}`;
+        while (takenIds.has(candidate)) {
+            k += 1;
+            candidate = `${id}--dup-${k}`;
+        }
+        dupSeq.set(id, k);
+        s.finalId = candidate;
+        takenIds.add(candidate);
+        result.renamedIds += 1;
+    }
+    const dupIds = new Set();
+    {
+        const counts = new Map();
+        for (const s of live) {
+            const orig = typeof s.entry?.id === "string" ? s.entry.id : null;
+            if (orig)
+                counts.set(orig, (counts.get(orig) ?? 0) + 1);
+        }
+        for (const [id, c] of counts)
+            if (c > 1)
+                dupIds.add(id);
+    }
+    if (dupIds.size > 0) {
+        // origId → 按行序排好的 (行号, 最终id)
+        const occ = new Map();
+        live.forEach((s, i) => {
+            const orig = typeof s.entry?.id === "string" ? s.entry.id : null;
+            if (!orig || !dupIds.has(orig))
+                return;
+            let arr = occ.get(orig);
+            if (!arr) {
+                arr = [];
+                occ.set(orig, arr);
+            }
+            arr.push({ idx: i, finalId: s.finalId });
+        });
+        live.forEach((s, i) => {
+            if (!s.entry)
+                return;
+            const p = parentIdOf(s.entry);
+            if (p === null || !dupIds.has(p))
+                return;
+            const arr = occ.get(p);
+            let target = null;
+            for (const o of arr) {
+                if (o.idx < i)
+                    target = o.finalId;
+                else
+                    break;
+            }
+            // 引用落在全部同名之前（正常追加不可能，手改文件才有）——保持悬空，
+            // SDK 按 orphan 截断，安全降级。
+            if (target === null || target === p)
+                return;
+            s.entry.parentId = target;
+            s.dirty = true;
+            result.rewiredParents += 1;
+        });
+        // 应用改名。
+        for (const s of live) {
+            if (!s.entry || s.finalId === null || s.entry.id === s.finalId)
+                continue;
+            s.entry.id = s.finalId;
+            s.dirty = true;
+        }
+    }
+    // 第 3 步：残余环截断（纵深防御——前两步之后正常已无环）。
+    // byId 语义与 SDK 一致：同名取其一（此时已无重复）。
+    if (live.length > 0) {
+        const byId = new Map();
+        for (const s of live)
+            if (s.finalId !== null)
+                byId.set(s.finalId, s);
+        for (const s of live) {
+            if (!s.entry)
+                continue;
+            const seen = new Set([s.finalId]);
+            let prev = s;
+            let cur = parentIdOf(s.entry);
+            while (cur !== null) {
+                if (seen.has(cur)) {
+                    prev.entry.parentId = null;
+                    prev.dirty = true;
+                    result.cyclesBroken += 1;
+                    break;
+                }
+                seen.add(cur);
+                const next = byId.get(cur);
+                if (!next?.entry)
+                    break;
+                prev = next;
+                cur = parentIdOf(next.entry);
+            }
+        }
+    }
+    const anyChange = result.removedPending > 0 || result.renamedIds > 0 || result.rewiredParents > 0 || result.cyclesBroken > 0;
+    if (!anyChange)
+        return result;
+    result.changed = true;
+    result.interrupted = result.removedPending > 0;
+    const out = [];
+    for (const s of slots) {
+        if (s.removed)
+            continue;
+        out.push(s.dirty && s.entry ? JSON.stringify(s.entry) : s.raw);
+    }
+    result.text = out.join("\n");
+    return result;
+}
+/**
+ * 落盘版修复：健康文件只读不写；坏文件先写 <原名>.bak（已存在则保留最早那份，
+ * 不覆盖），再写回修复文本。读失败/写失败返回 null（调用方按原错误继续抛）。
+ */
+export function repairSessionFile(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const r = repairSessionTranscript(raw);
+    if (!r.changed)
+        return { ...r, file: filePath, backup: null };
+    try {
+        const bak = `${filePath}.bak`;
+        if (!existsSync(bak))
+            writeFileSync(bak, raw, "utf8");
+        writeFileSync(filePath, r.text, "utf8");
+        return { ...r, file: filePath, backup: bak };
+    }
+    catch {
+        return null;
+    }
+}
+/** 链损坏的典型报错（SDK getBranch 死循环 → V8 RangeError）。 */
+export function looksLikeChainCorruption(err) {
+    const msg = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+    return /invalid array length|maximum call stack|too much recursion/i.test(msg);
+}