webtap-tool 0.1.4__tar.gz → 0.1.5__tar.gz

{webtap_tool-0.1.4 → webtap_tool-0.1.5}/CHANGELOG.md

@@ -15,6 +15,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [0.1.5] - 2025-09-10
+
+### Added
+- New `setup-desktop` command to install desktop entry for GUI Chrome integration
+- Desktop entry installation that overrides system Chrome launcher to use debug wrapper
+- Automatic detection and modification of system Chrome desktop files
+
+### Changed
+- Refactored setup service from monolithic file into modular components
+- Split `services/setup.py` into separate modules: `filters.py`, `extension.py`, `chrome.py`, `desktop.py`
+- Updated type hints to use modern Python 3.9+ style (`dict` instead of `Dict`)
+
+### Fixed
+- Code style issues across setup modules (imports, formatting, type hints)
+
+### Removed
+
 ## [0.1.4] - 2025-09-08
 
 ### Added

{webtap_tool-0.1.4 → webtap_tool-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtap-tool
-Version: 0.1.4
+Version: 0.1.5
 Summary: Terminal-based web page inspector for AI debugging sessions
 Author-email: Fredrik Angelsen <fredrikangelsen@gmail.com>
 Classifier: Development Status :: 3 - Alpha

{webtap_tool-0.1.4 → webtap_tool-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webtap-tool"
-version = "0.1.4"
+version = "0.1.5"
 description = "Terminal-based web page inspector for AI debugging sessions"
 readme = "README.md"
 authors = [

{webtap_tool-0.1.4 → webtap_tool-0.1.5}/src/webtap/commands/setup.py

@@ -61,6 +61,28 @@ def setup_chrome(state, force: bool = False) -> dict:
     return _format_setup_result(result, "chrome")
 
 
+@app.command(
+    display="markdown",
+    typer={"name": "setup-desktop", "help": "Install desktop entry to use Chrome wrapper from GUI"},
+    fastmcp={"enabled": False},
+)
+def setup_desktop(state, force: bool = False) -> dict:
+    """Install desktop entry to ~/.local/share/applications/google-chrome.desktop.
+
+    This makes the Chrome wrapper work when launching from GUI (app launcher, dock, etc).
+    The desktop entry overrides the system Chrome launcher to use our debug-enabled wrapper.
+
+    Args:
+        force: Overwrite existing desktop entry (default: False)
+
+    Returns:
+        Markdown-formatted result with success/error messages
+    """
+    service = SetupService()
+    result = service.install_desktop_entry(force=force)
+    return _format_setup_result(result, "desktop")
+
+
 def _format_setup_result(result: dict, component: str) -> dict:
     """Format setup result as markdown."""
     elements = []
@@ -123,5 +145,17 @@ def _format_setup_result(result: dict, component: str) -> dict:
                         ],
                     }
                 )
+        elif component == "desktop":
+            elements.append({"type": "text", "content": "\n**Next steps:**"})
+            elements.append(
+                {
+                    "type": "list",
+                    "items": [
+                        "Log out and log back in (or run `update-desktop-database ~/.local/share/applications`)",
+                        "Chrome will now launch with debugging enabled from GUI",
+                        "The wrapper at ~/.local/bin/wrappers/google-chrome-stable will be used",
+                    ],
+                }
+            )
 
     return {"elements": elements}

webtap_tool-0.1.5/src/webtap/services/setup/__init__.py

@@ -0,0 +1,66 @@
+"""Setup service for installing WebTap components.
+
+PUBLIC API:
+  - SetupService: Main service class for all setup operations
+"""
+
+from typing import Dict, Any
+
+from .filters import install_filters
+from .extension import install_extension
+from .chrome import install_chrome_wrapper
+from .desktop import install_desktop_entry
+
+
+class SetupService:
+    """Service for installing WebTap components.
+
+    Delegates to specialized modules for each component type.
+    """
+
+    def install_filters(self, force: bool = False) -> Dict[str, Any]:
+        """Install filter configuration.
+
+        Args:
+            force: Overwrite existing file
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return install_filters(force=force)
+
+    def install_extension(self, force: bool = False) -> Dict[str, Any]:
+        """Install Chrome extension files.
+
+        Args:
+            force: Overwrite existing files
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return install_extension(force=force)
+
+    def install_chrome_wrapper(self, force: bool = False) -> Dict[str, Any]:
+        """Install Chrome wrapper script.
+
+        Args:
+            force: Overwrite existing script
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return install_chrome_wrapper(force=force)
+
+    def install_desktop_entry(self, force: bool = False) -> Dict[str, Any]:
+        """Install desktop entry for GUI integration.
+
+        Args:
+            force: Overwrite existing entry
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return install_desktop_entry(force=force)
+
+
+__all__ = ["SetupService"]

