appclean 1.8.0

package/src/managers/customManager.ts

@@ -0,0 +1,167 @@
+import path from 'path';
+import { getHomeDir } from '../utils/platform';
+import {
+  pathExists,
+  listDirectory,
+  readFile,
+  listDirectoryDeep,
+} from '../utils/filesystem';
+import { InstalledApp, ArtifactPath } from '../types';
+
+export class CustomManager {
+  async findCustomInstalledApps(): Promise<InstalledApp[]> {
+    const apps: InstalledApp[] = [];
+    const home = getHomeDir();
+
+    const customBinPaths = [
+      '/usr/local/bin',
+      '/usr/bin',
+      `${home}/.local/bin`,
+    ];
+
+    const foundBinaries = new Set<string>();
+
+    for (const binPath of customBinPaths) {
+      if (!pathExists(binPath)) continue;
+
+      const binaries = listDirectory(binPath);
+      for (const binary of binaries) {
+        const fullPath = path.join(binPath, binary);
+
+        // Skip if already found
+        if (foundBinaries.has(binary)) continue;
+
+        // Try to detect installation method from the binary
+        const method = await this.detectInstallMethod(fullPath);
+
+        // Only add if it looks like a custom install (not from system)
+        if (method === 'custom') {
+          foundBinaries.add(binary);
+          apps.push({
+            name: binary,
+            version: 'unknown',
+            installMethod: 'custom',
+            mainPath: fullPath,
+            installedDate: undefined,
+          });
+        }
+      }
+    }
+
+    return apps;
+  }
+
+  private async detectInstallMethod(binaryPath: string): Promise<string> {
+    try {
+      const content = readFile(binaryPath);
+      if (!content) return 'unknown';
+
+      // Check for common shebangs/markers
+      if (content.includes('node') || content.includes('#!/usr/bin/env node')) {
+        return 'custom'; // Custom node script
+      }
+
+      if (content.includes('python') || content.includes('#!/usr/bin/env python')) {
+        return 'custom'; // Custom python script
+      }
+
+      if (content.startsWith('#!/bin/bash') || content.startsWith('#!/bin/sh')) {
+        return 'custom'; // Shell script
+      }
+
+      return 'custom';
+    } catch {
+      return 'unknown';
+    }
+  }
+
+  async findArtifacts(appName: string): Promise<ArtifactPath[]> {
+    const artifacts: ArtifactPath[] = [];
+    const home = getHomeDir();
+
+    // Search in common binary locations
+    const binPaths = [
+      `/usr/local/bin/${appName}`,
+      `/usr/bin/${appName}`,
+      `${home}/.local/bin/${appName}`,
+    ];
+
+    for (const binPath of binPaths) {
+      if (pathExists(binPath)) {
+        artifacts.push({
+          path: binPath,
+          type: 'binary',
+          size: 0,
+          description: 'Custom binary',
+        });
+      }
+    }
+
+    // Search for config files
+    const configPatterns = [
+      path.join(home, `.config`, appName),
+      path.join(home, `.${appName}`),
+      path.join(home, `.${appName}rc`),
+      path.join(home, `.${appName}rc.json`),
+    ];
+
+    for (const configPath of configPatterns) {
+      if (pathExists(configPath)) {
+        artifacts.push({
+          path: configPath,
+          type: 'config',
+          size: 0,
+          description: 'Configuration',
+        });
+      }
+    }
+
+    // Search for data files
+    const dataPath = path.join(home, `.local`, `share`, appName);
+    if (pathExists(dataPath)) {
+      artifacts.push({
+        path: dataPath,
+        type: 'data',
+        size: 0,
+        description: 'Data directory',
+      });
+    }
+
+    // Search for cache
+    const cachePath = path.join(home, `.cache`, appName);
+    if (pathExists(cachePath)) {
+      artifacts.push({
+        path: cachePath,
+        type: 'cache',
+        size: 0,
+        description: 'Cache directory',
+      });
+    }
+
+    return artifacts;
+  }
+
+  async searchByName(query: string): Promise<string[]> {
+    const results: string[] = [];
+    const home = getHomeDir();
+
+    const binPaths = [
+      '/usr/local/bin',
+      '/usr/bin',
+      `${home}/.local/bin`,
+    ];
+
+    for (const binPath of binPaths) {
+      if (!pathExists(binPath)) continue;
+
+      const binaries = listDirectory(binPath);
+      for (const binary of binaries) {
+        if (binary.toLowerCase().includes(query.toLowerCase())) {
+          results.push(binary);
+        }
+      }
+    }
+
+    return results;
+  }
+}

package/src/managers/linuxManager.ts

