feat(webui): add Phase 3 WebUI server implementation (WIP)

Copied all Phase 3 WebUI server components from FlashForgeUI-Electron alpha branch:

**WebUI Server Core:**
- AuthManager.ts (379 lines) - JWT-style token generation, session management
- auth-middleware.ts (198 lines) - Express middleware for auth, rate limiting
- WebSocketManager.ts - Real-time communication with authentication
- WebUIManager.ts - Express HTTP server orchestrator (Electron dependencies removed)
- api-routes.ts - Main router orchestrator

**API Routes (10 modules):**
- camera-routes.ts - Camera proxy and streaming endpoints
- context-routes.ts - Multi-printer context management
- filtration-routes.ts - Air filtration control
- job-routes.ts - Print job management (start, pause, resume, cancel)
- printer-control-routes.ts - Printer control commands
- printer-status-routes.ts - Status polling and feature detection
- spoolman-routes.ts - Spoolman filament tracking integration
- temperature-routes.ts - Temperature monitoring
- theme-routes.ts - UI theme settings
- route-helpers.ts - Shared utilities and dependency contracts

**Types & Schemas:**
- web-api.types.ts - WebSocket message types, API response types
- web-api.schemas.ts - Zod validation schemas
- camera.ts (updated) - Added URL resolution types, validation types
- gcode.ts (new) - GCode command result types

**Utilities:**
- camera-utils.ts (242 lines) - Camera config resolution, URL validation
  - Priority-based resolution (custom > builtin > none)
  - MJPEG and RTSP stream type detection
  - Context-aware settings retrieval

**Phase 1 Managers (from reference):**
- ConnectionFlowManager.ts (1280 lines) - Connection orchestration
- PrinterBackendManager.ts (from FlashForgeUI-Electron)

**Electron Removal:**
- Removed all electron imports from WebUIManager
- Removed EnvironmentDetectionService dependency
- Removed HeadlessDetection utility
- Simplified to pure Node.js Express/WebSocket server
- Static files served from dist/webui directory

**Configuration:**
- Updated tsconfig.json to exclude Electron files
- Only includes: managers, printer-backends, services, types, utils, webui

**Known Issues (Type Errors):**
The copied Phase 1 managers (ConnectionFlowManager, PrinterBackendManager) have
dependencies on Phase 1 services not yet ported:
- LoadingManager (UI-specific, needs headless adaptation)
- DialogIntegrationService (UI-specific, needs removal)
- PrinterDiscoveryService, SavedPrinterService, AutoConnectService
- ConnectionStateManager, ConnectionEstablishmentService
- ThumbnailRequestQueue, validation.utils

Next steps: Either port missing Phase 1 services or create minimal adapters for
WebUI-only functionality to complete Phase 3.

Author: claude

src/managers/ConnectionFlowManager.ts

@@ -1,10 +1,13 @@
 /**
- * @fileoverview Camera type definitions for camera proxy system
+ * @fileoverview Comprehensive type definitions for camera proxy system
  *
- * Provides type safety for camera configuration, proxy server management,
- * stream URL resolution, and client connection tracking.
+ * Provides complete type safety for camera configuration, proxy server management,
+ * stream URL resolution, and client connection tracking. Supports both built-in printer
+ * cameras (MJPEG/RTSP) and custom camera URLs with proper validation and type guards.
  */
 
+import { PrinterFeatureSet } from './printer-backend';
+
 /**
  * Camera source types
  */
@@ -38,6 +41,44 @@ export interface CameraProxyConfig {
   };
 }
 
+/**
+ * Camera configuration from user settings
+ */
+export interface CameraUserConfig {
+  /** Whether custom camera is enabled */
+  readonly customCameraEnabled: boolean;
+  /** Custom camera URL if enabled */
+  readonly customCameraUrl: string | null;
+}
+
+/**
+ * Resolved camera configuration after applying priority logic
+ */
+export interface ResolvedCameraConfig {
+  /** Source type of the camera */
+  readonly sourceType: CameraSourceType;
+  /** Stream protocol type (MJPEG or RTSP) */
+  readonly streamType?: CameraStreamType;
+  /** Final camera stream URL (null if no camera available) */
+  readonly streamUrl: string | null;
+  /** Whether camera feature is available */
+  readonly isAvailable: boolean;
+  /** Reason if camera is not available */
+  readonly unavailableReason?: string;
+}
+
+/**
+ * Camera URL resolution parameters
+ */
+export interface CameraUrlResolutionParams {
+  /** Printer IP address */
+  readonly printerIpAddress: string;
+  /** Printer feature set from backend */
+  readonly printerFeatures: PrinterFeatureSet;
+  /** User configuration for camera */
+  readonly userConfig: CameraUserConfig;
+}
+
 /**
  * Camera proxy client information
  */
@@ -116,3 +157,49 @@ export interface CameraProxyEvent {
   /** Error message if applicable */
   readonly error?: string;
 }