webtap_tool-0.1.5/src/webtap/services/setup/chrome.py

@@ -0,0 +1,77 @@
+"""Chrome wrapper setup functionality for WebTap."""
+
+import os
+import logging
+from pathlib import Path
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+def install_chrome_wrapper(force: bool = False) -> Dict[str, Any]:
+    """Install Chrome wrapper script for debugging.
+
+    Args:
+        force: Overwrite existing script
+
+    Returns:
+        Dict with success, message, path, details
+    """
+    target_path = Path.home() / ".local" / "bin" / "wrappers" / "google-chrome-stable"
+
+    if target_path.exists() and not force:
+        return {
+            "success": False,
+            "message": "Chrome wrapper already exists",
+            "path": str(target_path),
+            "details": "Use --force to overwrite",
+        }
+
+    wrapper_script = """#!/bin/bash
+# Chrome wrapper using bindfs for perfect state sync with debug port
+
+DEBUG_DIR="$HOME/.config/google-chrome-debug"
+REAL_DIR="$HOME/.config/google-chrome"
+
+# Check if bindfs is installed
+if ! command -v bindfs &>/dev/null; then
+    echo "Error: bindfs not installed. Install with: yay -S bindfs" >&2
+    exit 1
+fi
+
+# Mount real profile via bindfs if not already mounted
+if ! mountpoint -q "$DEBUG_DIR" 2>/dev/null; then
+    mkdir -p "$DEBUG_DIR"
+    if ! bindfs --no-allow-other "$REAL_DIR" "$DEBUG_DIR"; then
+        echo "Error: Failed to mount Chrome profile via bindfs" >&2
+        exit 1
+    fi
+    echo "Chrome debug profile mounted. To unmount: fusermount -u $DEBUG_DIR" >&2
+fi
+
+# Launch Chrome with debugging on bindfs mount
+exec /usr/bin/google-chrome-stable \\
+    --remote-debugging-port=9222 \\
+    --remote-allow-origins='*' \\
+    --user-data-dir="$DEBUG_DIR" \\
+    "$@"
+"""
+
+    # Create directory and save
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    target_path.write_text(wrapper_script)
+    target_path.chmod(0o755)  # Make executable
+
+    # Check PATH
+    path_dirs = os.environ.get("PATH", "").split(":")
+    wrapper_dir = str(target_path.parent)
+    in_path = wrapper_dir in path_dirs
+
+    logger.info(f"Installed Chrome wrapper to {target_path}")
+
+    return {
+        "success": True,
+        "message": "Installed Chrome wrapper script",
+        "path": str(target_path),
+        "details": "Already in PATH ✓" if in_path else "Add to PATH",
+    }

webtap_tool-0.1.5/src/webtap/services/setup/desktop.py

