appclean 1.8.0

package/src/core/pluginSystem.ts

@@ -0,0 +1,194 @@
+/**
+ * Plugin System for Custom Detectors
+ * Allows users to create custom app detectors via plugins
+ * v1.5.0 Feature
+ */
+
+import { ArtifactPath } from '../types';
+import { Logger } from '../utils/logger';
+
+export interface AppDetectorPlugin {
+  name: string;
+  version: string;
+  detect(appName: string): Promise<boolean>;
+  findArtifacts(appName: string): Promise<ArtifactPath[]>;
+  remove(appName: string): Promise<boolean>;
+  getInfo(): PluginInfo;
+}
+
+export interface PluginInfo {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  website?: string;
+  supportedPlatforms: string[];
+  capabilities: string[];
+}
+
+export interface PluginConfig {
+  enabled: boolean;
+  settings?: Record<string, any>;
+}
+
+export class PluginSystem {
+  private plugins: Map<string, AppDetectorPlugin> = new Map();
+  private pluginConfigs: Map<string, PluginConfig> = new Map();
+
+  /**
+   * Register a plugin
+   */
+  registerPlugin(plugin: AppDetectorPlugin, config?: PluginConfig): void {
+    this.plugins.set(plugin.name, plugin);
+    this.pluginConfigs.set(plugin.name, config || { enabled: true });
+    Logger.info(`Plugin registered: ${plugin.name} v${plugin.version}`);
+  }
+
+  /**
+   * Unregister a plugin
+   */
+  unregisterPlugin(pluginName: string): void {
+    this.plugins.delete(pluginName);
+    this.pluginConfigs.delete(pluginName);
+    Logger.info(`Plugin unregistered: ${pluginName}`);
+  }
+
+  /**
+   * Get all registered plugins
+   */
+  getPlugins(): AppDetectorPlugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Get plugin by name
+   */
+  getPlugin(pluginName: string): AppDetectorPlugin | null {
+    return this.plugins.get(pluginName) || null;
+  }
+
+  /**
+   * Execute plugin detection
+   */
+  async executeDetection(appName: string): Promise<Map<string, boolean>> {
+    const results = new Map<string, boolean>();
+
+    for (const [name, plugin] of this.plugins) {
+      const config = this.pluginConfigs.get(name);
+      if (config?.enabled) {
+        try {
+          const detected = await plugin.detect(appName);
+          results.set(name, detected);
+        } catch (error) {
+          Logger.debug(`Plugin ${name} detection failed: ${(error as Error).message}`);
+          results.set(name, false);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute plugin artifact finding
+   */
+  async executeFindArtifacts(appName: string): Promise<Map<string, ArtifactPath[]>> {
+    const results = new Map<string, ArtifactPath[]>();
+
+    for (const [name, plugin] of this.plugins) {
+      const config = this.pluginConfigs.get(name);
+      if (config?.enabled) {
+        try {
+          const artifacts = await plugin.findArtifacts(appName);
+          results.set(name, artifacts);
+        } catch (error) {
+          Logger.debug(`Plugin ${name} artifact finding failed: ${(error as Error).message}`);
+          results.set(name, []);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute plugin removal
+   */
+  async executeRemoval(appName: string, pluginName?: string): Promise<Map<string, boolean>> {
+    const results = new Map<string, boolean>();
+
+    if (pluginName) {
+      const plugin = this.plugins.get(pluginName);
+      if (plugin) {
+        const config = this.pluginConfigs.get(pluginName);
+        if (config?.enabled) {
+          try {
+            const removed = await plugin.remove(appName);
+            results.set(pluginName, removed);
+          } catch (error) {
+            Logger.debug(`Plugin ${pluginName} removal failed: ${(error as Error).message}`);
+            results.set(pluginName, false);
+          }
+        }
+      }
+    } else {
+      for (const [name, plugin] of this.plugins) {
+        const config = this.pluginConfigs.get(name);
+        if (config?.enabled) {
+          try {
+            const removed = await plugin.remove(appName);
+            results.set(name, removed);
+          } catch (error) {
+            Logger.debug(`Plugin ${name} removal failed: ${(error as Error).message}`);
+            results.set(name, false);
+          }
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Enable/disable plugin
+   */
+  setPluginEnabled(pluginName: string, enabled: boolean): void {
+    const config = this.pluginConfigs.get(pluginName);
+    if (config) {
+      config.enabled = enabled;
+      Logger.info(`Plugin ${pluginName} ${enabled ? 'enabled' : 'disabled'}`);
+    }
+  }
+
+  /**
+   * Get plugin configuration
+   */
+  getPluginConfig(pluginName: string): PluginConfig | null {
+    return this.pluginConfigs.get(pluginName) || null;
+  }
+
+  /**
+   * Update plugin configuration
+   */
+  updatePluginConfig(pluginName: string, config: Partial<PluginConfig>): void {
+    const existing = this.pluginConfigs.get(pluginName);
+    if (existing) {
+      this.pluginConfigs.set(pluginName, { ...existing, ...config });
+    }
+  }
+
+  /**
+   * Get plugin info
+   */
+  getPluginInfo(pluginName: string): PluginInfo | null {
+    const plugin = this.plugins.get(pluginName);
+    return plugin?.getInfo() || null;
+  }
+
+  /**
+   * List all plugins with info
+   */
+  listPlugins(): PluginInfo[] {
+    return Array.from(this.plugins.values()).map((p) => p.getInfo());
+  }
+}

package/src/core/removalRecorder.ts

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import path from 'path';
+import { getHomeDir } from '../utils/platform';
+import { ArtifactPath } from '../types';
+import { formatDate, formatBytes } from '../utils/logger';
+
+export interface RemovalRecord {
+  timestamp: Date;
+  appName: string;
+  installMethod: string;
+  userConsent: boolean;
+  artifactsDeleted: DeletedArtifact[];
+  verificationStatus: 'verified_removed' | 'still_exists' | 'partial_removal' | 'unknown';
+  totalSpaceFreed: number;
+  completionStatus: 'success' | 'partial' | 'failed';
+  userNotes?: string;
+}
+
+export interface DeletedArtifact {
+  path: string;
+  type: string;
+  size: number;
+  status: 'deleted' | 'failed' | 'skipped';
+  errorMessage?: string;
+}
+
+export class RemovalRecorder {
+  private recordsDir: string;
+
+  constructor() {
+    const home = getHomeDir();
+    this.recordsDir = path.join(home, '.appclean-records');
+
+    // Create records directory if it doesn't exist
+    if (!fs.existsSync(this.recordsDir)) {
+      fs.mkdirSync(this.recordsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Create a new removal record
+   */
+  createRecord(appName: string, installMethod: string, userConsent: boolean): RemovalRecord {
+    return {
+      timestamp: new Date(),
+      appName,
+      installMethod,
+      userConsent,
+      artifactsDeleted: [],
+      verificationStatus: 'unknown',
+      totalSpaceFreed: 0,
+      completionStatus: 'success',
+    };
+  }
+
+  /**
+   * Add deleted artifact to record
+   */
+  addDeletedArtifact(
+    record: RemovalRecord,
+    artifact: ArtifactPath,
+    status: 'deleted' | 'failed' | 'skipped',
+    error?: string
+  ): void {
+    record.artifactsDeleted.push({
+      path: artifact.path,
+      type: artifact.type,
+      size: artifact.size,
+      status,
+      errorMessage: error,
+    });
+
+    if (status === 'deleted') {
+      record.totalSpaceFreed += artifact.size;
+    }
+  }
+
+  /**
+   * Update verification status
+   */
+  updateVerificationStatus(
+    record: RemovalRecord,
+    status: 'verified_removed' | 'still_exists' | 'partial_removal' | 'unknown'
+  ): void {
+    record.verificationStatus = status;
+  }
+
+  /**
+   * Update completion status
+   */
+  updateCompletionStatus(
+    record: RemovalRecord,
+    status: 'success' | 'partial' | 'failed'
+  ): void {
+    record.completionStatus = status;
+  }
+
+  /**
+   * Save record to file
+   */
+  saveRecord(record: RemovalRecord): string {
+    const filename = `${record.appName}-${record.timestamp.getTime()}.json`;
+    const filepath = path.join(this.recordsDir, filename);
+
+    fs.writeFileSync(filepath, JSON.stringify(record, null, 2), 'utf-8');
+
+    return filepath;
+  }
+
+  /**
+   * Get all removal records
+   */
+  getAllRecords(): RemovalRecord[] {
+    const files = fs.readdirSync(this.recordsDir);
+    const records: RemovalRecord[] = [];
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const content = fs.readFileSync(path.join(this.recordsDir, file), 'utf-8');
+          const record = JSON.parse(content);
+          record.timestamp = new Date(record.timestamp);
+          records.push(record);
+        } catch {
+          // Skip invalid files
+        }
+      }
+    }
+
+    return records.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+  }
+
+  /**
+   * Get records for a specific app
+   */
+  getAppRecords(appName: string): RemovalRecord[] {
+    return this.getAllRecords().filter((r) => r.appName === appName);
+  }
+
+  /**
+   * Get records directory path
+   */
+  getRecordsDirectory(): string {
+    return this.recordsDir;
+  }
+}

package/src/core/remover.ts

@@ -0,0 +1,280 @@
+import path from 'path';
+import { execSync } from 'child_process';
+import { getHomeDir } from '../utils/platform';
+import {
+  deleteFile,
+  deleteDirectory,
+  pathExists,
+  getDirectorySize,
+} from '../utils/filesystem';
+import { ArtifactPath, RemovalOptions, RemovalResult } from '../types';
+import { Logger, formatBytes } from '../utils/logger';
+import { NpmManager } from '../managers/npmManager';
+import { BrewManager } from '../managers/brewManager';
+import { LinuxManager } from '../managers/linuxManager';
+import { PermissionHandler } from './permissionHandler';
+import { ServiceFileDetector } from './serviceFileDetector';
+import { RemovalRecorder, RemovalRecord } from './removalRecorder';
+import { ReportGenerator } from './reportGenerator';
+import { VerificationModule } from './verificationModule';
+
+export class Remover {
+  async previewRemoval(artifacts: ArtifactPath[]): Promise<void> {
+    Logger.info('Files to be removed:');
+    Logger.space();
+
+    let totalSize = 0;
+
+    for (const artifact of artifacts) {
+      const size = artifact.size || 0;
+      totalSize += size;
+
+      console.log(`  ${artifact.type.padEnd(8)} ${formatBytes(size).padEnd(10)} ${artifact.path}`);
+    }
+
+    Logger.space();
+    Logger.info(`Total space to be freed: ${formatBytes(totalSize)}`);
+  }
+
+  async createBackup(appName: string, artifacts: ArtifactPath[]): Promise<string> {
+    const home = getHomeDir();
+    const backupDir = path.join(home, '.appclean-backups');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = path.join(backupDir, `${appName}-${timestamp}.tar.gz`);
+
+    try {
+      // Create backup directory
+      execSync(`mkdir -p "${backupDir}"`);
+
+      // Create tar archive
+      const filePaths = artifacts.map((a) => `"${a.path}"`).join(' ');
+      execSync(`tar -czf "${backupPath}" ${filePaths} 2>/dev/null || true`);
+
+      Logger.success(`Backup created: ${backupPath}`);
+      return backupPath;
+    } catch (error) {
+      Logger.warn(`Failed to create backup: ${(error as Error).message}`);
+      return '';
+    }
+  }
+
+  async removeArtifacts(
+    artifacts: ArtifactPath[],
+    options: RemovalOptions
+  ): Promise<{ success: number; failed: number; errors: string[] }> {
+    const errors: string[] = [];
+    let success = 0;
+    let failed = 0;
+
+    for (const artifact of artifacts) {
+      try {
+        if (!pathExists(artifact.path)) {
+          continue;
+        }
+
+        // Check if it's a directory or file
+        const isDirectory = this.isDirectory(artifact.path);
+
+        if (isDirectory) {
+          const deleted = deleteDirectory(artifact.path);
+          if (deleted) {
+            success++;
+          } else {
+            failed++;
+            errors.push(`Failed to delete directory: ${artifact.path}`);
+          }
+        } else {
+          const deleted = deleteFile(artifact.path);
+          if (deleted) {
+            success++;
+          } else {
+            failed++;
+            errors.push(`Failed to delete file: ${artifact.path}`);
+          }
+        }
+      } catch (error) {
+        failed++;
+        errors.push(`Error removing ${artifact.path}: ${(error as Error).message}`);
+      }
+    }
+
+    return { success, failed, errors };
+  }
+
+  async removeApp(
+    appName: string,
+    installMethod: string,
+    artifacts: ArtifactPath[],
+    options: RemovalOptions = {}
+  ): Promise<RemovalResult> {
+    const result: RemovalResult = {
+      success: false,
+      appName,
+      removedFiles: 0,
+      freedSpace: 0,
+      errors: [],
+    };
+
+    const recorder = new RemovalRecorder();
+    const verificationModule = new VerificationModule();
+    const serviceDetector = new ServiceFileDetector();
+    const reportGenerator = new ReportGenerator();
+
+    let removalRecord: RemovalRecord | null = null;
+    const artifactPaths = artifacts.map((a) => a.path);
+
+    try {
+      // Step 1: Check if elevation is required
+      const requiresElevation = PermissionHandler.installationRequiresElevation(installMethod, artifactPaths);
+      if (requiresElevation && !PermissionHandler.isElevated()) {
+        await PermissionHandler.requestElevatedPermissions();
+        Logger.warn('Please run this command with sudo for complete removal of system packages');
+      }
+
+      // Step 2: Detect service files that need manual cleanup
+      const serviceFiles = await serviceDetector.findServiceFiles(appName);
+      if (serviceFiles.length > 0) {
+        Logger.info('\n⚠️  Manual Cleanup Required:');
+        Logger.info('The following service files require manual cleanup:');
+        serviceFiles.forEach((file, index) => {
+          console.log(`\n${index + 1}. ${file.type.toUpperCase()}`);
+          console.log(`   Path: ${file.path}`);
+          console.log(`   Command: ${file.manualCleanupInstructions}`);
+        });
+      }
+
+      // Step 3: Dry run
+      if (options.dryRun) {
+        await this.previewRemoval(artifacts);
+        result.success = true;
+        return result;
+      }
+
+      // Step 4: Create removal record and record user consent
+      removalRecord = recorder.createRecord(appName, installMethod, options.userConsent ?? true);
+
+      // Step 5: Create backup if requested
+      if (options.createBackup) {
+        result.backupPath = await this.createBackup(appName, artifacts);
+      }
+
+      // Step 6: Remove using package manager first
+      const removed = await this.removeViaPackageManager(appName, installMethod);
+
+      if (!removed) {
+        Logger.warn(`Package manager removal failed, attempting manual file removal...`);
+      }
+
+      // Step 7: Manually remove remaining artifacts
+      const removalResult = await this.removeArtifacts(artifacts, options);
+
+      // Step 8: Record deleted artifacts
+      artifacts.forEach((artifact, index) => {
+        const status = index < removalResult.success ? 'deleted' : 'failed';
+        const errorMsg = removalResult.errors.find((e) => e.includes(artifact.path));
+        recorder.addDeletedArtifact(removalRecord!, artifact, status as 'deleted' | 'failed' | 'skipped', errorMsg);
+      });
+
+      result.removedFiles = removalResult.success;
+      result.errors = removalResult.errors;
+      result.freedSpace = artifacts.reduce((total, a) => total + (a.size || 0), 0);
+
+      // Step 9: Verify removal
+      const verificationResult = await verificationModule.verifyRemoval(appName, artifactPaths);
+      recorder.updateVerificationStatus(removalRecord!, verificationResult.status);
+      Logger.info(`\n${verificationModule.getStatusMessage(verificationResult.status)}`);
+
+      if (removalResult.failed === 0) {
+        result.success = true;
+        recorder.updateCompletionStatus(removalRecord!, 'success');
+        Logger.success(`Successfully removed ${appName}`);
+      } else {
+        recorder.updateCompletionStatus(removalRecord!, removalResult.failed === removalResult.success + removalResult.failed ? 'partial' : 'failed');
+        Logger.warn(`Removed ${appName} with ${removalResult.failed} errors`);
+      }
+
+      // Step 10: Save removal record
+      if (removalRecord) {
+        const recordPath = recorder.saveRecord(removalRecord);
+        Logger.debug(`Removal record saved to: ${recordPath}`);
+
+        // Step 11: Generate and save report
+        const reportPath = ReportGenerator.saveReport(removalRecord, options.reportFormat ?? 'html');
+        Logger.success(`Report generated: ${reportPath}`);
+
+        // Display report summary
+        ReportGenerator.displayReport(removalRecord);
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors?.push((error as Error).message);
+      Logger.error(`Failed to remove ${appName}: ${(error as Error).message}`);
+
+      if (removalRecord) {
+        recorder.updateCompletionStatus(removalRecord, 'failed');
+        const recordPath = recorder.saveRecord(removalRecord);
+        Logger.debug(`Failed removal record saved to: ${recordPath}`);
+      }
+    }
+
+    return result;
+  }
+
+  private async removeViaPackageManager(
+    appName: string,
+    installMethod: string
+  ): Promise<boolean> {
+    try {
+      switch (installMethod) {
+        case 'npm': {
+          const npm = new NpmManager();
+          return await npm.removePackage(appName);
+        }
+
+        case 'brew': {
+          const brew = new BrewManager();
+          return await brew.removePackage(appName);
+        }
+
+        case 'apt':
+        case 'yum':
+        case 'dnf': {
+          const linux = new LinuxManager();
+          return await linux.removePackage(appName);
+        }
+
+        default:
+          return false;
+      }
+    } catch (error) {
+      Logger.debug(`Package manager removal failed: ${(error as Error).message}`);
+      return false;
+    }
+  }
+
+  private isDirectory(filePath: string): boolean {
+    try {
+      const fs = require('fs');
+      return fs.statSync(filePath).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  async rollback(backupPath: string): Promise<boolean> {
+    try {
+      if (!pathExists(backupPath)) {
+        Logger.error(`Backup file not found: ${backupPath}`);
+        return false;
+      }
+
+      Logger.info('Restoring from backup...');
+      execSync(`tar -xzf "${backupPath}" -C /`);
+      Logger.success('Backup restored successfully');
+      return true;
+    } catch (error) {
+      Logger.error(`Failed to restore backup: ${(error as Error).message}`);
+      return false;
+    }
+  }
+}