fastled 1.3.30__py3-none-any.whl → 1.4.50__py3-none-any.whl

fastled/open_browser.py

@@ -6,8 +6,27 @@ import weakref
 from multiprocessing import Process
 from pathlib import Path
 
+from fastled.playwright.playwright_browser import open_with_playwright
 from fastled.server_flask import run_flask_in_thread
 
+# Global reference to keep Playwright browser alive
+_playwright_browser_proxy = None
+
+
+def cleanup_playwright_browser() -> None:
+    """Clean up the Playwright browser on exit."""
+    try:
+        global _playwright_browser_proxy
+        if _playwright_browser_proxy:
+            _playwright_browser_proxy.close()
+            _playwright_browser_proxy = None
+    except Exception:
+        pass
+
+
+# Register cleanup function
+atexit.register(cleanup_playwright_browser)
+
 DEFAULT_PORT = 8089  # different than live version.
 PYTHON_EXE = sys.executable
 
@@ -38,9 +57,15 @@ def is_port_free(port: int) -> bool:
     import httpx
 
     try:
-        response = httpx.get(f"http://localhost:{port}", timeout=1)
-        response.raise_for_status()
-        return False
+        # Try HTTPS first, then fall back to HTTP
+        try:
+            response = httpx.get(f"https://localhost:{port}", timeout=1, verify=False)
+            response.raise_for_status()
+            return False
+        except (httpx.HTTPError, httpx.ConnectError):
+            response = httpx.get(f"http://localhost:{port}", timeout=1)
+            response.raise_for_status()
+            return False
     except (httpx.HTTPError, httpx.ConnectError):
         return True
 
@@ -56,16 +81,21 @@ def find_free_port(start_port: int) -> int:
     raise ValueError("Could not find a free port")
 
 
-def wait_for_server(port: int, timeout: int = 10) -> None:
+def wait_for_server(port: int, timeout: int = 10, enable_https: bool = True) -> None:
     """Wait for the server to start."""
     from httpx import get
 
     future_time = time.time() + timeout
+    protocol = "https" if enable_https else "http"
     while future_time > time.time():
         try:
-            url = f"http://localhost:{port}"
+            # Try the specified protocol (HTTPS with SSL verification disabled for self-signed certs)
+            url = f"{protocol}://localhost:{port}"
             # print(f"Waiting for server to start at {url}")
-            response = get(url, timeout=1)
+            verify = (
+                False if enable_https else True
+            )  # Only disable SSL verification for HTTPS
+            response = get(url, timeout=1, verify=verify)
             if response.status_code == 200:
                 return
         except Exception:
@@ -78,6 +108,8 @@ def spawn_http_server(
     compile_server_port: int,
     port: int | None = None,
     open_browser: bool = True,
+    app: bool = False,
+    enable_https: bool = True,
 ) -> Process:
 
     if port is not None and not is_port_free(port):
