feat(deletion-strategy): add windows deletion strategies

Author: zaldih

src/core/services/files/strategies/index.ts

@@ -3,4 +3,7 @@ export * from './unix-strategies/rsync-deletion.strategy.js';
 export * from './unix-strategies/find-deletion.strategy.js';
 export * from './unix-strategies/rm-rf-deletion.strategy.js';
 export * from './unix-strategies/perl-deletion.strategy.js';
+export * from './windows-strategies/robocopy-deletion.strategy.js';
+export * from './windows-strategies/powershell-deletion.strategy.js';
+export * from './windows-strategies/node-rm-deletion.strategy.js';
 export * from './strategy-manager.js';

src/core/services/files/strategies/windows-strategies/node-rm-deletion.strategy.ts

@@ -0,0 +1,29 @@
+import { rm } from 'fs/promises';
+import { IDeletionStrategy } from '../deletion-strategy.interface.js';
+
+export class NodeRmDeletionStrategy implements IDeletionStrategy {
+  readonly name = 'node-rm';
+
+  async isAvailable(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  async delete(path: string): Promise<boolean> {
+    try {
+      await rm(path, {
+        recursive: true,
+        force: true,
+        // maxRetries: Automatically retry on Windows if files are locked
+        maxRetries: process.platform === 'win32' ? 3 : 0,
+        retryDelay: 100,
+      });
+      return true;
+    } catch (error) {
+      // If the directory doesn't exist, consider it a success
+      if (error && (error as any).code === 'ENOENT') {
+        return true;
+      }
+      throw error;
+    }
+  }
+}

src/core/services/files/strategies/windows-strategies/powershell-deletion.strategy.ts

@@ -0,0 +1,54 @@
+import { exec } from 'child_process';
+import { IDeletionStrategy } from '../deletion-strategy.interface.js';
+
+export class PowerShellDeletionStrategy implements IDeletionStrategy {
+  readonly name = 'powershell';
+
+  async isAvailable(): Promise<boolean> {
+    return new Promise((resolve) => {
+      exec('powershell -Command "Get-Command Remove-Item" 2>nul', (error) => {
+        resolve(error === null);
+      });
+    });
+  }
+
+  async delete(path: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      // Use PowerShell with optimized flags for fast deletion
+      // -Force: Override read-only and hidden attributes
+      // -Recurse: Delete all child items
+      // -ErrorAction Stop: Stop on first error
+      // Get-ChildItem | Remove-Item pattern is often faster than Remove-Item alone for large dirs
+      const psCommand = `
+        if (Test-Path '${path}') {
+          try {
+            Get-ChildItem -Path '${path}' -Force -Recurse | Remove-Item -Force -Recurse -ErrorAction Stop
+            Remove-Item -Path '${path}' -Force -ErrorAction Stop
+            Write-Output 'Success'
+          } catch {
+            Write-Error $_.Exception.Message
+            exit 1
+          }
+        } else {
+          Write-Output 'Success'
+        }
+      `
+        .replace(/\s+/g, ' ')
+        .trim();
+
+      const command = `powershell -Command "${psCommand}"`;
+
+      exec(command, (error, stdout, stderr) => {
+        if (error !== null) {
+          reject(error);
+          return;
+        }
+        if (stderr && stderr.trim() !== '') {
+          reject(new Error(stderr));
+          return;
+        }
+        resolve(true);
+      });
+    });
+  }
+}

src/core/services/files/strategies/windows-strategies/robocopy-deletion.strategy.ts

@@ -0,0 +1,47 @@
+import { exec } from 'child_process';
+import { IDeletionStrategy } from '../deletion-strategy.interface.js';
+
+export class RobocopyDeletionStrategy implements IDeletionStrategy {
+  readonly name = 'robocopy';
+
+  async isAvailable(): Promise<boolean> {
+    return new Promise((resolve) => {
+      exec('robocopy /? >nul 2>&1', (error) => {
+        resolve(error === null || error.code === 16); // robocopy returns 16 for help
+      });
+    });
+  }
+
+  async delete(path: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      // Create a temporary empty directory
+      const tempDir = `${process.env.TEMP || process.env.TMP || 'C:\\temp'}\\npkill_empty_${Date.now()}`;
+
+      // Use robocopy to mirror empty directory to target (purge), then remove both
+      // /MIR = Mirror directory tree (equivalent to /E plus /PURGE)
+      // /NFL = No File List (don't log file names)
+      // /NDL = No Directory List (don't log directory names)
+      // /NJH = No Job Header
+      // /NJS = No Job Summary
+      // /NP = No Progress
+      const command = `mkdir "${tempDir}" && robocopy "${tempDir}" "${path}" /MIR /NFL /NDL /NJH /NJS /NP && rmdir "${path}" && rmdir "${tempDir}"`;
+
+      exec(command, (error, stdout, stderr) => {
+        // Robocopy returns different exit codes that aren't necessarily errors
+        // 0 = No files copied, no failures
+        // 1 = Files copied successfully
+        // 2 = Extra files or directories detected
+        // Exit codes 0-7 are generally successful
+        if (error && error.code && error.code > 7) {
+          reject(error);
+          return;
+        }
+        if (stderr && stderr.trim() !== '') {
+          reject(new Error(stderr));
+          return;
+        }
+        resolve(true);
+      });
+    });
+  }
+}

src/core/services/files/windows-files.service.ts

@@ -1,22 +1,44 @@
-import { Subject, Observable } from 'rxjs';
 import { FileService } from './files.service.js';
 import { FileWorkerService } from './files.worker.service.js';
-import { ScanOptions } from '@core/index.js';
 import { StreamService } from '../stream.service.js';
-import { rm } from 'fs/promises';
-import { DeletionStrategyManager } from './strategies/index.js';
+import { DeletionStrategyManager } from './strategies/strategy-manager.js';
+import {
+  RobocopyDeletionStrategy,
+  PowerShellDeletionStrategy,
+  NodeRmDeletionStrategy,
+} from './strategies/index.js';
 
 export class WindowsFilesService extends FileService {
   constructor(
-    private readonly streamService: StreamService,
+    protected streamService: StreamService,
     public override fileWorkerService: FileWorkerService,
     delstrategyManager: DeletionStrategyManager,
   ) {
     super(fileWorkerService, delstrategyManager);
+    this.initializeStrategies();
   }
 
   async deleteDir(path: string): Promise<boolean> {
-    await rm(path, { recursive: true, force: true });
-    return true;
+    try {
+      return await this.delStrategyManager.deleteDirectory(path);
+    } catch (error) {
+      throw new Error(`Failed to delete directory ${path}: ${error}`);
+    }
+  }
+
+  getSelectedDeletionStrategy(): string | null {
+    const strategy = this.delStrategyManager.getSelectedStrategy();
+    return strategy ? strategy.name : null;
+  }
+
+  resetDeletionStrategy(): void {
+    this.delStrategyManager.resetStrategy();
+  }
+
+  private initializeStrategies() {
+    // Order matters!
+    this.delStrategyManager.registerStrategy(new RobocopyDeletionStrategy());
+    this.delStrategyManager.registerStrategy(new PowerShellDeletionStrategy());
+    this.delStrategyManager.registerStrategy(new NodeRmDeletionStrategy());
   }
 }