appclean 1.9.0 → 2.0.2

package/src/ui/prompts.ts

@@ -1,6 +1,6 @@
 import inquirer from 'inquirer';
 import { InstalledApp, ArtifactPath } from '../types';
-import { Logger, formatBytes } from '../utils/logger';
+import { Logger, formatBytes } from '../utils/logger.js';
 import chalk from 'chalk';
 
 export async function promptSearchQuery(): Promise<string> {

package/src/ui/server/middleware/errorHandler.ts

@@ -0,0 +1,174 @@
+/**
+ * Error Handler Middleware
+ */
+
+import { IncomingMessage, ServerResponse } from 'http';
+
+export interface ApiError {
+  success: false;
+  error: string;
+  statusCode?: number;
+}
+
+export interface ApiSuccess<T> {
+  success: true;
+  data: T;
+}
+
+export type ApiResponse<T> = ApiSuccess<T> | ApiError;
+
+/**
+ * Send JSON response
+ */
+export function sendJson<T>(
+  res: ServerResponse,
+  data: T,
+  statusCode = 200
+): void {
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  const response: ApiSuccess<T> = {
+    success: true,
+    data,
+  };
+
+  res.end(JSON.stringify(response));
+}
+
+/**
+ * Send error response
+ */
+export function sendError(
+  res: ServerResponse,
+  message: string,
+  statusCode = 400
+): void {
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+
+  const response: ApiError = {
+    success: false,
+    error: message,
+    statusCode,
+  };
+
+  res.end(JSON.stringify(response));
+}
+
+/**
+ * Parse URL query parameters
+ */
+export function parseQueryParams(url: string): Record<string, string> {
+  const params: Record<string, string> = {};
+  const queryStart = url.indexOf('?');
+
+  if (queryStart === -1) return params;
+
+  const queryString = url.substring(queryStart + 1);
+  const pairs = queryString.split('&');
+
+  pairs.forEach((pair) => {
+    const [key, value] = pair.split('=');
+    if (key) {
+      params[decodeURIComponent(key)] = decodeURIComponent(value || '');
+    }
+  });
+
+  return params;
+}
+
+/**
+ * Parse URL path and extract parameters
+ * Example: /api/apps/:appName with path /api/apps/myapp returns { appName: 'myapp' }
+ */
+export function extractPathParams(
+  pattern: string,
+  path: string
+): Record<string, string> | null {
+  const patternParts = pattern.split('/').filter(Boolean);
+  const pathParts = path.split('/').filter(Boolean);
+
+  if (patternParts.length !== pathParts.length) {
+    return null;
+  }
+
+  const params: Record<string, string> = {};
+
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+
+    if (patternPart.startsWith(':')) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathParts[i]);
+    } else if (patternPart !== pathParts[i]) {
+      return null;
+    }
+  }
+
+  return params;
+}
+
+/**
+ * Parse request body as JSON
+ */
+export function parseBody(req: IncomingMessage): Promise<any> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+
+    req.on('data', (chunk) => {
+      data += chunk;
+      // Prevent abuse: reject if body > 1MB
+      if (data.length > 1024 * 1024) {
+        reject(new Error('Request body too large'));
+      }
+    });
+
+    req.on('end', () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch (error) {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+
+    req.on('error', reject);
+  });
+}
+
+/**
+ * Match URL pattern
+ */
+export function matchPattern(pattern: string, url: string): boolean {
+  const patternParts = pattern.split('/').filter(Boolean);
+  const urlParts = url.split('/').filter(Boolean);
+
+  if (patternParts.length !== urlParts.length) {
+    return false;
+  }
+
+  return patternParts.every((part, i) => {
+    return part.startsWith(':') || part === urlParts[i];
+  });
+}
+
+/**
+ * Async route handler wrapper
+ */
+export function asyncHandler(
+  handler: (req: IncomingMessage, res: ServerResponse, params?: any) => Promise<void>
+) {
+  return async (req: IncomingMessage, res: ServerResponse, params?: any) => {
+    try {
+      await handler(req, res, params);
+    } catch (error) {
+      console.error('Route handler error:', error);
+      const message = (error as Error).message || 'Internal server error';
+      sendError(res, message, 500);
+    }
+  };
+}

package/src/ui/server/routes/apps.ts

