dsh-sessions-manager 3.5.0 → 3.5.1

package/lib/index.js

@@ -1,32 +1,67 @@
 // src/index.js
-import { mkdir as mkdir4, realpath, rename as rename4, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile2, realpath, rename as rename4, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { basename, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
-import { readFileSync, writeFileSync } from "node:fs";
 var ZSTD_MAGIC = 4247762216;
 var CHECKSUM_OPTS = { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } };
-function findZstdFrameStarts(buf) {
-  const starts = [];
-  for (let i = 0; i + 4 <= buf.length; i++) {
-    if (buf.readUInt32LE(i) !== ZSTD_MAGIC) continue;
-    try {
-      const out = zlib.zstdDecompressSync(buf.subarray(i, i + Math.min(buf.length - i, 1e6)));
-      if (out.length > 0) starts.push(i);
-    } catch (_) {
-    }
-  }
-  return starts;
+function scanZstdFrames(buf, maxFrames = Number.POSITIVE_INFINITY) {
+  const frames = [];
+  let offset = 0;
+  while (offset < buf.length) {
+    const start = offset;
+    if (buf.length - offset < 4) return { frames, tornStart: start };
+    if (buf.readUInt32LE(offset) !== ZSTD_MAGIC) {
+      throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset} \u7684 zstd magic \u65E0\u6548\uFF09`);
+    }
+    offset += 4;
+    if (offset === buf.length) return { frames, tornStart: start };
+    const descriptor = buf.readUInt8(offset++);
+    if ((descriptor & 24) !== 0) throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset - 1} \u4F7F\u7528\u4FDD\u7559\u5E27\u5934\u4F4D\uFF09`);
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const checksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buf.length - offset < remainingHeaderBytes) return { frames, tornStart: start };
+    offset += remainingHeaderBytes;
+    for (; ; ) {
+      if (buf.length - offset < 3) return { frames, tornStart: start };
+      const blockHeader = buf.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = blockHeader >>> 1 & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5B57\u8282 ${offset - 3} \u4F7F\u7528\u4FDD\u7559\u5757\u7C7B\u578B\uFF09`);
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buf.length - offset < payloadBytes) return { frames, tornStart: start };
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (checksum) {
+      if (buf.length - offset < 4) return { frames, tornStart: start };
+      offset += 4;
+    }
+    frames.push({ start, end: offset });
+    if (frames.length === maxFrames) return { frames };
+  }
+  return { frames };
+}
+function firstFrame(buf) {
+  const scan = scanZstdFrames(buf, 1);
+  const frame = scan.frames[0];
+  if (!frame) throw new Error("\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u65E0\u5B8C\u6574 zstd \u5E27\uFF09");
+  return frame;
 }
-function rewriteFrame0Cwd(filePath, newCwd) {
-  const buf = readFileSync(filePath);
-  const starts = findZstdFrameStarts(buf);
-  if (starts.length === 0) throw new Error("\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u65E0 zstd \u5E27\uFF09");
-  const end0 = starts.length > 1 ? starts[1] : buf.length;
-  const frame0 = buf.subarray(starts[0], end0);
+function rewriteFrame0CwdInMemory(buf, newCwd) {
+  const frame = firstFrame(buf);
+  const end0 = frame.end;
+  const frame0 = buf.subarray(frame.start, end0);
   const text = zlib.zstdDecompressSync(frame0).toString("utf8");
   const nl = text.indexOf("\n");
   const line = nl >= 0 ? text.slice(0, nl) : text;
@@ -34,11 +69,10 @@ function rewriteFrame0Cwd(filePath, newCwd) {
   if (obj.type !== "session") {
     throw new Error(`\u4F1A\u8BDD\u65E5\u5FD7\u683C\u5F0F\u5F02\u5E38\uFF08\u5E270 \u4E0D\u662F session header\uFF0C\u5B9E\u9645 type=${obj.type}\uFF09`);
   }
-  if (obj.cwd === newCwd) return;
   obj.cwd = newCwd;
   const newFrame0 = zlib.zstdCompressSync(JSON.stringify(obj) + "\n", CHECKSUM_OPTS);
   const rest = buf.subarray(end0);
-  writeFileSync(filePath, Buffer.concat([newFrame0, rest]));
+  return Buffer.concat([newFrame0, rest]);
 }
 
 // src/markdown.js
@@ -182,7 +216,7 @@ function renderSessionMarkdown(meta, events, options = {}) {
 
 // src/star-index.js
 import { mkdir, rename, writeFile } from "node:fs/promises";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var STAR_SCHEMA_VERSION = 3;
@@ -210,7 +244,7 @@ function createStarIndex(options = {}) {
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeStarStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+      return normalizeStarStore(JSON.parse(readFileSync(indexPath, "utf8")));
     } catch {
       return normalizeStarStore(null);
     }
@@ -303,7 +337,7 @@ function aggregateStorage(items, options = {}) {
 
 // src/auto-archive.js
 import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 var AUTO_ARCHIVE_SCHEMA_VERSION = 4;
@@ -359,7 +393,7 @@ function createAutoArchiveStore(options = {}) {
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeAutoArchiveStore(JSON.parse(readFileSync3(indexPath, "utf8")));
+      return normalizeAutoArchiveStore(JSON.parse(readFileSync2(indexPath, "utf8")));
     } catch {
       return normalizeAutoArchiveStore(null);
     }
@@ -975,7 +1009,7 @@ function apply(ctx) {
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync4(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync3(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -1243,12 +1277,41 @@ function apply(ctx) {
       const newPath = locatePath(newHeaderObj);
       if (!oldPath || !newPath || oldPath === newPath) return false;
       const backupPath = `${oldPath}.move-backup-${Date.now()}`;
+      const stagedPath = `${newPath}.move-stage-${process.pid}-${Date.now()}`;
+      let destinationInstalled = false;
       try {
         await mkdir4(dirname2(newPath), { recursive: true });
+        try {
+          await stat(newPath);
+          throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u76EE\u6807\u4F4D\u7F6E\u5DF2\u5B58\u5728\u540C\u540D\u4F1A\u8BDD\u65E5\u5FD7");
+        } catch (e) {
+          if (e && e.code !== "ENOENT") throw e;
+        }
         await rename4(oldPath, backupPath);
-        await rewriteFrame0Cwd(backupPath, canonical);
-        await rename4(backupPath, newPath);
+        const original = await readFile2(backupPath);
+        const originalFrames = scanZstdFrames(original).frames;
+        if (originalFrames.length === 0) throw new Error("\u79FB\u52A8\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u6CA1\u6709\u5B8C\u6574 zstd \u5E27");
+        const rewritten = rewriteFrame0CwdInMemory(original, canonical);
+        const rewrittenFrames = scanZstdFrames(rewritten).frames;
+        if (rewrittenFrames.length !== originalFrames.length) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u5E27\u6570\u53D1\u751F\u53D8\u5316");
+        const originalTail = original.subarray(originalFrames[0].end);
+        const rewrittenTail = rewritten.subarray(rewrittenFrames[0].end);
+        if (!originalTail.equals(rewrittenTail)) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u4E8B\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316");
+        await writeFile4(stagedPath, rewritten, { mode: 384 });
+        await rename4(stagedPath, newPath);
+        destinationInstalled = true;
+        await unlink(backupPath);
       } catch (e) {
+        try {
+          await unlink(stagedPath);
+        } catch (_) {
+        }
+        if (destinationInstalled) {
+          try {
+            await unlink(newPath);
+          } catch (_) {
+          }
+        }
         try {
           await rename4(backupPath, oldPath);
         } catch (_) {