@@ -0,0 +1,151 @@
+"""Desktop entry setup functionality for WebTap."""
+
+import re
+import logging
+from pathlib import Path
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+def install_desktop_entry(force: bool = False) -> Dict[str, Any]:
+    """Install desktop entry to override system Chrome launcher.
+
+    Creates a .desktop file that makes Chrome launch with our debug wrapper
+    when started from GUI (app launcher, dock, etc).
+
+    Args:
+        force: Overwrite existing desktop entry
+
+    Returns:
+        Dict with success, message, path, details
+    """
+    # Check if wrapper exists first
+    wrapper_path = Path.home() / ".local" / "bin" / "wrappers" / "google-chrome-stable"
+    if not wrapper_path.exists():
+        return {
+            "success": False,
+            "message": "Chrome wrapper not found. Run 'setup-chrome' first",
+            "path": None,
+            "details": f"Expected wrapper at {wrapper_path}",
+        }
+
+    # Desktop entry location (user override of system entry)
+    desktop_path = Path.home() / ".local" / "share" / "applications" / "google-chrome.desktop"
+
+    if desktop_path.exists() and not force:
+        return {
+            "success": False,
+            "message": "Desktop entry already exists",
+            "path": str(desktop_path),
+            "details": "Use --force to overwrite",
+        }
+
+    # Get system Chrome desktop file for reference
+    system_desktop = _find_system_desktop_file()
+
+    if system_desktop:
+        desktop_content = _create_from_system_desktop(system_desktop, wrapper_path)
+        source_info = system_desktop.name
+    else:
+        desktop_content = _create_minimal_desktop(wrapper_path)
+        source_info = "minimal template"
+
+    # Create directory and save
+    desktop_path.parent.mkdir(parents=True, exist_ok=True)
+    desktop_path.write_text(desktop_content)
+    desktop_path.chmod(0o644)  # Standard permissions for desktop files
+
+    logger.info(f"Installed desktop entry to {desktop_path}")
+
+    return {
+        "success": True,
+        "message": "Installed Chrome desktop entry with debug wrapper",
+        "path": str(desktop_path),
+        "details": f"Based on {source_info}",
+    }
+
+
+def _find_system_desktop_file() -> Path | None:
+    """Find the system Chrome desktop file."""
+    for system_path in [
+        Path("/usr/share/applications/google-chrome.desktop"),
+        Path("/usr/share/applications/google-chrome-stable.desktop"),
+        Path("/usr/local/share/applications/google-chrome.desktop"),
+    ]:
+        if system_path.exists():
+            return system_path
+    return None
+
+
+def _create_from_system_desktop(system_desktop: Path, wrapper_path: Path) -> str:
+    """Create desktop content by modifying the system desktop file."""
+    try:
+        system_content = system_desktop.read_text()
+
+        # Replace all Exec= lines to use our wrapper
+        # Match Exec= lines that point to chrome executables
+        exec_pattern = re.compile(
+            r"^Exec=.*?(?:google-chrome-stable|google-chrome|chromium|chrome)(?:\s|$)", re.MULTILINE
+        )
+
+        # Replace with our wrapper, preserving arguments
+        def replace_exec(match):
+            line = match.group(0)
+            # Find where the executable ends and arguments begin
+            # Look for common chrome executables
+            for exe in ["google-chrome-stable", "google-chrome", "chromium-browser", "chromium", "chrome"]:
+                if exe in line:
+                    # Split at the executable name
+                    parts = line.split(exe, 1)
+                    if len(parts) > 1:
+                        # Has arguments after executable
+                        return f"Exec={wrapper_path}{parts[1]}"
+                    else:
+                        # No arguments
+                        return f"Exec={wrapper_path}"
+            # Fallback - shouldn't happen
+            return f"Exec={wrapper_path}"
+
+        desktop_content = exec_pattern.sub(replace_exec, system_content)
+
+        # Also handle TryExec if present (used to check if program exists)
+        tryexec_pattern = re.compile(
+            r"^TryExec=.*?(?:google-chrome-stable|google-chrome|chromium|chrome)", re.MULTILINE
+        )
+        desktop_content = tryexec_pattern.sub(f"TryExec={wrapper_path}", desktop_content)
+
+        return desktop_content
+
+    except Exception as e:
+        logger.warning(f"Failed to parse system desktop file, using minimal entry: {e}")
+        return _create_minimal_desktop(wrapper_path)
+
+
+def _create_minimal_desktop(wrapper_path: Path) -> str:
+    """Create a minimal desktop entry from scratch."""
+    return f"""[Desktop Entry]
+Version=1.0
+Type=Application
+Name=Google Chrome
+GenericName=Web Browser
+Comment=Access the Internet
+Icon=google-chrome
+Categories=Network;WebBrowser;
+MimeType=application/pdf;application/rdf+xml;application/rss+xml;application/xhtml+xml;application/xhtml_xml;application/xml;image/gif;image/jpeg;image/png;image/webp;text/html;text/xml;x-scheme-handler/ftp;x-scheme-handler/http;x-scheme-handler/https;
+StartupWMClass=Google-chrome
+StartupNotify=true
+Terminal=false
+Exec={wrapper_path} %U
+Actions=new-window;new-private-window;
+
+[Desktop Action new-window]
+Name=New Window
+StartupWMClass=Google-chrome
+Exec={wrapper_path}
+
+[Desktop Action new-private-window]
+Name=New Incognito Window
+StartupWMClass=Google-chrome
+Exec={wrapper_path} --incognito
+"""