@@ -0,0 +1,132 @@
+/**
+ * App Routes - Handle app listing, searching, analysis, and removal
+ */
+
+import { IncomingMessage, ServerResponse } from 'http';
+import { appService } from '../services/appService.js';
+import { removalService } from '../services/removalService.js';
+import {
+  sendJson,
+  sendError,
+  parseQueryParams,
+  extractPathParams,
+  parseBody,
+  asyncHandler,
+  matchPattern,
+} from '../middleware/errorHandler.js';
+
+/**
+ * GET /api/apps/list - Get paginated list of all apps
+ */
+export const listApps = asyncHandler(async (req, res) => {
+  const params = parseQueryParams(req.url || '');
+  const limit = Math.min(parseInt(params.limit || '50'), 100); // Max 100 per page
+  const offset = parseInt(params.offset || '0');
+
+  const result = await appService.listApps(limit, offset);
+  sendJson(res, result);
+});
+
+/**
+ * GET /api/apps/search - Search, filter, and sort apps
+ */
+export const searchApps = asyncHandler(async (req, res) => {
+  const params = parseQueryParams(req.url || '');
+
+  const result = await appService.searchApps({
+    q: params.q,
+    method: params.method,
+    sort: (params.sort as any) || 'name',
+    limit: Math.min(parseInt(params.limit || '50'), 100),
+    offset: parseInt(params.offset || '0'),
+  });
+
+  sendJson(res, result);
+});
+
+/**
+ * GET /api/apps/:appName/analysis - Analyze app and get artifacts
+ */
+export const analyzeApp = asyncHandler(async (req, res, params) => {
+  if (!params?.appName) {
+    return sendError(res, 'App name is required', 400);
+  }
+
+  const result = await appService.analyzeApp(params.appName);
+  sendJson(res, result);
+});
+
+/**
+ * GET /api/apps/:appName/preview - Get dry-run preview
+ */
+export const previewRemoval = asyncHandler(async (req, res, params) => {
+  if (!params?.appName) {
+    return sendError(res, 'App name is required', 400);
+  }
+
+  const result = await appService.previewRemoval(params.appName);
+  sendJson(res, result);
+});
+
+/**
+ * POST /api/apps/:appName/remove - Execute app removal
+ */
+export const removeApp = asyncHandler(async (req, res, params) => {
+  if (!params?.appName) {
+    return sendError(res, 'App name is required', 400);
+  }
+
+  const body = await parseBody(req);
+  const options = {
+    dryRun: body.dryRun || false,
+    createBackup: body.createBackup || false,
+  };
+
+  const result = await removalService.removeApp(params.appName, options);
+  sendJson(res, result);
+});
+
+/**
+ * Route matcher and handler
+ */
+export function handleAppRoutes(
+  method: string,
+  pathname: string,
+  req: IncomingMessage,
+  res: ServerResponse
+): boolean {
+  // GET /api/apps/list
+  if (method === 'GET' && pathname === '/api/apps/list') {
+    listApps(req, res);
+    return true;
+  }
+
+  // GET /api/apps/search
+  if (method === 'GET' && pathname.startsWith('/api/apps/search')) {
+    searchApps(req, res);
+    return true;
+  }
+
+  // GET /api/apps/:appName/analysis
+  if (method === 'GET' && matchPattern('/api/apps/:appName/analysis', pathname)) {
+    const params = extractPathParams('/api/apps/:appName/analysis', pathname);
+    analyzeApp(req, res, params);
+    return true;
+  }
+
+  // GET /api/apps/:appName/preview
+  if (method === 'GET' && matchPattern('/api/apps/:appName/preview', pathname)) {
+    const params = extractPathParams('/api/apps/:appName/preview', pathname);
+    previewRemoval(req, res, params);
+    return true;
+  }
+
+  // POST /api/apps/:appName/remove
+  if (method === 'POST' && matchPattern('/api/apps/:appName/remove', pathname)) {
+    const params = extractPathParams('/api/apps/:appName/remove', pathname);
+    removeApp(req, res, params);
+    return true;
+  }
+
+  return false;
+}

package/src/ui/server/routes/dashboard.ts

