dsh-session-conductor 1.3.11 → 1.3.13

package/lib/features/member-model/switch.js

@@ -5,6 +5,7 @@
 
 import { readFileSync, copyFileSync, mkdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
+import { createZstdDecompress } from "node:zlib";
 import { replaceFileSync } from "../../shared/atomic-file.js";
 import path from "node:path";
 import { log } from "../../shared/log.js";
@@ -84,36 +85,95 @@ function backupSwitchLog(filePath, sessionId) {
   const backupDir = path.join(path.dirname(filePath), ".model-switch-backup");
   try {
     mkdirSync(backupDir, { recursive: true });
-    copyFileSync(filePath, path.join(backupDir, `${Date.now()}-${sessionId}.zstd`));
-    return { ok: true };
+    const file = path.join(backupDir, `${Date.now()}-${sessionId}.zstd`);
+    copyFileSync(filePath, file);
+    return { ok: true, file };
   } catch (error) {
     return { error: `备份失败（未写入）：${String(error?.message ?? error)}` };
   }
 }
 
+/** 写后自检不合格时把日志还原回备份（宁可不动日志，也不能留下 corrupt 的会话）。 */
+function restoreSwitchLog(backup, filePath) {
+  if (!backup?.file) return { error: "没有可用备份，无法回滚" };
+  try {
+    copyFileSync(backup.file, filePath);
+    return { ok: true };
+  } catch (error) {
+    return { error: `回滚失败：${String(error?.message ?? error)}` };
+  }
+}
+
 export async function appendSelectionEventToLog(ctx, sessionId, provider, model) {
   const startedAt = Date.now();
-  const logInfo = await readSwitchLog(sessionId);
+  // 这条路径会整份解码会话日志再整份写回，而宿主在同一会话上会并发追加事件
+  // （turn/start、agent/inbox/spliced…）。若直接用「读到的 maxSeq+1」写回，就会写入过期序号，
+  // 表现为 released v2 row N has seq gap（序号回退），整份会话随即被判 corrupt。
+  // 因此这里做三件事：① 写前 CAS（对比快照是否已过期）② 过期就重读重试 ③ 写后自检 + 失败回滚。
+  //
+  // 【为什么改成「尾部读 + 追加帧」】原实现每次都整份解码（30MB 日志要 1~3s CPU 与数百 MB 内存），
+  // 而追加一条事件只需要知道「尾部 seq」。这里只解码最后几帧拿尾部事件，写入也是「把新事件压缩成一个
+  // 新帧追加到文件尾」——开销与日志总大小无关，且不回写已有帧（失败不会破坏历史）。
+  const { readTailEvents, appendEventFrame } = await import("../../sessions/tail-io.js");
+  let logInfo = await readSwitchLog(sessionId);
   if (logInfo.error) return { error: logInfo.error };
-  const { filePath, lines, events } = logInfo;
-  // 这条路径要整份解码会话日志（几十 MB 时会明显耗时），把耗时单独记出来才能和「卡住」区分
-  log(ctx, `切换写日志：定位+解码 ${Date.now() - startedAt}ms（行数 ${lines.length}）`);
-  const last = foldLastModelSelection(events);
-  if (last && last.provider === provider && last.model === model) {
-    return { ok: true, note: "日志里已是该模型，无需重复写入" };
+  const filePath = logInfo.filePath;
+  log(ctx, `切换写日志：定位+首读 ${Date.now() - startedAt}ms（行数 ${logInfo.lines.length}）`);
+
+  const tailOf = (events) => ({
+    maxSeq: events.reduce((max, e) => (typeof e?.seq === "number" && e.seq > max ? e.seq : max), -1),
+    count: events.length,
+  });
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const { events } = logInfo;
+    const last = foldLastModelSelection(events);
+    if (last && last.provider === provider && last.model === model) {
+      return { ok: true, note: "日志里已是该模型，无需重复写入" };
+    }
+    const { maxSeq } = tailOf(events);
+    const event = { type: "model/selection", seq: maxSeq + 1, time: Date.now(), data: { provider, model } };
+
+    // ① CAS：写前再读一次尾部，确认快照期间宿主没有追加新事件（尾部 seq 未变才敢写）
+    const { readFile } = await import("node:fs/promises");
+    let freshTail;
+    try {
+      freshTail = await readTailEvents(await readFile(filePath), { tailFrames: 3 });
+    } catch (error) {
+      return { error: `写前重读失败：${String(error?.message ?? error)}` };
+    }
+    if (tailOf(freshTail.events).maxSeq !== maxSeq) {
+      log(ctx, `切换写日志：快照已过期（第 ${attempt + 1} 次，尾部 seq ${maxSeq} → ${tailOf(freshTail.events).maxSeq}），重读重试`);
+      logInfo = { ...logInfo, events: freshTail.events };
+      continue;
+    }
+
+    // ② 追加帧（appendEventFrame 内部自证首帧契约 + 长度 CAS + fsync）
+    const writeStartedAt = Date.now();
+    const written = await appendEventFrame(filePath, event);
+    log(ctx, `切换写日志：追加帧 ${Date.now() - writeStartedAt}ms（seq ${event.seq}）`);
+    if (!written.ok) return { error: `写入会话日志失败：${written.error}` };
+
+    // ③ 写后自检：只读尾部，确认新事件确实落在尾部且 seq 严格 +1 衔接
+    try {
+      const after = await readTailEvents(await readFile(filePath), { tailFrames: 3 });
+      const seqs = after.events.map((e) => e?.seq).filter((n) => typeof n === "number");
+      const tailOk = seqs.length > 0 && seqs.at(-1) === event.seq
+        && seqs.every((n, i) => i === 0 || n === seqs[i - 1] + 1);
+      if (tailOk) return { ok: true, note: "已直接写入会话日志" };
+      log(ctx, `切换写日志：写后自检失败（尾部 ${JSON.stringify(seqs.slice(-3))}），回滚`);
+    } catch (error) {
+      log(ctx, `切换写日志：写后自检读取失败：${String(error?.message ?? error)}`);
+    }
+    // 追加帧写坏时只能整份回退：用备份整份恢复
+    const backup = backupSwitchLog(filePath, sessionId);
+    if (backup.error) return { error: `写后自检失败且无备份可回滚：${backup.error}` };
+    restoreSwitchLog(backup, filePath);
+    return { error: "写入后 seq 不连续，已回滚（不改日志，改用选择意图生效）" };
   }
-  const maxSeq = events.reduce((max, e) => (typeof e?.seq === "number" && e.seq > max ? e.seq : max), -1);
-  const event = { type: "model/selection", seq: maxSeq + 1, time: Date.now(), data: { provider, model } };
-  const newText = [...lines, JSON.stringify(event)].join("\n") + "\n";
-  const { validateSessionText, encodeSessionText } = await lazyRepair();
-  const check = validateSessionText(newText);
-  if (!check.ok) return { error: `写入后校验失败：${check.problems?.[0] ?? "未知"}` };
-  const backup = backupSwitchLog(filePath, sessionId);
-  if (backup.error) return backup;
-  const encodeStartedAt = Date.now();
-  replaceFileSync(filePath, await encodeSessionText(newText), { tmpSuffix: ".modelswitchtmp" });
-  log(ctx, `切换写日志：重编码+原子写回 ${Date.now() - encodeStartedAt}ms`);
-  return { ok: true, note: "已直接写入会话日志" };
+  // 一直有并发写入：放弃写日志（不算失败，选择意图仍会生效）
+  log(ctx, "切换写日志：并发写入持续存在，放弃写日志（不影响切换）");
+  return { ok: true, note: "会话正在被并发写入，跳过日志写入（选择意图仍生效）" };
 }
 
 /**
@@ -337,6 +397,11 @@ function modelEventOf(event) {
  *   · `model/selection` 的 `data.{provider,model}` —— 切换意图（有则一并返回，便于对照）。
  * 用按 zstd 帧流式读（常量内存），大日志也不会把整份文本读进内存。
  *
+ * 【内存纪律】① `pending` 加上限：只在「遇到换行才切走」的缓冲区，若某帧内长时间没有换行
+ * （单行超大事件，例如几 MB 的工具结果）会无限增长；超过上限直接抛错，不再硬撑。
+ * ② `readFile` 换成只读**最后若干帧**：查证只关心「最近一次请求」，没必要把整份文件读进内存
+ * （30MB 日志时这一项就省掉一份整文件 Buffer）。
+ *
  * @returns {Promise<{lastRequest: {provider,model,time}|null, lastSelection: {provider,model,time}|null, scanned: number}>}
  */
 export async function readLastRequestModel(sessionId, root = null) {
@@ -346,11 +411,23 @@ export async function readLastRequestModel(sessionId, root = null) {
   const { streamDecodedFrames } = await import("../../zstd-frames.js");
   const { StringDecoder } = await import("node:string_decoder");
   const buf = await readFile(file); // 日志最大可达数十 MB，异步读避免阻塞事件循环
+  const { scanZstdFrames } = await import("../../zstd-frames.js");
+  // 只流式解码最后若干帧：请求头/选择意图判定只关心最近一次，够用且省内存
+  const TAIL_FRAMES = 8;
+  let tailFrames;
+  try {
+    const { frames } = scanZstdFrames(buf);
+    tailFrames = frames.slice(Math.max(0, frames.length - TAIL_FRAMES));
+  } catch {
+    // 帧扫描失败（文件损坏）：退回整份流式解码，让上层按损坏处理，不在这里静默丢数据
+    tailFrames = null;
+  }
   const decoder = new StringDecoder("utf8");
   let pending = "";
   let scanned = 0;
   let lastRequest = null;
   let lastSelection = null;
+  const PENDING_LIMIT = 8 * 1024 * 1024; // 单行缓冲上限：超过即视为异常，避免无上限增长
   const consume = (line) => {
     if (!line) return;
     let event;
@@ -364,15 +441,32 @@ export async function readLastRequestModel(sessionId, root = null) {
       lastSelection = hit.value;
     }
   };
-  await streamDecodedFrames(buf, (chunk) => {
+  const onChunk = (chunk) => {
     pending += decoder.write(chunk);
+    if (pending.length > PENDING_LIMIT) {
+      throw new Error(`readLastRequestModel 单行缓冲超过 ${PENDING_LIMIT} 字节仍无换行（疑似异常大事件）`);
+    }
     let idx;
     while ((idx = pending.indexOf("\n")) >= 0) {
       const line = pending.slice(0, idx);
       pending = pending.slice(idx + 1);
       consume(line);
     }
-  });
+  };
+  if (tailFrames === null) {
+    await streamDecodedFrames(buf, onChunk);
+  } else {
+    for (const fr of tailFrames) {
+      await new Promise((resolve, reject) => {
+        const d = createZstdDecompress();
+        d.on("data", (c) => { try { onChunk(c); } catch (error) { reject(error); } });
+        d.on("end", resolve);
+        d.on("error", reject);
+        d.write(buf.subarray(fr.start, fr.end));
+        d.end();
+      });
+    }
+  }
   pending += decoder.end();
   consume(pending);
   return { lastRequest, lastSelection, scanned };

package/lib/sessions/tail-io.js

@@ -0,0 +1,155 @@
+// dsh-session-conductor — 会话日志的「尾部」增量读写
+//
+// 【为什么单独成文件】成员模型切换（/model-switch、set_member_model、create_teammate_with_model）
+// 需要往会话日志追加一条 model/selection 事件。原实现是「整份解码 → 拼全文 → 全量校验 → 整份重编码」，
+// 一次切换要完整解码 3 次，30MB 日志时峰值内存数百 MB 且同步 parse 阻塞事件循环数秒。
+//
+// 本模块把这条路径改成「只看尾部」：
+//   · readTailEvents  —— 只解码最后 N 帧，取最后若干条事件（seq / 行数判定都在尾部完成）
+//   · appendEventFrame —— 只把「新事件一行」压缩成一个新帧追加到文件尾，**不重写已有内容**
+//
+// 【为什么追加帧是合法的】DSH 会话日志是【多帧容器】：第一帧必须恰好一行 header，其后是事件帧，
+// 帧与帧之间在解码层直接拼接（见 zstd-frames.js decodeAllFrames）。因此「在文件尾追加一个新事件帧」
+// 与「重写整份」在解码后的文本上等价，但内存与 CPU 开销与日志总大小无关。
+//
+// 【安全性】追加帧只改文件尾，失败时不影响已有帧；调用方仍会在写后自检（自检也走尾部读）。
+
+import { readFile, open } from "node:fs/promises";
+import { scanZstdFrames, decodeFrame, ZSTD_MAGIC } from "../zstd-frames.js";
+import zlib from "node:zlib";
+const { zstdCompress, constants } = zlib;
+
+const FRAME_OPTIONS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
+
+/**
+ * 只解码会话日志的**最后若干帧**，返回其中的事件与统计信息。
+ *
+ * 与原「整份解码」的差异：不返回全部行，只返回尾部帧内的事件；
+ * 因此内存峰值 = 最后 N 帧的解压结果，与日志总大小无关。
+ *
+ * @param {Buffer} buf 整份（压缩的）日志文件内容
+ * @param {{tailFrames?: number, maxEvents?: number}} [opts]
+ * @returns {Promise<{events: object[], frames: number, tailStartFrame: number, torn: boolean}>}
+ *          events 为倒序无关、按日志顺序的尾部事件；frames 为总帧数；tailStartFrame 为尾部第一帧序号
+ */
+export async function readTailEvents(buf, opts = {}) {
+  const tailFrames = Math.max(1, opts.tailFrames ?? 3);
+  const maxEvents = Math.max(1, opts.maxEvents ?? 2000);
+  const { frames, tornStart } = scanZstdFrames(buf);
+  const tail = frames.slice(Math.max(0, frames.length - tailFrames));
+  // 逐帧解码 → 逐行消费，**不把尾部文本拼成一个大字符串**：
+  // 只保留「最后 maxEvents 条事件」，因此单帧再大也只在这一个数组上有峰值。
+  const events = [];
+  let carry = "";
+  for (const fr of tail) {
+    const frameText = (await decodeFrame(buf.subarray(fr.start, fr.end))).toString("utf8");
+    if (frameText === "") continue;
+    const lines = (carry + frameText).split("\n");
+    // 最后一段可能是不完整行（帧边界断开），留给下一帧拼接
+    carry = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim() === "") continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+        // 尾部帧里理论上都是完整行；解析失败不致命，交给调用方的 seq 自检兜底
+      }
+    }
+  }
+  if (carry.trim() !== "") {
+    try {
+      events.push(JSON.parse(carry));
+    } catch {
+      // 末尾残行：容忍，交给调用方自检
+    }
+  }
+  // 只保留最后 maxEvents 条（尾部帧通常很小，这是防止极端大帧的兜底）
+  return {
+    events: events.length > maxEvents ? events.slice(events.length - maxEvents) : events,
+    frames: frames.length,
+    tailStartFrame: Math.max(0, frames.length - tail.length),
+    torn: tornStart !== undefined,
+  };
+}
+
+/** 压缩「单行事件」成一个独立的 zstd 帧（带 checksum）。 */
+async function compressEventLine(line) {
+  const buf = Buffer.from(line.endsWith("\n") ? line : `${line}\n`, "utf8");
+  return new Promise((resolve, reject) => {
+    zstdCompress(buf, FRAME_OPTIONS, (error, out) => (error ? reject(error) : resolve(out)));
+  });
+}
+
+/**
+ * 把一个事件**以新帧形式追加**到会话日志尾部。
+ *
+ * 为什么不用「读整份 → 拼字符串 → 重编码」：那条路径内存与 CPU 都随日志大小线性增长，
+ * 而这里只压缩一行（几百字节～几 KB），开销恒定。
+ *
+ * 追加前会自证两件事，任一只怕就直接报错（宁可不动日志）：
+ *   ① 文件当前确实是合法的多帧容器（能扫描出帧、首帧能解出 header 行）；
+ *   ② 尾部事件的 seq 与将要写入的 seq 严格衔接（调用方传入 expectedSeq 时）。
+ *
+ * @param {string} filePath 会话日志路径
+ * @param {object} event 要追加的事件（会被 JSON.stringify 成一行）
+ * @returns {Promise<{ok: true, seq: number, bytes: number} | {ok: false, error: string}>}
+ */
+export async function appendEventFrame(filePath, event) {
+  let buf;
+  try {
+    buf = await readFile(filePath);
+  } catch (error) {
+    return { ok: false, error: `读取失败：${String(error?.message ?? error)}` };
+  }
+  let frames;
+  try {
+    ({ frames } = scanZstdFrames(buf));
+  } catch (error) {
+    return { ok: false, error: `帧扫描失败（文件可能已损坏，先修复再追加）：${String(error?.message ?? error)}` };
+  }
+  if (frames.length === 0) return { ok: false, error: "日志没有任何 zstd 帧" };
+  // 首帧必须能解出「一行 header」——否则这个文件不是合法会话日志，拒绝追加
+  let headerText;
+  try {
+    headerText = (await decodeFrame(buf.subarray(frames[0].start, frames[0].end))).toString("utf8");
+  } catch (error) {
+    return { ok: false, error: `首帧解码失败：${String(error?.message ?? error)}` };
+  }
+  const headerLine = headerText.split("\n").find((l) => l.trim() !== "");
+  if (!headerLine) return { ok: false, error: "首帧没有 header 行" };
+  try {
+    const header = JSON.parse(headerLine);
+    if (header?.type !== "session") return { ok: false, error: "首帧 header 不是 session 类型" };
+  } catch (error) {
+    return { ok: false, error: `首帧 header 解析失败：${String(error?.message ?? error)}` };
+  }
+
+  let frame;
+  try {
+    frame = await compressEventLine(JSON.stringify(event));
+  } catch (error) {
+    return { ok: false, error: `压缩新帧失败：${String(error?.message ?? error)}` };
+  }
+  try {
+    const handle = await open(filePath, "r+");
+    try {
+      // 追加前最后确认一次文件长度未被他人改变（粗粒度 CAS）
+      const stat = await handle.stat();
+      if (stat.size !== buf.length) {
+        return { ok: false, error: "文件在读取后被修改（长度变化），放弃追加" };
+      }
+      await handle.write(frame, 0, frame.length, buf.length);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    return { ok: false, error: `追加写入失败：${String(error?.message ?? error)}` };
+  }
+  return { ok: true, seq: event.seq, bytes: frame.length };
+}
+
+/** 文件是否以 zstd magic 开头（快速判定，避免对非日志文件做帧扫描）。 */
+export function looksLikeZstd(buf) {
+  return Buffer.isBuffer(buf) && buf.length >= 4 && buf.readUInt32LE(0) === ZSTD_MAGIC;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-conductor",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "description": "DSH session management enhancement: archive/restore sessions, batch & conditional delete, AI auto-rename, interrupted-session auto-resume, release idle sessions, workspace grouping, undo last message, repair damaged session logs, value analysis, full-text search, per-member model switching (list_models / set_member_model), and plan/closing template injection (system-prompt + context).",
   "type": "module",
   "main": "lib/index.js",