@@ -86,6 +118,17 @@ def spawn_http_server(
         offset = random.randint(0, 100)
         port = find_free_port(DEFAULT_PORT + offset)
 
+    # Get SSL certificate paths from the fastled assets directory if HTTPS is enabled
+    certfile: Path | None = None
+    keyfile: Path | None = None
+
+    if enable_https:
+        import fastled
+
+        assets_dir = Path(fastled.__file__).parent / "assets"
+        certfile = assets_dir / "localhost.pem"
+        keyfile = assets_dir / "localhost-key.pem"
+
     # port: int,
     # cwd: Path,
     # compile_server_port: int,
@@ -94,7 +137,7 @@ def spawn_http_server(
 
     proc = Process(
         target=run_flask_in_thread,
-        args=(port, fastled_js, compile_server_port),
+        args=(port, fastled_js, compile_server_port, certfile, keyfile),
         daemon=True,
     )
     add_cleanup(proc)
@@ -103,16 +146,41 @@ def spawn_http_server(
     # Add to cleanup set with weak reference
     add_cleanup(proc)
 
-    wait_for_server(port)
+    wait_for_server(port, enable_https=enable_https)
     if open_browser:
-        print(f"Opening browser to http://localhost:{port}")
-        import webbrowser
-
-        webbrowser.open(
-            url=f"http://localhost:{port}",
-            new=1,
-            autoraise=True,
-        )
+        protocol = "https" if enable_https else "http"
+        url = f"{protocol}://localhost:{port}"
+        should_use_playwright = app
+
+        if should_use_playwright:
+            if app:
+                # For --app mode, try to install browsers if needed
+                from fastled.playwright.playwright_browser import (
+                    install_playwright_browsers,
+                )
+
+                install_playwright_browsers()
+
+            print(f"Opening FastLED sketch in Playwright browser: {url}")
+            print(
+                "Auto-resize enabled: Browser window will automatically adjust to content size"
+            )
+            print(
+                "🔧 C++ DevTools Support extension will be loaded for DWARF debugging"
+            )
+            global _playwright_browser_proxy
+            _playwright_browser_proxy = open_with_playwright(
+                url, enable_extensions=True
+            )
+        else:
+            print(f"Opening browser to {url}")
+            import webbrowser
+
+            webbrowser.open(
+                url=url,
+                new=1,
+                autoraise=True,
+            )
     return proc
 
 

fastled/parse_args.py

@@ -8,6 +8,7 @@ from fastled.project_init import project_init
 from fastled.select_sketch_directory import select_sketch_directory
 from fastled.settings import DEFAULT_URL, IMAGE_NAME
 from fastled.sketch import (
+    find_sketch_by_partial_name,
     find_sketch_directories,
     looks_like_fastled_repo,
     looks_like_sketch_directory,
@@ -30,16 +31,20 @@ FastLED WASM Compiler - Useful options:
   --init [example]      Initialize one of the top tier WASM examples
   --web [url]           Use web compiler
   --server              Run the compiler server
+  --no-platformio       Bypass PlatformIO constraints using local Docker compilation
   --quick               Build in quick mode (default)
   --profile             Enable profiling the C++ build system
   --update              Update the docker image for the wasm compiler
+  --background-update   Update the docker image in the background after compilation
   --purge               Remove all FastLED containers and images
+  --emsdk-headers <path> Export EMSDK headers ZIP to specified path
   --version             Show version information
   --help                Show detailed help
 Examples:
   fastled (will auto detect the sketch directory and prompt you)
   fastled my_sketch
   fastled my_sketch --web (compiles using the web compiler only)
+  fastled my_sketch --background-update (compiles and updates docker image in background)
   fastled --init Blink (initializes a new sketch directory with the Blink example)
   fastled --server (runs the compiler server in the current directory)
 
@@ -81,8 +86,8 @@ def parse_args() -> Args:
     parser.add_argument(
         "--ram-disk-size",
         type=str,
-        default="0",
-        help="Set the size of the ramdisk for the docker container. Use suffixes like '25mb' or '1gb'.",
+        default="1gb",
+        help="Size of the RAM disk for compilation (e.g., '1gb', '512mb')",
     )
     parser.add_argument(
         "--web",
@@ -112,7 +117,17 @@ def parse_args() -> Args:
     parser.add_argument(
         "--no-auto-updates",
         action="store_true",
-        help="Disable automatic updates of the wasm compiler image when using docker.",
+        help="Disable automatic updates of the wasm compiler image when using docker. (Default: False)",
+    )
+    parser.add_argument(
+        "--no-platformio",
+        action="store_true",
+        help="Bypass PlatformIO constraints by using local Docker compilation with custom build environment",
+    )
+    parser.add_argument(
+        "--app",
+        action="store_true",
+        help="Use Playwright app-like browser experience (will download browsers if needed)",
     )
     parser.add_argument(
         "-u",
@@ -121,6 +136,11 @@ def parse_args() -> Args:
         action="store_true",
         help="Update the wasm compiler (if necessary) before running",
     )
+    parser.add_argument(
+        "--background-update",
+        action="store_true",
+        help="Update the docker image in the background after compilation (user doesn't have to wait)",
+    )
     parser.add_argument(
         "--localhost",
         "--local",
@@ -152,6 +172,30 @@ def parse_args() -> Args:
         help="Remove all FastLED containers and images",
     )
 
+    parser.add_argument(
+        "--install",
+        action="store_true",
+        help="Install FastLED development environment with VSCode configuration and Auto Debug extension",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Run in dry-run mode (simulate actions without making changes)",
+    )
+
+    parser.add_argument(
+        "--no-interactive",
+        action="store_true",
+        help="Run in non-interactive mode (fail instead of prompting for input)",
+    )
+    parser.add_argument(
+        "--emsdk-headers",
+        type=str,
+        default=None,
+        help="Export EMSDK headers ZIP to specified path",
+    )
+
     build_mode = parser.add_mutually_exclusive_group()
     build_mode.add_argument("--debug", action="store_true", help="Build in debug mode")
     build_mode.add_argument(
@@ -167,6 +211,38 @@ def parse_args() -> Args:
 
     args = parser.parse_args()
 
+    # Handle --emsdk-headers early before other processing
+    if args.emsdk_headers:
+        from fastled.header_dump import dump_emsdk_headers
+
+        out_path = args.emsdk_headers
+        dump_emsdk_headers(out_path)
+        sys.exit(0)
+
+    # Auto-enable app mode if debug is used and Playwright cache exists
+    if args.debug and not args.app:
+        playwright_dir = Path.home() / ".fastled" / "playwright"
+        if playwright_dir.exists() and any(playwright_dir.iterdir()):
+            from fastled.emoji_util import EMO
+
+            print(
+                f"{EMO('⚠️', 'WARNING:')} Debug mode detected with Playwright installed - automatically enabling app mode"
+            )
+            args.app = True
+        elif not args.no_interactive:
+            # Prompt user to install Playwright only if not in no-interactive mode
+            answer = (
+                input("Would you like to install the FastLED debugger? [y/n] ")
+                .strip()
+                .lower()
+            )
+            if answer in ["y", "yes"]:
+                print(
+                    "📦 To install Playwright, run: pip install playwright && python -m playwright install"
+                )
+                print("Then run your command again with --app flag")
+                sys.exit(0)
+
     # TODO: propagate the library.
     # from fastled.docker_manager import force_remove_previous
 
@@ -186,6 +262,11 @@ def parse_args() -> Args:
     #     print(msg)
     #     set_ramdisk_size(args.ram_disk_size)
 
+    # Handle --install early before other processing
+    if args.install:
+        # Don't process other arguments when --install is used
+        return Args.from_namespace(args)
+
     if args.purge:
         from fastled.docker_manager import DockerManager
 
@@ -268,6 +349,12 @@ def parse_args() -> Args:
         if cwd_is_fastled and not args.web and not args.server:
             print("Forcing --local mode because we are in the FastLED repo")
             args.localhost = True
+        if args.no_platformio:
+            print(
+                "--no-platformio mode enabled: forcing local Docker compilation to bypass PlatformIO constraints"
+            )
+            args.localhost = True
+            args.web = None  # Clear web flag to ensure local compilation
         if args.localhost:
             args.web = "localhost"
         if args.interactive and not args.server:
@@ -282,7 +369,7 @@ def parse_args() -> Args:
                 print("Searching for sketch directories...")
                 sketch_directories = find_sketch_directories(maybe_sketch_dir)
                 selected_dir = select_sketch_directory(
-                    sketch_directories, cwd_is_fastled
+                    sketch_directories, cwd_is_fastled, is_followup=True
                 )
                 if selected_dir:
                     print(f"Using sketch directory: {selected_dir}")
@@ -292,10 +379,24 @@ def parse_args() -> Args:
                         "\nYou either need to specify a sketch directory or run in --server mode."
                     )
                     sys.exit(1)
-        elif args.directory is not None and os.path.isfile(args.directory):
-            dir_path = Path(args.directory).parent
-            if looks_like_sketch_directory(dir_path):
-                print(f"Using sketch directory: {dir_path}")
-                args.directory = str(dir_path)
+        elif args.directory is not None:
+            # Check if directory is a file path
+            if os.path.isfile(args.directory):
+                dir_path = Path(args.directory).parent
+                if looks_like_sketch_directory(dir_path):
+                    print(f"Using sketch directory: {dir_path}")
+                    args.directory = str(dir_path)
+            # Check if directory exists as a path
+            elif not os.path.exists(args.directory):
+                # Directory doesn't exist - try partial name matching
+                try:
+                    matched_dir = find_sketch_by_partial_name(args.directory)
+                    print(
+                        f"Matched '{args.directory}' to sketch directory: {matched_dir}"
+                    )
+                    args.directory = str(matched_dir)
+                except ValueError as e:
+                    print(f"Error: {e}")
+                    sys.exit(1)
 
     return Args.from_namespace(args)

fastled/playwright/chrome_extension_downloader.py

@@ -0,0 +1,207 @@
+"""
+Chrome extension downloader utility for FastLED WASM compiler.
+
+This module provides functionality to download Chrome extensions from the
+Chrome Web Store and prepare them for use with Playwright browser.
+"""
+
+import os
+import re
+import shutil
+import tempfile
+import warnings
+import zipfile
+from pathlib import Path
+
+import httpx
+
+
+class ChromeExtensionDownloader:
+    """Downloads Chrome extensions from the Chrome Web Store."""
+
+    # Chrome Web Store CRX download URL
+    CRX_URL = "https://clients2.google.com/service/update2/crx?response=redirect&prodversion=114.0&acceptformat=crx2,crx3&x=id%3D{extension_id}%26uc"
+
+    # Modern user agent string
+    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36"
+
+    def __init__(self, cache_dir: Path | None = None):
+        """Initialize the Chrome extension downloader.
+
+        Args:
+            cache_dir: Directory to store downloaded extensions.
+                      Defaults to ~/.fastled/chrome-extensions
+        """
+        if cache_dir is None:
+            cache_dir = Path.home() / ".fastled" / "chrome-extensions"
+
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self.headers = {
+            "User-Agent": self.USER_AGENT,
+            "Referer": "https://chrome.google.com",
+        }
+
+    def extract_extension_id(self, url: str) -> str:
+        """Extract extension ID from Chrome Web Store URL.
+
+        Args:
+            url: Chrome Web Store URL
+
+        Returns:
+            Extension ID string
+
+        Raises:
+            ValueError: If URL is not a valid Chrome Web Store URL
+        """
+        # Match new Chrome Web Store URLs (chromewebstore.google.com)
+        new_pattern = r"chromewebstore\.google\.com/detail/[^/]+/([a-z]{32})"
+        match = re.search(new_pattern, url)
+
+        if match:
+            return match.group(1)
+
+        # Match old Chrome Web Store URLs (chrome.google.com/webstore)
+        old_pattern = r"chrome\.google\.com/webstore/detail/[^/]+/([a-z]{32})"
+        match = re.search(old_pattern, url)
+
+        if match:
+            return match.group(1)
+
+        # Try direct extension ID
+        if re.match(r"^[a-z]{32}$", url):
+            return url
+
+        raise ValueError(f"Invalid Chrome Web Store URL or extension ID: {url}")
+
+    def download_crx(self, extension_id: str) -> bytes:
+        """Download CRX file from Chrome Web Store.
+
+        Args:
+            extension_id: Chrome extension ID
+
+        Returns:
+            CRX file content as bytes
+
+        Raises:
+            httpx.RequestError: If download fails
+        """
+        download_url = self.CRX_URL.format(extension_id=extension_id)
+
+        with httpx.Client(follow_redirects=True) as client:
+            response = client.get(download_url, headers=self.headers)
+            response.raise_for_status()
+
+            return response.content
+
+    def extract_crx_to_directory(self, crx_content: bytes, extract_dir: Path) -> None:
+        """Extract CRX file content to a directory.
+
+        CRX files are essentially ZIP files with a header that needs to be removed.
+
+        Args:
+            crx_content: CRX file content as bytes
+            extract_dir: Directory to extract the extension to
+        """
+        # CRX files have a header before the ZIP content
+        # We need to find the ZIP header (starts with 'PK')
+        zip_start = crx_content.find(b"PK\x03\x04")
+        if zip_start == -1:
+            zip_start = crx_content.find(b"PK\x05\x06")  # Empty ZIP
+
+        if zip_start == -1:
+            raise ValueError("Could not find ZIP header in CRX file")
+
+        # Extract the ZIP portion
+        zip_content = crx_content[zip_start:]
+
+        # Create temporary file to extract from
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_zip:
+            temp_zip.write(zip_content)
+            temp_zip_path = temp_zip.name
+
+        try:
+            # Extract the ZIP file
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(temp_zip_path, "r") as zip_ref:
+                zip_ref.extractall(extract_dir)
+        finally:
+            # Clean up temporary file
+            os.unlink(temp_zip_path)
+
+    def get_extension_path(
+        self, url_or_id: str, extension_name: str | None = None
+    ) -> Path:
+        """Download and extract Chrome extension, returning the path to the extracted directory.
+
+        Args:
+            url_or_id: Chrome Web Store URL or extension ID
+            extension_name: Optional name for the extension directory
+
+        Returns:
+            Path to the extracted extension directory
+        """
+        extension_id = self.extract_extension_id(url_or_id)
+
+        if extension_name is None:
+            extension_name = extension_id
+
+        extension_dir = self.cache_dir / extension_name
+
+        # Check if extension is already downloaded and extracted
+        if extension_dir.exists() and (extension_dir / "manifest.json").exists():
+            print(f"✅ Chrome extension already cached: {extension_dir}")
+            return extension_dir
+
+        print(f"🔽 Downloading Chrome extension {extension_id}...")
+
+        try:
+            # Download the CRX file
+            crx_content = self.download_crx(extension_id)
+
+            # Clean up existing directory if it exists
+            if extension_dir.exists():
+                shutil.rmtree(extension_dir)
+
+            # Extract the CRX file
+            self.extract_crx_to_directory(crx_content, extension_dir)
+
+            # Verify extraction worked
+            if not (extension_dir / "manifest.json").exists():
+                raise ValueError("Extension extraction failed - no manifest.json found")
+
+            print(f"✅ Chrome extension downloaded and extracted: {extension_dir}")
+            return extension_dir
+
+        except Exception as e:
+            warnings.warn(f"Failed to download Chrome extension {extension_id}: {e}")
+            if extension_dir.exists():
+                shutil.rmtree(extension_dir)
+            raise
+
+
+def download_cpp_devtools_extension() -> Path | None:
+    """Download the C++ DevTools Support (DWARF) extension.
+
+    Returns:
+        Path to the extracted extension directory, or None if download failed
+    """
+    # C++ DevTools Support (DWARF) extension
+    extension_url = "https://chromewebstore.google.com/detail/cc++-devtools-support-dwa/pdcpmagijalfljmkmjngeonclgbbannb"
+
+    try:
+        downloader = ChromeExtensionDownloader()
+        return downloader.get_extension_path(extension_url, "cpp-devtools-support")
+    except Exception as e:
+        warnings.warn(f"Failed to download C++ DevTools Support extension: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    # Test the downloader with the C++ DevTools Support extension
+    extension_path = download_cpp_devtools_extension()
+    if extension_path:
+        print(f"Extension downloaded to: {extension_path}")
+    else:
+        print("Failed to download extension")