@@ -0,0 +1,93 @@
+/**
+ * Dashboard Routes - Handle statistics and metrics
+ */
+
+import { IncomingMessage, ServerResponse } from 'http';
+import { Detector } from '../../../core/detector.js';
+import { removalService } from '../services/removalService.js';
+import { sendJson, asyncHandler } from '../middleware/errorHandler.js';
+import { execSync } from 'child_process';
+
+/**
+ * GET /api/dashboard/stats - Get dashboard statistics
+ */
+export const getDashboardStats = asyncHandler(async (req, res) => {
+  const detector = new Detector();
+
+  // Get all apps
+  const allApps = await detector.searchApps({});
+  const totalApps = allApps.length;
+
+  // Calculate total space used
+  let totalSpaceUsed = 0;
+  for (const app of allApps) {
+    try {
+      const artifacts = await detector.findArtifacts(app.name, app.installMethod);
+      totalSpaceUsed += artifacts.reduce((sum, a) => sum + (a.size || 0), 0);
+    } catch (error) {
+      // Skip errors for individual apps
+    }
+  }
+
+  // Get disk usage
+  const diskUsagePercent = getDiskUsagePercent();
+
+  // Get session stats from removal service
+  const sessionRemovals = removalService.getSessionRemovals();
+  const sessionAppsRemoved = sessionRemovals.length;
+  const sessionSpaceFreed = sessionRemovals.reduce((sum, r) => sum + r.freedSpace, 0);
+
+  // Format recently removed for display
+  const recentlyRemoved = sessionRemovals.map((removal) => ({
+    appName: removal.appName,
+    timestamp: Date.now(), // Should track actual time, but using now for simplicity
+    freedSpace: removal.freedSpace,
+    filesRemoved: removal.removedFiles,
+  }));
+
+  const stats = {
+    totalApps,
+    totalSpaceUsed,
+    sessionAppsRemoved,
+    sessionSpaceFreed,
+    diskUsagePercent,
+    recentlyRemoved,
+  };
+
+  sendJson(res, stats);
+});
+
+/**
+ * Get disk usage percentage
+ */
+function getDiskUsagePercent(): number {
+  try {
+    // Try using 'df' command on Unix systems
+    const result = execSync('df -h / | tail -1', { encoding: 'utf-8' });
+    const parts = result.trim().split(/\s+/);
+    const percentStr = parts[4]?.replace('%', '');
+    const percent = parseInt(percentStr || '0', 10);
+    return isNaN(percent) ? 0 : Math.min(percent, 100);
+  } catch (error) {
+    // Fallback: return 0 if we can't determine
+    return 0;
+  }
+}
+
+/**
+ * Route matcher and handler
+ */
+export function handleDashboardRoutes(
+  method: string,
+  pathname: string,
+  req: IncomingMessage,
+  res: ServerResponse
+): boolean {
+  // GET /api/dashboard/stats
+  if (method === 'GET' && pathname === '/api/dashboard/stats') {
+    getDashboardStats(req, res);
+    return true;
+  }
+
+  return false;
+}

package/src/ui/server/routes/settings.ts

@@ -0,0 +1,63 @@
+/**
+ * Settings Routes - Handle version, upgrade, and uninstall
+ */
+
+import { IncomingMessage, ServerResponse } from 'http';
+import { UpgradeManager } from '../../../utils/upgrade.js';
+import { sendJson, sendError, asyncHandler } from '../middleware/errorHandler.js';
+
+const upgradeManager = new UpgradeManager();
+
+/**
+ * GET /api/version - Check version and get update info
+ */
+export const checkVersion = asyncHandler(async (req, res) => {
+  const versionInfo = await upgradeManager.checkForUpdates();
+  sendJson(res, versionInfo);
+});
+
+/**
+ * POST /api/upgrade - Upgrade to latest version
+ */
+export const upgrade = asyncHandler(async (req, res) => {
+  const result = await upgradeManager.upgrade();
+  sendJson(res, result);
+});
+
+/**
+ * POST /api/uninstall - Uninstall AppClean
+ */
+export const uninstall = asyncHandler(async (req, res) => {
+  const result = await upgradeManager.uninstall();
+  sendJson(res, result);
+});
+
+/**
+ * Route matcher and handler
+ */
+export function handleSettingsRoutes(
+  method: string,
+  pathname: string,
+  req: IncomingMessage,
+  res: ServerResponse
+): boolean {
+  // GET /api/version
+  if (method === 'GET' && pathname === '/api/version') {
+    checkVersion(req, res);
+    return true;
+  }
+
+  // POST /api/upgrade
+  if (method === 'POST' && pathname === '/api/upgrade') {
+    upgrade(req, res);
+    return true;
+  }
+
+  // POST /api/uninstall
+  if (method === 'POST' && pathname === '/api/uninstall') {
+    uninstall(req, res);
+    return true;
+  }
+
+  return false;
+}

package/src/ui/server/services/appService.ts