+
+/**
+ * Camera URL builder function type
+ */
+export type CameraUrlBuilder = (ipAddress: string) => string;
+
+/**
+ * Default camera URL patterns for different printer models
+ */
+export const DEFAULT_CAMERA_PATTERNS = {
+  /** Default MJPEG stream pattern for FlashForge printers */
+  FLASHFORGE_MJPEG: (ip: string) => `http://${ip}:8080/?action=stream`,
+} as const;
+
+/**
+ * Camera validation result
+ */
+export interface CameraUrlValidationResult {
+  /** Whether the URL is valid */
+  readonly isValid: boolean;
+  /** Validation error message if invalid */
+  readonly error?: string;
+  /** Parsed URL object if valid */
+  readonly parsedUrl?: URL;
+}
+
+/**
+ * Type guard to check if a camera source is available
+ */
+export function isCameraAvailable(config: ResolvedCameraConfig): config is ResolvedCameraConfig & { streamUrl: string } {
+  return config.isAvailable && config.streamUrl !== null;
+}
+
+/**
+ * Type guard to check if using custom camera
+ */
+export function isCustomCamera(config: ResolvedCameraConfig): boolean {
+  return config.sourceType === 'custom';
+}
+
+/**
+ * Type guard to check if using built-in camera
+ */
+export function isBuiltinCamera(config: ResolvedCameraConfig): boolean {
+  return config.sourceType === 'builtin';
+}

src/managers/PrinterBackendManager.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview GCode command types and result structures
+ */
+
+/**
+ * GCode command execution result
+ */
+export interface GCodeCommandResult {
+  readonly success: boolean;
+  readonly output?: string;
+  readonly error?: string;
+}

src/types/camera.ts

