feat(webui): complete Phase 3 - add Phase 1 services and headless adapters

Add all Phase 1 core infrastructure services required for WebUI operation:
- AutoConnectService: automatic connection decision logic
- ConnectionEstablishmentService: low-level connection setup and validation
- ConnectionStateManager: multi-context connection state tracking
- PrinterDiscoveryService: network scanning and printer detection
- SavedPrinterService: persistent printer storage and last connected tracking
- ThumbnailRequestQueue: thumbnail caching and request queue management
- validation.utils: Zod validation schemas and IP address validation

Add minimal headless adapters for UI-specific components:
- LoadingManager: logs loading states to console instead of showing UI
- DialogIntegrationService: returns sensible defaults for all dialog requests

Fix WebUIManager:
- Remove unused getRtspStreamService import

All Phase 1 services are full implementations from FlashForgeUI-Electron reference
to maintain 1:1 functionality match. Only UI-specific components use minimal adapters.

Type check: 0 errors
Phase 3 WebUI Server: Complete

Author: claude

src/managers/LoadingManager.ts

@@ -0,0 +1,244 @@
+/**
+ * @fileoverview Headless LoadingManager for standalone WebUI mode
+ *
+ * Provides a no-op implementation of LoadingManager for headless Node.js operation.
+ * All loading states are logged to console instead of displaying UI overlays.
+ *
+ * This adapter allows PrinterBackendManager and ConnectionFlowManager to work
+ * without requiring Electron-specific UI components.
+ */
+
+import { EventEmitter } from 'events';
+
+/**
+ * Loading state types for different UI states
+ */
+export type LoadingState = 'hidden' | 'loading' | 'success' | 'error';
+
+/**
+ * Loading operation options for customizing behavior
+ */
+export interface LoadingOptions {
+  message: string;
+  canCancel?: boolean;
+  showProgress?: boolean;
+  autoHideAfter?: number; // milliseconds
+}
+
+/**
+ * Loading event data sent to renderer
+ */
+export interface LoadingEventData {
+  state: LoadingState;
+  message?: string;
+  progress?: number;
+  canCancel?: boolean;
+  autoHideAfter?: number;
+}
+
+/**
+ * Branded type for LoadingManager singleton
+ */
+type LoadingManagerBrand = { readonly __brand: 'LoadingManager' };
+type LoadingManagerInstance = LoadingManager & LoadingManagerBrand;
+
+/**
+ * Headless LoadingManager - logs loading states instead of showing UI
+ */
+export class LoadingManager extends EventEmitter {
+  private static instance: LoadingManagerInstance | null = null;
+
+  private currentState: LoadingState = 'hidden';
+  private currentMessage: string = '';
+  private currentProgress: number = 0;
+  private canCancelFlag: boolean = false;
+
+  private constructor() {
+    super();
+  }
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): LoadingManagerInstance {
+    if (!LoadingManager.instance) {
+      LoadingManager.instance = new LoadingManager() as LoadingManagerInstance;
+    }
+    return LoadingManager.instance;
+  }
+
+  /**
+   * Show loading overlay with message (headless: just logs)
+   */
+  public show(options: LoadingOptions): void {
+    this.currentState = 'loading';
+    this.currentMessage = options.message;
+    this.currentProgress = 0;
+    this.canCancelFlag = options.canCancel || false;
+
+    console.log(`[Loading] ${this.currentMessage}`);
+
+    const eventData: LoadingEventData = {
+      state: this.currentState,
+      message: this.currentMessage,
+      progress: this.currentProgress,
+      canCancel: this.canCancelFlag
+    };
+
+    this.emit('loading-state-changed', eventData);
+    this.emit('loadingStateChanged', eventData.state);
+  }
+
+  /**
+   * Hide loading overlay (headless: just logs)
+   */
+  public hide(): void {
+    this.currentState = 'hidden';
+    this.currentMessage = '';
+    this.currentProgress = 0;
+    this.canCancelFlag = false;
+
+    const eventData: LoadingEventData = {
+      state: this.currentState
+    };
+
+    this.emit('loading-state-changed', eventData);
+    this.emit('loadingStateChanged', eventData.state);
+  }
+
+  /**
+   * Show success message (headless: just logs)
+   */
+  public showSuccess(message: string, _autoHideAfter: number = 4000): void {
+    this.currentState = 'success';
+    this.currentMessage = message;
+
+    console.log(`[Loading] ✓ ${message}`);
+
+    const eventData: LoadingEventData = {
+      state: this.currentState,
+      message: this.currentMessage,
+      autoHideAfter: _autoHideAfter
+    };
+
+    this.emit('loading-state-changed', eventData);
+    this.emit('loadingStateChanged', eventData.state);
+
+    // Auto-hide after timeout
+    setTimeout(() => this.hide(), _autoHideAfter);
+  }
+
+  /**
+   * Show error message (headless: just logs)
+   */
+  public showError(message: string, _autoHideAfter: number = 5000): void {
+    this.currentState = 'error';
+    this.currentMessage = message;
+
+    console.error(`[Loading] ✗ ${message}`);
+
+    const eventData: LoadingEventData = {
+      state: this.currentState,
+      message: this.currentMessage,
+      autoHideAfter: _autoHideAfter
+    };
+
+    this.emit('loading-state-changed', eventData);
+    this.emit('loadingStateChanged', eventData.state);
+
+    // Auto-hide after timeout
+    setTimeout(() => this.hide(), _autoHideAfter);
+  }
+
+  /**
+   * Set progress percentage
+   */
+  public setProgress(progress: number): void {
+    this.currentProgress = Math.min(100, Math.max(0, progress));
+
+    const eventData: LoadingEventData = {
+      state: this.currentState,
+      message: this.currentMessage,
+      progress: this.currentProgress,
+      canCancel: this.canCancelFlag
+    };
+
+    this.emit('loading-state-changed', eventData);
+  }
+
+  /**
+   * Update loading message
+   */
+  public updateMessage(message: string): void {
+    this.currentMessage = message;
+
+    console.log(`[Loading] ${message}`);
+
+    const eventData: LoadingEventData = {
+      state: this.currentState,
+      message: this.currentMessage,
+      progress: this.currentProgress,
+      canCancel: this.canCancelFlag
+    };
+
+    this.emit('loading-state-changed', eventData);
+  }
+
+  /**
+   * Handle cancel request (headless: always returns false - no cancellation)
+   */
+  public handleCancelRequest(): boolean {
+    return false;
+  }
+
+  /**
+   * Get current state
+   */
+  public getState(): LoadingState {
+    return this.currentState;
+  }
+
+  /**
+   * Get current message
+   */
+  public getMessage(): string {
+    return this.currentMessage;
+  }
+
+  /**
+   * Get current progress
+   */
+  public getProgress(): number {
+    return this.currentProgress;
+  }
+
+  /**
+   * Check if loading is visible
+   */
+  public isVisible(): boolean {
+    return this.currentState !== 'hidden';
+  }
+
+  /**
+   * Check if operation is cancellable
+   */
+  public isCancellable(): boolean {
+    return this.canCancelFlag;
+  }
+
+  /**
+   * Cleanup and dispose
+   */
+  public dispose(): void {
+    this.hide();
+    this.removeAllListeners();
+    LoadingManager.instance = null;
+  }
+}
+
+/**
+ * Get singleton instance
+ */
+export function getLoadingManager(): LoadingManagerInstance {
+  return LoadingManager.getInstance();
+}

