feat: Enhance logging and output handling across modules

- Updated logging messages to use a consistent format with "[ + ]" for success indicators.
- Added handling for empty results in various scans, ensuring informative messages are written to output files.
- Improved .gitignore to include backup directories and configuration files.
- Refactored AEM and other modules to always save discovered instances and results, even if empty.
- Enhanced README documentation for clarity on features and usage.

Author: h0tak88r

.gitignore

@@ -91,4 +91,7 @@ roots.txt
 .sql.gz
 autoar
 .db-shm
-.db-wal
+.db-wal
+
+/backups/
+Rules.yml

README.md

@@ -472,7 +472,7 @@ AutoAR includes **KeyHack**, a comprehensive API key validation system with **77
 
 - **📋 778+ Templates**: Comprehensive collection of API key validation templates from KeysKit and custom additions
 - **🔍 Smart Search**: Search templates by provider name or description
-- **✅ Quick Validation**: Generate ready-to-use validation commands (curl or shell)
+- **[ + ]Quick Validation**: Generate ready-to-use validation commands (curl or shell)
 - **➕ Extensible**: Add custom validation templates via Discord or CLI
 - **🌐 Multi-Format Support**: Supports HTTP-based (curl) and shell-based (AWS CLI, etc.) validation methods
 

internal/modules/aem/aem.go