@@ -0,0 +1,210 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { getHomeDir } from '../utils/platform';
+import { pathExists, listDirectory } from '../utils/filesystem';
+import { InstalledApp, ArtifactPath } from '../types';
+import { Logger } from '../utils/logger';
+
+export class LinuxManager {
+  private packageManager: 'apt' | 'yum' | 'dnf' | 'unknown' = 'unknown';
+
+  constructor() {
+    this.packageManager = this.detectPackageManager();
+  }
+
+  private detectPackageManager(): 'apt' | 'yum' | 'dnf' | 'unknown' {
+    try {
+      execSync('which apt', { stdio: 'ignore' });
+      return 'apt';
+    } catch {}
+
+    try {
+      execSync('which dnf', { stdio: 'ignore' });
+      return 'dnf';
+    } catch {}
+
+    try {
+      execSync('which yum', { stdio: 'ignore' });
+      return 'yum';
+    } catch {}
+
+    return 'unknown';
+  }
+
+  async getInstalledPackages(): Promise<InstalledApp[]> {
+    const packages: InstalledApp[] = [];
+
+    if (this.packageManager === 'unknown') {
+      return packages;
+    }
+
+    try {
+      let output: string;
+
+      if (this.packageManager === 'apt') {
+        output = execSync('apt list --installed 2>/dev/null').toString();
+        const lines = output.split('\n').slice(1); // Skip header
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const parts = line.split('/');
+          if (parts[0]) {
+            packages.push({
+              name: parts[0].trim(),
+              version: 'unknown',
+              installMethod: 'apt',
+              mainPath: '',
+              installedDate: undefined,
+            });
+          }
+        }
+      } else {
+        // yum or dnf
+        try {
+          output = execSync(`${this.packageManager} list installed`).toString();
+          const lines = output.split('\n');
+
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            const parts = line.split(/\s+/);
+            if (parts[0]) {
+              packages.push({
+                name: parts[0].split('.')[0],
+                version: parts[1] || 'unknown',
+                installMethod: this.packageManager as 'yum' | 'dnf',
+                mainPath: '',
+                installedDate: undefined,
+              });
+            }
+          }
+        } catch (error) {
+          Logger.debug(`Failed to query ${this.packageManager}: ` + (error as Error).message);
+        }
+      }
+    } catch (error) {
+      Logger.debug('Failed to get system packages: ' + (error as Error).message);
+    }
+
+    return packages;
+  }
+
+  async findArtifacts(appName: string): Promise<ArtifactPath[]> {
+    const artifacts: ArtifactPath[] = [];
+    const home = getHomeDir();
+
+    // Binaries
+    const binPaths = [
+      `/usr/bin/${appName}`,
+      `/usr/local/bin/${appName}`,
+      `${home}/.local/bin/${appName}`,
+    ];
+
+    for (const binPath of binPaths) {
+      if (pathExists(binPath)) {
+        artifacts.push({
+          path: binPath,
+          type: 'binary',
+          size: 0,
+          description: 'Binary executable',
+        });
+      }
+    }
+
+    // Config files
+    const configPaths = [
+      path.join(home, `.config`, appName),
+      path.join(home, `.${appName}rc`),
+      path.join(home, `.${appName}`),
+      `/etc/${appName}`,
+      `/etc/${appName}.conf`,
+    ];
+
+    for (const configPath of configPaths) {
+      if (pathExists(configPath)) {
+        artifacts.push({
+          path: configPath,
+          type: 'config',
+          size: 0,
+          description: 'Configuration directory/file',
+        });
+      }
+    }
+
+    // Cache files
+    const cachePaths = [
+      path.join(home, `.cache`, appName),
+      path.join(home, `.${appName}_cache`),
+    ];
+
+    for (const cachePath of cachePaths) {
+      if (pathExists(cachePath)) {
+        artifacts.push({
+          path: cachePath,
+          type: 'cache',
+          size: 0,
+          description: 'Cache directory',
+        });
+      }
+    }
+
+    // Data files
+    const dataPath = path.join(home, `.local`, `share`, appName);
+    if (pathExists(dataPath)) {
+      artifacts.push({
+        path: dataPath,
+        type: 'data',
+        size: 0,
+        description: 'Data directory',
+      });
+    }
+
+    // Log files
+    const logPaths = [
+      `/var/log/${appName}`,
+      `/var/log/${appName}.log`,
+      path.join(home, `.local`, `share`, `log`, appName),
+    ];
+
+    for (const logPath of logPaths) {
+      if (pathExists(logPath)) {
+        artifacts.push({
+          path: logPath,
+          type: 'log',
+          size: 0,
+          description: 'Log file/directory',
+        });
+      }
+    }
+
+    // Systemd services
+    const systemdPath = `/etc/systemd/system/${appName}.service`;
+    if (pathExists(systemdPath)) {
+      artifacts.push({
+        path: systemdPath,
+        type: 'service',
+        size: 0,
+        description: 'Systemd service file',
+      });
+    }
+
+    return artifacts;
+  }
+
+  async removePackage(appName: string): Promise<boolean> {
+    if (this.packageManager === 'unknown') {
+      return false;
+    }
+
+    try {
+      const command = this.packageManager === 'apt'
+        ? `apt-get remove -y ${appName}`
+        : `${this.packageManager} remove -y ${appName}`;
+
+      execSync(command, { stdio: 'pipe' });
+      return true;
+    } catch (error) {
+      Logger.debug(`Failed to uninstall ${appName}: ` + (error as Error).message);
+      return false;
+    }
+  }
+}

package/src/managers/npmManager.ts