@@ -0,0 +1,184 @@
+/**
+ * AppService - Wraps Detector to provide app listing, searching, and analysis
+ */
+
+import { Detector } from '../../../core/detector.js';
+import { InstalledApp } from '../../../types/index.js';
+
+export interface SearchQuery {
+  q?: string;
+  method?: string;
+  sort?: 'name' | 'size' | 'date';
+  limit?: number;
+  offset?: number;
+}
+
+export interface AppAnalysis {
+  app: InstalledApp;
+  artifacts: any[];
+  totalSize: number;
+  breakdown: {
+    binaries: number;
+    configs: number;
+    caches: number;
+    data: number;
+    logs: number;
+    other: number;
+  };
+}
+
+export class AppService {
+  private detector: Detector;
+
+  constructor() {
+    this.detector = new Detector();
+  }
+
+  /**
+   * Get paginated list of all apps
+   */
+  async listApps(limit = 50, offset = 0): Promise<{
+    apps: InstalledApp[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }> {
+    try {
+      const allApps = await this.detector.searchApps({ sortBy: 'name' });
+      const page = Math.floor(offset / limit) + 1;
+      const paginatedApps = allApps.slice(offset, offset + limit);
+
+      return {
+        apps: paginatedApps,
+        total: allApps.length,
+        page,
+        pageSize: limit,
+      };
+    } catch (error) {
+      throw new Error(`Failed to list apps: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Search, filter, and sort apps
+   */
+  async searchApps(query: SearchQuery): Promise<{
+    apps: InstalledApp[];
+    count: number;
+  }> {
+    try {
+      const searchOptions: any = {
+        query: query.q || '',
+        sortBy: query.sort || 'name',
+      };
+
+      if (query.method) {
+        searchOptions.installMethod = query.method;
+      }
+
+      const apps = await this.detector.searchApps(searchOptions);
+      const limit = query.limit || 50;
+      const offset = query.offset || 0;
+      const paginatedApps = apps.slice(offset, offset + limit);
+
+      return {
+        apps: paginatedApps,
+        count: apps.length,
+      };
+    } catch (error) {
+      throw new Error(`Failed to search apps: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Analyze an app and get all artifacts
+   */
+  async analyzeApp(appName: string): Promise<AppAnalysis> {
+    try {
+      // Find the app first
+      const allApps = await this.detector.searchApps({ query: appName });
+      const app = allApps.find((a) => a.name.toLowerCase() === appName.toLowerCase());
+
+      if (!app) {
+        throw new Error(`App "${appName}" not found`);
+      }
+
+      // Find all artifacts
+      const artifacts = await this.detector.findArtifacts(app.name, app.installMethod);
+
+      // Calculate breakdown
+      const breakdown = this.calculateBreakdown(artifacts);
+      const totalSize = artifacts.reduce((sum, a) => sum + (a.size || 0), 0);
+
+      return {
+        app,
+        artifacts,
+        totalSize,
+        breakdown,
+      };
+    } catch (error) {
+      throw new Error(`Failed to analyze app: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Get preview of what will be removed (dry-run)
+   */
+  async previewRemoval(appName: string): Promise<{
+    appName: string;
+    totalSize: number;
+    filesCount: number;
+    artifacts: any[];
+  }> {
+    try {
+      const analysis = await this.analyzeApp(appName);
+
+      return {
+        appName: analysis.app.name,
+        totalSize: analysis.totalSize,
+        filesCount: analysis.artifacts.length,
+        artifacts: analysis.artifacts,
+      };
+    } catch (error) {
+      throw new Error(`Failed to preview removal: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Calculate artifact breakdown by category
+   */
+  private calculateBreakdown(artifacts: any[]): AppAnalysis['breakdown'] {
+    const breakdown: AppAnalysis['breakdown'] = {
+      binaries: 0,
+      configs: 0,
+      caches: 0,
+      data: 0,
+      logs: 0,
+      other: 0,
+    };
+
+    artifacts.forEach((artifact) => {
+      const path = artifact.path.toLowerCase();
+      const size = artifact.size || 0;
+
+      if (path.includes('bin') || path.includes('/usr/')) {
+        breakdown.binaries += size;
+      } else if (path.includes('config') || path.includes('.config')) {
+        breakdown.configs += size;
+      } else if (path.includes('cache') || path.includes('.cache')) {
+        breakdown.caches += size;
+      } else if (path.includes('log')) {
+        breakdown.logs += size;
+      } else if (path.includes('data') || path.includes('share')) {
+        breakdown.data += size;
+      } else {
+        breakdown.other += size;
+      }
+    });
+
+    return breakdown;
+  }
+}
+
+// Export singleton
+export const appService = new AppService();