webtap_tool-0.1.5/src/webtap/services/setup/extension.py

@@ -0,0 +1,88 @@
+"""Chrome extension setup functionality for WebTap."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+# GitHub URLs for extension files
+EXTENSION_BASE_URL = "https://raw.githubusercontent.com/angelsen/tap-tools/main/packages/webtap/extension"
+EXTENSION_FILES = ["manifest.json", "popup.html", "popup.js"]
+
+
+def install_extension(force: bool = False) -> Dict[str, Any]:
+    """Install Chrome extension to ~/.config/webtap/extension/.
+
+    Args:
+        force: Overwrite existing files
+
+    Returns:
+        Dict with success, message, path, details
+    """
+    # XDG config directory for Linux
+    target_dir = Path.home() / ".config" / "webtap" / "extension"
+
+    # Check if exists (manifest.json is required file)
+    if (target_dir / "manifest.json").exists() and not force:
+        return {
+            "success": False,
+            "message": f"Extension already exists at {target_dir}",
+            "path": str(target_dir),
+            "details": "Use --force to overwrite",
+        }
+
+    # Create directory
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # Download each file
+    downloaded = []
+    failed = []
+
+    for filename in EXTENSION_FILES:
+        url = f"{EXTENSION_BASE_URL}/{filename}"
+        target_file = target_dir / filename
+
+        try:
+            logger.info(f"Downloading {filename}")
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+
+            # For manifest.json, validate it's proper JSON
+            if filename == "manifest.json":
+                json.loads(response.text)
+
+            target_file.write_text(response.text)
+            downloaded.append(filename)
+
+        except Exception as e:
+            logger.error(f"Failed to download {filename}: {e}")
+            failed.append(filename)
+
+    # Determine success level
+    if not downloaded:
+        return {
+            "success": False,
+            "message": "Failed to download any extension files",
+            "path": None,
+            "details": "Check network connection and try again",
+        }
+
+    if failed:
+        # Partial success - some files downloaded
+        return {
+            "success": True,  # Partial is still success
+            "message": f"Downloaded {len(downloaded)}/{len(EXTENSION_FILES)} files",
+            "path": str(target_dir),
+            "details": f"Failed: {', '.join(failed)}",
+        }
+
+    return {
+        "success": True,
+        "message": "Downloaded Chrome extension",
+        "path": str(target_dir),
+        "details": f"Files: {', '.join(downloaded)}",
+    }

webtap_tool-0.1.5/src/webtap/services/setup/filters.py

@@ -0,0 +1,79 @@
+"""Filter setup functionality for WebTap."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+# GitHub URL for filters
+FILTERS_URL = "https://raw.githubusercontent.com/angelsen/tap-tools/main/packages/webtap/data/filters.json"
+
+
+def install_filters(force: bool = False) -> Dict[str, Any]:
+    """Install filters to .webtap/filters.json.
+
+    Args:
+        force: Overwrite existing file
+
+    Returns:
+        Dict with success, message, path, details
+    """
+    # Same path that FilterManager uses
+    target_path = Path.cwd() / ".webtap" / "filters.json"
+
+    # Check if exists
+    if target_path.exists() and not force:
+        return {
+            "success": False,
+            "message": f"Filters already exist at {target_path}",
+            "path": str(target_path),
+            "details": "Use --force to overwrite",
+        }
+
+    # Download from GitHub
+    try:
+        logger.info(f"Downloading filters from {FILTERS_URL}")
+        response = requests.get(FILTERS_URL, timeout=10)
+        response.raise_for_status()
+
+        # Validate it's proper JSON
+        filters_data = json.loads(response.text)
+
+        # Quick validation - should have dict structure
+        if not isinstance(filters_data, dict):
+            return {
+                "success": False,
+                "message": "Invalid filter format - expected JSON object",
+                "path": None,
+                "details": None,
+            }
+
+        # Count categories for user feedback
+        category_count = len(filters_data)
+
+        # Create directory and save
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        target_path.write_text(response.text)
+
+        logger.info(f"Saved {category_count} filter categories to {target_path}")
+
+        return {
+            "success": True,
+            "message": f"Downloaded {category_count} filter categories",
+            "path": str(target_path),
+            "details": f"Categories: {', '.join(filters_data.keys())}",
+        }
+
+    except requests.RequestException as e:
+        logger.error(f"Network error downloading filters: {e}")
+        return {"success": False, "message": f"Network error: {e}", "path": None, "details": None}
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in filters: {e}")
+        return {"success": False, "message": f"Invalid JSON format: {e}", "path": None, "details": None}
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        return {"success": False, "message": f"Failed to download filters: {e}", "path": None, "details": None}

