dsh-live-compact 1.0.8 → 1.1.0

package/raw.js

@@ -6,8 +6,15 @@
  * An existing file must match the first meta hash. A mismatch is not a backup.
  */
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import {
+  discardShadowFiles,
+  ensureShadowDir,
+  tightenShadow,
+  writeShadowFile,
+  writeShadowOwner,
+} from "./shadow.js";
 
 export const PRUNE_MARKER = "[... tool result middle pruned ...]";
 
@@ -90,40 +97,106 @@ export function rawExcerptText(surface, record) {
 // 正文已经带修剪标记、又没有旧文件时，不把修剪后的文本当成原文。
 // Write once per toolCallId. An existing file is verified, never overwritten.
 // Pruned text with no earlier file is not stored as the original.
-export function captureToolResult({ dir, toolCallId, text, turn, name, pathLabel }) {
-  if (!toolCallId) return { ok: false, reason: "missing-id", toolCallId: "" };
+export function captureToolResult({
+  dir,
+  toolCallId,
+  text,
+  turn,
+  name,
+  pathLabel,
+  access = {},
+}) {
+  if (!toolCallId) {
+    return { ok: false, reason: "missing-id", toolCallId: "" };
+  }
+
   const body = String(text ?? "");
   const file = join(dir, rawName(toolCallId));
-  if (existsSync(file)) return readExisting(file, toolCallId);
-  if (body.includes(PRUNE_MARKER)) return { ok: false, reason: "already-pruned", toolCallId };
+  const metaPath = `${file}.meta.json`;
+
+  if (!existsSync(file) && body.includes(PRUNE_MARKER)) {
+    return { ok: false, reason: "already-pruned", toolCallId };
+  }
+
+  const readProtectedExisting = () => {
+    tightenShadow(file, "file", access);
+    if (existsSync(metaPath)) {
+      tightenShadow(metaPath, "file", access);
+    }
+    return readExisting(file, toolCallId);
+  };
+
+  let createdRaw = false;
+
   try {
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    ensureShadowDir(dir, access);
+
+    if (existsSync(file)) return readProtectedExisting();
+
     const bytes = Buffer.from(body, "utf8");
     const hash = contentHash(bytes);
-    const metaPath = `${file}.meta.json`;
-    writeFileSync(file, bytes, { flag: "wx", mode: 0o600 });
-    try {
-      writeFileSync(metaPath, JSON.stringify({
+
+    writeShadowFile(file, bytes, access, { exclusive: true });
+    createdRaw = true;
+
+    writeShadowFile(
+      metaPath,
+      JSON.stringify({
         toolCallId,
         bytes: bytes.length,
         sha256: hash,
         turn: turn ?? null,
         name: name || "",
         label: pathLabel || "",
-      }), { mode: 0o600 });
-    } catch (error) {
-      try {
-        unlinkSync(file);
-      } catch {}
+      }),
+      access,
+    );
+
+    return {
+      ok: true,
+      existed: false,
+      path: file,
+      bytes: bytes.length,
+      sha256: hash,
+      toolCallId,
+      label: pathLabel || "",
+    };
+  } catch (error) {
+    if (createdRaw) discardShadowFiles([file], error);
+
+    if (
+      error?.code === "ESHADOWACCESS" ||
+      error?.code === "ESHADOWCLEANUP"
+    ) {
       throw error;
     }
-    return { ok: true, existed: false, path: file, bytes: bytes.length, sha256: hash, toolCallId, label: pathLabel || "" };
-  } catch (error) {
-    if (error?.code === "EEXIST" && existsSync(file)) return readExisting(file, toolCallId);
+
+    if (error?.code === "EEXIST" && existsSync(file)) {
+      return readProtectedExisting();
+    }
+
     return { ok: false, reason: "unwritable", toolCallId };
   }
 }
 
+export function captureOwnedToolResult(options) {
+  const { dir, access = {} } = options;
+  const owner = join(dir, "owner");
+  const ownerExisted = existsSync(owner);
+  let ownerWritten = false;
+
+  try {
+    writeShadowOwner(dir, access);
+    ownerWritten = true;
+    return captureToolResult(options);
+  } catch (error) {
+    if (ownerWritten && !ownerExisted) {
+      discardShadowFiles([owner], error);
+    }
+    throw error;
+  }
+}
+
 export function pointerFor(record, readFile = readFileSync) {
   const id = record?.toolCallId || "";
   if (!id) return "";

package/shadow.js

@@ -7,9 +7,27 @@
  * Delete legacy root files, then dead sessions, then old files of the current session.
  * Never delete the current card's file or another live session. ENOENT counts as already freed.
  */
+import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { closeSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import {
+  chmodSync,
+  appendFileSync,
+  closeSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readFileSync,
+  readSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 
 const PLUGIN_NAME = /^(?:(?:cut|official|shadow)-\d+-[0-9a-f]{8}|raw-[0-9a-f]{16}|\d+-[0-9a-f]{8}-[0-9a-f]{8}|\d+-[0-9a-f]{8,16})\.txt$/;
 const SESSION_MARK = /^# spine-session (\S+)/;
@@ -52,6 +70,7 @@ export function shadowFileBody(sessionKey, body) {
 }
 
 export const STATS_NAME = "spine-stats.json";
+export const CUTS_NAME = "spine-cuts.jsonl";
 
 export function readCutStats(dir) {
   try {
@@ -60,9 +79,79 @@ export function readCutStats(dir) {
       cuts: Number(parsed.cuts) || 0,
       savedTokens: Number(parsed.savedTokens) || 0,
       rewriteTokens: Number(parsed.rewriteTokens) || 0,
+      drains: Number(parsed.drains) || 0,
     };
   } catch {
-    return { cuts: 0, savedTokens: 0, rewriteTokens: 0 };
+    return { cuts: 0, savedTokens: 0, rewriteTokens: 0, drains: 0 };
+  }
+}
+
+export function drainRewrite(notes) {
+  const cuts = (notes || []).filter((note) => note?.kind === "cut" && note.saved > 0);
+  if (!cuts.length) return 0;
+  const later = cuts.slice(1).reduce((sum, note) => sum + (note.saved || 0), 0);
+  return Math.max(0, (cuts[0].afterPrefix || 0) - later);
+}
+
+export function flushDrainStats(dir, notes, meta = {}) {
+  const cuts = (notes || []).filter((note) => note?.kind === "cut" && note.saved > 0);
+  const charged = drainRewrite(notes);
+  const saved = cuts.reduce((sum, note) => sum + note.saved, 0);
+  if (cuts.length) recordDrainStats(dir, { cuts: cuts.length, saved, rewrite: charged });
+  const lines = (notes || []).map((note, index) => JSON.stringify({
+    v: 1,
+    ts: new Date().toISOString(),
+    sid: meta.sid || "",
+    kind: note.kind || "cut",
+    pass: index,
+    drain: meta.drain === true,
+    saved: note.saved || 0,
+    rewriteCharged: note.kind === "cut" && index === (notes || []).findIndex((item) => item?.kind === "cut") ? charged : 0,
+    tailBeyondKept: note.tailBeyondKept || 0,
+    prefix: note.prefix || 0,
+    afterPrefix: note.afterPrefix || 0,
+    tokens: note.tokens || 0,
+    total: note.total || 0,
+    gate: note.gate || "cut",
+  }));
+  if (!lines.length) return charged;
+  try {
+    appendFileSync(join(dir, CUTS_NAME), `${lines.join("\n")}\n`);
+  } catch {}
+  return charged;
+}
+
+function recordDrainStats(dir, { cuts = 0, saved = 0, rewrite = 0 } = {}) {
+  if (!(cuts > 0) || !(saved > 0)) return null;
+  try {
+    const file = join(dir, STATS_NAME);
+    const lock = join(dir, "spine-stats.lock");
+    const tmp = `${file}.${process.pid}-${randomBytes(8).toString("hex")}.tmp`;
+    let fd;
+    try {
+      fd = openSync(lock, "wx");
+    } catch {
+      return null;
+    }
+    try {
+      const prev = readCutStats(dir);
+      const locked = {
+        cuts: prev.cuts + cuts,
+        savedTokens: prev.savedTokens + saved,
+        rewriteTokens: prev.rewriteTokens + rewrite,
+        drains: (Number(prev.drains) || 0) + 1,
+        updatedAt: new Date().toISOString(),
+      };
+      writeFileSync(tmp, JSON.stringify(locked));
+      renameSync(tmp, file);
+      return locked;
+    } finally {
+      try { unlinkSync(tmp); } catch {}
+      closeSync(fd);
+      try { unlinkSync(lock); } catch {}
+    }
+  } catch {
+    return null;
   }
 }
 
@@ -99,6 +188,179 @@ export function recordCutStats(dir, { saved = 0, rewrite = 0 } = {}) {
   }
 }
 
+export function shadowAccessPlan(platform = process.platform, userSid = "") {
+  if (platform === "win32") {
+    if (!/^S-\d+(?:-\d+)+$/.test(userSid)) {
+      throw new Error("spine: current Windows user SID is required");
+    }
+
+    return {
+      kind: "acl",
+      usesChmodOnly: false,
+      inheritance: "remove",
+      grant: [
+        `*${userSid}:(OI)(CI)F`,
+        "*S-1-5-18:(OI)(CI)F",
+        "*S-1-5-32-544:(OI)(CI)F",
+      ],
+      sddl:
+        `D:P(A;OICI;FA;;;${userSid})` +
+        "(A;OICI;FA;;;SY)" +
+        "(A;OICI;FA;;;BA)",
+    };
+  }
+
+  return {
+    kind: "mode",
+    usesChmodOnly: true,
+    dirMode: 0o700,
+    fileMode: 0o600,
+  };
+}
+
+export function defaultShadowAccessRunner({ path, kind, platform, execFile = execFileSync }) {
+  if (platform !== "win32") {
+    const plan = shadowAccessPlan(platform);
+    chmodSync(path, kind === "dir" ? plan.dirMode : plan.fileMode);
+    return true;
+  }
+
+  const identity = execFile(
+    "whoami.exe",
+    ["/user", "/fo", "csv", "/nh"],
+    { encoding: "utf8", windowsHide: true },
+  );
+  const match = identity.match(/,"(S-\d+(?:-\d+)+)"\s*$/i);
+  if (!match) {
+    throw new Error("spine: cannot determine current Windows user SID");
+  }
+
+  const plan = shadowAccessPlan("win32", match[1]);
+  const target = resolve(path);
+  const temp = mkdtempSync(join(tmpdir(), "spine-acl-"));
+
+  try {
+    const aclFile = join(temp, "access.acl");
+    const aclBody = `\ufeff${basename(target)}\r\n${plan.sddl}\r\n`;
+
+    writeFileSync(aclFile, Buffer.from(aclBody, "utf16le"), {
+      flag: "wx",
+      mode: 0o600,
+    });
+
+    execFile(
+      "icacls.exe",
+      [dirname(target), "/restore", aclFile, "/q"],
+      { stdio: "pipe", windowsHide: true },
+    );
+
+    return true;
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+export function tightenShadow(path, kind = "dir", access = {}) {
+  const platform = access.platform ?? process.platform;
+  const runner = access.runner ?? defaultShadowAccessRunner;
+
+  try {
+    if (runner({ path, kind, platform }) !== true) {
+      throw new Error("permission runner did not confirm success");
+    }
+  } catch (cause) {
+    const error = new Error(
+      "spine: shadow permission action failed; backup refused",
+      { cause },
+    );
+    error.code = "ESHADOWACCESS";
+    throw error;
+  }
+}
+
+export function ensureShadowDir(dir, access = {}) {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  tightenShadow(dir, "dir", access);
+  return dir;
+}
+
+export function discardShadowFiles(files, cause) {
+  const errors = [];
+
+  for (const file of files) {
+    try {
+      unlinkSync(file);
+    } catch (error) {
+      if (error?.code !== "ENOENT") errors.push(error);
+    }
+  }
+
+  if (errors.length > 0) {
+    const error = new AggregateError(
+      [cause, ...errors],
+      "spine: shadow write failed and cleanup failed",
+    );
+    error.code = cause?.code || "ESHADOWCLEANUP";
+    throw error;
+  }
+}
+
+export function writeShadowFile(
+  file,
+  body,
+  access = {},
+  { exclusive = false } = {},
+) {
+  const dir = dirname(file);
+  ensureShadowDir(dir, access);
+
+  const target = exclusive
+    ? file
+    : join(
+        dir,
+        `.${basename(file)}-${randomBytes(8).toString("hex")}.tmp`,
+      );
+
+  let fd = null;
+  let created = false;
+  let protectedPath = target;
+
+  try {
+    fd = openSync(target, "wx", 0o600);
+    created = true;
+
+    if (!exclusive) {
+      renameSync(target, file);
+      protectedPath = file;
+    }
+
+    tightenShadow(protectedPath, "file", access);
+    writeFileSync(fd, body);
+
+    const opened = fd;
+    fd = null;
+    closeSync(opened);
+    return file;
+  } catch (error) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+
+    if (created) discardShadowFiles([protectedPath], error);
+    throw error;
+  }
+}
+
+export function writeShadowOwner(dir, access = {}) {
+  return writeShadowFile(
+    join(dir, "owner"),
+    String(process.pid),
+    access,
+  );
+}
+
 export function shadowMaxBytes(env = process.env) {
   const bytes = Number(env.SPINE_SHADOW_MAX_BYTES);
   if (Number.isFinite(bytes) && bytes > 0) return Math.floor(bytes);