feat: comprehensive debug logging across all controller modules

Add detailed [DEBUG] logging to every controller module when
logging.level is set to "debug". Each module with stateful debug
uses SetDebug(bool) wired from main.go. Covers stacks, backup,
cloudflare, integrations, system, monitor, settings, scheduler,
web handlers, storage, metrics, API, selfupdate, and assets.

Also includes the app export/import (.fab bundles) feature from
v0.32.0 and its debug page integration.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

controller/internal/backup/restore_app_linux.go

@@ -10,19 +10,26 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
 )
 
 // RestoreAppFromBackup restores a single app from its cross-drive backup.
 // Steps: restore config → verify/restore data → copy DB dumps → docker compose up.
 func RestoreAppFromBackup(ctx context.Context, app *RestorableApp, stacksDir string, logger *log.Logger) error {
 	stackDir := filepath.Join(stacksDir, app.Name)
+	start := time.Now()
+
+	logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: app=%s, stackDir=%s, hasConfig=%v, hasData=%v, hasDBDump=%v, hasRsyncData=%v",
+		app.Name, stackDir, app.HasConfig, app.HasData, app.HasDBDump, app.HasRsyncData)
 
 	// Step 1: Restore stack config from _config/ backup
 	if app.HasConfig {
 		logger.Printf("[INFO] Restoring config for %s from %s", app.Name, app.ConfigPath)
+		stepStart := time.Now()
 		if err := restoreConfigDir(ctx, app.ConfigPath, stackDir); err != nil {
 			return fmt.Errorf("restoring config: %w", err)
 		}
+		logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: config restore for %s completed in %s", app.Name, time.Since(stepStart))
 	} else {
 		// No config backup — check if stack dir already exists (from catalog sync)
 		if !dirExists(stackDir) {
@@ -35,20 +42,29 @@ func RestoreAppFromBackup(ctx context.Context, app *RestorableApp, stacksDir str
 	if app.NeedsHDD && !app.HasData && app.HasRsyncData {
 		// App data is missing but rsync backup exists — restore it
 		logger.Printf("[INFO] Restoring user data for %s from rsync backup", app.Name)
+		stepStart := time.Now()
 		if err := restoreUserData(ctx, app, logger); err != nil {
 			logger.Printf("[WARN] User data restore failed for %s: %v", app.Name, err)
 			// Non-fatal: app might still start without all data
+		} else {
+			logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: user data restore for %s completed in %s", app.Name, time.Since(stepStart))
 		}
 	} else if app.HasData {
 		logger.Printf("[INFO] App data for %s found at %s — no restore needed", app.Name, app.DataPath)
+	} else {
+		logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: %s — no user data to restore (needsHDD=%v, hasData=%v, hasRsyncData=%v)",
+			app.Name, app.NeedsHDD, app.HasData, app.HasRsyncData)
 	}
 
 	// Step 3: Copy DB dumps to primary backup location
 	if app.HasDBDump {
 		logger.Printf("[INFO] Restoring DB dumps for %s", app.Name)
+		stepStart := time.Now()
 		if err := restoreDBDumps(app, logger); err != nil {
 			logger.Printf("[WARN] DB dump restore failed for %s: %v", app.Name, err)
 			// Non-fatal
+		} else {
+			logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: DB dump restore for %s completed in %s", app.Name, time.Since(stepStart))
 		}
 	}
 
@@ -62,22 +78,30 @@ func RestoreAppFromBackup(ctx context.Context, app *RestorableApp, stacksDir str
 	}
 
 	composeDir := filepath.Dir(composePath)
+	logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: %s using compose file %s", app.Name, composePath)
 
 	logger.Printf("[INFO] Pulling images for %s", app.Name)
+	pullStart := time.Now()
 	pullCmd := exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "pull")
 	pullCmd.Dir = composeDir
 	if out, err := pullCmd.CombinedOutput(); err != nil {
 		logger.Printf("[WARN] docker compose pull failed for %s: %v (%s)", app.Name, err, strings.TrimSpace(string(out)))
 		// Non-fatal: might work with cached images
+	} else {
+		logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: docker compose pull for %s completed in %s", app.Name, time.Since(pullStart))
 	}
 
 	logger.Printf("[INFO] Starting %s", app.Name)
+	upStart := time.Now()
 	upCmd := exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "up", "-d")
 	upCmd.Dir = composeDir
 	if out, err := upCmd.CombinedOutput(); err != nil {
 		return fmt.Errorf("docker compose up: %v (%s)", err, strings.TrimSpace(string(out)))
 	}
 