webtap_tool-0.1.4/src/webtap/services/setup.py

@@ -1,229 +0,0 @@
-"""Setup service for installing WebTap components."""
-
-import os
-import json
-import logging
-from pathlib import Path
-from typing import Dict, Any
-
-import requests
-
-logger = logging.getLogger(__name__)
-
-
-class SetupService:
-    """Service for installing WebTap components."""
-
-    # GitHub URLs
-    FILTERS_URL = "https://raw.githubusercontent.com/angelsen/tap-tools/main/packages/webtap/data/filters.json"
-    EXTENSION_BASE_URL = "https://raw.githubusercontent.com/angelsen/tap-tools/main/packages/webtap/extension"
-    EXTENSION_FILES = ["manifest.json", "popup.html", "popup.js"]
-
-    def install_filters(self, force: bool = False) -> Dict[str, Any]:
-        """Install filters to .webtap/filters.json.
-
-        Args:
-            force: Overwrite existing file
-
-        Returns:
-            Dict with success, message, path, details
-        """
-        # Same path that FilterManager uses
-        target_path = Path.cwd() / ".webtap" / "filters.json"
-
-        # Check if exists
-        if target_path.exists() and not force:
-            return {
-                "success": False,
-                "message": f"Filters already exist at {target_path}",
-                "path": str(target_path),
-                "details": "Use --force to overwrite",
-            }
-
-        # Download from GitHub
-        try:
-            logger.info(f"Downloading filters from {self.FILTERS_URL}")
-            response = requests.get(self.FILTERS_URL, timeout=10)
-            response.raise_for_status()
-
-            # Validate it's proper JSON
-            filters_data = json.loads(response.text)
-
-            # Quick validation - should have dict structure
-            if not isinstance(filters_data, dict):
-                return {
-                    "success": False,
-                    "message": "Invalid filter format - expected JSON object",
-                    "path": None,
-                    "details": None,
-                }
-
-            # Count categories for user feedback
-            category_count = len(filters_data)
-
-            # Create directory and save
-            target_path.parent.mkdir(parents=True, exist_ok=True)
-            target_path.write_text(response.text)
-
-            logger.info(f"Saved {category_count} filter categories to {target_path}")
-
-            return {
-                "success": True,
-                "message": f"Downloaded {category_count} filter categories",
-                "path": str(target_path),
-                "details": f"Categories: {', '.join(filters_data.keys())}",
-            }
-
-        except requests.RequestException as e:
-            logger.error(f"Network error downloading filters: {e}")
-            return {"success": False, "message": f"Network error: {e}", "path": None, "details": None}
-        except json.JSONDecodeError as e:
-            logger.error(f"Invalid JSON in filters: {e}")
-            return {"success": False, "message": f"Invalid JSON format: {e}", "path": None, "details": None}
-        except Exception as e:
-            logger.error(f"Unexpected error: {e}")
-            return {"success": False, "message": f"Failed to download filters: {e}", "path": None, "details": None}
-
-    def install_extension(self, force: bool = False) -> Dict[str, Any]:
-        """Install Chrome extension to ~/.config/webtap/extension/.
-
-        Args:
-            force: Overwrite existing files
-
-        Returns:
-            Dict with success, message, path, details
-        """
-        # XDG config directory for Linux
-        target_dir = Path.home() / ".config" / "webtap" / "extension"
-
-        # Check if exists (manifest.json is required file)
-        if (target_dir / "manifest.json").exists() and not force:
-            return {
-                "success": False,
-                "message": f"Extension already exists at {target_dir}",
-                "path": str(target_dir),
-                "details": "Use --force to overwrite",
-            }
-
-        # Create directory
-        target_dir.mkdir(parents=True, exist_ok=True)
-
-        # Download each file
-        downloaded = []
-        failed = []
-
-        for filename in self.EXTENSION_FILES:
-            url = f"{self.EXTENSION_BASE_URL}/{filename}"
-            target_file = target_dir / filename
-
-            try:
-                logger.info(f"Downloading {filename}")
-                response = requests.get(url, timeout=10)
-                response.raise_for_status()
-
-                # For manifest.json, validate it's proper JSON
-                if filename == "manifest.json":
-                    json.loads(response.text)
-
-                target_file.write_text(response.text)
-                downloaded.append(filename)
-
-            except Exception as e:
-                logger.error(f"Failed to download {filename}: {e}")
-                failed.append(filename)
-
-        # Determine success level
-        if not downloaded:
-            return {
-                "success": False,
-                "message": "Failed to download any extension files",
-                "path": None,
-                "details": "Check network connection and try again",
-            }
-
-        if failed:
-            # Partial success - some files downloaded
-            return {
-                "success": True,  # Partial is still success
-                "message": f"Downloaded {len(downloaded)}/{len(self.EXTENSION_FILES)} files",
-                "path": str(target_dir),
-                "details": f"Failed: {', '.join(failed)}",
-            }
-
-        return {
-            "success": True,
-            "message": "Downloaded Chrome extension",
-            "path": str(target_dir),
-            "details": f"Files: {', '.join(downloaded)}",
-        }
-
-    def install_chrome_wrapper(self, force: bool = False) -> Dict[str, Any]:
-        """Install Chrome wrapper script for debugging.
-
-        Args:
-            force: Overwrite existing script
-
-        Returns:
-            Dict with success, message, path, details
-        """
-        target_path = Path.home() / ".local" / "bin" / "wrappers" / "google-chrome-stable"
-
-        if target_path.exists() and not force:
-            return {
-                "success": False,
-                "message": "Chrome wrapper already exists",
-                "path": str(target_path),
-                "details": "Use --force to overwrite",
-            }
-
-        wrapper_script = """#!/bin/bash
-# Chrome wrapper using bindfs for perfect state sync with debug port
-
-DEBUG_DIR="$HOME/.config/google-chrome-debug"
-REAL_DIR="$HOME/.config/google-chrome"
-
-# Check if bindfs is installed
-if ! command -v bindfs &>/dev/null; then
-    echo "Error: bindfs not installed. Install with: yay -S bindfs" >&2
-    exit 1
-fi
-
-# Mount real profile via bindfs if not already mounted
-if ! mountpoint -q "$DEBUG_DIR" 2>/dev/null; then
-    mkdir -p "$DEBUG_DIR"
-    if ! bindfs --no-allow-other "$REAL_DIR" "$DEBUG_DIR"; then
-        echo "Error: Failed to mount Chrome profile via bindfs" >&2
-        exit 1
-    fi
-    echo "Chrome debug profile mounted. To unmount: fusermount -u $DEBUG_DIR" >&2
-fi
-
-# Launch Chrome with debugging on bindfs mount
-exec /usr/bin/google-chrome-stable \\
-    --remote-debugging-port=9222 \\
-    --remote-allow-origins='*' \\
-    --user-data-dir="$DEBUG_DIR" \\
-    "$@"
-"""
-
-        # Create directory and save
-        target_path.parent.mkdir(parents=True, exist_ok=True)
-        target_path.write_text(wrapper_script)
-        target_path.chmod(0o755)  # Make executable
-
-        # Check PATH
-        path_dirs = os.environ.get("PATH", "").split(":")
-        wrapper_dir = str(target_path.parent)
-        in_path = wrapper_dir in path_dirs
-
-        logger.info(f"Installed Chrome wrapper to {target_path}")
-
-        return {
-            "success": True,
-            "message": "Installed Chrome wrapper script",
-            "path": str(target_path),
-            "details": "Already in PATH ✓" if in_path else "Add to PATH",
-        }
-
-
-__all__ = ["SetupService"]