@@ -0,0 +1,137 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { getHomeDir } from '../utils/platform';
+import { pathExists, listDirectory, readFile } from '../utils/filesystem';
+import { InstalledApp, ArtifactPath } from '../types';
+import { Logger } from '../utils/logger';
+
+export class NpmManager {
+  private globalNpmPath: string;
+
+  constructor() {
+    this.globalNpmPath = this.getNpmGlobalPath();
+  }
+
+  private getNpmGlobalPath(): string {
+    try {
+      return execSync('npm config get prefix').toString().trim();
+    } catch {
+      return path.join(getHomeDir(), '.npm-global');
+    }
+  }
+
+  async getInstalledPackages(): Promise<InstalledApp[]> {
+    const packages: InstalledApp[] = [];
+
+    try {
+      const output = execSync('npm list -g --json --depth=0').toString();
+      const data = JSON.parse(output);
+      const dependencies = data.dependencies || {};
+
+      for (const [name, pkg] of Object.entries(dependencies)) {
+        const typedPkg = pkg as any;
+        packages.push({
+          name,
+          version: typedPkg.version || 'unknown',
+          installMethod: 'npm',
+          mainPath: path.join(this.globalNpmPath, 'lib', 'node_modules', name),
+          installedDate: undefined,
+        });
+      }
+    } catch (error) {
+      Logger.debug('Failed to get npm packages: ' + (error as Error).message);
+    }
+
+    return packages;
+  }
+
+  async findArtifacts(appName: string): Promise<ArtifactPath[]> {
+    const artifacts: ArtifactPath[] = [];
+    const home = getHomeDir();
+
+    // Main package directory
+    const packagePath = path.join(
+      this.globalNpmPath,
+      'lib',
+      'node_modules',
+      appName
+    );
+    if (pathExists(packagePath)) {
+      artifacts.push({
+        path: packagePath,
+        type: 'other',
+        size: 0,
+        description: 'Package directory',
+      });
+    }
+
+    // Binaries in bin directory
+    const binPath = path.join(this.globalNpmPath, 'bin', appName);
+    if (pathExists(binPath)) {
+      artifacts.push({
+        path: binPath,
+        type: 'binary',
+        size: 0,
+        description: 'Executable binary',
+      });
+    }
+
+    // Config files
+    const configPaths = [
+      path.join(home, `.${appName}rc`),
+      path.join(home, `.${appName}rc.json`),
+      path.join(home, `.config`, appName),
+    ];
+
+    for (const configPath of configPaths) {
+      if (pathExists(configPath)) {
+        artifacts.push({
+          path: configPath,
+          type: 'config',
+          size: 0,
+          description: `${appName} configuration`,
+        });
+      }
+    }
+
+    // Cache directories
+    const cachePaths = [
+      path.join(home, `.cache`, appName),
+      path.join(home, `Library`, `Caches`, appName),
+    ];
+
+    for (const cachePath of cachePaths) {
+      if (pathExists(cachePath)) {
+        artifacts.push({
+          path: cachePath,
+          type: 'cache',
+          size: 0,
+          description: `${appName} cache`,
+        });
+      }
+    }
+
+    // Data directories
+    const dataPath = path.join(home, `.local`, `share`, appName);
+    if (pathExists(dataPath)) {
+      artifacts.push({
+        path: dataPath,
+        type: 'data',
+        size: 0,
+        description: `${appName} data files`,
+      });
+    }
+
+    return artifacts;
+  }
+
+  async removePackage(appName: string): Promise<boolean> {
+    try {
+      execSync(`npm uninstall -g ${appName}`);
+      return true;
+    } catch (error) {
+      Logger.debug('Failed to uninstall npm package: ' + (error as Error).message);
+      return false;
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,59 @@
+export type Platform = 'darwin' | 'linux' | 'win32';
+
+export type InstallMethod =
+  | 'npm'
+  | 'yarn'
+  | 'pnpm'
+  | 'brew'
+  | 'apt'
+  | 'yum'
+  | 'dnf'
+  | 'custom'
+  | 'unknown';
+
+export interface InstalledApp {
+  name: string;
+  version: string;
+  installMethod: InstallMethod;
+  mainPath: string;
+  installedDate?: Date;
+  size?: number;
+}
+
+export interface ArtifactPath {
+  path: string;
+  type: 'binary' | 'config' | 'cache' | 'log' | 'data' | 'service' | 'other';
+  size: number;
+  description: string;
+}
+
+export interface AppAnalysis {
+  app: InstalledApp;
+  artifacts: ArtifactPath[];
+  totalSize: number;
+  dependents?: string[];
+}
+
+export interface RemovalOptions {
+  dryRun?: boolean;
+  createBackup?: boolean;
+  backupPath?: string;
+  force?: boolean;
+  userConsent?: boolean;
+  reportFormat?: 'html' | 'text';
+}
+
+export interface RemovalResult {
+  success: boolean;
+  appName: string;
+  removedFiles: number;
+  freedSpace: number;
+  backupPath?: string;
+  errors?: string[];
+}
+
+export interface SearchOptions {
+  query?: string;
+  installMethod?: InstallMethod;
+  sortBy?: 'name' | 'date' | 'size';
+}