130 lines
4.3 KiB
TypeScript
130 lines
4.3 KiB
TypeScript
import fs from "fs/promises";
|
|
import path from "path";
|
|
import * as os from "os";
|
|
|
|
/**
|
|
* Recursively delete files & symlinks under the parent folder of `filePath`.
|
|
* Will remove subfolders only if they become empty.
|
|
*
|
|
* Safety checks:
|
|
* - Refuses to operate on root or extremely short folders.
|
|
* - Refuses to operate on the user's home directory.
|
|
*
|
|
* Throws on critical safety failure; otherwise logs and continues on per-file errors.
|
|
*/
|
|
export async function emptyFolderContainingFile(
|
|
filePath: string | null | undefined
|
|
): Promise<void> {
|
|
if (!filePath) return;
|
|
|
|
const absFile = path.resolve(String(filePath));
|
|
const folder = path.dirname(absFile);
|
|
|
|
// Basic sanity / safety checks
|
|
if (!folder) {
|
|
throw new Error(
|
|
`Refusing to clean: resolved folder is empty for filePath=${filePath}`
|
|
);
|
|
}
|
|
|
|
const parsed = path.parse(folder);
|
|
if (folder === parsed.root) {
|
|
throw new Error(`Refusing to clean root folder: ${folder}`);
|
|
}
|
|
|
|
// Don't allow cleaning the user's home directory
|
|
const home = os.homedir();
|
|
if (home && path.resolve(home) === path.resolve(folder)) {
|
|
throw new Error(`Refusing to clean user's home directory: ${folder}`);
|
|
}
|
|
|
|
// Heuristic: require folder basename length >= 2 (prevents cleaning very short names like '/a')
|
|
const base = path.basename(folder).toLowerCase();
|
|
if (!base || base.length < 2) {
|
|
throw new Error(`Refusing to clean suspicious folder: ${folder}`);
|
|
}
|
|
|
|
// Now recursively walk and remove files & symlinks. Remove directories if empty after processing.
|
|
async function removeContentsRecursively(dir: string): Promise<boolean> {
|
|
// returns true if directory is empty (and therefore safe-to-delete by caller)
|
|
let entries;
|
|
try {
|
|
entries = await fs.readdir(dir, { withFileTypes: true });
|
|
} catch (err) {
|
|
console.error(`[cleanup] failed to read directory ${dir}:`, err);
|
|
// If we can't read, don't attempt to delete it
|
|
return false;
|
|
}
|
|
|
|
for (const entry of entries) {
|
|
const full = path.join(dir, entry.name);
|
|
try {
|
|
if (entry.isFile() || entry.isSymbolicLink()) {
|
|
await fs.unlink(full);
|
|
console.log(`[cleanup] removed file/symlink: ${full}`);
|
|
} else if (entry.isDirectory()) {
|
|
// Recurse into subdirectory
|
|
const subEmpty = await removeContentsRecursively(full);
|
|
if (subEmpty) {
|
|
// remove the now-empty directory
|
|
try {
|
|
await fs.rmdir(full);
|
|
console.log(`[cleanup] removed empty directory: ${full}`);
|
|
} catch (rmDirErr) {
|
|
// Could fail due to permissions/race; log and continue
|
|
console.error(
|
|
`[cleanup] failed to remove directory ${full}:`,
|
|
rmDirErr
|
|
);
|
|
}
|
|
} else {
|
|
// directory not empty (or had read error) — we leave it
|
|
console.log(
|
|
`[cleanup] left directory (not empty or read error): ${full}`
|
|
);
|
|
}
|
|
} else {
|
|
// Other types (socket, FIFO, etc.) — try unlink as fallback
|
|
try {
|
|
await fs.unlink(full);
|
|
console.log(`[cleanup] removed special entry: ${full}`);
|
|
} catch (unlinkErr) {
|
|
console.error(
|
|
`[cleanup] failed to remove special entry ${full}:`,
|
|
unlinkErr
|
|
);
|
|
}
|
|
}
|
|
} catch (entryErr) {
|
|
console.error(`[cleanup] error handling ${full}:`, entryErr);
|
|
// continue with other entries
|
|
}
|
|
}
|
|
|
|
// After processing entries, check if directory is now empty
|
|
try {
|
|
const after = await fs.readdir(dir);
|
|
return after.length === 0;
|
|
} catch (readAfterErr) {
|
|
console.error(
|
|
`[cleanup] failed to re-read directory ${dir}:`,
|
|
readAfterErr
|
|
);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Start recursive cleaning at the folder (we do NOT delete the top folder itself,
|
|
// only its contents; if you want the folder removed too, you can call fs.rmdir after)
|
|
try {
|
|
await removeContentsRecursively(folder);
|
|
console.log(`[cleanup] finished cleaning contents of folder: ${folder}`);
|
|
} catch (err) {
|
|
console.error(
|
|
`[cleanup] unexpected error while cleaning folder ${folder}:`,
|
|
err
|
|
);
|
|
throw err;
|
|
}
|
|
}
|