src/services/AutoConnectService.ts

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview
+ * AutoConnectService.ts
+ * 
+ * Provides automated printer connection functionality for the FlashForgeUI-Electron application.
+ * This service handles the logic for determining when and how to automatically connect to 
+ * previously saved printers based on network discovery results. It implements decision-making
+ * algorithms for selecting the appropriate printer when multiple matches are found, and manages
+ * auto-connect preferences and retry logic. The service follows a singleton pattern and extends
+ * EventEmitter to provide event-based communication with other components.
+ * 
+ * Key responsibilities:
+ * - Determine when auto-connection should be attempted
+ * - Make decisions about which printer to connect to when multiple options exist
+ * - Manage auto-connect preferences and configuration
+ * - Handle auto-connect retry logic and logging
+ */
+
+import { EventEmitter } from 'events';
+import { getConfigManager } from '../managers/ConfigManager';
+import { SavedPrinterMatch, AutoConnectDecision } from '../types/printer';
+export class AutoConnectService extends EventEmitter {
+  private static instance: AutoConnectService | null = null;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private readonly _configManager = getConfigManager();
+
+  private constructor() {
+    super();
+  }
+
+  /**
+   * Get singleton instance of AutoConnectService
+   */
+  public static getInstance(): AutoConnectService {
+    if (!AutoConnectService.instance) {
+      AutoConnectService.instance = new AutoConnectService();
+    }
+    return AutoConnectService.instance;
+  }
+
+  /**
+   * Determine if auto-connect should be attempted
+   * Based on configuration settings and saved printer availability
+   */
+  public shouldAutoConnect(): boolean {
+    // Auto-connect is always enabled by default
+    // We could add a config option later if needed
+    return true;
+  }
+
+  /**
+   * Determine the auto-connect choice based on available matches
+   * @param matches - Array of saved printer matches found on network
+   * @returns The auto-connect choice and selected match if applicable
+   */
+  public determineAutoConnectChoice(matches: SavedPrinterMatch[]): AutoConnectDecision {
+    if (matches.length === 0) {
+      // No saved printers found on network
+      return {
+        action: 'none',
+        reason: 'No saved printers found on network'
+      };
+    } else if (matches.length === 1) {
+      // Single saved printer found - auto-connect
+      return {
+        action: 'connect',
+        selectedMatch: matches[0],
+        reason: 'Single saved printer found'
+      };
+    } else {
+      // Multiple saved printers found - need user selection
+      return {
+        action: 'select',
+        matches,
+        reason: 'Multiple saved printers found'
+      };
+    }
+  }
+
+  /**
+   * Get the preferred printer for auto-connect
+   * Returns the last used printer if available
+   */
+  public getPreferredPrinter(matches: SavedPrinterMatch[]): SavedPrinterMatch | null {
+    if (matches.length === 0) {
+      return null;
+    }
+
+    // For now, return null to let the UI handle selection
+    // We could add last used printer tracking later
+    return null;
+  }
+
+  /**
+   * Check if a specific printer should be auto-connected
+   * Can be used for direct connection attempts
+   */
+  public shouldAutoConnectToPrinter(_serialNumber: string): boolean {
+    // For now, always return false
+    // We could add last used printer tracking later
+    return false;
+  }
+
+  /**
+   * Update auto-connect preferences after successful connection
+   */
+  public updateAutoConnectPreferences(serialNumber: string): void {
+    // This might update config settings for future auto-connect
+    this.emit('auto-connect-preferences-updated', serialNumber);
+  }
+
+  /**
+   * Get auto-connect delay in milliseconds
+   * Allows for a brief delay before attempting auto-connect
+   */
+  public getAutoConnectDelay(): number {
+    // Return default delay of 100ms
+    return 100;
+  }
+
+  /**
+   * Check if auto-connect should be retried after failure
+   */
+  public shouldRetryAutoConnect(_attemptCount: number): boolean {
+    // No retries by default
+    return false;
+  }
+
+  /**
+   * Log auto-connect attempt for debugging
+   */
+  public logAutoConnectAttempt(
+    action: 'started' | 'succeeded' | 'failed' | 'cancelled',
+    details?: unknown
+  ): void {
+    const timestamp = new Date().toISOString();
+    console.log(`[AutoConnect] ${timestamp} - ${action}`, details);
+    this.emit('auto-connect-logged', { action, details, timestamp });
+  }
+}
+
+// Export singleton getter function
+export const getAutoConnectService = (): AutoConnectService => {
+  return AutoConnectService.getInstance();
+};
+