@@ -108,35 +108,20 @@ func DiscoverAEM(opts Options) ([]string, error) {
 	log.Printf("[AEM] Starting AEM discovery (native Go)...")
 	discovered := DiscoverAEMFromURLs(urls, client, opts.Threads)
 
-	// Save discovered instances
-	if len(discovered) > 0 {
-		discoveredFH, err := os.Create(discoveredFile)
-		if err == nil {
+	// Always save discovered instances (even if empty)
+	discoveredFH, err := os.Create(discoveredFile)
+	if err == nil {
+		if len(discovered) > 0 {
 			for _, url := range discovered {
 				fmt.Fprintln(discoveredFH, url)
 			}
-			discoveredFH.Close()
-		}
-		
-		// Send findings to Discord webhook if configured
-		webhookURL := os.Getenv("DISCORD_WEBHOOK")
-		if webhookURL != "" {
-			if info, err := os.Stat(discoveredFile); err == nil && info.Size() > 0 {
-				domain := opts.Domain
-				if domain == "" && opts.LiveHostsFile != "" {
-					domain = "targets"
-				}
-				utils.SendWebhookFileAsync(discoveredFile, fmt.Sprintf("AEM Discovery: AEM instances found (%d discovered)", len(discovered)))
-				utils.SendWebhookLogAsync(fmt.Sprintf("AEM discovery: %d AEM instance(s) found", len(discovered)))
-			}
-		}
-	} else {
-		// No findings
-		webhookURL := os.Getenv("DISCORD_WEBHOOK")
-		if webhookURL != "" {
-			utils.SendWebhookLogAsync("AEM discovery completed with 0 AEM instances found")
+		} else {
+			fmt.Fprintln(discoveredFH, "No AEM instances discovered.")
 		}
+		discoveredFH.Close()
 	}
+	
+	// Don't send individual discovery messages - will be sent in consolidated file from Run()
 
 	return discovered, nil
 }
@@ -180,27 +165,22 @@ func ScanAEM(url string, opts Options) ([]Finding, error) {
 	log.Printf("[AEM] Scanning %s for vulnerabilities (native Go)...", url)
 	findings := ScanAEMInstance(url, ssrfHost, client, opts.Handlers)
 
-	// Save findings as JSON
+	// Always save findings as JSON (even if empty)
+	var data []byte
 	if len(findings) > 0 {
-		if data, err := json.MarshalIndent(findings, "", "  "); err == nil {
+		if jsonData, err := json.MarshalIndent(findings, "", "  "); err == nil {
+			data = jsonData
 			os.WriteFile(resultsFile, data, 0644)
 		}
-		
-		// Send findings to Discord webhook if configured
-		webhookURL := os.Getenv("DISCORD_WEBHOOK")
-		if webhookURL != "" {
-			if info, err := os.Stat(resultsFile); err == nil && info.Size() > 0 {
-				utils.SendWebhookFileAsync(resultsFile, fmt.Sprintf("AEM Finding: Vulnerabilities found for %s (%d findings)", url, len(findings)))
-			}
-			utils.SendWebhookLogAsync(fmt.Sprintf("AEM scan completed for %s - %d vulnerability/vulnerabilities found", url, len(findings)))
-		}
 	} else {
-		// No findings
-		webhookURL := os.Getenv("DISCORD_WEBHOOK")
-		if webhookURL != "" {
-			utils.SendWebhookLogAsync(fmt.Sprintf("AEM scan completed for %s with 0 findings", url))
+		// Save empty findings array
+		if jsonData, err := json.MarshalIndent([]Finding{}, "", "  "); err == nil {
+			data = jsonData
+			os.WriteFile(resultsFile, data, 0644)
 		}
 	}
+	
+	// Don't send individual scan messages - will be sent in consolidated file from Run()
 
 	return findings, nil
 }
@@ -260,8 +240,49 @@ func Run(opts Options) (*Result, error) {
 	}
 	res.DiscoveredCount = len(discovered)
 
+	// Always create consolidated result file even if no instances discovered
 	if len(discovered) == 0 {
 		log.Printf("[AEM] No AEM instances discovered")
+		
+		// Create consolidated file with "no results" message
+		consolidatedFile := filepath.Join(outputDir, "aem-scan.txt")
+		consolidatedF, err := os.Create(consolidatedFile)
+		if err == nil {
+			defer consolidatedF.Close()
+			domain := opts.Domain
+			if domain == "" && opts.LiveHostsFile != "" {
+				domain = "targets"
+			}
+			fmt.Fprintf(consolidatedF, "AEM Scan Results for %s\n", domain)
+			fmt.Fprintf(consolidatedF, "========================================\n\n")
+			fmt.Fprintf(consolidatedF, "No AEM instances discovered.\n")
+		}
+		
+		// Save empty results to JSON
+		allResults := map[string]interface{}{
+			"discovered_count": 0,
+			"vulnerabilities":  0,
+			"discovered":       []string{},
+			"findings":         []Finding{},
+			"scan_time":       time.Now().Format(time.RFC3339),
+		}
+		if data, err := json.MarshalIndent(allResults, "", "  "); err == nil {
+			os.WriteFile(resultsFile, data, 0644)
+		}
+		
+		// Send to Discord
+		webhookURL := os.Getenv("DISCORD_WEBHOOK")
+		if webhookURL != "" {
+			domain := opts.Domain
+			if domain == "" && opts.LiveHostsFile != "" {
+				domain = "targets"
+			}
+			if info, err := os.Stat(consolidatedFile); err == nil && info.Size() > 0 {
+				utils.SendWebhookFileAsync(consolidatedFile, fmt.Sprintf("AEM Scan Results: 0 AEM instances found for %s", domain))
+			}
+			utils.SendWebhookLogAsync(fmt.Sprintf("AEM scan completed for %s: 0 AEM instances discovered", domain))
+		}
+		
 		res.Duration = time.Since(startTime)
 		return res, nil
 	}
@@ -283,7 +304,7 @@ func Run(opts Options) (*Result, error) {
 
 	res.Vulnerabilities = len(allFindings)
 
-	// Save all results
+	// Save all results to JSON files
 	allResults := map[string]interface{}{
 		"discovered_count": res.DiscoveredCount,
 		"vulnerabilities":  res.Vulnerabilities,
@@ -297,23 +318,58 @@ func Run(opts Options) (*Result, error) {
 		os.WriteFile(scannedFile, data, 0644)
 	}
 
-	// Send findings to Discord webhook if configured
+	// Always create consolidated aem-scan.txt file (even with 0 findings)
+	consolidatedFile := filepath.Join(outputDir, "aem-scan.txt")
+	consolidatedF, err := os.Create(consolidatedFile)
+	if err == nil {
+		defer consolidatedF.Close()
+		
+		domain := opts.Domain
+		if domain == "" && opts.LiveHostsFile != "" {
+			domain = "targets"
+		}
+		
+		fmt.Fprintf(consolidatedF, "AEM Scan Results for %s\n", domain)
+		fmt.Fprintf(consolidatedF, "========================================\n\n")
+		fmt.Fprintf(consolidatedF, "Discovered AEM Instances: %d\n", res.DiscoveredCount)
+		fmt.Fprintf(consolidatedF, "Vulnerabilities Found: %d\n\n", res.Vulnerabilities)
+		
+		if len(discovered) > 0 {
+			fmt.Fprintf(consolidatedF, "Discovered Instances:\n")
+			for _, url := range discovered {
+				fmt.Fprintf(consolidatedF, "  - %s\n", url)
+			}
+			fmt.Fprintf(consolidatedF, "\n")
+		}
+		
+		if len(allFindings) > 0 {
+			fmt.Fprintf(consolidatedF, "Vulnerabilities:\n")
+			for _, finding := range allFindings {
+				fmt.Fprintf(consolidatedF, "  - [%s] %s\n", finding.Name, finding.URL)
+				if finding.Description != "" {
+					fmt.Fprintf(consolidatedF, "    Description: %s\n", finding.Description)
+				}
+			}
+		} else {
+			fmt.Fprintf(consolidatedF, "No vulnerabilities found.\n")
+		}
+	}
+
+	// Send findings to Discord webhook if configured (only the consolidated file)
 	webhookURL := os.Getenv("DISCORD_WEBHOOK")
 	if webhookURL != "" {
+		domain := opts.Domain
+		if domain == "" && opts.LiveHostsFile != "" {
+			domain = "targets"
+		}
+		
+		if info, err := os.Stat(consolidatedFile); err == nil && info.Size() > 0 {
+			utils.SendWebhookFileAsync(consolidatedFile, fmt.Sprintf("AEM Scan Results: %d AEM instances, %d vulnerabilities for %s", res.DiscoveredCount, res.Vulnerabilities, domain))
+		}
+		
 		if res.Vulnerabilities > 0 {
-			if info, err := os.Stat(resultsFile); err == nil && info.Size() > 0 {
-				domain := opts.Domain
-				if domain == "" && opts.LiveHostsFile != "" {
-					domain = "targets"
-				}
-				utils.SendWebhookFileAsync(resultsFile, fmt.Sprintf("AEM Scan Summary: %d AEM instances, %d vulnerabilities for %s", res.DiscoveredCount, res.Vulnerabilities, domain))
-			}
 			utils.SendWebhookLogAsync(fmt.Sprintf("AEM scan completed: %d AEM instance(s), %d vulnerability/vulnerabilities found", res.DiscoveredCount, res.Vulnerabilities))
 		} else {
-			domain := opts.Domain
-			if domain == "" && opts.LiveHostsFile != "" {
-				domain = "targets"
-			}
 			utils.SendWebhookLogAsync(fmt.Sprintf("AEM scan completed for %s: %d AEM instance(s), 0 vulnerabilities", domain, res.DiscoveredCount))
 		}
 	}

internal/modules/apkx/apkx.go

@@ -33,11 +33,12 @@ type Options struct {
 
 // Result describes where apkX wrote its output.
 type Result struct {
-	ReportDir    string
-	LogFile      string
-	Duration     time.Duration
+	ReportDir      string
+	LogFile        string
+	Duration       time.Duration
 	MITMPatchedAPK string // Path to MITM patched APK if MITM was enabled
-	FromCache    bool     // True if this result was loaded from cache
+	OriginalAPKPath string // Path to original downloaded APK (for RunFromPackage)
+	FromCache      bool   // True if this result was loaded from cache
 }
 
 // PackageOptions controls apkX scans where AutoAR first downloads the
@@ -449,7 +450,7 @@ func RunFromPackage(opts PackageOptions) (*Result, error) {
 
 		cachePath, found := CheckCache(packageName, cacheVersion)
 		if found {
-			fmt.Printf("[CACHE] ✅ Using cached results for %s v%s (skipping scan)\n", packageName, version)
+			fmt.Printf("[CACHE] [ + ]Using cached results for %s v%s (skipping scan)\n", packageName, version)
 
 			// Load cached result
 			if strings.HasPrefix(cachePath, "r2:") {
@@ -464,7 +465,7 @@ func RunFromPackage(opts PackageOptions) (*Result, error) {
 					// Now load from local cache
 					cachedResult, err := LoadCachedResult(localCachePath)
 					if err == nil {
-						fmt.Printf("[CACHE] ✅ Loaded cache from R2 for %s v%s\n", packageName, version)
+						fmt.Printf("[CACHE] [ + ]Loaded cache from R2 for %s v%s\n", packageName, version)
 						return cachedResult, nil
 					}
 					fmt.Printf("[CACHE] ⚠️  Failed to load downloaded cache: %v, doing fresh scan\n", err)
@@ -494,6 +495,11 @@ func RunFromPackage(opts PackageOptions) (*Result, error) {
 		OutputDir: opts.OutputDir,
 		MITM:      opts.MITM,
 	})
+	
+	// Store the original APK path in the result
+	if result != nil {
+		result.OriginalAPKPath = inputPath
+	}
 
 	// Save to cache after successful scan
 	if err == nil && result != nil && packageName != "" {
@@ -530,7 +536,7 @@ func RunFromPackage(opts PackageOptions) (*Result, error) {
 						}
 
 						if version != "" {
-							fmt.Printf("[CACHE] ✅ Extracted version from decompiled manifest: %s v%s\n", packageName, version)
+							fmt.Printf("[CACHE] [ + ]Extracted version from decompiled manifest: %s v%s\n", packageName, version)
 						}
 					}
 				}

internal/modules/apkx/cache.go

@@ -61,7 +61,7 @@ func CheckCache(packageName, version string) (string, bool) {
 		if version == "latest" {
 			foundVersion, found := findAnyCachedVersionInR2(packageName)
 			if found {
-				log.Printf("[CACHE] ✅ Found R2 cached results for %s v%s (was looking for 'latest')", packageName, foundVersion)
+				log.Printf("[CACHE] [ + ]Found R2 cached results for %s v%s (was looking for 'latest')", packageName, foundVersion)
 				r2CachePrefix := getR2CachePath(packageName, foundVersion)
 				return "r2:" + r2CachePrefix, true
 			}
@@ -70,7 +70,7 @@ func CheckCache(packageName, version string) (string, bool) {
 			r2ResultsKey := r2CachePrefix + "/results.json"
 			exists, err := r2storage.FileExists(r2ResultsKey)
 			if err == nil && exists {
-				log.Printf("[CACHE] ✅ Found R2 cached results for %s vlatest", packageName)
+				log.Printf("[CACHE] [ + ]Found R2 cached results for %s vlatest", packageName)
 				return "r2:" + r2CachePrefix, true
 			}
 		} else {
@@ -79,7 +79,7 @@ func CheckCache(packageName, version string) (string, bool) {
 			r2ResultsKey := r2CachePrefix + "/results.json"
 			exists, err := r2storage.FileExists(r2ResultsKey)
 			if err == nil && exists {
-				log.Printf("[CACHE] ✅ Found R2 cached results for %s v%s", packageName, version)
+				log.Printf("[CACHE] [ + ]Found R2 cached results for %s v%s", packageName, version)
 				return "r2:" + r2CachePrefix, true // Return with r2: prefix to indicate R2 location
 			}
 		}
@@ -90,15 +90,15 @@ func CheckCache(packageName, version string) (string, bool) {
 	if version == "latest" {
 		foundVersion, found := findAnyCachedVersionLocal(packageName)
 		if found {
-			log.Printf("[CACHE] ✅ Found local cached results for %s v%s (was looking for 'latest')", packageName, foundVersion)
+			log.Printf("[CACHE] [ + ]Found local cached results for %s v%s (was looking for 'latest')", packageName, foundVersion)
 			localCachePath := getCachePath(packageName, foundVersion)
 			return localCachePath, true
 		}
 	} else {
 		localCachePath := getCachePath(packageName, version)
 		resultsJson := filepath.Join(localCachePath, "results.json")
 		if _, err := os.Stat(resultsJson); err == nil {
-			log.Printf("[CACHE] ✅ Found local cached results for %s v%s", packageName, version)
+			log.Printf("[CACHE] [ + ]Found local cached results for %s v%s", packageName, version)
 			return localCachePath, true
 		}
 	}
@@ -152,7 +152,7 @@ func CheckCache(packageName, version string) (string, bool) {
 
 		// Save to cache
 		if err := SaveToCache(packageName, extractedVersion, "", existingResult); err == nil {
-			log.Printf("[CACHE] ✅ Migrated existing scan to cache: %s v%s", packageName, extractedVersion)
+			log.Printf("[CACHE] [ + ]Migrated existing scan to cache: %s v%s", packageName, extractedVersion)
 			// Return the new cache path
 			newCachePath := getCachePath(packageName, extractedVersion)
 			return newCachePath, true
@@ -344,7 +344,7 @@ func SaveToCache(packageName, version, versionCode string, result *Result) error
 		if err != nil {
 			log.Printf("[CACHE] ⚠️  Failed to upload cache to R2: %v", err)
 		} else {
-			log.Printf("[CACHE] ✅ Cache uploaded to R2")
+			log.Printf("[CACHE] [ + ]Cache uploaded to R2")
 		}
 	}
 

internal/modules/backup/backup.go

@@ -186,6 +186,12 @@ func Run(opts Options) (*Result, error) {
 			foundCount++
 		}
 	}
+	
+	// Always write a message if no results found
+	if foundCount == 0 {
+		resultsFH.WriteString("No backup files found.\n")
+	}
+	
 	log.Printf("[INFO] Backup scan: Wrote %d backup URLs to results file: %s", foundCount, resultsFile)
 
 	res.Duration = time.Since(start)

internal/modules/db/backup.go

@@ -41,7 +41,7 @@ func BackupDatabase(uploadToR2 bool) (string, string, error) {
 			log.Printf("[DB] ⚠️  Failed to upload backup to R2: %v", err)
 			// Don't fail the backup if R2 upload fails
 		} else {
-			log.Printf("[DB] ✅ Database backup uploaded to R2: %s", r2URL)
+			log.Printf("[DB] [ + ]Database backup uploaded to R2: %s", r2URL)
 		}
 	}
 
@@ -94,7 +94,7 @@ func backupSQLite() (string, error) {
 		return "", fmt.Errorf("failed to copy database file: %w", err)
 	}
 
-	log.Printf("[DB] ✅ SQLite backup created: %s", backupPath)
+	log.Printf("[DB] [ + ]SQLite backup created: %s", backupPath)
 	return backupPath, nil
 }
 
@@ -150,7 +150,7 @@ func backupPostgreSQL() (string, error) {
 		return "", fmt.Errorf("backup file was not created")
 	}
 
-	log.Printf("[DB] ✅ PostgreSQL backup created: %s", backupPath)
+	log.Printf("[DB] [ + ]PostgreSQL backup created: %s", backupPath)
 	return backupPath, nil
 }