appclean 1.8.0

package/src/core/serviceFileDetector.ts

@@ -0,0 +1,181 @@
+import path from 'path';
+import { isMacOS, isLinux, getHomeDir } from '../utils/platform';
+import { pathExists, readFile, listDirectory } from '../utils/filesystem';
+import { ArtifactPath } from '../types';
+
+export interface ServiceFile {
+  path: string;
+  type: 'launchagent' | 'launchdaemon' | 'systemd' | 'service';
+  appName: string;
+  requiresManualCleanup: boolean;
+  dependencies?: string[];
+  manualCleanupInstructions: string;
+}
+
+export class ServiceFileDetector {
+  /**
+   * Find all service files related to an app
+   */
+  async findServiceFiles(appName: string): Promise<ServiceFile[]> {
+    const serviceFiles: ServiceFile[] = [];
+
+    if (isMacOS()) {
+      serviceFiles.push(...(await this.findMacOSServiceFiles(appName)));
+    }
+
+    if (isLinux()) {
+      serviceFiles.push(...(await this.findLinuxServiceFiles(appName)));
+    }
+
+    return serviceFiles;
+  }
+
+  /**
+   * Find macOS LaunchAgent and LaunchDaemon files
+   */
+  private async findMacOSServiceFiles(appName: string): Promise<ServiceFile[]> {
+    const home = getHomeDir();
+    const serviceFiles: ServiceFile[] = [];
+
+    // LaunchAgents
+    const launchAgentsPath = path.join(home, 'Library', 'LaunchAgents');
+    if (pathExists(launchAgentsPath)) {
+      const agents = listDirectory(launchAgentsPath);
+      for (const agent of agents) {
+        if (agent.toLowerCase().includes(appName.toLowerCase())) {
+          const fullPath = path.join(launchAgentsPath, agent);
+          serviceFiles.push({
+            path: fullPath,
+            type: 'launchagent',
+            appName,
+            requiresManualCleanup: this.checkDependencies(fullPath, appName),
+            manualCleanupInstructions: `To manually remove: rm "${fullPath}"`,
+          });
+        }
+      }
+    }
+
+    // LaunchDaemons
+    const launchDaemonsPath = path.join(home, 'Library', 'LaunchDaemons');
+    if (pathExists(launchDaemonsPath)) {
+      const daemons = listDirectory(launchDaemonsPath);
+      for (const daemon of daemons) {
+        if (daemon.toLowerCase().includes(appName.toLowerCase())) {
+          const fullPath = path.join(launchDaemonsPath, daemon);
+          serviceFiles.push({
+            path: fullPath,
+            type: 'launchdaemon',
+            appName,
+            requiresManualCleanup: true, // Daemons usually need manual removal
+            manualCleanupInstructions: `To manually remove: sudo rm "${fullPath}" && sudo launchctl unload "${fullPath}"`,
+          });
+        }
+      }
+    }
+
+    return serviceFiles;
+  }
+
+  /**
+   * Find Linux systemd service files
+   */
+  private async findLinuxServiceFiles(appName: string): Promise<ServiceFile[]> {
+    const home = getHomeDir();
+    const serviceFiles: ServiceFile[] = [];
+
+    // User systemd services
+    const userSystemdPath = path.join(home, '.config', 'systemd', 'user');
+    if (pathExists(userSystemdPath)) {
+      const services = listDirectory(userSystemdPath);
+      for (const service of services) {
+        if (service.includes(appName)) {
+          const fullPath = path.join(userSystemdPath, service);
+          serviceFiles.push({
+            path: fullPath,
+            type: 'systemd',
+            appName,
+            requiresManualCleanup: this.checkDependencies(fullPath, appName),
+            manualCleanupInstructions: `To manually remove: systemctl --user stop ${service} && rm "${fullPath}" && systemctl --user daemon-reload`,
+          });
+        }
+      }
+    }
+
+    // System-wide services (requires elevation)
+    const systemServicePath = '/etc/systemd/system';
+    if (pathExists(systemServicePath)) {
+      try {
+        const services = listDirectory(systemServicePath);
+        for (const service of services) {
+          if (service.includes(appName)) {
+            const fullPath = path.join(systemServicePath, service);
+            serviceFiles.push({
+              path: fullPath,
+              type: 'service',
+              appName,
+              requiresManualCleanup: true,
+              manualCleanupInstructions: `To manually remove: sudo systemctl stop ${service} && sudo rm "${fullPath}" && sudo systemctl daemon-reload`,
+            });
+          }
+        }
+      } catch {
+        // Permission denied, skip system services
+      }
+    }
+
+    return serviceFiles;
+  }
+
+  /**
+   * Check if service has dependencies
+   */
+  private checkDependencies(filePath: string, appName: string): boolean {
+    try {
+      const content = readFile(filePath);
+      if (!content) return false;
+
+      // Check for KeepAlive, RunAtLoad, or other critical properties
+      return (
+        content.includes('KeepAlive') ||
+        content.includes('RunAtLoad') ||
+        content.includes('StartCalendarInterval')
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Convert service files to artifact paths for UI display
+   */
+  convertToArtifacts(serviceFiles: ServiceFile[]): ArtifactPath[] {
+    return serviceFiles.map((file) => ({
+      path: file.path,
+      type: 'service',
+      size: 0,
+      description: `${file.type} service file (requires manual cleanup)`,
+    }));
+  }
+
+  /**
+   * Get manual cleanup instructions
+   */
+  getManualCleanupInstructions(serviceFiles: ServiceFile[]): string {
+    if (serviceFiles.length === 0) {
+      return '';
+    }
+
+    let instructions = '\n⚠️  Manual Cleanup Required:\n\n';
+    instructions += 'The following service files require manual cleanup:\n\n';
+
+    serviceFiles.forEach((file, index) => {
+      instructions += `${index + 1}. ${file.type.toUpperCase()}\n`;
+      instructions += `   Path: ${file.path}\n`;
+      instructions += `   Command: ${file.manualCleanupInstructions}\n\n`;
+    });
+
+    instructions += 'Run these commands in your terminal to complete the cleanup.\n';
+
+    return instructions;
+  }
+}

package/src/core/verificationModule.ts

@@ -0,0 +1,140 @@
+import { execSync } from 'child_process';
+import { isMacOS, isLinux, isWindows } from '../utils/platform';
+import { pathExists } from '../utils/filesystem';
+
+export type VerificationStatus = 'verified_removed' | 'still_exists' | 'partial_removal' | 'unknown';
+
+export interface VerificationResult {
+  status: VerificationStatus;
+  remainingPaths: string[];
+  commandOutput: string;
+  timestamp: Date;
+}
+
+export class VerificationModule {
+  /**
+   * Verify if app is completely removed from the system
+   */
+  async verifyRemoval(
+    appName: string,
+    artifactPaths: string[]
+  ): Promise<VerificationResult> {
+    const result: VerificationResult = {
+      status: 'unknown',
+      remainingPaths: [],
+      commandOutput: '',
+      timestamp: new Date(),
+    };
+
+    try {
+      // Check if artifacts still exist on filesystem
+      const remainingPaths = artifactPaths.filter((path) => pathExists(path));
+      result.remainingPaths = remainingPaths;
+
+      // Verify via command line
+      const commandStatus = await this.verifyViaCommand(appName);
+      result.commandOutput = commandStatus;
+
+      // Determine overall status
+      if (remainingPaths.length === 0 && !commandStatus) {
+        result.status = 'verified_removed';
+      } else if (remainingPaths.length === 0 && commandStatus) {
+        result.status = 'unknown'; // Found via command but not filesystem
+      } else if (remainingPaths.length > 0 && remainingPaths.length < artifactPaths.length) {
+        result.status = 'partial_removal';
+      } else if (remainingPaths.length === artifactPaths.length) {
+        result.status = 'still_exists';
+      }
+    } catch (error) {
+      result.status = 'unknown';
+      result.commandOutput = (error as Error).message;
+    }
+
+    return result;
+  }
+
+  /**
+   * Verify via command line (which, where, etc.)
+   */
+  private async verifyViaCommand(appName: string): Promise<string> {
+    try {
+      if (isMacOS() || isLinux()) {
+        // Try 'which' command to locate binary
+        try {
+          const output = execSync(`which ${appName} 2>/dev/null || true`).toString().trim();
+          if (output) {
+            return `Found at: ${output}`;
+          }
+        } catch {
+          // which command failed or app not found
+        }
+
+        // Try to run the app to see if it's accessible
+        try {
+          execSync(`${appName} --version 2>/dev/null || true`).toString().trim();
+          return `App still responds to --version`;
+        } catch {
+          // App not found or doesn't respond
+        }
+
+        return '';
+      }
+
+      if (isWindows()) {
+        // Try 'where' command on Windows
+        try {
+          const output = execSync(`where ${appName} 2>nul || echo ""`).toString().trim();
+          if (output && output !== '""') {
+            return `Found at: ${output}`;
+          }
+        } catch {
+          // where command failed or app not found
+        }
+
+        return '';
+      }
+
+      return '';
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Get human-readable status message
+   */
+  getStatusMessage(status: VerificationStatus): string {
+    const messages: Record<VerificationStatus, string> = {
+      verified_removed: '✓ Application successfully removed',
+      still_exists: '✗ Application still exists on system',
+      partial_removal: '⚠ Application partially removed (some files remain)',
+      unknown: '? Verification status unknown',
+    };
+
+    return messages[status] || messages['unknown'];
+  }
+
+  /**
+   * Get detailed verification report
+   */
+  getDetailedReport(result: VerificationResult): string {
+    let report = `\n📋 Verification Report\n`;
+    report += `${'─'.repeat(40)}\n`;
+    report += `Status: ${this.getStatusMessage(result.status)}\n`;
+
+    if (result.remainingPaths.length > 0) {
+      report += `\nRemaining Files/Folders:\n`;
+      result.remainingPaths.forEach((path) => {
+        report += `  - ${path}\n`;
+      });
+    }
+
+    if (result.commandOutput) {
+      report += `\nCommand Output: ${result.commandOutput}\n`;
+    }
+
+    report += `Verified at: ${result.timestamp.toISOString()}\n`;
+
+    return report;
+  }
+}