+	logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: %s fully restored and started in %s", app.Name, time.Since(start))
+	logger.Printf("[DEBUG] [backup] RestoreAppFromBackup: docker compose up for %s completed in %s", app.Name, time.Since(upStart))
+
 	return nil
 }
 
@@ -103,6 +127,8 @@ func restoreUserData(ctx context.Context, app *RestorableApp, logger *log.Logger
 		return fmt.Errorf("no rsync data path or HDD path")
 	}
 
+	logger.Printf("[DEBUG] [backup] restoreUserData: app=%s, rsyncPath=%s, hddPath=%s", app.Name, app.RsyncDataPath, app.HDDPath)
+
 	// The rsync backup contains the app's data directories.
 	// Walk the backup dir and rsync each subdirectory (excluding _config/_db)
 	// back to the app's HDD data directory.
@@ -112,10 +138,12 @@ func restoreUserData(ctx context.Context, app *RestorableApp, logger *log.Logger
 	}
 
 	dataDir := AppDataDir(app.HDDPath, app.Name)
+	logger.Printf("[DEBUG] [backup] restoreUserData: %s — target dataDir=%s, %d entries in backup", app.Name, dataDir, len(entries))
 	if err := os.MkdirAll(dataDir, 0755); err != nil {
 		return fmt.Errorf("creating data dir: %w", err)
 	}
 
+	restored := 0
 	for _, e := range entries {
 		name := e.Name()
 		if name == "_config" || name == "_db" || strings.HasPrefix(name, ".") {
@@ -132,9 +160,12 @@ func restoreUserData(ctx context.Context, app *RestorableApp, logger *log.Logger
 				continue
 			}
 			dst = strings.TrimRight(dst, "/") + "/"
+			logger.Printf("[DEBUG] [backup] restoreUserData: %s — rsync dir %s → %s", app.Name, src, dst)
 			cmd := exec.CommandContext(ctx, "rsync", "-a", src, dst)
 			if out, err := cmd.CombinedOutput(); err != nil {
 				logger.Printf("[WARN] rsync data %s: %v (%s)", name, err, strings.TrimSpace(string(out)))
+			} else {
+				restored++
 			}
 		} else {
 			// Single file — copy directly
@@ -143,12 +174,16 @@ func restoreUserData(ctx context.Context, app *RestorableApp, logger *log.Logger
 				logger.Printf("[WARN] Cannot read %s: %v", src, err)
 				continue
 			}
+			logger.Printf("[DEBUG] [backup] restoreUserData: %s — copying file %s (%d bytes)", app.Name, name, len(data))
 			if err := os.WriteFile(dst, data, 0644); err != nil {
 				logger.Printf("[WARN] Cannot write %s: %v", dst, err)
+			} else {
+				restored++
 			}
 		}
 	}
 
+	logger.Printf("[DEBUG] [backup] restoreUserData: %s — restored %d items", app.Name, restored)
 	return nil
 }
 
@@ -170,6 +205,7 @@ func restoreDBDumps(app *RestorableApp, logger *log.Logger) error {
 	}
 
 	destDir := AppDBDumpPath(drivePath, app.Name)
+	logger.Printf("[DEBUG] [backup] restoreDBDumps: app=%s, src=%s, destDir=%s", app.Name, app.DBDumpPath, destDir)
 	if err := os.MkdirAll(destDir, 0755); err != nil {
 		return fmt.Errorf("creating dump dir: %w", err)
 	}
@@ -179,6 +215,7 @@ func restoreDBDumps(app *RestorableApp, logger *log.Logger) error {
 		return err
 	}
 
+	copied := 0
 	for _, e := range entries {
 		if e.IsDir() {
 			continue
@@ -190,11 +227,15 @@ func restoreDBDumps(app *RestorableApp, logger *log.Logger) error {
 			logger.Printf("[WARN] Cannot read dump %s: %v", e.Name(), err)
 			continue
 		}
+		logger.Printf("[DEBUG] [backup] restoreDBDumps: %s — copying %s (%d bytes)", app.Name, e.Name(), len(data))
 		if err := os.WriteFile(dst, data, 0644); err != nil {
 			logger.Printf("[WARN] Cannot write dump %s: %v", e.Name(), err)
+		} else {
+			copied++
 		}
 	}
 
+	logger.Printf("[DEBUG] [backup] restoreDBDumps: %s — copied %d dump files", app.Name, copied)
 	return nil
 }