Implement configuration management, drag-and-drop functionality, and logging utilities for WebDrop Bridge

src/webdrop_bridge/config.py

@@ -0,0 +1,143 @@
+"""Configuration management for WebDrop Bridge application."""
+
+import logging
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurationError(Exception):
+    """Raised when configuration is invalid."""
+
+    pass
+
+
+@dataclass
+class Config:
+    """Application configuration loaded from environment variables.
+
+    Attributes:
+        app_name: Application display name
+        app_version: Application version (semantic versioning)
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        log_file: Optional log file path
+        allowed_roots: List of whitelisted root directories for file access
+        webapp_url: URL to load in embedded web application
+        window_width: Initial window width in pixels
+        window_height: Initial window height in pixels
+        enable_logging: Whether to write logs to file
+
+    Raises:
+        ConfigurationError: If configuration values are invalid
+    """
+
+    app_name: str
+    app_version: str
+    log_level: str
+    log_file: Path | None
+    allowed_roots: List[Path]
+    webapp_url: str
+    window_width: int
+    window_height: int
+    enable_logging: bool
+
+    @classmethod
+    def from_env(cls, env_file: str | None = None) -> "Config":
+        """Load configuration from environment variables.
+
+        Looks for a .env file in the current working directory and loads
+        environment variables from it. All unset variables use sensible defaults.
+
+        Args:
+            env_file: Optional path to .env file to load. If None, loads default .env
+
+        Returns:
+            Config: Configured instance with environment values or defaults
+
+        Raises:
+            ConfigurationError: If any configured value is invalid
+        """
+        # Load .env file if it exists
+        load_dotenv(env_file)
+
+        # Extract and validate configuration values
+        app_name = os.getenv("APP_NAME", "WebDrop Bridge")
+        app_version = os.getenv("APP_VERSION", "1.0.0")
+        log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+        log_file_str = os.getenv("LOG_FILE", "logs/webdrop_bridge.log")
+        allowed_roots_str = os.getenv("ALLOWED_ROOTS", "Z:/,C:/Users/Public")
+        webapp_url = os.getenv("WEBAPP_URL", "file:///./webapp/index.html")
+        window_width = int(os.getenv("WINDOW_WIDTH", "1024"))
+        window_height = int(os.getenv("WINDOW_HEIGHT", "768"))
+        enable_logging = os.getenv("ENABLE_LOGGING", "true").lower() == "true"
+
+        # Validate log level
+        valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+        if log_level not in valid_levels:
+            raise ConfigurationError(
+                f"Invalid LOG_LEVEL: {log_level}. "
+                f"Must be one of: {', '.join(valid_levels)}"
+            )
+
+        # Validate and parse allowed roots
+        try:
+            allowed_roots = []
+            for p in allowed_roots_str.split(","):
+                root_path = Path(p.strip()).resolve()
+                if not root_path.exists():
+                    raise ConfigurationError(
+                        f"Allowed root '{p.strip()}' does not exist"
+                    )
+                if not root_path.is_dir():
+                    raise ConfigurationError(
+                        f"Allowed root '{p.strip()}' is not a directory"
+                    )
+                allowed_roots.append(root_path)
+        except ConfigurationError:
+            raise
+        except (ValueError, OSError) as e:
+            raise ConfigurationError(
+                f"Invalid ALLOWED_ROOTS: {allowed_roots_str}. Error: {e}"
+            ) from e
+
+        # Validate window dimensions
+        if window_width <= 0 or window_height <= 0:
+            raise ConfigurationError(
+                f"Window dimensions must be positive: "
+                f"{window_width}x{window_height}"
+            )
+
+        # Create log file path if logging enabled
+        log_file = None
+        if enable_logging:
+            log_file = Path(log_file_str).resolve()
+
+        # Validate webapp URL is not empty
+        if not webapp_url:
+            raise ConfigurationError("WEBAPP_URL cannot be empty")
+
+        return cls(
+            app_name=app_name,
+            app_version=app_version,
+            log_level=log_level,
+            log_file=log_file,
+            allowed_roots=allowed_roots,
+            webapp_url=webapp_url,
+            window_width=window_width,
+            window_height=window_height,
+            enable_logging=enable_logging,
+        )
+
+    def __repr__(self) -> str:
+        """Return developer-friendly representation."""
+        return (
+            f"Config(app={self.app_name} v{self.app_version}, "
+            f"log_level={self.log_level}, "
+            f"allowed_roots={len(self.allowed_roots)} dirs, "
+            f"window={self.window_width}x{self.window_height})"
+        )