@@ -0,0 +1,241 @@
+/**
+ * @fileoverview Camera configuration resolution and validation utilities implementing priority-based
+ * camera URL selection logic. Supports both built-in printer cameras and custom camera URLs (MJPEG/RTSP),
+ * with context-aware settings retrieval for multi-printer environments. Provides stream type detection,
+ * URL validation, and human-readable status messaging.
+ *
+ * Key Features:
+ * - Priority-based camera resolution: custom camera > built-in camera > none
+ * - MJPEG and RTSP stream type detection and validation
+ * - Context-aware camera configuration (per-printer or global settings)
+ * - Automatic URL generation for custom cameras without explicit URLs
+ * - Comprehensive URL validation (protocol, hostname, format)
+ * - Camera availability checking with detailed unavailability reasons
+ * - Proxy URL formatting for client consumption
+ *
+ * Resolution Priority:
+ * 1. Custom camera (if enabled): Uses user-provided URL or auto-generates default FlashForge URL
+ * 2. Built-in camera: Uses default FlashForge MJPEG pattern if printer supports camera
+ * 3. No camera: Returns unavailable status with reason
+ *
+ * Stream Types Supported:
+ * - MJPEG (Motion JPEG over HTTP/HTTPS)
+ * - RTSP (Real-Time Streaming Protocol)
+ *
+ * Context Awareness:
+ * - Supports per-printer camera settings when contextId is provided
+ * - Falls back to global configuration for backward compatibility
+ * - Integrates with PrinterContextManager for multi-printer camera configurations
+ *
+ * Usage:
+ * - resolveCameraConfig(): Main resolution function with comprehensive config object
+ * - validateCameraUrl(): Standalone URL validation with detailed error messages
+ * - getCameraUserConfig(): Context-aware settings retrieval
+ * - isCameraFeatureAvailable(): Boolean availability check
+ */
+
+import {
+  CameraUrlResolutionParams,
+  ResolvedCameraConfig,
+  CameraUrlValidationResult,
+  CameraUserConfig,
+  CameraStreamType,
+  DEFAULT_CAMERA_PATTERNS
+} from '../types/camera';
+import { getConfigManager } from '../managers/ConfigManager';
+import { getPrinterContextManager } from '../managers/PrinterContextManager';
+
+/**
+ * Detect stream type from camera URL
+ *
+ * @param url - Camera URL to analyze
+ * @returns Stream type (mjpeg or rtsp)
+ */
+export function detectStreamType(url: string): CameraStreamType {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.protocol === 'rtsp:' ? 'rtsp' : 'mjpeg';
+  } catch {
+    // Default to MJPEG for invalid URLs
+    return 'mjpeg';
+  }
+}
+
+/**
+ * Validate a camera URL
+ */
+export function validateCameraUrl(url: string | null | undefined): CameraUrlValidationResult {
+  if (!url || url.trim() === '') {
+    return {
+      isValid: false,
+      error: 'URL is empty or not provided'
+    };
+  }
+
+  try {
+    const parsedUrl = new URL(url);
+
+    // Check for supported protocols
+    if (!['http:', 'https:', 'rtsp:'].includes(parsedUrl.protocol)) {
+      return {
+        isValid: false,
+        error: `Unsupported protocol: ${parsedUrl.protocol}. Use http://, https://, or rtsp://`
+      };
+    }
+
+    // Check for valid hostname
+    if (!parsedUrl.hostname || parsedUrl.hostname === '') {
+      return {
+        isValid: false,
+        error: 'Invalid hostname in URL'
+      };
+    }
+
+    return {
+      isValid: true,
+      parsedUrl
+    };
+  } catch {
+    return {
+      isValid: false,
+      error: 'Invalid URL format'
+    };
+  }
+}
+
+/**
+ * Resolve camera configuration based on priority rules
+ */
+export function resolveCameraConfig(params: CameraUrlResolutionParams): ResolvedCameraConfig {
+  const { printerIpAddress, printerFeatures, userConfig } = params;
+
+  // Priority 1: Check custom camera
+  if (userConfig.customCameraEnabled) {
+    // If custom camera is enabled but no URL provided, use automatic URL
+    if (!userConfig.customCameraUrl || userConfig.customCameraUrl.trim() === '') {
+      // Use the default FlashForge camera URL pattern when custom camera is enabled
+      // but no URL is specified. This supports cameras installed on printers that
+      // don't have them by default.
+      const autoUrl = `http://${printerIpAddress}:8080/?action=stream`;
+
+
+      return {
+        sourceType: 'custom',
+        streamType: 'mjpeg', // Auto URL is always MJPEG
+        streamUrl: autoUrl,
+        isAvailable: true
+      };
+    }
+
+    // Custom camera enabled with a user-provided URL
+    const validation = validateCameraUrl(userConfig.customCameraUrl);
+
+    if (validation.isValid) {
+      return {
+        sourceType: 'custom',
+        streamType: detectStreamType(userConfig.customCameraUrl),
+        streamUrl: userConfig.customCameraUrl,
+        isAvailable: true
+      };
+    } else {
+      // Custom camera enabled but URL is invalid
+      return {
+        sourceType: 'custom',
+        streamUrl: null,
+        isAvailable: false,
+        unavailableReason: `Custom camera URL is invalid: ${validation.error}`
+      };
+    }
+  }
+
+  // Priority 2: Check built-in camera
+  if (printerFeatures.camera.builtin) {
+    // Use default FlashForge MJPEG pattern
+    const streamUrl = DEFAULT_CAMERA_PATTERNS.FLASHFORGE_MJPEG(printerIpAddress);
+
+
+    return {
+      sourceType: 'builtin',
+      streamType: 'mjpeg', // Built-in cameras are always MJPEG
+      streamUrl,
+      isAvailable: true
+    };
+  }
+
+  // Priority 3: No camera available
+  return {
+    sourceType: 'none',
+    streamUrl: null,
+    isAvailable: false,
+    unavailableReason: 'Printer does not have built-in camera and custom camera is not configured'
+  };
+}
+
+/**
+ * Get camera configuration from user settings
+ * Now context-aware: reads from per-printer settings if contextId provided,
+ * otherwise falls back to global config (for backward compatibility)
+ *
+ * @param contextId - Optional context ID to get per-printer camera settings
+ * @returns Camera user configuration
+ */
+export function getCameraUserConfig(contextId?: string): CameraUserConfig {
+  const configManager = getConfigManager();
+
+  // If contextId provided, try to get per-printer settings first
+  if (contextId) {
+    const contextManager = getPrinterContextManager();
+    const context = contextManager.getContext(contextId);
+
+    if (context?.printerDetails) {
+      const { customCameraEnabled, customCameraUrl } = context.printerDetails;
+
+      // Per-printer settings override global config
+      if (customCameraEnabled !== undefined) {
+        return {
+          customCameraEnabled,
+          customCameraUrl: customCameraUrl || null
+        };
+      }
+    }
+  }
+
+  // Fall back to global config
+  return {
+    customCameraEnabled: configManager.get('CustomCamera') || false,
+    customCameraUrl: configManager.get('CustomCameraUrl') || null
+  };
+}
+
+/**
+ * Format camera proxy URL for client consumption
+ */
+export function formatCameraProxyUrl(port: number): string {
+  return `http://localhost:${port}/stream`;
+}
+
+/**
+ * Check if camera feature is available for a printer
+ */
+export function isCameraFeatureAvailable(params: CameraUrlResolutionParams): boolean {
+  const config = resolveCameraConfig(params);
+  return config.isAvailable;
+}
+
+/**
+ * Get human-readable camera status message
+ */
+export function getCameraStatusMessage(config: ResolvedCameraConfig): string {
+  if (config.isAvailable) {
+    switch (config.sourceType) {
+      case 'builtin':
+        return 'Using printer built-in camera';
+      case 'custom':
+        return 'Using custom camera URL';
+      default:
+        return 'Camera available';
+    }
+  } else {
+    return config.unavailableReason || 'Camera not available';
+  }
+}